Aracılığıyla paylaş

Sürükle ve Bırak İşleyicisi Ekleme

Kullanıcıların diğer diyagramlardan veya Visual Studio'nun diğer bölümlerinden diyagramınıza öğe sürükleyebilmesi için DSL'nize sürükleyip bırakma olayları için işleyiciler ekleyebilirsiniz. Çift tıklama gibi olaylar için işleyiciler de ekleyebilirsiniz. Sürükle ve bırak ve çift tıklama işleyicileri birlikte hareket işleyicileri olarak bilinir.

Bu konu başlığında, diğer diyagramlardan kaynaklanan sürükle ve bırak hareketleri açıklanmaktadır. Olayları tek bir diyagramda taşımak ve kopyalamak için alt sınıfını tanımlama alternatifini ElementOperationsgöz önünde bulundurun. Daha fazla bilgi için bkz . Kopyalama Davranışını Özelleştirme. DSL tanımını da özelleştirebilirsiniz.

ShapeElement Yöntemlerini Geçersiz Kılarak Hareket İşleyicilerini Tanımlama

OnDragDrop, OnDoubleClick, OnDragOverve diğer yöntemler geçersiz kılınabilir.

DSL projenize yeni bir kod dosyası ekleyin. Bir hareket işleyicisi için genellikle en azından aşağıdaki using yönergeleriniz olmalıdır:

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

Yeni dosyada, şekil veya diyagram sınıfı için sürükleme işlemine yanıt vermesi gereken kısmi bir sınıf tanımlayın. Aşağıdaki yöntemleri geçersiz kılın:

  • OnDragOver- Bu yöntem, fare işaretçisi sürükleme işlemi sırasında şekle girdiğinde çağrılır. Yönteminiz kullanıcının sürüklediği öğeyi incelemeli ve kullanıcının öğeyi bu şekle bırakıp bırakamayacağını belirtmek için Effect özelliğini ayarlamalıdır. Efekt özelliği, imlecin bu şeklin üzerindeyken görünümünü belirler ve ayrıca kullanıcı fare düğmesini serbest bıraktığında çağrılıp çağrılmayacağını OnDragDrop() belirler.

    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- Kullanıcı fare düğmesini serbest bırakırken fare işaretçisi bu şeklin veya diyagramın üzerinde kalırsa, daha önce dışında Nonebir değere ayarlanmışsa OnDragOver(DiagramDragEventArgs e) e.Effect bu yöntem çağrılır.

    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 - Kullanıcı şekle veya diyagrama çift tıkladığında bu yöntem çağrılır.

    Daha fazla bilgi için bkz . Nasıl yapılır: Bir Şekle veya Dekoratöre Tıklamayı Kesme.

Sürüklenen öğenin kabul edilebilir olup olmadığını belirlemek için tanımlayın IsAcceptableDropItem(e) ve öğe bırakıldığında modelinizi güncelleştirmek için ProcessDragDropItem(e). Bu yöntemlerin önce öğeyi olay bağımsız değişkenlerinden ayıklaması gerekir. Bunun nasıl yapılacağını öğrenmek için bkz . Sürüklenen öğeye başvuru alma.

MEF kullanarak Hareket İşleyicileri Tanımlama

Üçüncü taraf geliştiricilerin DSL'nize kendi işleyicilerini tanımlayabilmesini istiyorsanız bu yöntemi kullanın. Kullanıcılar DSL'nizi yükledikten sonra üçüncü taraf uzantılarını yüklemeyi seçebilir.

MEF (Yönetilen Genişletilebilirlik Çerçevesi), en az yapılandırmayla yüklenebilen bileşenleri tanımlamanızı sağlar. Daha fazla bilgi için bkz . Yönetilen Genişletilebilirlik Çerçevesi (MEF).

MEF hareket işleyicisi tanımlamak için

  1. DSL ve DslPackage projelerinize MEF kullanarak DSL'nizi genişletme bölümünde açıklanan MefExtension dosyalarını ekleyin.

  2. Artık bir hareket işleyicisini MEF bileşeni olarak tanımlayabilirsiniz:

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

    Sürüklenen nesne türleriniz farklı olduğunda olduğu gibi birden fazla hareket işleyici bileşeni oluşturabilirsiniz.

  3. Hedef şekil, bağlayıcı veya diyagram sınıfları için kısmi sınıf tanımları ekleyin ve ve ProcessDragDropItem()yöntemlerini IsAcceptableDropItem() tanımlayın. Bu yöntemler, sürüklenen öğeyi olay bağımsız değişkenlerinden ayıklayarak başlamalıdır. Daha fazla bilgi için bkz . Sürüklenen öğeye başvuru alma.

Sürüklenen öğenin kodunu çözme

Öğeler herhangi bir pencereden veya masaüstünden ve dsl'den sürüklenebilir.

Kullanıcı diyagramınıza veya diyagramınızın bir bölümünden diğerine bir öğe sürüklediğinde, sürüklenen öğe hakkındaki bilgiler içinde DiagramDragEventArgskullanılabilir. Sürükleme işlemi ekrandaki herhangi bir nesnede başlamış olabileceğinden, veriler çeşitli biçimlerden herhangi birinde kullanılabilir. Kodunuz, işlem yapabilecek biçimlerini tanımalıdır.

Sürükleme kaynağı bilgilerinizin kullanılabildiği biçimleri bulmak için kodunuzu hata ayıklama modunda çalıştırın ve veya girişinde OnDragOver() CanDragDrop()bir kesme noktası ayarlayın. parametresinin DiagramDragEventArgs değerlerini inceleyin. Bilgiler iki biçimde sağlanır:

  • IDataObject Data - Bu özellik, genellikle birden fazla biçimde, kaynak nesnelerin serileştirilmiş sürümlerini taşır. En kullanışlı işlevleri şunlardır:

    • diagramEventArgs.Data.GetDataFormats() - Sürüklenen nesnenin kodunu çözebileceğiniz biçimleri listeler. Örneğin, kullanıcı masaüstünden bir dosya sürüklerse, kullanılabilir biçimler dosya adını ("FileNameW") içerir.

    • diagramEventArgs.Data.GetData(format) - Sürüklenen nesnenin kodunu belirtilen biçimde çözer. Nesneyi uygun türe dönüştürebilirsiniz. Örneğin:

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

      Ayrıca, kaynaktan model veri yolu başvuruları gibi nesneleri kendi özel biçiminizde iletebilirsiniz. Daha fazla bilgi için bkz . Sürükle ve Bırak ile Model Veri Yolu Başvuruları Gönderme.

  • ElementGroupPrototypePrototype - Kullanıcıların DSL veya UML modelinden öğe sürüklemesini istiyorsanız bu özelliği kullanın. Öğe grubu prototipi bir veya daha fazla nesne, bağlantı ve bunların özellik değerlerini içerir. Ayrıca, yapıştırma işlemlerinde ve araç kutusundan bir öğe eklerken de kullanılır. Bir prototipte nesneler ve türleri Guid tarafından tanımlanır. Örneğin, bu kod kullanıcının sınıf öğelerini BIR UML diyagramından veya UML Model Gezgini'nden sürüklemesine olanak tanır:

    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
}

    UML şekillerini kabul etmek için, denemeye göre UML şekil sınıflarının GUID'lerini belirleyin. Herhangi bir diyagramda genellikle birden fazla öğe türü olduğunu unutmayın. Dsl veya UML diyagramından sürüklenen bir nesnenin model öğesi değil şekil olduğunu da unutmayın.

DiagramDragEventArgs ayrıca geçerli fare işaretçisinin konumunu ve kullanıcının CTRL, ALT veya SHIFT tuşlarına basıp basmadığını gösteren özelliklere sahiptir.

Sürüklenen öğenin orijinalini alma

Sürüklenen öğe bir DSL öğesiyse, kaynak modeli açabilir ve öğesine erişebilirsiniz.

Data Olay bağımsız değişkenlerinin ve Prototype özellikleri yalnızca sürüklenen şekle başvuru içerir. Genellikle hedef DSL'de bir şekilde prototipten türetilmiş bir nesne oluşturmak istiyorsanız, örneğin dosya içeriğini okuma veya bir şeklin temsil ettiği model öğesine gitmek gibi özgün nesneye erişim elde etmeniz gerekir. Bu konuda yardımcı olması için Visual Studio Model Bus'ı kullanabilirsiniz.

Model Veri Yolu için DSL projesi hazırlamak için

Kaynak DSL'yi Visual Studio Model Veri Yolu ile erişilebilir hale getirin:

  1. Kaynak DSL'nin DSL tanım dosyasını DSL Tasarımcısı'nda açın. Tasarım yüzeyine sağ tıklayın ve ardından Modelbus'ı Etkinleştir'e tıklayın. İletişim kutusunda seçeneklerden birini veya ikisini birden seçin. Tamam'a tıklayın. DSL çözümüne yeni bir "ModelBus" projesi eklenir.

  2. Tüm Şablonları Dönüştür'e tıklayın ve çözümü yeniden oluşturun.

Bir nesneyi kaynak DSL'den göndermek için

  1. ElementOperations alt sınıfınızda, IDataObject içine bir Model Veri Yolu Başvurusu (MBR) kodlaması için geçersiz kılın Copy() . Kullanıcı kaynak diyagramdan sürüklemeye başladığında bu yöntem çağrılır. Kodlanmış MBR, kullanıcı hedef diyagrama düştüğünde IDataObject içinde kullanılabilir.

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

Hedef DSL veya UML projesindeki bir DSL'den Model Veri Yolu Başvurusu almak için

  1. Hedef DSL projesine proje başvuruları ekleyin:

    • Kaynak Dsl projesi.

    • Kaynak ModelBus projesi.

  2. Hareket işleyicisi kod dosyasına aşağıdaki ad alanı başvurularını ekleyin:

    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. Aşağıdaki örnek, kaynak model öğesine nasıl erişim elde etmek için gösterilmektedir:

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

UML modelinden alınan bir öğeyi kabul etmek için

  • Aşağıdaki kod örneği UML diyagramından bırakılan bir nesneyi kabul eder.

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

Fare Eylemlerini Kullanma: Bölme Öğelerini Sürükleme

Şeklin alanlarında fare eylemlerini kesen bir işleyici yazabilirsiniz. Aşağıdaki örnek, kullanıcının fareyle sürükleyerek bölmedeki öğeleri yeniden sıralamasını sağlar.

Bu örneği oluşturmak için Sınıf Diyagramları çözüm şablonunu kullanarak bir çözüm oluşturun. Bir kod dosyası ekleyin ve aşağıdaki kodu ekleyin. Ad alanını kendi ad alanınızla aynı olacak şekilde ayarlayın.

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

İlgili içerik

Not

Metin Şablonu Dönüştürme bileşeni, Visual Studio uzantısı geliştirme iş yükünün bir parçası olarak otomatik olarak yüklenir. Ayrıca Visual Studio Yükleyicisi Tek tek bileşenler sekmesinden SDK'lar, kitaplıklar ve çerçeveler kategorisinin altından da yükleyebilirsiniz. Tek tek bileşenler sekmesinden Modelleme SDK'sı bileşenini yükleyin.

  • Last updated on