You can prevent the user from creating two model elements with the same name using custom change rules. That is, when the user tries to change the name of an element to the same name of another existing element, you just show him a message and rollback the current modeling transaction so the name rolls back to its previous (valid) value.

This is very easy to achieve using the NamedElement domain class I’ve been talking about and the extension methods described in the previous post.

1. Add the Change Rule to NamedElement

This rule acts on any change to the Name property:

using System;
using Microsoft.VisualStudio.Modeling;

namespace Experimental.Library
{
    /// <summary>
    /// Defines a change rule for the Entity domain class.
    /// </summary>
    [RuleOn(typeof(NamedElement), FireTime = TimeToFire.TopLevelCommit)]
    public class NamedElementChangeRule : ChangeRule
    {
        #region Public Methods

        /// <summary>
        /// Alerts listeners that a property for an element has changed.
        /// </summary>
        /// <param name="e">Provides data for the ElementPropertyChanged event.</param>
        public override void ElementPropertyChanged(ElementPropertyChangedEventArgs e)
        {
            // Validate arguments

            if (e == null)
            {
                throw new ArgumentNullException("e");
            }

            // Property being changed

            if (e.DomainProperty.Id.Equals(NamedElement.NameDomainPropertyId))
            {
                this.HandleNameChange(e);
            }

            // Default behavior

            base.ElementPropertyChanged(e);
        }

        #endregion

        #region Private Methods

        /// <summary>
        /// When the Name property changes.
        /// </summary>
        /// <param name="e">The <see cref="Microsoft.VisualStudio.Modeling.ElementPropertyChangedEventArgs"/> instance containing the event data.</param>
        private void HandleNameChange(ElementPropertyChangedEventArgs e)
        {
            // Ignore change?

            if (RuleHelper.IgnoreChange(e.ModelElement))
            {
                return;
            }

            // Something changed?

            string oldName = (string)e.OldValue;
            string newName = (string)e.NewValue;

            if ((string.IsNullOrEmpty(oldName) && !string.IsNullOrEmpty(newName)) ||
                (!newName.Equals(oldName, StringComparison.CurrentCulture)))
            {
                RuleHelper.PreventRepeatedName<NamedElement>(e.ModelElement as NamedElement, newName, oldName);
            }
        }

        #endregion
    }
}

Here I’m using a static helper method (PreventRepeatedName) so that I can share this behavior between NamedElement and ReadOnlyNamedElement.

2. Implement the Rule Logic

The custom logic goes into PreventRepeatedName and it involves basically getting the siblings of the element that is being modified and checking if any of them has the same name. When that occurs, I just rollback the current transaction and show an error message to the user.

/// <summary>
/// Checks if the specified model element has any sibling with the same name. If so it rolls back
/// the current transaction and shows a message to the user.
/// </summary>
/// <typeparam name="T">The type of the model element.</typeparam>
/// <param name="modelElement">The model element whose name will be checked.</param>
/// <param name="newName">The new name of the model element.</param>
/// <param name="oldName">The old name of the model element.</param>
/// <remarks>
/// This method is designed to be called from a change rule on the Name property of the
/// model element.
/// </remarks>
public static void PreventRepeatedName<T>(T modelElement, string newName, string oldName)
    where T : ModelElement, INamedModelElement
{
    // Validation

    if (modelElement == null)
    {
        throw new ArgumentNullException("modelElement");
    }

    // Domain class

    DomainClassInfo domainClass = modelElement.GetDomainClass();

    // Get the siblings for this element

    IEnumerable<T> siblings = modelElement.GetSiblings<T>();
    if (siblings != null)
    {
        // Search any element that has the same name

        foreach (T sibling in siblings)
        {
            if (sibling.Name.Equals(modelElement.Name, StringComparison.CurrentCulture))
            {
                // Rollback transaction to cancel change

                modelElement.Store.TransactionManager.CurrentTransaction.Rollback();

                // Show message

                string message = string.Format(CultureInfo.CurrentCulture, "Cannot change {0} name from '{1}' to '{2}'. Another element with that name already exists in the model. The change was cancelled.", domainClass.DisplayName, oldName, newName);
                Dialogs.ShowWarning("Element Name...", message);
                return;
            }
        }
    }
}

Notice that this shows a technique of rolling back changes by rolling back the current transaction which is much better than modifying the Name property to its previous value, which, in turn, will trigger the rule again. It is better in this case but you should be ware that rules in the DSL Tools are cascading, in the sense that a change rule can be triggered by other rules and/or custom code that modifies the related property. When the current transaction is rollback, ALL changes to the model will be rolled back, not only the change to the property evaluated by the change rule.

3. Build All

Then you’ll just need to build the library, all dependent DSL projects and it’s done. No more repeated names in elements of the same type.

The first way to prevent this is by presenting validation errors when that happens. And that can be easily implemented when you have a DslLibrary that defines the NamedElement (and ReadOnlyNamedElement for that matter).

Assuming that you know how to implement validation rules, the steps are the following:

1. Add a Validation Method to the NamedElement domain class in the DslLibrary

The code is quite simple and it will be triggered when the Name is defined (there is another validation rule that is triggered when that is not defined):

/// <summary>
/// Name cannot be repeated between siblings.
/// </summary>
/// <param name="context">The validation context.</param>
[ValidationMethod(ValidationCategories.Menu | ValidationCategories.Open | ValidationCategories.Save)]
private void ValidateRepeatedNames(ValidationContext context)
{
    // Name is defined?

    if (!string.IsNullOrEmpty(this.Name))
    {
        ValidationHelper.ValidateRepeatedNames<NamedElement>(context, this, ValidationError);
    }
}

2. Implement the Validation Logic

I have created a more generic validation logic that can be shared between NamedElement and ReadOnlyNamedElement. It goes to the ValidateRepeatedNames method in a ValidationHelper static class.

Basically it involves getting all the siblings elements of the model element that is being validated and checking if any of them has the same as the current element. Siblings are model elements of the same type of the current element that are involved in the same embedding relationship as that element.

/// <summary>
/// Checks if the specified model element name is repeated in the containing embedding relationship.
/// </summary>
/// <typeparam name="T">The type of the model element.</typeparam>
/// <param name="context">The validation context.</param>
/// <param name="modelElement">The model element that should be validated.</param>
/// <param name="validationCode">The validation error code.</param>
/// <remarks>
/// This method is designed to be called from a validation method of the model element domain class.
/// </remarks>
public static void ValidateRepeatedNames<T>(ValidationContext context, T modelElement, string validationCode)
    where T : ModelElement, INamedModelElement
{
    // Validation

    if (context == null)
    {
        throw new ArgumentNullException("context");
    }

    if (modelElement == null)
    {
        throw new ArgumentNullException("modelElement");
    }

    // Get the domain class

    DomainClassInfo domainClass = modelElement.GetDomainClass();

    // Get the siblings

    IEnumerable<NamedElement> siblings = modelElement.GetSiblings<NamedElement>();
    if (siblings != null)
    {
        // Search for any other element that has the same name

        IEnumerable<NamedElement> repeated = from sibling in siblings
                                                where sibling.Name.Equals(modelElement.Name, StringComparison.CurrentCulture)
                                                select sibling;
        if (repeated != null)
        {
            int count = repeated.Count();

            if (count > 0)
            {
                string error = string.Format(CultureInfo.CurrentCulture, "{0} name '{1}' is repeated {2} times.", domainClass.DisplayName, modelElement.Name, count + 1);
                context.LogError(error, validationCode, modelElement);
            }
        }
    }
}

Notice that this generic method enforces a type rule that requires type T to implement the INamedModelElement interface. This is a custom interface – shared by NamedElement and ReadOnlyNamedElement – created to define common behavior – the Name property in this case – between both classes.

The interfaces involved are the following:

using System;

namespace Experimental.Library
{
    /// <summary>
    /// Defines the interface of a model element.
    /// </summary>
    public interface IModelElement
    {
        #region Properties

        /// <summary>
        /// The identifier of the model element.
        /// </summary>
        Guid Id
        {
            get;
        }

        #endregion
    }
}

using System;

namespace Experimental.Library
{
    /// <summary>
    /// Defines the interface of a named model element.
    /// </summary>
    public interface INamedModelElement : IModelElement
    {
        #region Properties

        /// <summary>
        /// The name of the model element.
        /// </summary>
        string Name
        {
            get;
            set;
        }

        #endregion
    }
}

To have the NamedElement and ReadOnlyNamedElement implement them requires only that you add a partial class for each of them to your DslLibrary project:

using System;

namespace Experimental.Library
{
    /// <summary>
    /// Defines custom code for the NamedElement domain class.
    /// </summary>
    public partial class NamedElement : INamedModelElement
    {
    }
}

using System;

namespace Experimental.Library
{
    /// <summary>
    /// Defines custom code for the ReadOnlyNamedElement domain class.
    /// </summary>
    public partial class ReadOnlyNamedElement : INamedModelElement
    {
    }
}

3. Build All

Then you’ll just need to build the library, all dependent DSL projects and it’s done. No more repeated names in elements of the same type.

The Magic

The actual magic in this same is done with some extension methods to the ModelElement class that add two interesting features to the DSL Tools. One is the ability to get “the model element that contains a given model element” (GetContainer) and the other is the ability of “given a model element, getting all the other sibling model elements in an embedding relationship” (GetSiblings).

Here is the code for those extensions:

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using Microsoft.VisualStudio.Modeling;

namespace Experimental.Core.Extensions
{
    /// <summary>
    /// Provides extension methods for the ModelElement class.
    /// </summary>
    public static class ModelElementExtensions
    {
        #region Public Methods

        /// <summary>
        /// Gets the model element that contains this model element in an embedding relationship.
        /// </summary>
        /// <param name="element">The model element whose container will be returned.</param>
        /// <returns>The model element that contains this model element in an embedding relationship.</returns>
        /// <remarks>Returns null if there is not container.</remarks>
        public static ModelElement GetContainer(this ModelElement element)
        {
            // Validation

            if (element == null)
            {
                throw new ArgumentNullException("element");
            }

            // Get the embedding domain role

            DomainRoleInfo embeddedDomainRole = GetEmbeddingDomainRole(element);
            if (embeddedDomainRole != null)
            {
                // Opposite domain role

                DomainRoleInfo oppositeDomainRole = embeddedDomainRole.OppositeDomainRole;

                // Get the container

                ReadOnlyCollection<ElementLink> elementLinks = embeddedDomainRole.GetElementLinks(element);
                if (elementLinks != null && elementLinks.Count > 0)
                {
                    return oppositeDomainRole.GetRolePlayer(elementLinks[0]);
                }
            }

            // Default result

            return null;
        }

        /// <summary>
        /// Gets the model element that contains this model element in an embedding relationship.
        /// </summary>
        /// <typeparam name="T">The type of the container model element.</typeparam>
        /// <param name="element">The model element whose container will be returned.</param>
        /// <returns>The model element that contains this model element in an embedding relationship.</returns>
        /// <remarks>Returns null if there is no container or if the container is not of the specified type.</remarks>
        public static T GetContainer<T>(this ModelElement element)
            where T : ModelElement
        {
            return GetContainer(element) as T;
        }

        /// <summary>
        /// Gets all the model elements that are siblings in an embedding relationship of the specified model element.
        /// </summary>
        /// <param name="element">The model element whose siblings will be returned.</param>
        /// <returns>All the model elements that are siblings in an embedding relationship of the specified model element.</returns>
        /// <remarks>Returns null if the specified element is not part of any embedding relationship (has no container).</remarks>
        public static IEnumerable<ModelElement> GetSiblings(this ModelElement element)
        {
            // Validation

            if (element == null)
            {
                throw new ArgumentNullException("element");
            }

            // Get the container and the embedding domain role

            ModelElement container = element.GetContainer();
            DomainRoleInfo embeddedDomainRole = GetEmbeddingDomainRole(element);

            // Continue?

            if (container != null && embeddedDomainRole != null)
            {
                // Get all the elements contained by container

                LinkedElementCollection<ModelElement> linkedElements = embeddedDomainRole.OppositeDomainRole.GetLinkedElements(container);

                // Ignore the specified element and return

                IEnumerable<ModelElement> result = from linkedElement in linkedElements
                                                   where !linkedElement.Id.Equals(element.Id)
                                                   select linkedElement;
                return result;
            }

            // Default result

            return null;
        }

        /// <summary>
        /// Gets all the model elements that are siblings in an embedding relationship of the specified model element.
        /// </summary>
        /// <typeparam name="T">The type of the siblings model elements.</typeparam>
        /// <param name="element">The model element whose siblings will be returned.</param>
        /// <returns>All the model elements that are siblings in an embedding relationship of the specified model element.</returns>
        /// <remarks>Returns null if the specified element is not part of any embedding relationship (has no container).</remarks>
        public static IEnumerable<T> GetSiblings<T>(this ModelElement element)
            where T : ModelElement
        {
            return GetSiblings(element).Cast<T>();
        }

        #endregion

        #region Private Methods

        /// <summary>
        /// Gets the domain role that defines the specified model element as the target of an embedding relationship.
        /// </summary>
        /// <param name="element">The model element whose embedding domain role will be returned.</param>
        /// <returns>The domain role that defines the specified model element as the target of an embedding relationship.</returns>
        private static DomainRoleInfo GetEmbeddingDomainRole(ModelElement element)
        {
            // Validation

            if (element == null)
            {
                throw new ArgumentNullException("element");
            }

            // Get the domain class

            DomainClassInfo domainClass = element.GetDomainClass();
            if (domainClass != null)
            {
                // All domain roles played

                ReadOnlyCollection<DomainRoleInfo> allDomainRolesPlayed = domainClass.AllDomainRolesPlayed;

                // Get the container

                int count = allDomainRolesPlayed.Count;
                for (int i = 0; i < count; i++)
                {
                    DomainRoleInfo embeddedDomainRole = allDomainRolesPlayed[i];
                    DomainRoleInfo oppositeDomainRole = embeddedDomainRole.OppositeDomainRole;

                    if (oppositeDomainRole.IsEmbedding)
                    {
                        return embeddedDomainRole;
                    }
                }
            }

            // Default result

            return null;
        }

        #endregion
    }
}

As soon as you specify a domain property (Name in this case) to be the element name, when you add a class of that type to the diagram, the DSL Tools will generate a default name based on the existing classes of that type (through the ElementNameProvider class). For example, if you have a domain class called Entity and that class includes a domain property marked with “Is Element Name” the value of that property will be by default Entity1, Entity2, and so forth. This will also work for my NamedElement abstract domain class, meaning that you can share that behavior along with sharing the Name property.

So far so good but there is a problem with the ReadOnlyNamedElement because the Name property in that class is marked with “Is UI Read Only” and in that case the default name will not be generated. I suppose that the default implementation assumes that if the user cannot change that value in the designer, there is no reason to generate a default name as it will probably be created by custom code.

Although that is reasonable, I still want a default name to prevent validation errors relating with the class name before the user as the possibility of defining the other domain property(ies) that will change the name.

There is a simple customization that you can do to override this default behavior. Here’s how you can do it in the DslLibrary so that it affects all classes that will derive from ReadOnlyNamedElement.

1. Create the Custom Element Name Provider

First you will need to create a custom element name provider and have inherit from ElementNameProvider. In this case I will name it ReadOnlyNamedElementNameProvider.

In this new class just override SetUniqueNameCore and implement the logic to generate the default name.

using System;
using System.Collections.Generic;
using System.Globalization;
using Microsoft.VisualStudio.Modeling;
using Microsoft.VisualStudio.Modeling.Design;

namespace Experimental.Library
{
    /// <summary>
    /// Provides a custom element name provider for the ReadOnlyNamedElement domain class.
    /// </summary>
    public class ReadOnlyNamedElementNameProvider : ElementNameProvider
    {
        #region Protected Methods

        /// <summary>
        /// Sets a unique name for the model element based on the base name.
        /// </summary>
        /// <param name="element">The model element.</param>
        /// <param name="baseName">The base name.</param>
        /// <param name="siblingNames">The names in use by sibling model elements.</param>
        protected override void SetUniqueNameCore(ModelElement element, string baseName, IDictionary<string, ModelElement> siblingNames)
        {
            // Is it a ReadOnlyNamedElement?

            ReadOnlyNamedElement namedElement = element as ReadOnlyNamedElement;
            if (namedElement != null)
            {
                // Get the last number in use

                int lastNumber = 0;

                foreach (string name in siblingNames.Keys)
                {
                    if (name.StartsWith(baseName, StringComparison.CurrentCulture))
                    {
                        string sufix = name.Remove(0, baseName.Length);

                        int value = 0;
                        if (int.TryParse(sufix, NumberStyles.Integer, CultureInfo.CurrentCulture, out value))
                        {
                            lastNumber = value;
                        }
                    }
                }

                // Update the name

                string defaultName = baseName + (++lastNumber).ToString(CultureInfo.CurrentCulture);
                namedElement.Name = defaultName;

                return;
            }

            // Default behavior

            base.SetUniqueNameCore(element, baseName, siblingNames);
        }

        #endregion
    }
}

Note that I’ve designed this class so that it will only do something different from the default implementation if it is applied to a ReadOnlyNamedElement.

2. Register the External Type

Before you can use this new type in the DslLibrary model you will need to register it:

1. Open DslDefinition.dsl.
2. Select the root node in the DSL Explorer.
3. Select “Add New External Type” from the context menu. This will create a new node under “Domain Types”.
4. Select that node and, in the properties window, set the Name (equal to the class name) and the Namespace.

3. Specify the Custom Element Name Provider

Now select the Name property of the domain class in the DSL designer – ReadOnlyNameElement in this case. In the properties window, for the “Element Name Provider” property chose the external type that you created from the list.

4. Transform All & Re-build

To finish you will need to transform all templates in the DSL Library, rebuild it and rebuild all dependent DSL projects. Now you have a default name even for domain classes where the name domain property is read-only.

If you want to learn the basics about DslLibraries check this article: Sharing Classes between DSLs by using a DSL Library.

One common behavior that all the DSL models that I’ve created have is this concept that most domain classes have one property called Name. In some cases I let the user specify it, in other cases I don’t because the element name is derived from another domain property.

A good implementation of such common behavior can be achieve using a simple DslLibrary and it involves creating two domain classes – NamedElement and ReadOnlyNamedElement – that are used as the base classes for all the specific domain classes where I want to have that behavior.

Here’s how you can implement such a thing easily.

1. Create the DslLibrary

First you will need to create a new project for the DslLibrary.

Be careful with the language name and with the root namespace that you specify in this wizard. These will be used when you import the library in your DSL models.

2. Model the Base Classes

Open the DslDefinition.dsl file and model the two abstract domain classes: NamedElement and ReadOnlyNamedElement.

NOTE: The Name domain property of the ReadOnlyNamedElement should have the “Is UI Read Only” property set to true.

3. Transform All & Build

Finish the library definition by running “Transform All Templates” and building the project. This will generate the assembly for your model, which will be required by each DSL that references this library.

4. Import the DslLibrary

The next step is to open each DSL that will use the domain classes defined in the library and importing it.

To do that you should open the DslDefinition.dsl file, go to the DSL Explorer, select the root node in the tree (corresponding to the model root) and select “Add New Dsl Library Import”.

This will create a new node under “Dsl Library Imports”. Select it and point the “File Path” property to the DslDefinition.dsl file of the DslLibrary project.

At this point you can reference the domain classes defined in the library in the current DSL definition.

5. Change the Model

In one particular model where I wanted to implement this “named element behavior” I have the following domain classes:

• Entity – that should derive from NamedElement (so the user can edit the entity name).
• Module Reference – that should derive from ReadOnlyNamedElement (so that the name is read-only).

At this point, the next step is to define the correct base class for each of these domain classes. To do that:

1. Select the domain class in the DSL diagram.
2. Modify the “Base Class” property and select the correct base class (from the DslLibrary).

6. Transform All & Build

Finally, you need to transform all templates and build your DSL.

After transforming templates you will notice references to your DslLibrary project. For example, if you search for the Entity class in the DomainClasses.cs generated file, you will see that class implementing NamedElement from your library. Something like this:

If you compile your project at this moment you will see that a reference is missing to the DslLibrary assembly. Add that reference to your Dsl and DslPackage projects and you’re set.

One thing that the default implementation of the DSL Tools doesn’t do is to validate the model before executing the actual code generation. But the infrastructure is there to implement it quite easily, although it may very easy to miss it in the documentation.

My simple model includes a very simple custom validation (see this post if you need help with implementing custom validations):

[ValidationMethod(ValidationCategories.Menu | ValidationCategories.Open | ValidationCategories.Save)]
private void ValidateReservedNames(ValidationContext context)
{
    string[] reservedNames = { "Entity", "BusinessEntity" };

    if (reservedNames.Contains(this.Name))
    {
        string error = string.Format(CultureInfo.CurrentCulture, "Entity '{0}' name is reserved.", this.Name);
        context.LogError(error, ValidationError, this);
    }
}

Then I have a very simple text template that generates a XML file from it.

<#@ ExEntitiesModel processor="ExEntitiesModelDirectiveProcessor"
	requires="fileName='ExEntitiesModel.entitiesModel'"#>
<#@ template inherits="Microsoft.VisualStudio.TextTemplating.VSHost.ModelingTextTransformation" debug="true"#>
<#@ output extension=".xml" #>
<#@ import namespace = "Experimental.Entities" #>

<?xml version="1.0" encoding="utf-8" ?>
<entities>
<#
foreach (Entity entity in this.ExEntitiesModelRoot.Entities)
{
#>
	<entity name="<#= entity.Name #>">
	</entity>
<#
}
#>
</entities>

Now imagine that the code generation is a lot more complex and that it really requires the model to be valid before even trying to generate anything.

To do that you just need to modify the directive processor requires parameter to include the “Validation” parameter. This parameter should specify the validation category (ValidationCategories enum) that should be considered:

<#@ ExEntitiesModel processor="ExEntitiesModelDirectiveProcessor"
	requires="fileName='ExEntitiesModel.entitiesModel';validation='Save'"#>
...

The problem with this approach is that you have to put it in every single text template that generates code from your model.

There is another way to achieve this that will affect any code generator created over your model. It involves customizing the directive processor itself.

1. Create a Partial Class for the Model Directive Processor

The name of the directive processor class can be found in the text template (processor=?) and depends on your model name. If, for example, your model is named “ExEntitiesModel” than the directive processor will be named “ExEntitiesModelDirectiveProcessor”;

2. Override GeneratePostInitializationCode

This method is called in the directive processor base class to obtain the values of the requires arguments and generate the code transformation accordingly. You can access these values and inject the “Validation” argument if it was not provided in the text template:

using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Text;

namespace Experimental.Entities
{
    /// <summary>
    /// Provides custom code for the ExEntitiesModelDirectiveProcessor.
    /// </summary>
    public partial class ExEntitiesModelDirectiveProcessor
    {
        #region Protected Methods

        /// <summary>
        /// Contribute additively to initialization code for the TextTransformation generated class.
        /// </summary>
        /// <param name="directiveName">The directive name.</param>
        /// <param name="codeBuffer">The code buffer.</param>
        /// <param name="languageProvider">The language provider.</param>
        /// <param name="requiresArguments">The requires arguments values.</param>
        /// <param name="providesArguments">The provides arguments values.</param>
        /// <remarks>
        /// This code will be added after the call to the base class.
        /// </remarks>
        protected override void GeneratePostInitializationCode(string directiveName, StringBuilder codeBuffer, CodeDomProvider languageProvider, IDictionary<string, string> requiresArguments, IDictionary<string, string> providesArguments)
        {
            // Check if requires includes validation

            if (requiresArguments.Keys.Contains("Validation"))
            {
                if (string.IsNullOrEmpty(requiresArguments["Validation"]))
                {
                    requiresArguments["Validation"] = "Save";
                }
            }
            else
            {
                requiresArguments.Add("Validation", "Save");
            }

            // Default behavior

            base.GeneratePostInitializationCode(directiveName, codeBuffer, languageProvider, requiresArguments, providesArguments);
        }

        #endregion
    }
}

And you are done.

NOTE: This idea of having text templates force the validation of the underlying model has a potential issue. If you have, say, 10 different text templates in the same solution, all generating code from the same model, each one will execute the validation before running (if you run Transform All Templates for example). That will probably result in some kind of performance issue.

In fact, we have a set of models (different DSLs) that are integrated through custom commands that read the original model and import them (or parts of them) in the destination model.

So, I decided to implement also a custom command that resets the model so that the import command can be easily executed again. But this means removing only some of the shapes in the model, not all.

Off-course the user can select the shapes in the model and delete them but that is not really handy. So the “Reset Model” command actually iterates trough all the shapes in the model and deletes them leaving the shapes of types specified to be ignored.

The code is very simple. I wanted it to be absolutly generic so I’m using a Diagram extension method, iterating through the node shapes in the diagram, instead of using the Clear() methods available for generated embedded relations.

/// <summary>
/// Resets the current diagram.
/// </summary>
/// <param name="diagram">The diagram.</param>
/// <param name="prompt">A value indicating whether the user should be prompted to confirm.</param>
/// <param name="dontDelete">A list of types that specify shape elements and/or model elements that should not be deleted.</param>
public static void ResetModel(this Diagram diagram, bool prompt, params Type[] dontDelete)
{
    // Validation

    if (diagram == null)
    {
        throw new ArgumentNullException("diagram");
    }

    // Prompt the user?

    if (prompt)
    {
        if (!Dialogs.ShowQuestion(Properties.Resources.RES_PleaseConfirm, Properties.Resources.RES_Question_ResetModel))
        {
            return;
        }
    }

    // Get the child node shapes
    // Add the shapes that should be deleted to a collection

    Collection<NodeShape> toDelete = new Collection<NodeShape>();
    foreach (NodeShape child in diagram.NestedChildNodeShapes())
    {
        // Check if the shape is set to be ignored

        bool delete = true;

        if (dontDelete != null)
        {
            Type nodeShapeType = child.GetType();
            if (dontDelete.Contains(nodeShapeType))
            {
                delete = false;
            }
            else
            {
                if (child.ModelElement != null)
                {
                    Type modelElementType = child.ModelElement.GetType();
                    if (dontDelete.Contains(modelElementType))
                    {
                        delete = false;
                    }
                }
            }
        }

        // Delete?

        if (delete)
        {
            toDelete.Add(child);
        }
    }

    // Transaction

    using (Transaction transaction = diagram.Store.TransactionManager.BeginTransaction("ResetModel"))
    {
        // Delete

        foreach (NodeShape shape in toDelete)
        {
            shape.Delete();
        }

        // Commit

        transaction.Commit();
    }
}

Note that NestedChildNodeShapes is an extension of ShapeElement:

/// <summary>
/// Gets a list of the nested node shapes.
/// </summary>
/// <param name="shape">The parent shape.</param>
/// <returns>A list of the nested node shapes that are connected to the specified node shape.</returns>
public static IEnumerable<NodeShape> NestedChildNodeShapes(this ShapeElement shape)
{
    // Validation

    if (shape == null)
    {
        throw new ArgumentNullException("shape");
    }

    // Search all nested child shapes

    Collection<NodeShape> result = new Collection<NodeShape>();
    foreach (ShapeElement child in shape.NestedChildShapes)
    {
        // Is it a node shape?

        NodeShape nodeShape = child as NodeShape;
        if (nodeShape != null)
        {
            result.Add(nodeShape);
        }
    }

    return result.AsEnumerable<NodeShape>();
}

And also that the argument dontDelete allows you to specify the types of the shapes or model elements that should not be deleted from the diagram.

Very simple.

Thinking of this I’ve created a new feature in my models – called auto-hide connectors – that does something like that.

I’ve set the following requirements:

• The user should be able to set the feature on and off at any time (through a context menu).
• By default the feature is off.
• The user setting should be persisted when the user closes the model (to be in the same state the next he opens it).
• When the feature is off, connectors are always visible.
• When the feature is on:
  • If nothing is selected in the diagram, all the connectors are hidden.
  • When a node shape is selected, all the connectors to and from that shape will be visible.

Implementing these requirements is quite simple.

1. AutoHideConnectors Domain Property

You need a place to persist a flag that turns the feature on and off. For that you can create a domain property called AutoHideConnectors in the model root.

NOTE: Be sure to make it not browsable so that it won’t appear in the model properties as it will be changed by a context menu.

2. Transform All

Transform all templates to reflect the new domain property in the model object model.

3. Context Menu

The next step is to create a context menu that allows the user to activate/deactivate this feature.

To make the Checked property of the menu depend on the AutoHideConnectors domain property you have to add the following code to OnPopUpMenuDisplayAction:

internal void OnPopUpMenuDisplayAction(object sender, EventArgs e)
{
    // Menu command

    MenuCommand command = sender as MenuCommand;
    if (command != null)
    {
        if (command.CommandID.Guid.Equals(this.cmdAutoHideConnectorsGUID))
        {
            command.Visible = this.CurrentModel != null;
            command.Enabled = command.Visible;
            command.Checked = command.Visible && this.CurrentModel.AutoHideConnectors;
        }

        // Default behavior

        command.Visible = true;
        command.Enabled = command.Visible;
    }
}

The code associated with the MenuClick event is the following:

private void ExecuteAutoHideConnectors()
{
    // Validation

    if (this.CurrentDocData == null || this.CurrentDocView == null || this.CurrentDocView.CurrentDiagram == null)
    {
        return;
    }

    // Transaction to change the model

    using (Transaction transaction = this.CurrentDocData.Store.TransactionManager.BeginTransaction("AutoHideConnectors"))
    {
        // Change model property

        this.CurrentModel.AutoHideConnectors = !this.CurrentModel.AutoHideConnectors;

        // Update the view

        if (this.CurrentModel.AutoHideConnectors)
        {
            this.CurrentDocView.CurrentDiagram.HideAllLinks();
        }
        else
        {
            this.CurrentDocView.CurrentDiagram.ShowAllLinks();
        }

        // Commit

        transaction.Commit();
    }
}

This code relies in the ShowAllLinks and HideAllLinks extensions described in this previous post.

NOTE: The infrastructure to add context menus his explained here.

4. OnSelectionChanged (DocView)

Now the only thing remaining is to have the diagram react to the shape that is selected.

To implement that you will need to extend the DocView for your model and there override the OnSelectionChanged event handler.

NOTE: The name of the class that you will need to extend depends on your DSL and can be found in the DocView.cs file of your DSLPackage project (it ends with DocView).

The code is quite simple. You have to check if the primary selection corresponds to a node shape (meaning that is a shape that can have connectors to/from it) and then have the diagram show only the links that come from or go to that shape.

using System;
using Experimental.Core.Extensions;
using Microsoft.VisualStudio.Modeling.Diagrams;

namespace Experimental.Reporting
{
    /// <summary>
    /// Provides custom code for the ExReportingModelDocView.
    /// </summary>
    internal partial class ExReportingModelDocView
    {
        #region Protected Methods

        /// <summary>
        /// Called when selection changes in this window.
        /// </summary>
        /// <param name="e"></param>
        /// <remarks>
        /// Overriden to update the F1 help keyword for the selection.
        /// </remarks>
        protected override void OnSelectionChanged(EventArgs e)
        {
            // Default behavior

            base.OnSelectionChanged(e);

            // There is something to do only if AutoHideConnectors is true

            if (!this.CurrentModel<ExReportingModelRoot>().AutoHideConnectors)
            {
                return;
            }

            // Process selection

            NodeShape selectedShape = (this.PrimarySelection as NodeShape);
            if (selectedShape != null)
            {
                // Hide all the links in the diagram

                if (this.CurrentDiagram != null)
                {
                    this.CurrentDiagram.HideAllLinks();
                }

                // If the shape is the diagram itself, nothing more to do

                if (selectedShape is Diagram)
                {
                    return;
                }

                // Show the links connected to the selected shape

                if (selectedShape.Diagram != null)
                {
                    selectedShape.Diagram.ShowAllLinks(selectedShape);
                }
            }
        }

        #endregion
    }
}

The ShowAllLinks method used here is also an extension of the Diagram class:

/// <summary>
/// Shows all the links in the current diagram that connect to the specified node shape.
/// </summary>
/// <param name="diagram">The diagram.</param>
/// <param name="nodeShape">The node shape whose links should be shown.</param>
public static void ShowAllLinks(this Diagram diagram, NodeShape nodeShape)
{
    ShowHideAllLinks(diagram, nodeShape, true);
}

private static void ShowHideAllLinks(this Diagram diagram, NodeShape nodeShape, bool show)
{
    // Validation

    if (diagram == null)
    {
        throw new ArgumentNullException("diagram");
    }

    // Get the links that should be shown or hidden

    IEnumerable<BinaryLinkShape> links = diagram.NestedChildBinaryLinkShapes(nodeShape);

    // Show/hide the links

    foreach (BinaryLinkShape link in links)
    {
        if (show)
        {
            if (!link.IsVisible)
            {
                link.Show();
            }
        }
        else
        {
            if (link.IsVisible)
            {
                link.Hide();
            }
        }
    }
}

Thinking about this a bit, one of the things that contributes more to make a model hard to read are connectors, that is when you have a lot of them.

So a very useful thing that diagrams should have is the ability to hide and show all the connectors at the user’s discretion.

It turns out that this is very easy to implement just by adding two extensions to the Diagram class.

Here is how I’ve done it.

1. Extend Diagram

I’ve created a static class called DiagramExtensions that provides extension methods for the Diagram class. This class adds two extensions:

• ShowAllLinks
• HideAllLinks

The magic happens in the ShowHideAllLinks private method:

• First I get an IEnumerable of all the shapes in the diagram that are of type BinaryLinkShape through another extension method called NestedChildBinaryLinkShapes (defined for ShapeElement).
• NestedChildBinaryLinkShapes just iterates through NestedChildShapes and returns only the shapes that are of type BinaryLinkShape (a connector in the DSL Tools).
• Finally, the IEnumerable is enumerated and the connector is shown if it is hidden or hidden if it is visible.

Here is the source code for DiagramExtensions:

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using Microsoft.VisualStudio.Modeling;
using Microsoft.VisualStudio.Modeling.Diagrams;

namespace Experimental.Core.Extensions
{
    /// <summary>
    /// Provides extension methods for the Diagram class.
    /// </summary>
    public static class DiagramExtensions
    {
        #region Public Methods

        /// <summary>
        /// Shows all the links in the current diagram.
        /// </summary>
        /// <param name="diagram">The diagram.</param>
        public static void ShowAllLinks(this Diagram diagram)
        {
            ShowHideAllLinks(diagram, true);
        }

        /// <summary>
        /// Hides all the links in the current diagram.
        /// </summary>
        /// <param name="diagram">The diagram.</param>
        public static void HideAllLinks(this Diagram diagram)
        {
            ShowHideAllLinks(diagram, false);
        }

        #endregion

        #region Private Methods

        private static void ShowHideAllLinks(this Diagram diagram, bool show)
        {
            ShowHideAllLinks(diagram, null, show);
        }

        private static void ShowHideAllLinks(this Diagram diagram, NodeShape nodeShape, bool show)
        {
            // Validation

            if (diagram == null)
            {
                throw new ArgumentNullException("diagram");
            }

            // Get the links that should be shown or hidden

            IEnumerable<BinaryLinkShape> links = diagram.NestedChildBinaryLinkShapes(nodeShape);

            // Show/hide the links

            foreach (BinaryLinkShape link in links)
            {
                if (show)
                {
                    if (!link.IsVisible)
                    {
                        link.Show();
                    }
                }
                else
                {
                    if (link.IsVisible)
                    {
                        link.Hide();
                    }
                }
            }
        }

        #endregion
    }
}

And the source code for ShapeElementExtensions:

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using Microsoft.VisualStudio.Modeling.Diagrams;

namespace Experimental.Core.Extensions
{
    /// <summary>
    /// Provides extension methods for the ShapeElement class.
    /// </summary>
    public static class ShapeElementExtensions
    {
        #region Public Methods

        /// <summary>
        /// Gets a list of the nested binary link shapes.
        /// </summary>
        /// <param name="shape">The shape.</param>
        /// <returns>A list of the nested binary link shapes.</returns>
        public static IEnumerable<BinaryLinkShape> NestedChildBinaryLinkShapes(this ShapeElement shape)
        {
            return NestedChildBinaryLinkShapes(shape, null);
        }

        /// <summary>
        /// Gets a list of the nested binary link shapes that are connected to the specified node shape.
        /// </summary>
        /// <param name="shape">The shape.</param>
        /// <param name="toOrFromShape">The node shape to which the link shape must be connected to appear in the result.</param>
        /// <returns>A list of the nested binary link shapes that are connected to the specified node shape.</returns>
        public static IEnumerable<BinaryLinkShape> NestedChildBinaryLinkShapes(this ShapeElement shape, NodeShape toOrFromShape)
        {
            // Validation

            if (shape == null)
            {
                throw new ArgumentNullException("shape");
            }

            // Search all nested child shapes

            Collection<BinaryLinkShape> result = new Collection<BinaryLinkShape>();
            foreach (ShapeElement child in shape.NestedChildShapes)
            {
                // Is it a link shape?

                BinaryLinkShape linkShape = child as BinaryLinkShape;
                if (linkShape != null)
                {
                    // If the node shape is not specified, just add to the result

                    if (toOrFromShape == null)
                    {
                        result.Add(linkShape);
                    }
                    else
                    {
                        // Otherwise the link shape must connect to the specified node shape

                        if (linkShape.FromLinkConnectsToNode.Nodes.Equals(toOrFromShape) ||
                            linkShape.ToLinkConnectsToNode.Nodes.Equals(toOrFromShape))
                        {
                            result.Add(linkShape);
                        }
                    }
                }
            }

            return result.AsEnumerable<BinaryLinkShape>();
        }

        #endregion
    }
}

2. Add Context Menus

The two new operations are available to the user through context menus (implemented as explained here). The corresponding commands just need to call the extension methods defined in the previous step.

private void ExecuteShowAllConnectors()
{
    // Validation

    if (this.CurrentDocView == null || this.CurrentDocView.CurrentDiagram == null)
    {
        return;
    }

    // Execute

    this.CurrentDocView.CurrentDiagram.ShowAllLinks();
}

private void ExecuteHideAllConnectors()
{
    // Validation

    if (this.CurrentDocView == null || this.CurrentDocView.CurrentDiagram == null)
    {
        return;
    }

    // Execute

    this.CurrentDocView.CurrentDiagram.HideAllLinks();
}

Easy.

In my DSL project I wanted to achieve a context menu like this:

Notice my custom context menus:

• Auto-hide
• Show All
• Hide All
• Reset Model

Based on Filipe’s sample, all you need to do is the following:

1. Add CommandSetConfig.tt to the DSLPackage project

This file contains the model that defines the context menus. There are three collections here – menus, groups, and commands – that you populate and relate according to what you are trying to achieve.

<#
string languageNamespace = "Experimental.Reporting";
string languageName = "ExReportingModel";

// Lists

Collection> menus = new Collection>();
Collection> groups = new Collection>();
Collection> commands = new Collection>();

// -- Menus --

Dictionary menu = null;

// Menu Connectors

menu = new Dictionary();
menu.Add("CanonicalName", "mnuConnectors");
menu.Add("ButtonText", "Connectors");
menu.Add("Id", "{E4AB24D9-31C4-4AD5-B7DC-07E33D997265}");
menus.Add(menu);

// -- Groups --

Dictionary group = null;

// Group Connectors

group = new Dictionary();
group.Add("Parent", "mnuConnectors");
group.Add("CanonicalName", "grpConnectors");
group.Add("Id", "{F933E696-BD92-4498-AD64-E3BEFE926278}");
groups.Add(group);

// -- Buttons --

Dictionary command = null;

// ... Menu Connectors

// Command AutoHideConnectors

command = new Dictionary();
command.Add("Parent", "grpConnectors");
command.Add("CanonicalName", "cmdAutoHideConnectors");
command.Add("ButtonText", "Auto-hide");
command.Add("ToolTipText", "Toggle auto-hide connectors.");
command.Add("Id", "{804CBDAD-0D02-4966-B0D7-3FFEE8DA4F59}");
commands.Add(command);

// Command ShowAllConnectors

command = new Dictionary();
command.Add("Parent", "grpConnectors");
command.Add("CanonicalName", "cmdShowAllConnectors");
command.Add("ButtonText", "Show All");
command.Add("ToolTipText", "Shows all connectors in the model.");
command.Add("Id", "{31024157-E41F-4AB6-A530-306EC0F290DE}");
commands.Add(command);

// Command HideAllConnectors

command = new Dictionary();
command.Add("Parent", "grpConnectors");
command.Add("CanonicalName", "cmdHideAllConnectors");
command.Add("ButtonText", "Hide All");
command.Add("ToolTipText", "Hides all connectors in the model.");
command.Add("Id", "{3E992345-126B-46F0-8921-9FB62AF42A32}");
commands.Add(command);

// ...

// Command cmdResetModel

command = new Dictionary();
command.Add("CanonicalName", "cmdResetModel");
command.Add("ButtonText", "Reset Model");
command.Add("ToolTipText", "Reset the current model.");
command.Add("Id", "{874741C7-26E5-427E-B73C-DE6BEE7133ED}");
commands.Add(command);

#>

NOTE: You will need to remove custom tool associated with this file to prevent Visual Studio from trying to generate code from it.

2. Add Commands.tt

This will generate the custom command definitions file in xml from the configuration you set in CommandSetConfig.tt.

The source code is the following:

<#@ template inherits="Microsoft.VisualStudio.TextTemplating.VSHost.ModelingTextTransformation" debug="true"#>
<#@ assembly name="Microsoft.VisualStudio.TextTemplating.Modeling.10.0.dll"#>
<#@ output extension=".vsct" #>
<#@ import namespace = "System.Collections.Generic" #>
<#@ import namespace = "System.Collections.ObjectModel" #>
<#@ include file="CommandSetConfig.tt" #>
<?xml version="1.0" encoding="utf-8"?>
<CommandTable xmlns="http://schemas.microsoft.com/VisualStudio/2005-10-18/CommandTable" xmlns:xs="http://www.w3.org/2001/XMLSchema">
	<!-- -->
	<!-- This file contains custom command definitions. -->
	<!-- -->
	<!-- NOTE: Each time commands are added or changed, the "version" parameter to the -->
	<!-- ProvideMenuResource attribute in Shell\Package.tt should be incremented. -->
	<!-- This causes Visual Studio to re-merge the menu definitions for the package. -->
	<!-- Otherwise, changes won't take effect until the next time devenv /setup is run. -->
	<!-- -->
	<Extern href="stdidcmd.h"/>
	<Extern href="vsshlids.h"/>
	<Extern href="msobtnid.h"/>
	<Extern href="virtkeys.h"/>
	<Extern href="DSLToolsCmdID.h"/>
	<Include href="GeneratedCode\GeneratedVsct.vsct"/>
	<Commands package="guidPkg">

		<Menus>

<#
foreach (Dictionary<string, string> element in menus)
{
#>
				<Menu guid="<#= element["CanonicalName"] #>GUID" id="<#= element["CanonicalName"] #>ID" priority="0x0000" type="Menu">
					<Parent guid="guidCmdSet" id="grpidContextMain" />
					<CommandFlag>DynamicVisibility</CommandFlag>
					<Strings>
					  <ButtonText><#= element["ButtonText"] #></ButtonText>
					  <CanonicalName><#= element["CanonicalName"] #></CanonicalName>
					</Strings>
				</Menu>

<#
}
#>
		</Menus>

		<Groups>

<#
foreach (Dictionary<string, string> element in groups)
{
#>
			<Group guid="<#= element["CanonicalName"] #>GUID" id="<#= element["CanonicalName"] #>ID" priority="0x0000">
				<Parent guid="<#= element["Parent"] #>GUID" id="<#= element["Parent"] #>ID" />
			</Group>

<#
}
#>
		</Groups>

		<Buttons>

<#
foreach (Dictionary<string, string> element in commands)
{
	string parentGuid = null;
	string parentId = null;

	if (element.TryGetValue("Parent", out parentGuid))
	{
		parentId = parentGuid + "ID";
		parentGuid = parentGuid + "GUID";
	}
	else
	{
		parentId = "grpidContextMain";
		parentGuid = "guidCmdSet";
	}

#>
			<Button guid="<#= element["CanonicalName"] #>GUID" id="<#= element["CanonicalName"] #>ID" priority="0x0000" type="Button">
				<Parent guid="<#= parentGuid #>" id="<#= parentId #>" />
				<CommandFlag>DynamicVisibility</CommandFlag>
				<Strings>
					<CanonicalName><#= element["CanonicalName"] #></CanonicalName>
					<ButtonText><#= element["ButtonText"] #></ButtonText>
					<ToolTipText><#= element["ToolTipText"] #></ToolTipText>
				</Strings>
			</Button>

<#
}
#>
		</Buttons>

	</Commands>

	<Symbols>

		<!-- Menus -->

<#
int index = 1000;
foreach (Dictionary<string, string> element in menus)
{
#>
		<GuidSymbol name="<#= element["CanonicalName"] #>GUID" value="<#= element["Id"] #>">
			<IDSymbol name="<#= element["CanonicalName"] #>ID" value="0x<#= index #>" />
		</GuidSymbol>

<#
index++;
}
#>

		<!-- Groups -->

<#
index = 1100;
foreach (Dictionary<string, string> element in groups)
{
#>
		<GuidSymbol name="<#= element["CanonicalName"] #>GUID" value="<#= element["Id"] #>">
			<IDSymbol name="<#= element["CanonicalName"] #>ID" value="0x<#= index #>" />
		</GuidSymbol>

<#
index++;
}
#>

		<!-- Commands -->

<#
index = 1200;
foreach (Dictionary<string, string> element in commands)
{
#>
		<GuidSymbol name="<#= element["CanonicalName"] #>GUID" value="<#= element["Id"] #>">
			<IDSymbol name="<#= element["CanonicalName"] #>ID" value="0x<#= index #>" />
		</GuidSymbol>

<#
index++;
}
#>

	</Symbols>

</CommandTable>

3. Add CommandSet.tt

This will generate the commandset partial class. The source code is the following:

<#@ template inherits="Microsoft.VisualStudio.TextTemplating.VSHost.ModelingTextTransformation" debug="true"#>
<#@ assembly name="Microsoft.VisualStudio.TextTemplating.Modeling.10.0.dll"#>
<#@ output extension=".cs" #>
<#@ import namespace = "System.Collections.Generic" #>
<#@ import namespace = "System.Collections.ObjectModel" #>
<#@ include file="CommandSetConfig.tt" #>
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel.Design;
using Microsoft.VisualStudio.Modeling;
using Microsoft.VisualStudio.Modeling.Shell;

namespace <#= languageNamespace #>
{
    /// <summary>
    /// Custom code for <#= languageName #>CommandSet.
    /// </summary>
    internal partial class <#= languageName #>CommandSet : <#= languageName #>CommandSetBase
    {
        #region Constants

<#
int index = 1200;

foreach (Dictionary<string, string> element in commands)
{
	string canonicalName = element["CanonicalName"];

	string constName = canonicalName.Substring(0, 1).ToUpper() + canonicalName.Substring(1);
#>
        /// <summary>
        /// <#= constName #> commmand identifier.
        /// </summary>
        private const int <#= constName #>ID = 0x<#= index #>;

<#
	index++;
}
#>
        #endregion

        #region Members

<#
foreach (Dictionary<string, string> element in commands)
{
	string canonicalName = element["CanonicalName"];
#>
        /// <summary>
        /// Enable related task commmand unique identifier.
        /// </summary>
        private Guid <#= canonicalName #>GUID = new Guid("<#= element["Id"] #>");

<#
}
#>
        #endregion

        #region Protected Methods

        /// <summary>
        /// Provide the menu commands that this command set handles.
        /// </summary>
        /// <returns>A list of commands.</returns>
        protected override IList<MenuCommand> GetMenuCommands()
        {
            // Execute base

            IList<MenuCommand> commands = base.GetMenuCommands();

<#
foreach (Dictionary<string, string> element in commands)
{
	string canonicalName = element["CanonicalName"];

	string constName = canonicalName.Substring(0, 1).ToUpper() + canonicalName.Substring(1);
#>
            // Add the new menu command

            DynamicStatusMenuCommand <#= canonicalName #> =
                new DynamicStatusMenuCommand(
                    new EventHandler(this.OnPopUpMenuDisplayAction),
                    new EventHandler(this.OnPopUpMenuClick),
                    new CommandID(this.<#= canonicalName #>GUID, <#= constName #>ID));
            commands.Add(<#= canonicalName #>);

<#
}
#>
            // Result

            return commands;
        }

        #endregion
    }
}

4. Transform

Next you’ll need to transform the previous two templates to get the code generated and to be able to continue to finish the CommandSet class.

5. Finish the CommandSet class

This is the ExReportingModelCommandSet.cs in my project. Here you will need to implement the following methods:

• OnPopUpMenuDisplayAction: to control menu status.
• OnPopUpMenuClick: to execute the menu command.

The basic source code in my project is the following:

using System;
using System.ComponentModel.Design;
using Experimental.Core.Extensions;
using Microsoft.VisualStudio.Modeling;
using Experimental.Core;

namespace Experimental.Reporting
{
    /// <summary>
    /// Custom code for ExReportingModelCommandSet.
    /// </summary>
    internal partial class ExReportingModelCommandSet : ExReportingModelCommandSetBase
    {
        #region Internal Methods

        #region EventHandlers

        /// <summary>
        /// Called when the pop up menu is going to be displayed.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        internal void OnPopUpMenuDisplayAction(object sender, EventArgs e)
        {
            // Menu command

            MenuCommand command = sender as MenuCommand;
            if (command != null)
            {
                if (command.CommandID.Guid.Equals(this.cmdAutoHideConnectorsGUID))
                {
                    command.Visible = this.CurrentModel != null;
                    command.Enabled = command.Visible;
                    command.Checked = command.Visible && this.CurrentModel.AutoHideConnectors;
                }

                // Default behavior

                command.Visible = true;
                command.Enabled = command.Visible;
            }
        }

        /// <summary>
        /// Called when the user clicks an option in the pop up menu.
        /// </summary>
        /// <param name="sender">The sender.</param>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
        internal void OnPopUpMenuClick(object sender, EventArgs e)
        {
            // Menu command

            MenuCommand command = sender as MenuCommand;
            if (command != null)
            {
                if (command.CommandID.Guid.Equals(this.cmdAutoHideConnectorsGUID))
                {
                    this.ExecuteAutoHideConnectors();
                }
                else if (command.CommandID.Guid.Equals(this.cmdShowAllConnectorsGUID))
                {
                    this.ExecuteShowAllConnectors();
                }
                else if (command.CommandID.Guid.Equals(this.cmdHideAllConnectorsGUID))
                {
                    this.ExecuteHideAllConnectors();
                }
                else if (command.CommandID.Guid.Equals(this.cmdResetModelGUID))
                {
                    this.ExecuteResetModel();
                }
            }
        }

        #endregion

        #endregion

        #region Private Methods

        #region Execute

        private void ExecuteAutoHideConnectors()
        {
            // ...
        }

        private void ExecuteShowAllConnectors()
        {
            // ...
        }

        private void ExecuteHideAllConnectors()
        {
            // ...
        }

        private void ExecuteResetModel()
        {
            // ...
        }

        #endregion

        #endregion
    }
}

The DSLPackage project should look something along these lines:

6. Copy Commands.vsct

To finish just copy the contents of the generated Commands.vsct to the file with the same name that is found in the DSLPackage project root.

Build the DSL and that’s it. You have a very simple and effective code generator to create custom context menus in your DSL projects.

I truly hope that this will make blog a lot more than these last months. Let’s see. I do have a lot of possible posts to continue the DSL Tools series.

PS: You don’t need to update the feed. Just continue using feeds.feedburner.com/HugoRibeiro.