Jak: Definiowanie obsługi gest na diagramie modelowania

W Visual Studio Ultimate można zdefiniować poleceń, które są wykonywane, gdy użytkownik kliknie dwukrotnie lub przeciągane elementy na diagramie UML.Można spakować tych rozszerzeń w Visual Studio Integration rozszerzenie (VSIX) i przesyła je do innych użytkowników programu Visual Studio Ultimate.

Jeśli istnieje już wbudowane zachowanie typ diagramu, a następnie wpisz element, który chcesz przeciągnąć, nie można dodać do lub zastąpić to zachowanie.

Wymagania

• Visual Studio SDK, który można otrzymać od Galerii Visual Studio.

• Visual Studio wizualizacji i modelowania SDK, który można uzyskać z Visual Studio wizualizacji i modelowania zestawu SDK w galerii kodów.

Tworzenie Obsługa gestu

Aby definiuje obsługi gestu dla projektanta UML, należy utworzyć klasę, która definiuje zachowanie obsługi gestu i osadzić w Visual Studio Integration rozszerzenie (VSIX) tej klasy.VSIX działa jako kontener, który można zainstalować program obsługi.Istnieją dwie alternatywne metody definiowania Obsługa gestu:

• Utwórz program obsługi gestu w własnej VSIX przy użyciu szablonu projektu. Jest to metoda szybsza.Użyj go, jeśli nie chcesz się połączyć nasza procedura obsługi z innymi rodzajami rozszerzeniem na przykład rozszerzenia sprawdzania poprawności, elementy do przybornika niestandardowych lub polecenia menu.

• Tworzenie oddzielnych gest obsługi i projekty VSIX. Metoda ta jest używana, jeśli chcesz połączyć kilka rodzajów rozszerzenie w tym samym VSIX.Na przykład jeśli program obsługi gest oczekuje modelu do przestrzegania szczególnych ograniczeń, może go osadzić w tym samym VSIX jako metoda sprawdzania poprawności.

Aby utworzyć Obsługa gestu w własnej VSIX

1. W Nowy projekt dialogowe, pod Modelowanie projektów, wybierz Rozszerzenie w przypadku gestu odpowiadającego.

2. Otwórz .cs plik w nowym projekcie i zmodyfikować GestureExtension klasy implementującej nasza procedura obsługi gestu.

   Aby uzyskać więcej informacji, zobacz Implementowanie obsługi w przypadku gestu odpowiadającego.

3. Przetestuj program obsługi gest naciskając klawisz F5.Aby uzyskać więcej informacji, zobacz wykonywanie programu obsługi w przypadku gestu odpowiadającego.

4. Zainstaluj program obsługi gest na innym komputerze przez skopiowanie pliku bin\*\*.vsix wbudowane w danym projekcie.Aby uzyskać więcej informacji, zobacz Instalowanie obsługi w przypadku gestu odpowiadającego.

W tym miejscu jest alternatywna procedura:

Aby utworzyć projekt osobnej klasy biblioteki (DLL) dla programu obsługi gest

1. Tworzenie projektu biblioteki klas, albo w nowym Visual Studio roztwór, lub w istniejącego rozwiązania.

   1. Na pliku menu, wybierz polecenie New, Projekt.

   2. W obszarze Szablonów, rozwiń węzeł Visual C# lub języka Visual Basic, następnie w środkowej kolumnie Wybierz Biblioteka klas.

2. Dodaj następujące odwołania do projektu.

   Microsoft.VisualStudio.Modeling.Sdk.11.0

   Microsoft.VisualStudio.Modeling.Sdk.Diagrams.11.0

   Microsoft.VisualStudio.ArchitectureTools.Extensibility

   Microsoft.VisualStudio.Uml.Interfaces

   System.ComponentModel.Composition

   System.Windows.Forms

   Microsoft.VisualStudio.ArchitectureTools.Extensibility.Layer-Należy to tylko wtedy, gdy jest kolejnym krokiem diagramy warstwy.Aby uzyskać więcej informacji, zobacz Rozszerzanie diagramy warstwy.

3. Dodaj plik klasy do projektu i ustaw jej zawartość na następujący kod.

   [!UWAGA]

   Zmień nazwę obszaru nazw i klasy zgodnie z preferencjami.

   using System.ComponentModel.Composition;
   using System.Linq;
   using System.Collections.Generic;
   using Microsoft.VisualStudio.Modeling.Diagrams;
   using Microsoft.VisualStudio.Modeling.Diagrams.ExtensionEnablement;
   using Microsoft.VisualStudio.Modeling.ExtensionEnablement;
   using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml;
   using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Presentation;
   using Microsoft.VisualStudio.Uml.AuxiliaryConstructs;
   using Microsoft.VisualStudio.Modeling;
   using Microsoft.VisualStudio.Uml.Classes;
   // ADD other UML namespaces if required
   
   namespace MyGestureHandler // CHANGE
   {
     // DELETE any of these attributes if the handler
     // should not work with some types of diagram.
     [ClassDesignerExtension]
     [ActivityDesignerExtension]
     [ComponentDesignerExtension]
     [SequenceDesignerExtension]
     [UseCaseDesignerExtension]
     // [LayerDesignerExtension]
   
     // Gesture handlers must export IGestureExtension:
     [Export(typeof(IGestureExtension))]
     // CHANGE class name
     public class MyGesture1 : IGestureExtension
     {
       [Import]
       public IDiagramContext DiagramContext { get; set; }
   
       /// <summary>
       /// Called when the user double-clicks on the diagram
       /// </summary>
       /// <param name="targetElement"></param>
       /// <param name="diagramPointEventArgs"></param>
       public void OnDoubleClick(ShapeElement targetElement, DiagramPointEventArgs diagramPointEventArgs)
       {
         // CHANGE THIS CODE FOR YOUR APPLICATION.
   
         // Get the target shape, if any. Null if the target is the diagram.
         IShape targetIShape = targetElement.CreateIShape();
   
         // Do something...
       }
   
       /// <summary>
       /// Called repeatedly when the user drags from anywhere on the screen.
       /// Return value should indicate whether a drop here is allowed.
       /// </summary>
       /// <param name="targetMergeElement">References the element to be dropped on.</param>
       /// <param name="diagramDragEventArgs">References the element to be dropped.</param>
       /// <returns></returns>
       public bool CanDragDrop(ShapeElement targetMergeElement, DiagramDragEventArgs diagramDragEventArgs)
       {
         // CHANGE THIS CODE FOR YOUR APPLICATION.
   
         // Get the target element, if any. Null if the target is the diagram.
         IShape targetIShape = targetMergeElement.CreateIShape();
   
         // This example allows drag of any UML elements.
         return GetModelElementsFromDragEvent(diagramDragEventArgs).Count() > 0;
       }
   
   
       /// <summary>
       /// Execute the action to be performed on the drop.
       /// </summary>
       /// <param name="targetDropElement"></param>
       /// <param name="diagramDragEventArgs"></param>
       public void OnDragDrop(ShapeElement targetDropElement, DiagramDragEventArgs diagramDragEventArgs)
       {
         // CHANGE THIS CODE FOR YOUR APPLICATION.
       }
   
       /// <summary>
       /// Retrieves UML IElements from drag arguments.
       /// Works for drags from UML diagrams.
       /// </summary>
       private IEnumerable<IElement> GetModelElementsFromDragEvent
               (DiagramDragEventArgs dragEvent)
       {
         //ElementGroupPrototype is the container for
         //dragged and copied elements and toolbox items.
         ElementGroupPrototype prototype =
            dragEvent.Data.
            GetData(typeof(ElementGroupPrototype))
                 as ElementGroupPrototype;
         // Locate the originals in the implementation store.
         IElementDirectory implementationDirectory =
            dragEvent.DiagramClientView.Diagram.Store.ElementDirectory;
   
         return prototype.ProtoElements.Select(
           prototypeElement =>
           {
             ModelElement element = implementationDirectory
               .FindElement(prototypeElement.ElementId);
             ShapeElement shapeElement = element as ShapeElement;
             if (shapeElement != null)
             {
               // Dragged from a diagram.
               return shapeElement.ModelElement as IElement;
             }
             else
             {
               // Dragged from UML Model Explorer.
               return element as IElement;
             }
           });
       }
   
     }
   }
   

   Aby uzyskać więcej informacji na temat czynności umieścić w metodach, zobacz Implementowanie obsługi w przypadku gestu odpowiadającego.

Polecenia menu należy dodać do projektu VSIX, który działa jako kontener dla polecenia instalowania.Jeśli chcesz, może zawierać inne składniki, w tym samym VSIX.

Aby dodać program obsługi oddzielnych gestu do projektu VSIX

1. Nie musisz tej procedury po utworzeniu obsługi gest z własnym VSIX.

2. Utwórz projekt VSIX, chyba że rozwiązania już jest jeden.

   1. W Solution Explorer, w menu skrótów w roztworze wybrać Dodaj, Nowego projektu.

   2. W obszarze Szablonów, rozwiń węzeł Visual C# lub programu Visual Basic, a następnie wybierz rozszerzalności.W środkowej kolumnie Wybierz Projektu VSIX.

3. Ustawić projektu VSIX jako projekt uruchamiania roztworu.

   • W oknie Solution Explorer, w menu skrótów projektu VSIX wybrać jako projekt uruchamiania.

4. W source.extension.vsixmanifest, dodać projektu biblioteki klas obsługi gestu jako składnik MEF:

   1. Na metadanych kartę, należy ustawić nazwę VSIX.

   2. Na Zainstalować obiekty docelowe kartę, należy ustawić Visual Studio Ultimate i premii jako cele.

   3. Na aktywów tab, wybrać Newi w oknie dialogowym Ustaw:

      Typ = składnik MEF

      Źródło = projektu w bieżącym rozwiązaniu

      Projekt = projektu biblioteki klas

Wykonywanie programu obsługi gest

Do testów należy wykonać program obsługi w przypadku gestu odpowiadającego w trybie debugowania.

Aby przetestować program obsługi gest

1. Naciśnij F5, lub na program Debug: polecenie menu, kliknij przycisk Start Debugging.

   Wystąpienie doświadczalnych Visual Studio rozpoczyna się.

   Rozwiązywanie problemów z: Jeśli nowy Visual Studio nie można uruchomić:

   • Jeśli masz więcej niż jeden projekt, upewnij się, że projekt VSIX jest ustawiony na projekt uruchamiania roztworu.

   • W oknie Solution Explorer uruchamiania lub tylko projektu, w menu skrótów wybierz polecenie Właściwości.W oknie edytora właściwości projektu, wybierz polecenie program Debug: polecenie kartę.Upewnij się, że ciąg w Start zewnętrzny program pole jest pełną ścieżką dostępu Visual Studio, zazwyczaj:

     C:\Program Files\Microsoft Visual Studio 11.0\Common7\IDE\devenv.exe

2. Danych eksperymentalnych Visual Studio, otwórz lub Utwórz projekt modelowania i Otwórz lub Utwórz diagram modelowania.Diagram, który należy do jednego z typów wymienionych na liście atrybuty klasy programu obsługi w przypadku gestu odpowiadającego służy.

3. Kliknij dwukrotnie dowolne miejsce na diagramie.Powinna zostać wywołana nasza procedura obsługi dwukrotnego kliknięcia.

4. Przeciągnij element z Eksploratora UML na diagram.Nasza procedura obsługi przeciągania powinna zostać wywołana.

Rozwiązywanie problemów z: Jeśli program obsługi gest nie działa, upewnij się, że:

• Projekt programu obsługi gest jest wymieniony jako składnik MEF w aktywów kartę w source.extensions.manifest w projekcie VSIX.

• Parametry wszystkich Import i Export atrybuty są prawidłowe.

• CanDragDrop Metoda nie jest powrót false.

• Typ modelu diagramu używasz (UML klasy, sekwencja i tak dalej) jest wymieniony jako jeden z gestu obsługi klasy atrybuty [ClassDesignerExtension] [SequenceDesignerExtension] i tak dalej.

• Nie ma żadnych wbudowaną funkcję już zdefiniowane dla tego typu urządzenia docelowego oraz element elementów usuniętych.

Implementowanie obsługi gest

Metody obsługi gest

Klasy obsługi gest implementuje i eksportuje IGestureExtension.Dostępne są następujące metody, którą należy zdefiniować:

bool CanDragDrop (ShapeElement target, DiagramDragEventArgs dragEvent)	Zwraca true zezwalająca na element źródła, do których odwołuje się dragEvent ma być przerwane na ten cel. Ta metoda nie należy wprowadzać zmian do modelu.Powinno działać szybko, ponieważ jest używany do określania stanu strzałkę przesuniesz mysz.
void OnDragDrop (ShapeElement target, DiagramDragEventArgs dragEvent)	Zaktualizować model, w oparciu o obiekt źródłowy, do którego odwołuje się dragEventi miejsce docelowe. Wywoływane, gdy użytkownik zwolni przycisk myszy po przeciągnięciu.
void OnDoubleClick (ShapeElement target, DiagramPointEventArgs pointEvent)	targetjest kształtem, który użytkownik kliknięty dwukrotnie.

Można pisać programy obsługi, które mogą akceptować UML nie tylko również cały szereg innych elementów, takich jak pliki, węzły w widoku klasy .NET, węzły w Eksploratorze architektury i tak dalej.Użytkownika można przeciągnąć te elementy na diagramie UML, pod warunkiem, że piszesz OnDragDrop metodę, która może dekodować serializowane formą elementy.Dekodowanie metody różnią się od elementy jednego typu do drugiego.

Parametry te metody są:

• ShapeElement target.Kształt lub diagramu, na którym użytkownik ma holowanych coś.

  ShapeElementjest klasy w celu wykonania, który jest podstawą notacji UML narzędzia do modelowania.Aby zmniejszyć ryzyko wprowadzenia modelu UML i diagramów w niespójnym stanie, zaleca się, że nie używasz metody tej klasy bezpośrednio.Zamiast tego owinąć elementu w IShape, a następnie użyj metodami opisanymi w Jak: wyświetlanie modelu na diagramach.

  • Aby uzyskać IShape:

    IShape targetIShape = target.CreateIShape(target);
    

  • Aby uzyskać elementu modelu, który jest określony przez przeciąganie lub dwukrotnie kliknij operację:

    IElement target = targetIShape.Element;
    

    Można rzutować to do bardziej określonego typu elementu.

  • Aby uzyskać magazyn modelu UML, zawierający modelu UML:

    IModelStore modelStore = 
      targetIShape.Element.GetModelStore(); 
    

  • Aby uzyskać dostęp do hosta i usługodawca:

    target.Store.GetService(typeof(EnvDTE.DTE)) as EnvDTE.DTE
    

• DiagramDragEventArgs eventArgs.Ten parametr niesie ze sobą formularzu szeregowany obiekt źródłowy operacji przeciągania:

  System.Windows.Forms.IDataObject data = eventArgs.Data;  
  

  Można przeciągnąć elementy różnego rodzaju na diagramie z różnych części Visual Studio, lub z pulpitu systemu Windows.Różne rodzaje elementu są zakodowane w różny sposób w IDataObject.Aby wyodrębnić elementy z niego, zajrzyj do dokumentacji dla odpowiedni typ obiektu.

  Jeśli obiekt źródłowy jest element UML przeciągnięte z Eksploratora modelu UML lub z innego diagramu UML, odnoszą się do Jak: pobieranie elementów modelu UML z IDataObject.

Pisanie kodu metody

Aby uzyskać więcej informacji na temat pisania kodu do odczytywania i zaktualizować model, zobacz Programowanie przy użyciu interfejsu API UML.

Aby uzyskać informacje na temat dostępu do informacji o modelu w operacji przeciągania, zobacz Jak: pobieranie elementów modelu UML z IDataObject.

Jeśli mamy do czynienia z diagramu sekwencji, zobacz też Jak: Edycja diagramy sekwencji za pomocą interfejsu API UML.

Oprócz parametrów metod można również zadeklarować przywożonego majątku w swojej klasy, która zapewnia dostęp do bieżącego diagramu i modelu.

[Import] public IDiagramContext DiagramContext { get; set; }

Deklaracja IDiagramContext pozwala na pisanie kodu w Twoje metody, które uzyskuje dostęp do diagramu, bieżące zaznaczenie i modelu:

IDiagram diagram = this.DiagramContext.CurrentDiagram;
foreach (IShape<IElement> shape in diagram.GetSelectedShapes<IElement>)
{ IElement element = shape.Element; ... }
IModelStore modelStore = diagram.ModelStore;
IModel model = modelStore.Root;
foreach (IDiagram diagram in modelStore.Diagrams) {...}
foreach (IElement element in modelStore.AllInstances<IUseCase>) {...}

Aby uzyskać więcej informacji, zobacz Jak: Przejdź do modelu UML.

Instalowanie i odinstalowywanie rozszerzenia

Można zainstalować Visual Studio rozszerzenie zarówno na komputerze użytkownika, jak i na innych komputerach.

Aby zainstalować rozszerzenie

1. W komputerze, należy znaleźć .vsix pliku, który został zbudowany w danym projekcie VSIX.

   1. W Solution Explorer, w menu skrótów w projekcie VSIX wybrać Otwórz Folder w Eksploratorze Windows.

   2. Zlokalizuj plik bin\*\YourProject.vsix

2. Kopiuj .vsix pliku do komputera docelowego, na którym chcesz zainstalować rozszerzenie.Może to być komputer, albo inną.

   Na komputerze docelowym musi mieć jedną z wersji Visual Studio określona w source.extension.vsixmanifest.

3. Na komputerze docelowym otwórz .vsix pliku.

   Instalator rozszerzenia usługi Visual Studio zostanie otwarty i instaluje rozszerzenia.

4. Uruchom lub ponownie uruchom Visual Studio.

Aby odinstalować rozszerzenie

1. Na Narzędzia menu, wybierz polecenie Extension Manager.

2. Rozwiń węzeł zainstalowanych rozszerzeń.

3. Zaznacz rozszerzenie, a następnie wybierz Odinstaluj.

Rzadko wadliwe rozszerzenia nie ładuje się i tworzy raport w oknie błędów, ale nie pojawia się w Menedżerze rozszerzeń.W takim przypadku można usunąć rozszerzenie, usuwając plik z:

% LocalAppData %\Local\Microsoft\VisualStudio\11.0\Extensions

Przykład

Poniżej pokazano sposób tworzenia życia w diagramie sekwencji, na podstawie części i porty składnika przeciągnięte z diagramu składników.

Aby przetestować go, naciśnij klawisz F5.Otwiera doświadczalnych wystąpienie programu Visual Studio.W tym wypadku Otwórz UML model i utworzyć składnik na diagramie składników.Niektóre interfejsy i wewnętrznej części zamiennych, należy dodać do tego składnika.Wybierz interfejsy i części.Następnie przeciągnij interfejsów i części na diagramie sekwencji.(Przeciągnij z diagram składników do kartę diagram sekwencji, a następnie co do diagramu sekwencji.) Kształt linia życia pojawi się dla poszczególnych interfejsów i części.

Aby uzyskać więcej informacji o interakcjach wiązania do diagramy sekwencji, zobacz Jak: Edycja diagramy sekwencji za pomocą interfejsu API UML.

using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.Linq;
using Microsoft.VisualStudio.Modeling;
using Microsoft.VisualStudio.Modeling.Diagrams;
using Microsoft.VisualStudio.Modeling.Diagrams.ExtensionEnablement;
using Microsoft.VisualStudio.Modeling.ExtensionEnablement;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Presentation;
using Microsoft.VisualStudio.Uml.AuxiliaryConstructs;
using Microsoft.VisualStudio.Uml.Classes;
using Microsoft.VisualStudio.Uml.Interactions;
using Microsoft.VisualStudio.Uml.CompositeStructures;
using Microsoft.VisualStudio.Uml.Components;

/// <summary>
/// Creates lifelines from component ports and parts.
/// </summary>
[Export(typeof(IGestureExtension))]
[SequenceDesignerExtension]
public class CreateLifelinesFromComponentParts : IGestureExtension
{
  [Import]
  public IDiagramContext Context { get; set; }

  /// <summary>
  /// Called by the modeling framework when
  /// the user drops something on a target.
  /// </summary>
  /// <param name="target">The target shape or diagram </param>
  /// <param name="dragEvent">The item being dragged</param>
  public void OnDragDrop(ShapeElement target,
           DiagramDragEventArgs dragEvent)
  {
    ISequenceDiagram diagram = Context.CurrentDiagram
            as ISequenceDiagram;
    IInteraction interaction = diagram.Interaction;
    if (interaction == null)
    {
      // Sequence diagram is empty: create an interaction.
      interaction = diagram.ModelStore.Root.CreateInteraction();
      interaction.Name = Context.CurrentDiagram.Name;
      diagram.Bind(interaction);
    }
    foreach (IConnectableElement connectable in
       GetConnectablesFromDrag(dragEvent))
    {
      ILifeline lifeline = interaction.CreateLifeline();
      lifeline.Represents = connectable;
      lifeline.Name = connectable.Name;
    }
  }

  /// <summary>
  /// Called by the modeling framework to determine whether
  /// the user can drop something on a target.
  /// Must not change anything.
  /// </summary>
  /// <param name="target">The target shape or diagram</param>
  /// <param name="dragEvent">The item being dragged</param>
  /// <returns>true if this item can be dropped on this target</returns>
  public bool CanDragDrop(ShapeElement target,
           DiagramDragEventArgs dragEvent)
  {
    IEnumerable<IConnectableElement> connectables = GetConnectablesFromDrag(dragEvent);
    return connectables.Count() > 0;
  }

  ///<summary>
  /// Get dragged parts and ports of an IComponent.
  ///</summary>
  private IEnumerable<IConnectableElement>
    GetConnectablesFromDrag(DiagramDragEventArgs dragEvent)
  {
    foreach (IElement element in
      GetModelElementsFromDragEvent(dragEvent))
    {
      IConnectableElement part = element as IConnectableElement;
      if (part != null)
      {
        yield return part;
      }
    }
  }

  /// <summary>
  /// Retrieves UML IElements from drag arguments.
  /// Works for drags from UML diagrams.
  /// </summary>
  private IEnumerable<IElement> GetModelElementsFromDragEvent
          (DiagramDragEventArgs dragEvent)
  {
    //ElementGroupPrototype is the container for
    //dragged and copied elements and toolbox items.
    ElementGroupPrototype prototype =
       dragEvent.Data.
       GetData(typeof(ElementGroupPrototype))
            as ElementGroupPrototype;
    // Locate the originals in the implementation store.
    IElementDirectory implementationDirectory =
       dragEvent.DiagramClientView.Diagram.Store.ElementDirectory;

    return prototype.ProtoElements.Select(
      prototypeElement =>
      {
        ModelElement element = implementationDirectory
          .FindElement(prototypeElement.ElementId);
        ShapeElement shapeElement = element as ShapeElement;
        if (shapeElement != null)
        {
          // Dragged from a diagram.
          return shapeElement.ModelElement as IElement;
        }
        else
        {
          // Dragged from UML Model Explorer.
          return element as IElement;
        }
      });
  }

  public void OnDoubleClick(ShapeElement targetElement, DiagramPointEventArgs diagramPointEventArgs)
  {
  }
}

Kod GetModelElementsFromDragEvent() jest opisany w Jak: pobieranie elementów modelu UML z IDataObject.

Zobacz też

Koncepcje

Jak: definiowanie i zainstalować rozszerzenie modelowania

Rozszerzanie modeli UML i diagramów

Jak: Definiowanie polecenia Menu na diagramie modelowania

Jak: definiowanie ograniczeń sprawdzania poprawności dla modeli UML

Programowanie przy użyciu interfejsu API UML