Partager via

Ajout de commandes et de mouvements aux diagrammes de couche

  • Article

Ce Feature Pack Visual Studio 2010 vous permet d'étendre les diagrammes de couche dans Visual Studio 2010 Ultimate en définissant des commandes de menu et des gestionnaires de mouvements de menu contextuel. Vous pouvez empaqueter ces extensions dans une extension d'intégration Visual Studio (VSIX) et les distribuer à d'autres utilisateurs de Visual Studio Ultimate. Pour plus d'informations, consultez Packs de fonctionnalités Visual Studio.

Vous pouvez définir plusieurs commandes et gestionnaires de mouvement dans le même projet Visual Studio. Vous pouvez également combiner plusieurs projets de ce type dans une extension VSIX. Par exemple, vous pouvez définir une extension VSIX unique qui inclut des commandes de couche, un langage spécifique au domaine et des commandes pour les diagrammes UML.

Notes

Si vous souhaitez définir une méthode de validation architecturale personnalisée, vous devez la définir dans un projet Visual Studio séparé. Vous pouvez l'ajouter à la même extension VSIX que les autres extensions. Pour plus d'informations, consultez Ajout d'une validation d'architecture personnalisée aux diagrammes de couche.

Spécifications

Pour obtenir les spécifications et les instructions nécessaires à l'installation, consultez Spécifications dans Création d'extensions de diagrammes de couche.

Définition d'une commande ou d'un mouvement dans une nouvelle extension VSIX

La méthode la plus rapide pour créer une extension consiste à utiliser le modèle de projet. Cela place le code et le manifeste VSIX dans le même projet.

Pour définir une extension à l'aide d'un modèle de projet

  1. Créez un projet dans une nouvelle solution, en utilisant la commande Nouveau projet dans le menu Fichier.

  2. Dans la boîte de dialogue Nouveau projet, sous Projets de modélisation, sélectionnez Layer Designer Gesture Extension (Extension de mouvement de concepteur de couche) ou Layer Designer Gesture Extension (Extension de mouvement de concepteur de couche).

    Le modèle crée un projet qui contient un petit exemple.

  3. Pour tester l'extension, appuyez sur CTRL+F5 ou F5.

    Une instance expérimentale de Visual Studio démarre alors. Dans cette instance, créez un diagramme de couche. Votre extension de commande ou de mouvement doit fonctionner dans ce diagramme.

  4. Fermez l'instance expérimentale et modifiez l'exemple de code. Pour plus d'informations, consultez Navigation et mise à jour des modèles de couche dans le code de programme.

  5. Vous pouvez ajouter d'autres gestionnaires de commandes ou de mouvements au même projet. Pour plus d'informations, consultez l'une des sections suivantes :

    Définition d'une commande de menu

    Définition d'un gestionnaire de mouvements

  6. Pour installer l'extension dans l'instance principale de Visual Studio ou sur un autre ordinateur, recherchez le fichier .vsix dans bin\*. Copiez-le sur l'ordinateur sur lequel vous souhaitez l'installer, puis double-cliquez dessus. Pour le désinstaller, utilisez le Gestionnaire d'extensions dans le menu Outils.

Ajout d'une commande ou d'un mouvement à un VSIX séparé

Si vous souhaitez créer un VSIX qui contient des commandes, des validateurs de couche et d'autres extensions, nous vous recommandons de créer un projet pour définir le VSIX et des projets séparés pour les gestionnaires. Pour plus d'informations sur les autres types d'extensions de modélisation, consultez l'article Extension de modèles et de diagrammes UML.

Pour ajouter des extensions de couche à un VSIX séparé

  1. Créez un projet de bibliothèque de classes dans une solution Visual Studio Ultimate nouvelle ou existante. Dans la boîte de dialogue Nouveau projet, cliquez sur Visual C#, puis sur Bibliothèque de classes. Ce projet contient les classes de gestionnaires de mouvements ou de commandes.

    Notes

    Vous pouvez définir plusieurs classes de gestionnaires de mouvements ou de commandes dans une bibliothèque de classes, mais vous devez définir les classes de validation de couche dans une bibliothèque de classes séparée.

  2. Identifiez ou créez un projet VSIX dans votre solution. Un projet VSIX contient un fichier nommé source.extension.vsixmanifest. Pour ajouter un projet VSIX :

    1. Dans la boîte de dialogue Nouveau projet, développez Visual C#, cliquez sur Extensibilité, puis sur Projet VSIX.

    2. Dans l'Explorateur de solutions, cliquez avec le bouton droit sur le projet VSIX, puis cliquez sur Définir comme projet de démarrage.

    3. Cliquez sur Sélectionner des éditions et assurez-vous que Visual Studio Ultimate est sélectionné.

  3. Dans source.extension.vsixmanifest, sous Contenu, ajoutez le projet du gestionnaire de mouvements ou de commandes en tant que composant MEF.

    1. Cliquez sur Ajouter du contenu.

    2. Dans Sélectionner un type de contenu, sélectionnez Composant MEF.

    3. Sous Sélectionner une source, cliquez sur Projet et sélectionnez le nom du projet de votre gestionnaire de mouvements ou de commandes.

    4. Enregistrez le fichier.

  4. Sous Références, cliquez sur Ajouter une référence, puis sélectionnez le runtime de ce Feature Pack.

  5. Revenez au projet du gestionnaire de mouvements ou de commandes et ajoutez les références de projet suivantes.

Référence

Actions autorisées

Si Visual Studio 2010 Visualization and Modeling Feature Pack est installé :

%LocalAppData%\Microsoft\VisualStudio\10.0\Extensions\Microsoft\Visualization and Modeling Feature Pack Runtime\1.0\Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer.dll

RemarqueRemarque
%LocalAppData% est en général NomLecteur:\Users\NomUtilisateur\AppData\Local.Sous Windows XP ou Windows 2003, utilisez %AppData% au lieu de %LocalAppData%.

Si Microsoft Visual Studio 2010 Feature Pack 2 est installé :

…\Microsoft Visual Studio 10.0\Common7\IDE\Extensions\Visualization and Modeling Feature Pack Runtime\1.0\Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer.dll

Créer et modifier des couches

Microsoft.VisualStudio.Uml.Interfaces

Créer et modifier des couches

Microsoft.VisualStudio.ArchitectureTools.Extensibility

Modifier des formes sur les diagrammes

System.ComponentModel.Composition

Définir des composants à l'aide de Managed Extensibility Framework (MEF)

Microsoft.VisualStudio.Modeling.Sdk.10.0

Définir des extensions de modélisation

Microsoft.VisualStudio.Modeling.Sdk.Diagrams.10.0

Mettre à jour des formes et des diagrammes

  1. Modifiez le fichier de classe dans le projet de bibliothèque de classes C# pour qu'il contienne le code de votre extension. Pour plus d'informations, consultez l'une des sections suivantes :

    Définition d'une commande de menu

    Définition d'un gestionnaire de mouvements

    Voir aussi Navigation et mise à jour des modèles de couche dans le code de programme.

  2. Pour tester la fonctionnalité, appuyez sur CTRL+F5 ou F5. Une instance expérimentale de Visual Studio s'ouvre alors. Dans cette instance, créez ou ouvrez un diagramme de couche.

  3. Pour installer le VSIX dans l'instance principale de Visual Studio ou sur un autre ordinateur, recherchez le fichier .vsix dans le répertoire bin du projet VSIX. Copiez-le sur l'ordinateur sur lequel vous souhaitez installer le VSIX. Double-cliquez sur le fichier VSIX dans l'Explorateur Windows.

    Pour le désinstaller, utilisez le Gestionnaire d'extensions dans le menu Outils.

Définition d'une commande de menu

Vous pouvez ajouter d'autres définitions de commande de menu dans un projet de commande ou de mouvement existant. Chaque commande est définie par une classe avec les caractéristiques suivantes :

  • La classe est déclarée comme suit :

    [LayerDesignerExtension]

    [Export(typeof(ICommandExtension))]

    public class MyLayerCommand : ICommandExtension { ... }

  • L'espace de noms et le nom de la classe sont sans importance.

  • Les méthodes qui implémentent ICommandExtension sont les suivantes :

    • string Text {get;}- L'étiquette qui s'affiche dans le menu.

    • void QueryStatus(IMenuCommand command)- appelée lorsque l'utilisateur clique avec le bouton droit sur le diagramme, et détermine si la commande doit être visible et active pour la sélection actuelle de l'utilisateur.

    • void Execute(IMenuCommand command)- appelée lorsque l'utilisateur sélectionne la commande.

  • Pour déterminer la sélection actuelle, vous pouvez importer IDiagramContext :

    [Import]

    public IDiagramContext DiagramContext { get; set; }

    ...

    DiagramContext.CurrentDiagram.SelectedShapes.Count()...

Pour plus d'informations, consultez Navigation et mise à jour des modèles de couche dans le code de programme.

Pour ajouter une nouvelle commande, créez un fichier de code qui contient l'exemple suivant. Ensuite, testez-le et modifiez-le.

using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Presentation;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml; 
using Microsoft.VisualStudio.Modeling.Diagrams.ExtensionEnablement;
using Microsoft.VisualStudio.Modeling.ExtensionEnablement;
using System.ComponentModel.Composition;
using System.Linq;

namespace MyLayerExtension // Change to your preference.
{
  // This is a feature for Layer diagrams:
  [LayerDesignerExtension]
  // This feature is a menu command:
  [Export(typeof(ICommandExtension))]
  // Change the class name to your preference:
  public class MyLayerCommand : ICommandExtension
  {
    [Import]
    public IDiagramContext DiagramContext { get; set; }

    [Import]
    public ILinkedUndoContext LinkedUndoContext { get; set; }

    // Menu command label:
    public string Text
    {
      get { return "Duplicate layers"; }
    }

    // Called when the user right-clicks the diagram.
    // Defines whether the command is visible and enabled.
    public void QueryStatus(IMenuCommand command)
    { 
      command.Visible = 
      command.Enabled = DiagramContext.CurrentDiagram
        .SelectedShapes.Count() > 0;
    }

    // Called when the user selects the command.
    public void Execute(IMenuCommand command)
    {
      // A selection of starting points:
      IDiagram diagram = this.DiagramContext.CurrentDiagram;
      ILayerModel lmodel = diagram.GetLayerModel();
      foreach (ILayer layer in lmodel.Layers)
      { // All layers in model.
      }
      // Updates should be performed in a transaction:
      using (ILinkedUndoTransaction t =
        LinkedUndoContext.BeginTransaction("copy selection"))
      {
        foreach (ILayer layer in 
          diagram.SelectedShapes
            .Select(shape=>shape.GetLayerElement())
            .Where(element => element is ILayer))
        {
          ILayer copy = lmodel.CreateLayer(layer.Name + "+");
          // Position the shapes:
          IShape originalShape = layer.GetShape();
          copy.GetShape().Move(
            originalShape.XPosition + originalShape.Width * 1.2,
            originalShape.YPosition);
        }
        t.Commit();
      }
    }
  }
}

Définition d'un gestionnaire de mouvements

Vous pouvez ajouter à votre projet VSIX du gestionnaire de mouvements ou de commandes existant, un fichier de code qui définit un gestionnaire de mouvements :

using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Presentation;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml;
using Microsoft.VisualStudio.Modeling.Diagrams.ExtensionEnablement;
using Microsoft.VisualStudio.Modeling.ExtensionEnablement;
using System.ComponentModel.Composition;
using System.Linq;
namespace MyLayerExtensions // change to your preference
{
  [LayerDesignerExtension]
  [Export(typeof(IGestureExtension))]
  public class MyLayerGestureHandler : IGestureExtension
  {
  }
}

Notez les points suivants à propos des gestionnaires de mouvements :

  • Les membres de IGestureExtension sont les suivants :

    OnDoubleClick - appelé lorsque l'utilisateur double-clique sur le diagramme.

    CanDragDrop - appelé à plusieurs reprises lorsque l'utilisateur déplace la souris pour faire glisser un élément sur le diagramme. Cela doit fonctionner rapidement.

    OnDragDrop - appelé lorsque l'utilisateur dépose un élément sur le diagramme.

  • Le premier argument de chaque méthode est un ShapeElement. Vous pouvez le convertir en IShape, qui correspond à un wrapper plus approprié pour la modélisation :

    IShape ishape = targetElement.CreateIShape();
if (ishape is IDiagram) { ... }
else { ILayerElement layerElement = s.GetLayerElement(); ... }

  • Les gestionnaires de certains types d'éléments glissés sont déjà définis. Par exemple, l'utilisateur peut faire glisser des éléments de l'Explorateur de solutions vers un diagramme de couche. Vous ne pouvez pas définir de gestionnaire de glisser-déplacer pour ces types d'éléments. Dans ces situations, vos méthodes DragDrop ne seront pas appelées.

Pour plus d'informations sur le décodage d'autres éléments lorsqu'ils sont glissés sur le diagramme, consultez Comment : définir un gestionnaire déposer et double-cliquer sur un diagramme de modélisation.

Voir aussi

Autres ressources

Navigation et mise à jour des modèles de couche dans le code de programme

Ajout d'une validation d'architecture personnalisée aux diagrammes de couche

Comment : définir et installer une extension de modélisation

Historique des modifications

Date

Historique

Motif

Décembre 2010

Mis à jour pour Microsoft Visual Studio 2010 Feature Pack 2.

Améliorations apportées aux informations.