Cómo: Interceptar un clic en una forma o decorador

Artículo
02/19/2013

Los procedimientos siguientes muestran cómo interceptar un clic en una forma o un elemento decorator del icono.Puede interceptar hace clic en, los doble clic, arrastra, y otro los gestos, y hace que el elemento responder.

Para interceptar hace clic en formas

En el proyecto de DSL, en un archivo de código que es independiente de los archivos de código generados, escriba una definición de clase parcial para la clase shape.Reemplace OnDoubleClick() o uno de los otros métodos que tengan un nombre empezando por On...Por ejemplo:

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

[!NOTA]

Establezca e.Handled a true, a menos que desee que el evento que se va a pasar a la forma o el diagrama que contiene.

Para interceptar haga clic en elementos decorator

Conducen a los elementos decorator de imagen en una instancia de la clase de ImageField, que tiene métodos de un OnDoubleClick.Puede interceptar haga clic en si escribe una subclase de ImageField.Los campos se definen en el método de InitializeShapeFields.Por consiguiente, debe cambiar el método para crear instancias de la subclase en lugar de ImageField regular.El método de InitializeShapeFields está en el código de la clase shape.Puede reemplazar la clase shape si establece la propiedad de Generates Double Derived como se describe en el procedimiento siguiente.

Aunque InitializeShapeFields es un método de instancia, sólo se llama una vez para cada clase.Por consiguiente, solo una instancia de ClickableImageField existe para cada campo en cada clase, no una instancia para cada forma en el diagrama.Cuando el usuario hace doble clic en una instancia, debe identificar qué instancia ha estado obtuvo, como el código del ejemplo muestra.

Para interceptar un clic en un elemento decorator de icono

Al Abrir o crear una solución de ADSL.
Elija o cree una forma con un elemento decorator de icono, y asignela a una clase de dominio.

En un archivo de código que es independiente de los archivos en la carpeta de GeneratedCode , cree la nueva subclase 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)
   { }
}

Debe establecer administrado en true si no desea que el evento que se va a pasar a la forma que contiene.

Invalide el método de InitializeShapeFields en los classs de forma agrega la definición de clase parcial siguiente.

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);
}

Compile y ejecute la solución.
Haga doble clic en el icono en una instancia de la forma.el mensaje de prueba debe aparecer.

La interceptación clics y arrastres en las listas de CompartmentShape

El ejemplo siguiente permite a los usuarios cambiar el orden de elementos en una forma de compartimiento arrastrándolos.Para ejecutar este código:

Cree una nueva solución ADSL mediante la plantilla de solución de diagramas de clases .

También puede ejecutar una solución de dispone que contiene formas de compartimiento.Este código supone que hay una relación de incrustación entre los elementos de modelo representados por la forma, y los elementos representados en los elementos de la lista de compartimiento.
Establezca la propiedad de genera derivado doble del compartimiento.
Agregue este código en un archivo del proyecto de Dsl .
Ajuste los nombres de clase y del dominio de este código para coincidir para ser ADSL.

en resumen, el código funciona como sigue.En este ejemplo, ClassShape es el nombre del compartimiento.

Hay un conjunto de controladores de eventos del mouse para cada instancia de compartimiento cuando se crea.
el evento de ClassShape.MouseDown almacena el elemento actual.
Cuando se mueve el mouse del elemento actual, una instancia de MouseAction se crea, que establece el cursor y captura el mouse hasta que se libere.

Para evitar interferir con otras acciones del mouse, como la selección de texto de un elemento, el MouseAction no se crea hasta que el mouse haya salido del elemento original.

Una alternativa a la creación de un MouseAction sería simplemente escuchar MouseUp.Sin embargo, esto no funcionaría correctamente si el usuario suelta el mouse después de arrastrarlo fuera del compartimiento.El MouseAction puede realizar la acción adecuada no importa dónde se suelte el mouse.
Cuando se publica el mouse, MouseAction.MouseUp reorganizar el orden de los vínculos entre los elementos de modelo.
El cambio de rol order desencadena una regla que actualiza la pantalla.este comportamiento es ya definido, y no se requiere ningún código adicional.

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;
  }
 }
}

Compartir a través de

Cómo: Interceptar un clic en una forma o decorador

Para interceptar hace clic en formas

Para interceptar haga clic en elementos decorator

Para interceptar un clic en un elemento decorator de icono

La interceptación clics y arrastres en las listas de CompartmentShape

Vea también

Referencia

Otros recursos

Recursos adicionales