Procedura: aggiungere un comando al menu di scelta rapida

Articolo
02/18/2013

È possibile aggiungere i comandi di menu al (DSL) linguaggio specifico di dominio in modo da poter eseguire gli utenti le attività che sono specifiche del linguaggio DSL.I controlli vengono visualizzati nel menu di contesto (collegamento) quando un utente fa clic con il pulsante destro del mouse sul diagramma.È possibile definire un comando in modo che venga visualizzato solo nel menu in presenza di circostanze specifiche.Ad esempio, è possibile preparare il comando visibili solo quando l'utente fa clic su tipi specifici di elementi, gli elementi o gli stati di specifici.

In breve, che vengono eseguiti nel progetto DslPackage, come segue:

dichiarare il comando in Commands.vsct
Aggiornare il numero di versione del pacchetto in Package.tt.È necessario eseguire questa operazione ogni volta che si modifica Commands.vsct
Scrivere i metodi della classe di CommandSet per rendere il comando visibile e per definire cosa si desidera che il comando eseguire.

Per esempi, vedere Sito Web dell'SDK di visualizzazione e modellazione.

[!NOTA]

È inoltre possibile modificare il comportamento di alcuni controlli esistenti come taglia, incolla, selezionare tutti e stampare con i metodi di override in CommandSet.cs.Per ulteriori informazioni, vedere Procedura: modificare un comando di menu standard in un linguaggio specifico di dominio.

Definizione di comando utilizzando MEF

L'estensione gestita Framework (MEF) viene fornito un metodo alternativo di definizione dei comandi del menu del diagramma.Lo scopo principale è quello di consentire a un modello DSL per essere esteso dall'utente o da altre parti.Gli utenti possono scegliere di installare solo il modello DSL, o possono installare sia il modello DSL che le estensioni.Tuttavia, il framework MEF consente inoltre di ridurre il lavoro di definizione dei comandi del menu di scelta rapida, dopo il lavoro iniziale abilitare il framework MEF sul modello DSL.

utilizzare il metodo in questo argomento se:

Si desidera definire comandi di menu nei menu diverso dal menu di scelta rapida in fare clic con il pulsante destro del mouse.
Si desidera definire raggruppamenti specifici dei comandi del menu.
Non si desidera consentire agli altri per estendere il modello DSL con i rispettivi controlli.
Si desidera solo per definire un comando.

In caso contrario, considerare l'utilizzo del metodo MEF per definire i controlli.Per ulteriori informazioni, vedere Estendere il DSL mediante MEF.

dichiarare il comando in Commands.Vsct

I comandi di menu vengono dichiarati in DslPackage \Commands .vsct.Queste definizioni specificano etichette delle voci di menu e in cui vengono visualizzati i menu.

Il file che modifica, Commands.vsct, le definizioni delle importazioni da diversi h archiviate, che si trovano nella directory Visual Studio SDK il percorso di installazione\VisualStudioIntegration\Common\Inc.Include inoltre GeneratedVsct.vsct, generato dalla definizione di modello DSL.

per ulteriori informazioni sui file di .vsct, vedere Tabella dei comandi di Visual Studio (. file di Vsct).

Per aggiungere il comando

in Esplora soluzioniin, DslPackage progetto, Commands.vsct aperto.

in Commands l'elemento, definisce uno o più pulsanti e un gruppo.In pulsante è un elemento nel menu.In gruppo è una sezione nel menu.per definire questi elementi, aggiungere i seguenti elementi:

<!-- Define a group - a section in the menu -->
<Groups>
  <Group guid="guidCustomMenuCmdSet" id="grpidMyMenuGroup" priority="0x0100">
    <!-- These symbols are defined in GeneratedVSCT.vsct -->
    <Parent guid="guidCmdSet" id="menuidContext" />
  </Group>
</Groups>
<!-- Define a button - a menu item - inside the Group -->
<Buttons>
  <Button guid="guidCustomMenuCmdSet" id="cmdidMyContextMenuCommand"
    priority="0x0100" type="Button">
    <Parent guid="guidCustomMenuCmdSet" id="grpidMyMenuGroup"/>
    <!-- If you do not want to place the command in your own Group, 
         use Parent guid="guidCmdSet" id="grpidContextMain".
         These symbols are defined in GeneratedVSCT.vsct -->
    <CommandFlag>DynamicVisibility</CommandFlag>
    <Strings>
      <ButtonText>My Context Menu Command</ButtonText>
    </Strings>
  </Button>
</Buttons>

[!NOTA]

Ogni pulsante o gruppo viene identificato da un GUID e un ID integerÈ possibile creare diversi gruppi e pulsanti con lo stesso GUID.Tuttavia, devono avere ID diversi.I nomi di GUID e i nomi di ID vengono tradotti agli effettivi GUID e gli ID numerico in <simboli> nodo.

Aggiungere un vincolo di visibilità per il comando in modo che venga caricato solo nel contesto del linguaggio specifico di dominio.Per ulteriori informazioni, vedere Elementi VisibilityConstraints.

A tale scopo, aggiungere i seguenti elementi in CommandTable elemento dopo Commands elemento.
```
<VisibilityConstraints>
  
  <VisibilityItem guid="guidCustomMenuCmdSet" id="cmdidMyContextMenuCommand"
    context="guidEditor"/>
</VisibilityConstraints>
```

Definire i nomi utilizzato per i guids e l'ID.A tale scopo, aggiungere un oggetto Symbols elemento in CommandTable elemento dopo Commands elemento.

<Symbols>
  <!-- Substitute a unique GUID for the placeholder: -->
  <GuidSymbol name="guidCustomMenuCmdSet"
    value="{00000000-0000-0000-0000-000000000000}" >
    <IDSymbol name="grpidMyMenuGroup" value="0x01001"/>
    <IDSymbol name="cmdidMyContextMenuCommand" value="0x00001"/>
  </GuidSymbol>
</Symbols>

di sostituzione {000...000} con un GUID che identificano i gruppi e le voci di menu.per ottenere un nuovo GUID, utilizzare Crea GUID strumento su strumenti menu.

[!NOTA]

Se si aggiungono più gruppi o voci di menu, è possibile utilizzare lo stesso GUID.Tuttavia, è necessario utilizzare i nuovi valori per IDSymbols.
Nel codice copiato da questa procedura, sostituire tutte le occorrenze delle stringhe con diventi proprietaria delle stringhe:
- grpidMyMenuGroup
- cmdidMyContextMenuCommand
- guidCustomMenuCmdSet
- La funzionalità comando del menu di scelta rapida

Aggiornare la versione del pacchetto in Package.tt

Ogni volta che si aggiunge o si modifica un comando, l'aggiornamento version parametro di ProvideMenuResourceAttribute che viene applicato alla classe del pacchetto prima di rilasciare la nuova versione del linguaggio specifico di dominio.

Poiché la classe del pacchetto è definita in un file generato, aggiornare l'attributo nel file modello di testo che genera il file di Package.cs.

Per aggiornare il file di Package.tt

in Esplora soluzioniin, DslPackage progetto, in GeneratedCode la cartella, aprire il file di Package.tt.
individuare ProvideMenuResource attributo.
incrementare version parametro dell'attributo, che è il secondo parametro.Se lo si desidera, è possibile scrivere il nome del parametro in modo esplicito per ricordargli della finalità.Di seguito è riportato un esempio:

[VSShell::ProvideMenuResource("1000.ctmenu", version: 2 )]

Definire il comportamento del comando

Il modello DSL è già presente alcuni controlli che vengono distribuiti in una classe parziale dichiarata in DslPackage \GeneratedCode\CommandSet CS.Per aggiungere nuovi controlli, è necessario estendere la classe creando un nuovo file contenente una dichiarazione parziale della stessa classe.Il nome della classe è in genere <TheDslName> CommandSet.È utile iniziare verifica del nome della classe e il controllo del contenuto.

La classe di comando è derivata da CommandSet.

Per estendere la classe di CommandSet

In Esplora soluzioni, Nel progetto DslPackage, aprire la cartella GeneratedCode quindi cerca in CommandSet.tt e apre il file generato CommandSet.cs.Si noti lo spazio dei nomi e il nome di classe definita in.Ad esempio, è possibile vedere:

namespace Company.Language1

{ ... internal partial class Language1CommandSet : ...
in DslPackage, creare una cartella denominata codice personalizzato.In questa cartella, creare un nuovo file di classe denominato CommandSet.cs.
Nel nuovo file, scrivere una dichiarazione parziale con lo stesso spazio dei nomi e nome della classe parziale generata.Di seguito è riportato un esempio:

namespace Company.Language1 /* Make sure this is correct */

{ internal partial class Language1CommandSet { ...

nota Se è stato utilizzato il modello della classe per creare il nuovo file, è necessario correggere sia lo spazio dei nomi dal nome della classe.

Estendere la classe con set di comando

Il codice del comando in genere dovrà includere gli spazi dei nomi seguenti:

using System;
using System.Collections.Generic;
using System.ComponentModel.Design; 
using System.Linq;
using Microsoft.VisualStudio.Modeling;
using Microsoft.VisualStudio.Modeling.Diagrams;
using Microsoft.VisualStudio.Modeling.Shell;

Modificare lo spazio dei nomi e il nome della classe per corrispondere a quelle del CommandSet.cs generato:

namespace Company.Language1 /* Make sure this is correct */
{
  // Same class as the generated class.
  internal partial class Language1CommandSet 
  {

È necessario definire due metodi, uno per determinare quando il comando sarà visibile nel menu di scelta rapida e l'altro per eseguire il comando.questi metodi non sono override; al contrario, vengono registrate in un elenco dei controlli.

definire quando il comando sarà visibile

per ogni comando, definire OnStatus... metodo che determina se il comando verrà visualizzato nel menu e se verrà attivato o inattivo esterno.impostare Visible e Enabled proprietà di MenuCommand, come illustrato nell'esempio seguente.Questo metodo viene chiamato per costruire ogni volta che il menu di scelta rapida che l'utente fa clic con il pulsante destro del mouse sul diagramma, pertanto deve essere eseguito rapidamente.

In questo esempio, il comando è visibile solo quando l'utente ha selezionato un tipo particolare di formato e è abilitato solo quando almeno uno degli elementi selezionati in un determinato stato.L'esempio è basato sul modello DSL del diagramma classi e ClassShape e ModelClass sono tipi definiti nel modello DSL:

private void OnStatusMyContextMenuCommand(object sender, EventArgs e)
{
  MenuCommand command = sender as MenuCommand;
  command.Visible = command.Enabled = false;
  foreach (object selectedObject in this.CurrentSelection)
  {
    ClassShape shape = selectedObject as ClassShape;
    if (shape != null)
    {
      // Visibility depends on what is selected.
      command.Visible = true;
      ModelClass element = shape.ModelElement as ModelClass;
      // Enabled depends on state of selection.
      if (element != null && element.Comments.Count == 0)
      {
        command.Enabled = true;
        return; // seen enough
} } } }

I seguenti frammenti vengono spesso utili nei metodi di OnStatus:

this.CurrentSelection.La forma che l'utente ha fatto clic con il pulsante destro del mouse è inclusa sempre in questo elenco.Se l'utente fa clic su una parte vuota del diagramma, il diagramma è l'unico membro list.
this.IsDiagramSelected() - true se l'utente fa clic su una parte vuota del diagramma.
this.IsCurrentDiagramEmpty()
this.IsSingleSelection() - l'utente non ha selezionato più oggetti
this.SingleSelection - la forma o diagramma che l'utente ha fatto clic con il pulsante destro del mouse
shape.ModelElement as MyLanguageElement - l'elemento del modello rappresentato da una forma.

Come regola generale, rendere Visible la proprietà dipende a quanto è selezionata e rende Enabled la proprietà dipende dallo stato degli elementi selezionati.

Un metodo di OnStatus non deve modificare lo stato dell'archivio.

Per definire cosa il comando fa

per ogni comando, definire OnMenu... metodo che esegua l'azione obbligatoria quando l'utente fa clic sul comando di menu.

Se si apportano modifiche agli elementi del modello, è necessario farlo in una transazione.Per ulteriori informazioni, vedere Procedura: modificare un comando di menu standard in un linguaggio specifico di dominio.

in questo esempio, ClassShape, ModelClasse Comment sono i tipi definiti nel modello DSL, derivato dal modello DSL del diagramma classi.

private void OnMenuMyContextMenuCommand(object sender, EventArgs e)
{
  MenuCommand command = sender as MenuCommand;
  Store store = this.CurrentDocData.Store;
  // Changes to elements and shapes must be performed in a Transaction.
  using (Transaction transaction =
       store.TransactionManager.BeginTransaction("My command"))
  {
    foreach (object selectedObject in this.CurrentSelection)
    {
      // ClassShape is defined in my DSL.
      ClassShape shape = selectedObject as ClassShape;
      if (shape != null)
      {
        // ModelClass is defined in my DSL.
        ModelClass element = shape.ModelElement as ModelClass;
        if (element != null)
        {
          // Do required action here - for example:

          // Create a new element. Comment is defined in my DSL.
          Comment newComment = new Comment(element.Partition);
          // Every element must be the target of an embedding link.
          element.ModelRoot.Comments.Add(newComment);
          // Set properties of new element.
          newComment.Text = "This is a comment";
          // Create a reference link to existing object.
          element.Comments.Add(newComment);
        }
      }
    }
    transaction.Commit(); // Don't forget this!
  }
}

Per ulteriori informazioni su come passare dall'oggetto in un oggetto nel modello e su come creare oggetti e collegamenti, vedere Procedura: modificare un comando di menu standard in un linguaggio specifico di dominio.

registrare il comando

Scorrere in c# le dichiarazioni dei valori ID e di GUID eseguite nella sezione dei simboli di CommandSet.vsct:

    private Guid guidCustomMenuCmdSet = 
        new Guid("00000000-0000-0000-0000-000000000000");
    private const int grpidMyMenuGroup = 0x01001;
    private const int cmdidMyContextMenuCommand = 1;

Utilizzare lo stesso valore GUID di è stato racchiuso in Commands.vsct.

[!NOTA]

Se si modifica la sezione dei simboli del file di VSCT, è necessario modificare anche le dichiarazioni per accoppiare.È inoltre necessario incrementare il numero di versione in Package.tt

Registrare i comandi di menu come parte di questo set di comando.GetMenuCommands() viene chiamato una volta al diagramma viene inizializzato:

protected override IList<MenuCommand> GetMenuCommands()
{
  // Get the list of generated commands.
  IList<MenuCommand> commands = base.GetMenuCommands();
  // Add a custom command:
  DynamicStatusMenuCommand myContextMenuCommand =
    new DynamicStatusMenuCommand(
      new EventHandler(OnStatusMyContextMenuCommand),
      new EventHandler(OnMenuMyContextMenuCommand),
      new CommandID(guidCustomMenuCmdSet, cmdidMyContextMenuCommand));
  commands.Add(myContextMenuCommand);
  // Add more commands here.
  return commands;
}

Per testare il comando

Compilare ed eseguire il modello DSL in un'istanza sperimentale di Visual Studio.Il comando deve essere visualizzato nel menu di scelta rapida in situazioni specificato.

Per verificare il comando

In Esplora soluzioni barra degli strumenti, fare clic su Trasformazione di tutti i modelli.
stampa F5 per ricompilare la soluzione e avviare il debug del linguaggio specifico di dominio nella compilazione sperimentale.
Nella compilazione sperimentale, aprire un diagramma di esempio.
Fare clic con il pulsante destro del mouse sui vari elementi nel diagramma per verificare che il comando correttamente sia abilitato o disabilitato e in modo appropriato visualizzato o nascosto, come l'elemento selezionato.

Risoluzione dei problemi

Il comando non viene visualizzato nel menu:

Il comando viene visualizzato solo nelle istanze di debug di Visual Studio, finché non installare il pacchetto DSL.Per ulteriori informazioni, vedere Distribuzione di soluzioni per un linguaggio specifico di dominio.
Assicurarsi che nell'esempio sperimentale l'estensione di file corretta per questo modello DSL.Per controllare l'estensione di file, aprire DslDefinition.dsl nell'istanza principale di Visual Studio.Quindi nel modello DSL Esplora Soluzioni, fare clic con il pulsante destro del mouse sul nodo dell'editor e scegliere proprietà.Nella Finestra Proprietà, esaminare la proprietà di FileExtension.
È stato effettuato incrementare il numero di versione del pacchetto?
Impostare un punto di interruzione all'inizio del metodo di OnStatus.Deve essere interrotta quando si fa clic con il pulsante destro del mouse su un punto qualsiasi del diagramma.

Il metodo di OnStatus non viene chiamato:
- Assicurarsi che i GUID e gli ID del codice di CommandSet corrispondano a quelli nella sezione dei simboli di Commands.vsct.
- In Commands.vsct, assicurarsi che il GUID e l'ID di ogni nodo padre di identificare il gruppo padre corretto.
- In un prompt dei comandi di Visual Studio 2005, digitare devenv /rootsuffix exp /setup.Riavviare l'istanza di debug di Visual Studio.
Avanzare nel metodo di OnStatus per verificare che il comando. visibile e comando. Attivato sono impostati su true.

Errato testo di menu viene visualizzato, o il comando viene visualizzato nella finestra errata:

Assicurarsi che la combinazione di GUID e di ID sia univoca a questo comando.
Verificare di avere disinstallato le versioni precedenti del pacchetto.

Vedere anche

Concetti

Procedura: modificare un comando di menu standard in un linguaggio specifico di dominio

Altre risorse

Scrittura di codice per personalizzare un linguaggio specifico di dominio

codice di esempio: schemi circuitali

Condividi tramite