Intercepter un clic sur une forme ou un décorateur

Article
01/15/2024

Les procédures suivantes montrent comment intercepter un clic sur une forme ou un décorateur d’icônes. Vous pouvez intercepter des clics, double-clics, des glissements et autres mouvements et faire en sorte que l’élément réponde.

Interceptez les clics sur les formes

Dans le projet Dsl, dans un fichier de code distinct des fichiers de code générés, écrivez une définition de classe partielle pour la classe de forme. Remplacez OnDoubleClick() ou l’une des autres méthodes dont le nom commence par On.... Par exemple :

public partial class MyShape // change
{
  public override void OnDoubleClick(DiagramPointEventArgs e)
  {
    base.OnDoubleClick(e);
    System.Windows.Forms.MessageBox.Show("Click");
    e.Handled = true;
  }
}

Notes

Définissez e.Handled sur true, sauf si vous souhaitez que l’événement soit passé à la forme ou au diagramme contenant.

Interceptez les clics sur les décorateurs

Les décorateurs d’images sont portés sur une instance de classe ImageField, qui a une méthode OnDoubleClick. Vous pouvez intercepter les clics si vous écrivez une sous-classe ImageField. Les champs sont configurés dans la méthode InitializeShapeFields. Par conséquent, vous devez modifier cette méthode pour instancier votre sous-classe au lieu du standard ImageField. La méthode InitializeShapeFields se trouve dans le code généré de la classe de forme. Vous pouvez remplacer la classe de forme si vous définissez sa propriété Generates Double Derived comme décrit dans la procédure suivante.

Bien que InitializeShapeFields soit une méthode d’instance, elle n’est appelée qu’une seule fois pour chaque classe. Par conséquent, il n’existe qu’une seule instance de ClickableImageField pour chaque champ de chaque classe, et non une instance pour chaque forme du diagramme. Lorsque l’utilisateur double-clique sur une instance, vous devez identifier l’instance qui a été atteinte, comme le montre le code de l’exemple.

Pour intercepter un clic sur un décorateur d’icône, procédez comme suit :

Ouvrez ou créez une solution DSL.
Choisissez ou créez une forme qui a un décorateur d’icônes et mappez-la à une classe de domaine.

Dans un fichier de code distinct des fichiers du dossier GeneratedCode, créez la nouvelle sous-classe de ImageField :

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

namespace Fabrikam.MyDsl { // Change to your namespace
internal class ClickableImageField : ImageField
{
  // You can also override OnClick and so on.
  public override void OnDoubleClick(DiagramPointEventArgs e)
  {
    base.OnDoubleClick(e);
    // Work out which instance was hit.
    MyShape shapeHit = e.HitDiagramItem.Shape as MyShape;
    if (shapeHit != null)
    {
      MyDomainClass element =
          shapeHit.ModelElement as MyDomainClass;
      System.Windows.Forms.MessageBox.Show(
         "Double click on shape for " + element.Name);
      // If we do not set Handled, the event will
      // be passed to the containing shape:
      e.Handled = true;
    }
  }

   public ClickableImageField(string fieldName)
     : base(fieldName)
   { }
}

Vous devez définir Handled sur true si vous ne souhaitez pas que l’événement soit transmis à la forme contenante.

Remplacez la méthode InitializeShapeFields dans votre classe de forme en ajoutant la définition de classe partielle suivante.

public partial class MyShape // change
{
 protected override void InitializeShapeFields
      (IList<ShapeField> shapeFields)
 {
  base.InitializeShapeFields(shapeFields);
  // You can see the above method in MyShapeBase
  // in the generated Shapes.cs
  // It has already added fields for the Icons.
  // So you will have to retrieve them and replace with your own.
  ShapeField unwantedField = shapeFields.First
      (field => field.Name == "IconDecorator1");
  shapeFields.Remove(unwantedField);

  // Now replicate the generated code from the base class
  // in Shape.cs, but with your own image constructor.
  ImageField field2 = new ClickableImageField("IconDecorator1");
  field2.DefaultImage = ImageHelper.GetImage(
    MyDslDomainModel.SingletonResourceManager
    .GetObject("MyShapeIconDecorator1DefaultImage"));
      shapeFields.Add(field2);
}

Créez et exécutez la solution.
Double-cliquez sur l’icône sur une instance de la forme. Votre message de test devrait apparaître.

Intercepter les clics et les glisser sur les listes FormeDeCompartiment

L’exemple suivant permet aux utilisateurs de réorganiser les éléments d’une forme de compartiment en les faisant glisser.

Créez une nouvelle solution DSL à l’aide du modèle de solution Diagrammes de classes.

Vous pouvez également utiliser votre propre solution qui contient des formes de compartiment. Ce code suppose qu’il existe une imbrication de la relation entre les éléments de modèle représentés par la forme et les éléments représentés dans les éléments de liste de compartiment.
Définissez la propriété Génère un double dérivé de la forme de compartiment.
Ajoutez ce code dans un fichier dans le projet Dsl.
Ajustez les noms de la classe de domaine et de la forme dans ce code pour qu’ils correspondent à votre propre DSL.

Le code fonctionne comme suit. Dans cet exemple, ClassShape est le nom de la forme de compartiment.

Un ensemble de gestionnaires d’événements de souris est attaché à chaque instance de compartiment lors de sa création.
L’événement ClassShape.MouseDown stocke l’élément actif.
Lorsque la souris sort de l’élément actif, une instance de MouseAction est créée, qui définit le curseur et capture la souris jusqu’à ce qu’elle soit relâchée.

Pour éviter toute interférence avec d’autres actions de la souris, telles que la sélection du texte d’un élément, MouseAction n’est pas créée tant que la souris n’a pas quitté l’élément d’origine.

Une alternative à la création d’un MouseAction serait simplement d’écouter MouseUp. Toutefois, cette approche ne fonctionnerait pas correctement si l’utilisateur relâche la souris après l’avoir fait glisser en dehors du compartiment. Le MouseAction est en mesure d’effectuer l’action appropriée, quel que soit l’endroit où la souris est relâchée.
Lorsque la souris est relâchée, MouseAction.MouseUp réorganise l’ordre des liens entre les éléments du modèle.
La modification de l’ordre des rôles déclenche une règle qui met à jour l’affichage. Ce comportement est déjà défini et aucun code supplémentaire n’est requis.

Voici l'exemple de code :

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

// This sample allows users to re-order items in a compartment shape by dragging.

// This example is built on the "Class Diagrams" solution template of VMSDK (DSL Tools).
// You will need to change the following domain class names to your own:
// ClassShape = a compartment shape
// ClassModelElement = the domain class displayed using a ClassShape
// This code assumes that the embedding relationships
// displayed in the compartments don't use inheritance
// (don't have base or derived domain relationships).

namespace Company.CompartmentDrag
{
 /// <summary>
 /// Manage the mouse while dragging a compartment item.
 /// </summary>
 public class CompartmentDragMouseAction : MouseAction
 {
  private ModelElement sourceChild;
  private ClassShape sourceShape;
  private RectangleD sourceCompartmentBounds;

  public CompartmentDragMouseAction(ModelElement sourceChildElement, ClassShape sourceParentShape, RectangleD bounds)
   : base (sourceParentShape.Diagram)
  {
   sourceChild = sourceChildElement;
   sourceShape = sourceParentShape;
   sourceCompartmentBounds = bounds; // For cursor.
  }

  /// <summary>
  /// Call back to the source shape to drop the dragged item.
  /// </summary>
  /// <param name="e"></param>
  protected override void OnMouseUp(DiagramMouseEventArgs e)
  {
   base.OnMouseUp(e);
   sourceShape.DoMouseUp(sourceChild, e);
   this.Cancel(e.DiagramClientView);
   e.Handled = true;
  }

  /// <summary>
  /// Ideally, this shouldn't happen. This action should only be active
  /// while the mouse is still pressed. However, it can happen if you
  /// move the mouse rapidly out of the source shape, let go, and then
  /// click somewhere else in the source shape.
  /// </summary>
  /// <param name="e"></param>
  protected override void OnMouseDown(DiagramMouseEventArgs e)
  {
   base.OnMouseDown(e);
   this.Cancel(e.DiagramClientView);
   e.Handled = false;
  }

  /// <summary>
  /// Display an appropriate cursor while the drag is in progress:
  /// Up-down arrow if we are inside the original compartment.
  /// No entry if we are elsewhere.
  /// </summary>
  /// <param name="currentCursor"></param>
  /// <param name="diagramClientView"></param>
  /// <param name="mousePosition"></param>
  /// <returns></returns>
  public override System.Windows.Forms.Cursor GetCursor(System.Windows.Forms.Cursor currentCursor, DiagramClientView diagramClientView, PointD mousePosition)
  {
   // If the cursor is inside the original compartment, show up-down cursor.
   return sourceCompartmentBounds.Contains(mousePosition)
    ? System.Windows.Forms.Cursors.SizeNS // Up-down arrow.
    : System.Windows.Forms.Cursors.No;
  }
 }

 /// <summary>
 /// Override some methods of the compartment shape.
 /// *** GenerateDoubleDerived must be set for this shape in DslDefinition.dsl. ****
 /// </summary>
 public partial class ClassShape
 {
  /// <summary>
  /// Model element that is being dragged.
  /// </summary>
  private static ClassModelElement dragStartElement = null;
  /// <summary>
  /// Absolute bounds of the compartment, used to set the cursor.
  /// </summary>
  private static RectangleD compartmentBounds;

  /// <summary>
  /// Attach mouse listeners to the compartments for the shape.
  /// This is called once per compartment shape.
  /// The base method creates the compartments for this shape.
  /// </summary>
  public override void EnsureCompartments()
  {
   base.EnsureCompartments();
   foreach (Compartment compartment in this.NestedChildShapes.OfType<Compartment>())
   {
    compartment.MouseDown += new DiagramMouseEventHandler(compartment_MouseDown);
    compartment.MouseUp += new DiagramMouseEventHandler(compartment_MouseUp);
    compartment.MouseMove += new DiagramMouseEventHandler(compartment_MouseMove);
   }
  }

  /// <summary>
  /// Remember which item the mouse was dragged from.
  /// We don't create an Action immediately, as this would inhibit the
  /// inline text editing feature. Instead, we just remember the details
  /// and will create an Action when/if the mouse moves off this list item.
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  void compartment_MouseDown(object sender, DiagramMouseEventArgs e)
  {
   dragStartElement = e.HitDiagramItem.RepresentedElements
     .OfType<ClassModelElement>().FirstOrDefault();
   compartmentBounds = e.HitDiagramItem.Shape.AbsoluteBoundingBox;
  }

  /// <summary>
  /// When the mouse moves away from the initial list item,
  /// but still inside the compartment, create an Action
  /// to supervise the cursor and handle subsequent mouse events.
  /// Transfer the details of the initial mouse position to the Action.
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  void compartment_MouseMove(object sender, DiagramMouseEventArgs e)
  {
   if (dragStartElement != null)
   {
    if (dragStartElement != e.HitDiagramItem.RepresentedElements.OfType<ClassModelElement>().FirstOrDefault())
    {
     e.DiagramClientView.ActiveMouseAction = new CompartmentDragMouseAction(dragStartElement, this, compartmentBounds);
     dragStartElement = null;
    }
   }
  }

  /// <summary>
  /// User has released the mouse button.
  /// </summary>
  /// <param name="sender"></param>
  /// <param name="e"></param>
  void compartment_MouseUp(object sender, DiagramMouseEventArgs e)
  {
   dragStartElement = null;
  }

  /// <summary>
  /// Forget the source item if mouse up occurs outside the
  /// compartment.
  /// </summary>
  /// <param name="e"></param>
  public override void OnMouseUp(DiagramMouseEventArgs e)
  {
   base.OnMouseUp(e);
   dragStartElement = null;
  }

  /// <summary>
  /// Called by the Action when the user releases the mouse.
  /// If we are still on the same compartment but in a different list item,
  /// move the starting item to the position of the current one.
  /// </summary>
  /// <param name="dragFrom"></param>
  /// <param name="e"></param>
  public void DoMouseUp(ModelElement dragFrom, DiagramMouseEventArgs e)
  {
   // Original or "from" item:
   ClassModelElement dragFromElement = dragFrom as ClassModelElement;
   // Current or "to" item:
   ClassModelElement dragToElement = e.HitDiagramItem.RepresentedElements.OfType<ClassModelElement>().FirstOrDefault();
   if (dragFromElement != null && dragToElement != null)
   {
    // Find the common parent model element, and the relationship links:
    ElementLink parentToLink = GetEmbeddingLink(dragToElement);
    ElementLink parentFromLink = GetEmbeddingLink(dragFromElement);
    if (parentToLink != parentFromLink && parentFromLink != null && parentToLink != null)
    {
     // Get the static relationship and role (= end of relationship):
     DomainRelationshipInfo relationshipFrom = parentFromLink.GetDomainRelationship();
     DomainRoleInfo parentFromRole = relationshipFrom.DomainRoles[0];
     // Get the node in which the element is embedded, usually the element displayed in the shape:
     ModelElement parentFrom = parentFromLink.LinkedElements[0];

     // Same again for the target:
     DomainRelationshipInfo relationshipTo = parentToLink.GetDomainRelationship();
     DomainRoleInfo parentToRole = relationshipTo.DomainRoles[0];
     ModelElement parentTo = parentToLink.LinkedElements[0];

     // Mouse went down and up in same parent and same compartment:
     if (parentTo == parentFrom && relationshipTo == relationshipFrom)
     {
      // Find index of target position:
      int newIndex = 0;
      var elementLinks = parentToRole.GetElementLinks(parentTo);
      foreach (ElementLink link in elementLinks)
      {
       if (link == parentToLink) { break; }
       newIndex++;
      }

      if (newIndex < elementLinks.Count)
      {
       using (Transaction t = parentFrom.Store.TransactionManager.BeginTransaction("Move list item"))
       {
        parentFromLink.MoveToIndex(parentFromRole, newIndex);
        t.Commit();
       }
      }
     }
    }
   }
  }

  /// <summary>
  /// Get the embedding link to this element.
  /// Assumes there is no inheritance between embedding relationships.
  /// (If there is, you need to make sure you've got the relationship
  /// that is represented in the shape compartment.)
  /// </summary>
  /// <param name="child"></param>
  /// <returns></returns>
  ElementLink GetEmbeddingLink(ClassModelElement child)
  {
   foreach (DomainRoleInfo role in child.GetDomainClass().AllEmbeddedByDomainRoles)
   {
    foreach (ElementLink link in role.OppositeDomainRole.GetElementLinks(child))
    {
     // Just the assume the first embedding link is the only one.
     // Not a valid assumption if one relationship is derived from another.
     return link;
    }
   }
   return null;
  }
 }
}

Partager via

Intercepter un clic sur une forme ou un décorateur

Interceptez les clics sur les formes

Interceptez les clics sur les décorateurs

Intercepter les clics et les glisser sur les listes FormeDeCompartiment

Commentaires

Ressources supplémentaires

Partager via

Intercepter un clic sur une forme ou un décorateur

Interceptez les clics sur les formes

Interceptez les clics sur les décorateurs

Intercepter les clics et les glisser sur les listes FormeDeCompartiment

Contenu connexe

Commentaires

Ressources supplémentaires