Jak: zobrazení v diagramech modelu

Článek
03/04/2013

Program kód pro rozšíření Visual Studio Ultimate, můžete řídit způsob zobrazení prvků modelu v diagramech.

V tomto tématu:
- Zobrazit prvek v diagramu
- Přístup k obrazce, které představují prvek
- Přesun a změna velikosti obrazce
- K odstranění obrazce z diagramu
- Otevírání a vytváření diagramů
- Příklad: Příkaz zarovnání obrazců

Zobrazit prvek v diagramu

Vytvoříte-li prvek například případ použití nebo akce, uživatel může zobrazit v Průzkumníku modelů UML, ale nezobrazí se vždy automaticky v diagramu.V některých případech musíte napsat kód jej zobrazit.Následující tabulka shrnuje alternativy.

Typ prvku	Například	Chcete-li zobrazit tento kód musí
Třídění	Class Component Actor Use Case	Vytvořte přidružené tvary v zadaném diagramů.Můžete vytvořit libovolný počet obrazců pro každé třídění. diagram.Display<modelElementType> (modelElement, parentShape, xPosition , yPosition); Nastavit parentShape na null pro obrazec na nejvyšší úrovni diagramu. Jeden obrazec uvnitř jiného zobrazení: IShape<IUseCase> usecaseShape = useCaseDiagram.Display (useCase, subsystemShape, subsystemShape.XPosition + 5, subsystemShape.YPosition + 5); Poznámka Pokud provádíte zobrazení uvnitř ILinkedUndo transakce, někdy vrací metoda č IShape.Ale obrazce správně vytvořen a je přístupná pomocíIElement.Shapes().
Podřízené třídění	Atribut operace, Část Port	Automatické - žádný kód vyžaduje. Zobrazí se jako součást nadřazeného objektu.
Chování	Interakce (posloupnost) Aktivity	Svázat chování odpovídající diagramu. Každé chování mohou být vázány na maximálně jeden diagramu najednou. Příklad: sequenceDiagram.Bind(interaction); activityDiagram.Bind(activity);
Podřízené chování	Životnosti, zprávy, akce, uzly objektů	Automatické - žádný kód vyžaduje. Zobrazí se, pokud nadřazený diagram je vázán.
Vztah	Přidružení, generalizace, toku, závislost	Automatické - žádný kód vyžaduje. Zobrazí se na každý diagram, ve kterém jsou zobrazeny obě zakončení.

Přístup k obrazce, které představují prvek

Obrazec představující prvek patří typy:

IShape

IShape<Typ ElementType>

kde ElementType je typ prvku modelu, například IClass nebo IUseCase.

anElement.Shapes ()	Všechny IShapes představující tento prvek v diagramech otevřít.
anElement.Shapes(aDiagram)	Všechny IShapes představující tento prvek zejména diagramu.
anIShape.GetElement()	IElement , Který obrazec představuje.By je obvykle přetypovat na podtřídu IElement.
anIShape.Diagram	IDiagram , Který obsahuje obrazec.
anIShape.ParentShape	Obrazec, který obsahuje anIShape.Například obrazec portu uvnitř obrazce součást.
anIShape.ChildShapes	Obrazce obsažené v IShape nebo IDiagram.
anIShape.GetChildShapes<IUseCase>()	Obrazce obsažené v IShape nebo IDiagram , jako například představují prvky zadaného typu IUseCase.
IShape iShape = ...; IShape<IClass> classShape = iShape.ToIShape<IClass>(); IClass aClass = classShape.Element;	Obecný nádech IShape k silnými IShape<IElement>.
IShape<IClassifier> classifierShape; IShape<IUseCase> usecaseShape = classifierShape.ToIShape<IUseCase>();	Typ jednoho obrazce Parametrizovaná obrazec nádech.

Přesun a změna velikosti obrazce

anIShape.Move(x, y, [width], [height])	Přesunutí nebo změna velikosti tvaru.
IDiagram.EnsureVisible( IEnumerable<IShape> shapes, bool zoomToFit = false)	Aktivovat okno a posuňte diagramu tak, aby byly viditelné daného obrazce.Obrazce musí být všechny v diagramu.Pokud zoomToFit je PRAVDA diagramu bude měněn podle potřeby tak, aby všechny tvary jsou viditelné.

Jako příklad viz příkaz Zarovnání k definování.

K odstranění obrazce z diagramu

Tvary některých typů prvků můžete odstranit bez odstranění prvku.

Prvek modelu	Odstranit obrazec
Třídění: třídy, rozhraní, výčet, herce, případ použití nebo součásti	shape.Delete();
Chování: interakce nebo činnosti	Diagram můžete odstranit z projektu.Použití IDiagram.FileName získat cestu. Nedojde k odstranění chování z modelu.
Jiný tvar	Ostatní obrazce nelze odstranit explicitně z diagramu.Tvar automaticky zmizí, pokud je prvek odstraněn z modelu nebo odebrání nadřazeného obrazce z diagramu.

Třídění: třídy, rozhraní, výčet, herce, případ použití nebo součásti

shape.Delete();

Chování: interakce nebo činnosti

Diagram můžete odstranit z projektu.Použití IDiagram.FileName získat cestu.

Nedojde k odstranění chování z modelu.

Jiný tvar

Ostatní obrazce nelze odstranit explicitně z diagramu.Tvar automaticky zmizí, pokud je prvek odstraněn z modelu nebo odebrání nadřazeného obrazce z diagramu.

Otevírání a vytváření diagramů

Přístup z rozšíření příkazu nebo gesto uživatele v aktuálním diagramu

Prohlašuji, že tato vlastnost importované ve své třídě:

[Import]

IDiagramContext Context { get; set; }

V metodě přístup k diagramu:

IClassDiagram classDiagram =

Context.CurrentDiagram as IClassDiagram;

[!POZNÁMKA]

Instance IDiagram (a jeho subtypů, jako například IClassDiagram) je platná pouze v rámci příkazu při zpracování.Není vhodné vést IDiagram objektu v proměnné, který přetrvává při řízení se vrátí uživateli.

Další informace naleznete v tématu Postup: definování příkazu nabídky diagramu modelování.

Seznam otevřených diagramy

Seznam diagramy, které jsou právě otevřené v projektu:

Context.CurrentDiagram.ModelStore.Diagrams()

Přístup k diagramy v projektu

Visual Studio Rozhraní API lze použít k otevření a vytváření diagramů a projektů pro modelování.

Všimněte si nádech z EnvDTE.ProjectItem na IDiagramContext.

using EnvDTE; // Visual Studio API
...
[Import]
public IServiceProvider ServiceProvider { get; set; }
...
// Get Visual Studio API
DTE dte = ServiceProvider.GetService(typeof(DTE)) as DTE;
// Get current Visual Studio project
Project project = dte.ActiveDocument.ProjectItem.ContainingProject;
// Open and process every diagram in the project.
foreach (ProjectItem item in project.ProjectItems)
{
  // Cast ProjectItem to IDiagramContext
  IDiagramContext context = item as IDiagramContext;
  if (context == null)
  {
     // This is not a diagram file.
     continue;
  }
  // Open the file and give the window the focus.
  if (!item.IsOpen)
  {
      item.Open().Activate();
  }
  // Get the diagram.
  IDiagram diagram = context.CurrentDiagram;
  // Deal with specific diagram types.
  ISequenceDiagram seqDiagram = diagram as ISequenceDiagram;
  if (seqDiagram != null)
  { ... } } }

Instance IDiagram a jeho podtypy nejsou platné po vrátit ovládací prvek Visual Studio.

Úložiště modelu ze můžete získat také Visual Studio projektu:

Project project = ...;
IModelStore modelStore = (project as IModelingProject).Store;

Příklad: Příkaz zarovnání obrazců

Následující kód používá příkaz nabídky, který se snadno a přesně zarovnává obrazce.Uživatel musí nejprve umístěte dva nebo více tvarů v přibližné zarovnání svisle nebo vodorovně.Příkaz Zarovnat pak lze použít k zarovnání středů.

Příkaz zpřístupnit, přidejte tento kód do příkazu nabídky projektu a uživatelům instalovat výsledný rozšíření.Další informace naleznete v tématu Postup: definování příkazu nabídky diagramu modelování.

using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using System.Linq;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Presentation;
using Microsoft.VisualStudio.ArchitectureTools.Extensibility.Uml;
using Microsoft.VisualStudio.Modeling.ExtensionEnablement;

namespace AlignCommand
{
  // Implements a command to align shapes in a UML class diagram.
  // The user first selects shapes that are roughly aligned either vertically or horizontally.
  // This command will straighten them up.

  // Place this file in a menu command extension project.
  // See https://msdn.microsoft.com/library/ee329481.aspx

  [Export(typeof(ICommandExtension))]
  [ClassDesignerExtension] // TODO: Add other diagram types if needed
  class CommandExtension : ICommandExtension
  {
    /// <summary>
    /// See https://msdn.microsoft.com/library/ee329481.aspx
    /// </summary>
    [Import]
    IDiagramContext context { get; set; }

    /// <summary>
    /// Transaction context.
    /// See https://msdn.microsoft.com/library/ee330926.aspx
    /// </summary>
    [Import]
    ILinkedUndoContext linkedUndo { get; set; }

    /// <summary>
    /// Called when the user selects the command.
    /// </summary>
    /// <param name="command"></param>
    public void Execute(IMenuCommand command)
    {
      Align(context.CurrentDiagram.SelectedShapes);
    }

    /// <summary>
    /// Called when the user right-clicks on the diagram.
    /// Determines whether the command is enabled.
    /// </summary>
    /// <param name="command"></param>
    public void QueryStatus(IMenuCommand command)
    {
      IEnumerable<IShape> currentSelection = context.CurrentDiagram.SelectedShapes;
      // Make it visible if there are shapes selected:
      command.Visible = currentSelection.Count() > 0 && !(currentSelection.FirstOrDefault() is IDiagram);

      // Make it enabled if there are two or more shapes that are roughly in line:
      command.Enabled = currentSelection.Count() > 1
        && (HorizontalAlignCenter(currentSelection) > 0.0
        || VerticalAlignCenter(currentSelection) > 0.0);

    }

    /// <summary>
    /// Title of the menu command.
    /// </summary>
    public string Text
    {
      get { return "Align Shapes"; }
    }

    /// <summary>
    /// Find a horizontal line that goes through a list of shapes.
    /// </summary>
    /// <param name="shapes"></param>
    /// <returns></returns>
    private static double HorizontalAlignCenter(IEnumerable<IShape> shapes)
    {
      double Y = -1.0;
      double top = 0.0, bottom = shapes.First().Bottom();
      foreach (IShape shape in shapes)
      {
        top = Math.Max(top, shape.Top());
        bottom = Math.Min(bottom, shape.Bottom());
      }
      if (bottom > top) Y = (bottom + top) / 2.0;
      return Y;
    }

    /// <summary>
    /// Find a vertical line that goes through a list of shapes.
    /// </summary>
    /// <param name="shapes"></param>
    /// <returns></returns>
    private static double VerticalAlignCenter(IEnumerable<IShape> shapes)
    {
      double X = -1.0;
      double left = 0.0, right = shapes.First().Right();
      foreach (IShape shape in shapes)
      {
        left = Math.Max(left, shape.Left());
        right = Math.Min(right, shape.Right());
      }
      if (right > left) X = (right + left) / 2.0;
      return X;
    }

    /// <summary>
    /// Line up those shapes that are roughly aligned.
    /// </summary>
    /// <param name="shapes"></param>
    private void Align(IEnumerable<IShape> shapes)
    {
      if (shapes.Count() > 1)
      {
        // The shapes must all overlap either horizontally or vertically.
        // Find a horizontal line that is covered by all the shapes:
        double Y = HorizontalAlignCenter(shapes);
        if (Y > 0.0) // Negative if they don't overlap.
        {
          // Adjust all the shape positions in one transaction:
          using (ILinkedUndoTransaction t = linkedUndo.BeginTransaction("align"))
          {
            foreach (IShape shape in shapes)
            {
              shape.AlignYCenter(Y);
            }
            t.Commit();
          }
        }
        else
        {
          // Find a vertical line that is covered by all the shapes:
          double X = VerticalAlignCenter(shapes);
          if (X > 0.0) // Negative if they don't overlap.
          {
            // Adjust all the shape positions in one transaction:
            using (ILinkedUndoTransaction t = linkedUndo.BeginTransaction("align"))
            {
              foreach (IShape shape in shapes)
              {
                shape.AlignXCenter(X);
              }
              t.Commit();
            }
          }
        }
      }
    }
  }
  
  /// <summary>
  /// Convenience extensions for IShape.
  /// </summary>
  public static class IShapeExtension
  {
    public static double Bottom(this IShape shape)
    {
      return shape.YPosition + shape.Height;
    }

    public static double Top(this IShape shape)
    {
      return shape.YPosition;
    }

    public static double Left(this IShape shape)
    {
      return shape.XPosition;
    }

    public static double Right(this IShape shape)
    {
      return shape.XPosition + shape.Width;
    }

    public static void AlignYCenter(this IShape shape, double Y)
    {
      shape.Move(shape.XPosition, Y - shape.YCenter());
    }

    public static void AlignXCenter(this IShape shape, double X)
    {
      shape.Move(X - shape.XCenter(), shape.YPosition);
    }

    /// <summary>
    /// We can adjust what bit of the shape we want to be aligned.
    /// The default is the center of the shape.
    /// </summary>
    /// <param name="shape"></param>
    /// <returns></returns>
    public static double YCenter(this IShape shape)
    {
        return shape.Height / 2.0;
    } 
    
    /// <summary>
    /// We can adjust what bit of the shape we want to be aligned.
    /// The default is the center of the shape.
    /// </summary>
    /// <param name="shape"></param>
    /// <returns></returns>
    public static double XCenter(this IShape shape)
    {
        return shape.Width / 2.0;
    }
  }
}