Udostępnij za pośrednictwem

Porady: dodawanie obsługi przeciągania i upuszczania

  • Artykuł

Programy obsługi zdarzeń przeciągania i upuszczania można dodać do swojego DSL tak, aby użytkownicy mogą przeciągnij elementów diagramu z innych diagramów lub z innymi elementami Visual Studio.Można także dodać programów obsługi dla zdarzenia takie jak dwukrotnym kliknięciu.Razem, przeciągania i upuszczania, a następnie dwukrotnie kliknij programy obsługi są znane jako gestu obsługi.

W tym temacie opisano gesty przeciągania i upuszczania, które pochodzą na innych diagramów.W przypadku przenoszenia i kopiowania zdarzeń w obrębie jednego diagramu, należy wziąć pod uwagę alternatywne zdefiniowania podklasą klasy ElementOperations.Aby uzyskać więcej informacji, zobacz Dostosowywanie zachowania dotyczącego kopiowania.Można również dostosować definicji DSL.

W tym temacie:

  • Pierwsze dwie sekcje opisują alternatywne metody definiowania gest program obsługi:

    • Definiowanie gest obsługi przy użyciu metod zastępowanie ShapeElement.OnDragDrop, OnDoubleClick, OnDragOver, i inne metody może zostać zastąpiona.

    • Definiowanie gest obsługi przy użyciu MEF.Użyj tej metody, jeśli chcesz, aby deweloperom innych firm można definiować własne programy obsługi do swojego DSL.Użytkownicy mogą wybrać instalacji rozszerzeń innych firm zainstalowane swoje DSL.

  • Jak dekodowania przeciąganego elementu.Elementy mogą być przeciągnąć z dowolnego okna lub z pulpitu, a także z DSL.

  • Jak uzyskać oryginalny przeciągnąć element.Jeśli przeciąganego elementu jest elementem DSL, możesz otworzyć modelu źródłowego i dostęp do elementu.

  • Przy użyciu myszy: Przeciągając elementy przedziału.Ten przykład pokazuje niskiego poziomu programu obsługi, który przechwytuje akcje myszy na pola kształtu.Przykład użytkownicy będą mogli zmienić kolejność elementów w przedziale przeciągając myszą.

Definiowanie obsługi gest przez zastąpienie metody ShapeElement

Dodaj nowy plik kodu do projektu DSL.Program obsługi gest, zwykle mają co najmniej następujących using instrukcji:

using Microsoft.VisualStudio.Modeling;
using Microsoft.VisualStudio.Modeling.Diagrams;
using System.Linq;

W pliku należy zdefiniować klasę częściowe dla klasy diagramu lub kształtu, którą należy odpowiedzieć operacji przeciągania.Zastąp następujących metod:

  • OnDragOver— Ta metoda jest wywoływana, gdy wskaźnik myszy zostanie kształtu podczas operacji przeciągania.Metody, należy sprawdzić element, który jest przeciągając użytkownika i ustaw właściwość efekt, aby wskazać, czy użytkownika można upuścić element na ten kształt.Właściwość efekt określa wygląd kursora podczas jest powyżej tego kształtu, a także określa, czy OnDragDrop() będzie wywoływany, gdy użytkownik zwolni przycisk myszy.

    partial class MyShape // MyShape generated from DSL Definition.
{
    public override void OnDragOver(DiagramDragEventArgs e)
    {
      base.OnDragOver(e);
      if (e.Effect == System.Windows.Forms.DragDropEffects.None 
           && IsAcceptableDropItem(e)) // To be defined
      {
        e.Effect = System.Windows.Forms.DragDropEffects.Copy;
      }
    }

  • OnDragDrop— Ta metoda jest wywoływana, gdy użytkownik zwolni przycisk myszy podczas przesunie wskaźnik myszy na tego kształtu lub diagramu, jeśli OnDragOver(DiagramDragEventArgs e) wcześniej ustawiony e.Effect na wartość inną niż None.

    public override void OnDragDrop(DiagramDragEventArgs e)
    {
      if (!IsAcceptableDropItem(e))
      {
        base.OnDragDrop(e);
      }
      else 
      { // Process the dragged item, for example merging a copy into the diagram
        ProcessDragDropItem(e); // To be defined
      }  
    }

  • OnDoubleClick— Ta metoda jest wywoływana, gdy użytkownik kliknie dwukrotnie kształt lub diagramu.

    Aby uzyskać więcej informacji, zobacz Porady: przechwytywanie kliknięć w kształcie lub elemencie Decorator.

Definiowanie IsAcceptableDropItem(e) w celu ustalenia, czy jest akceptowany przeciąganego elementu i ProcessDragDropItem(e) aktualizacji modelu, gdy element jest usuwany.Te metody należy najpierw wyodrębniania element argumenty zdarzenia.Aby dowiedzieć się, jak to zrobić, zobacz jak odwołać do przeciąganego elementu.

Definiowanie gest obsługi przy użyciu MEF

MEF (zarządzane strukturę rozszerzalności) pozwala zdefiniować składniki, które można zainstalować przy użyciu minimalnego konfiguracji.Aby uzyskać więcej informacji, zobacz Oprogramowanie Managed Extensibility Framework (MEF).

Aby zdefiniować program obsługi gest MEF

  1. Dodaj do swojego Dsl i DslPackage projektów MefExtension plików, które są opisane w Rozszerzanie DSL za pomocą MEF.

  2. Program obsługi gest można zdefiniować jako składnik MEF:

      // This attribute is defined in the generated file
  // DslPackage\MefExtension\DesignerExtensionMetaDataAttribute.cs:
  [MyDslGestureExtension]
  public class MyGestureHandlerClassName : IGestureExtension
  {
    /// <summary>
    /// Called to determine whether a drag onto the diagram can be accepted.
    /// </summary>
    /// <param name="diagramDragEventArgs">Contains a link to the item that is being dragged</param>
    /// <param name="targetMergeElement">The shape or connector that the mouse is over</param>
    /// <returns>True if the item can be accepted on the targetMergeElement.</returns>
    public bool CanDragDrop(ShapeElement targetMergeElement, DiagramDragEventArgs diagramDragEventArgs)
    {
      MyShape target = targetMergeElement as MyShape;
      if (target == null) return false;
      if (target.IsAcceptableDropItem(diagramDragEventArgs)) return true; 
      return false;
    }
    public void OnDragDrop(ShapeElement targetDropElement, DiagramDragEventArgs diagramDragEventArgs)
    {
      MyShape target = targetMergeElement as MyShape;
      if (target == null || ! target.IsAcceptableDropItem(diagramDragEventArgs)) return;
      // Process the dragged item, for example merging a copy into the diagram:
      target.ProcessDragDropItem(diagramDragEventArgs);
   }

    Można utworzyć więcej niż jeden składnik obsługi gest, np. Jeśli używasz różnych typów przeciąganego obiektów.

  3. Dodaj definicje klas częściowe dla kształtu docelowego, łącznik lub diagramu klas, a także określać metody IsAcceptableDropItem() i ProcessDragDropItem().Te metody należy zacząć od wyodrębniania przeciąganego elementu z argumenty zdarzenia.Aby uzyskać więcej informacji, zobacz jak odwołać do przeciąganego elementu.

Jak dekodowania przeciąganego elementu

Jeśli użytkownik przeciągnie element na diagramie, lub z jednej części diagramu na inny, informacje o elemencie, który jest przeciąganie jest dostępna w DiagramDragEventArgs.Ponieważ może mieć rozpocząć operacji przeciągania na dowolny obiekt na ekranie, dane mogą być dostępne w jednym z różnych formatach.Kod musi rozpoznać formatów, z którymi jest możliwa postępowania.

Odnajdywanie formaty, w których informacje źródła przeciągania jest dostępna, uruchom kodu w tryb debugowania, ustawienia punktu przerwania w pozycji do OnDragOver() lub CanDragDrop().Sprawdź wartości DiagramDragEventArgs parametru.Informacje są dostarczane w dwóch formularzach:

  • IDataObject Data— Ta właściwość ma wersji serializacji obiektów źródła, zwykle w więcej niż jeden format.Działanie funkcji najbardziej przydatne są następujące:

    • diagramEventArgs.Data.GetDataFormats() — Wyświetla listę formatów, w których można zdekodować przeciąganego obiektu.Na przykład, jeśli użytkownik przeciąga pliku z pulpitu, dostępne formaty zawierać nazwy pliku ("FileNameW").

    • diagramEventArgs.Data.GetData(format)— Dekoduje przeciąganego obiektu w określonym formacie.Obiekt na odpowiedni typ rzutowania.Na przykład:

      string fileName = diagramEventArgs.Data.GetData("FileNameW") as string;

      Można również przesłać obiekty, takie jak odwołania magistrali modelu ze źródła w format niestandardowy.Aby uzyskać więcej informacji, zobacz sposób wysłania odwołania do modelu magistrali w przeciągania i upuszczania.

  • ElementGroupPrototypePrototype— Użyj tej właściwości, jeśli użytkownicy mają przenoszenia elementów z DSL lub modelu UML.Prototyp grupy element zawiera co najmniej jednego obiektu, łącza i ich wartości właściwości.Jest on również używany w operacje wklejania i podczas dodawania elementu z przybornika.W prototyp obiektów i ich typy są identyfikowane przez identyfikator Guid.Na przykład ten kod umożliwia użytkownikowi przeciągnij elementów klas z diagramów UML lub Eksploratora modelu UML:

    private bool IsAcceptableDropItem(DiagramDragEventArgs e)
{
  return e.Prototype != null && e.Prototype.RootProtoElements.Any(element => 
        element.DomainClassId.ToString() 
        == "3866d10c-cc4e-438b-b46f-bb24380e1678"); // Accept UML class shapes.
 // Or, from another DSL: SourceNamespace.SourceShapeClass.DomainClassId
}

    Aby zaakceptować kształtów UML, należy określić identyfikatory GUID klasy kształtów UML przez doświadczenia.Należy pamiętać, że jest zwykle więcej niż jeden typ elementu na dowolnym diagramu.Należy pamiętać, że obiekt przeciągnąć z diagramu DSL lub UML jest kształtu, nie elementu modelu.

DiagramDragEventArgszawiera także właściwości, które określają położenie bieżącego wskaźnika myszy, a określa, czy użytkownik jest naciskając klawisz CTRL, ALT lub klawisze SHIFT.

Jak uzyskać oryginalny przeciąganego elementu

Data i Prototype właściwości argumenty zdarzenia zawierają tylko odwołanie do przeciąganego kształtu.Zazwyczaj jeśli ma zostać utworzony obiekt w celu DSL, który jest tworzony na podstawie prototypu w jakiś sposób, należy do uzyskania dostępu do strony, na przykład odczytywania zawartości pliku lub przejściu do elementu modelu reprezentowany przez kształt.Program Visual Studio Model Bus umożliwia w tym pomóc.

Aby przygotować projekt DSL modelu magistrali

  • Wybierz źródło DSL dostępny za pomocą Visual Studio magistrali modelu:

    1. Pobierz i zainstaluj rozszerzenie Visual Studio Model Bus, jeśli nie zostało to już zrobione.Aby uzyskać więcej informacji, zobacz wizualizacji i modelowania SDK.

    2. Otwórz plik definicji DSL źródła DSL DSL Designer.Kliknij prawym przyciskiem myszy powierzchnię projektową, a następnie kliknij przycisk Włącz Modelbus.W oknie dialogowym Wybierz co najmniej jedną z opcji.Kliknij przycisk OK.Nowy projekt "ModelBus" zostanie dodany do rozwiązania DSL.

    3. Kliknij przycisk Transform wszystkie szablony i odbudowy rozwiązanie.

Aby wysłać obiekt ze źródła DSL

  • W podklasa ElementOperations użytkownika musi zostać zastąpiona w Copy() , aby go koduje odwołania magistrali modelu (MBR) w IDataObject.Ta metoda zostanie wywołana uruchomienia przeciągnij z diagramu źródła użytkownika.Zakodowany MBR następnie będzie ona dostępna w IDataObject, gdy użytkownik spada w docelowym diagramie.

    

using Microsoft.VisualStudio.Modeling;
using Microsoft.VisualStudio.Modeling.Shell;
using Microsoft.VisualStudio.Modeling.Diagrams;
using Microsoft.VisualStudio.Modeling.Integration;
using Microsoft.VisualStudio.Modeling.Integration.Shell;
using System.Drawing; // PointF
using  System.Collections.Generic; // ICollection
using System.Windows.Forms; // for IDataObject
...
public class MyElementOperations : DesignSurfaceElementOperations
{
    public override void Copy(System.Windows.Forms.IDataObject data, System.Collections.Generic.ICollection<ModelElement> elements, ClosureType closureType, System.Drawing.PointF sourcePosition)
    {
      base.Copy(data, elements, closureType, sourcePosition);

      // Get the ModelBus service:
      IModelBus modelBus =
          this.Store.GetService(typeof(SModelBus)) as IModelBus;
      DocData docData = ((VSDiagramView)this.Diagram.ActiveDiagramView).DocData;
      string modelFile = docData.FileName;
      // Get an adapterManager for the target DSL:
      ModelBusAdapterManager manager =
          (modelBus.FindAdapterManagers(modelFile).First());
      ModelBusReference modelReference = manager.CreateReference(modelFile);
      ModelBusReference elementReference = null;
      using (ModelBusAdapter adapter = modelBus.CreateAdapter(modelReference))
      {
        elementReference = adapter.GetElementReference(elements.First());
      }

      data.SetData("ModelBusReference", elementReference);
    }
...}

Do odbierania magistrali odwołanie modelu z DSL w projekcie docelowym DSL lub UML

  1. W projekcie DSL docelowym należy dodać odwołań do projektu:

    • Projekt Dsl źródła.

    • Projekt ModelBus źródła.

  2. W pliku kodu obsługi gest należy dodać następujące odwołania przestrzeń nazw:

    using Microsoft.VisualStudio.Modeling;
using Microsoft.VisualStudio.Modeling.ExtensionEnablement;
using Microsoft.VisualStudio.Modeling.Diagrams;
using Microsoft.VisualStudio.Modeling.Diagrams.ExtensionEnablement;
using Microsoft.VisualStudio.Modeling.Integration;
using SourceDslNamespace;
using SourceDslNamespace.ModelBusAdapters;

  3. Poniższy przykład przedstawia sposób uzyskiwania dostępu do elementu modelu źródła:

      partial class MyTargetShape // or diagram or connector 
  {
    internal void ProcessDragDropItem(DiagramDragEventArgs diagramDragEventArgs)
    {
      // Verify that we're being passed an Object Shape.
      ElementGroupPrototype prototype = diagramDragEventArgs.Prototype;
      if (prototype == null) return;
      if (Company.InstanceDiagrams.ObjectShape.DomainClassId
        != prototype.RootProtoElements.First().DomainClassId)
        return;
      // - This is an ObjectShape.
      // - We need to access the originating Store, find the shape, and get its object.

      IModelBus modelBus = targetDropElement.Store.GetService(typeof(SModelBus)) as IModelBus;

      // Unpack the MBR that was packed in Copy:
      ModelBusReference reference = diagramDragEventArgs.Data.GetData("ModelBusReference") as ModelBusReference;
      using (SourceDslAdapter adapter = modelBus.CreateAdapter(reference) as SourceDslAdapter)
      {
        using (ILinkedUndoTransaction t = LinkedUndoContext.BeginTransaction("doing things"))
        {
          // Quickest way to get the shape from the MBR:
          ObjectShape firstShape = adapter.ResolveElementReference<ObjectShape>(reference);

          // But actually there might be several shapes - so get them from the prototype instead:
          IElementDirectory remoteDirectory = adapter.Store.ElementDirectory;
          foreach (Guid shapeGuid in prototype.SourceRootElementIds)
          {
            PresentationElement pe = remoteDirectory.FindElement(shapeGuid) as PresentationElement;
            if (pe == null) continue;
            SourceElement instance = pe.ModelElement as SourceElement;
            if (instance == null) continue;

            // Do something with the object:
        instance...
          }
          t.Commit();
        }
      }
  }

Aby zaakceptować element pochodzących z modelu UML

  • Poniższy przykładowy kod akceptuje obiektu z diagramu UML.

      using Microsoft.VisualStudio.ArchitectureTools.Extensibility;
  using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml;
  using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Presentation;
  using Microsoft.VisualStudio.Modeling;
  using Microsoft.VisualStudio.Modeling.Diagrams;
  using Microsoft.VisualStudio.Modeling.Diagrams.ExtensionEnablement;
  using Microsoft.VisualStudio.Uml.Classes;
  using System;
  using System.ComponentModel.Composition;
  using System.Linq;
...
partial class TargetShape
{
  internal void ProcessDragDropItem(DiagramDragEventArgs diagramDragEventArgs)
  {
        EnvDTE.DTE dte = this.Store.GetService(typeof(EnvDTE.DTE)) as EnvDTE.DTE;
        // Find the UML project
        foreach (EnvDTE.Project project in dte.Solution.Projects)
        {
          IModelingProject modelingProject = project as IModelingProject;
          if (modelingProject == null) continue; // not a modeling project
          IModelStore store = modelingProject.Store;
          if (store == null) return;

          foreach (IDiagram dd in store.Diagrams())
          {
              // Get Modeling.Diagram that implements UML.IDiagram:
              Diagram diagram = dd.GetObject<Diagram>(); 

              foreach (Guid elementId in e.Prototype.SourceRootElementIds)
              {
                ShapeElement shape = diagram.Partition.ElementDirectory.FindElement(elementId) as ShapeElement;
                if (shape == null) continue;
                // This example assumes the shape is a UML class:
                IClass classElement = shape.ModelElement as IClass;
                if (classElement == null) continue;

                // Now do something with the UML class element ...
              }
        }
      break; // don't try any more projects 
}  }  }

Przy użyciu myszy: Przeciągając elementy przedziału

Można napisać program obsługi, który przechwytuje akcje myszy w polach kształtu.Poniższy przykład użytkownicy będą mogli zmienić kolejność elementów w przedziale przeciągając myszą.

Do tworzenia w tym przykładzie, należy utworzyć rozwiązanie przy użyciu diagramy klas rozwiązanie szablonu.Dodanie pliku kodu i Dodaj następujący kod.Dostosuj przestrzeń nazw być taki sam jak własny.

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  // EDIT.
{
 /// <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. Yuk.
  /// </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;
  }
 }
}

Zobacz też

Koncepcje

Dostosowywanie zachowania dotyczącego kopiowania

Wdrażanie rozwiązań dla języka specyficznego dla domeny