Procédure pas - à - pas : créer une fenêtre Outil (partie de 4)

Article
05/17/2015

Les fenêtres Outil sont courantes dans l'environnement de développement intégré Visual (IDE) Studio. Quelques exemples des fenêtres Outil inclus dans Visual Studio sont Explorateur de solutions, Liste des tâches, Liste d'erreurs, et la fenêtre de Sortie . Toutes les fenêtres Outil ont des fonctionnalités en commun, par exemple, tout peut être ancré dans l'IDE de la même façon. L'ancrage prévisible permet aux utilisateurs de gérer leurs tâches et informations efficacement.

Cette procédure pas - à - pas explique comment créer une fenêtre Outil de l'IDE de Visual Studio à l'aide de les étapes suivantes :

créez une fenêtre Outil.
incluez un contrôle dans la fenêtre Outil.
ajoutez une barre d'outils à une fenêtre Outil.
Ajoutez les commandes de la barre d'outils.
implémentez les commandes.
Définissez la position par défaut de la fenêtre Outil.

Cette procédure pas - à - pas fait partie d'une série de procédures qui explique comment étendre l'IDE de Visual Studio. Pour plus d'informations, consultez Procédures pas - à - pas pour personnaliser Visual Studio à l'aide de les VSPackages.

Composants requis

Pour exécuter cette procédure, vous devez installer Kit de développement logiciel Visual Studio 2010.

Notes

Pour plus d'informations sur le kit de développement Visual Studio, consultez Étendre la présentation de Visual Studio.Pour savoir comment télécharger le kit de développement Visual Studio, consultez Visual Studio Extensibility Developer Center sur le site Web MSDN.

Emplacements du modèle de projet de package Visual Studio

Le modèle de projet de package Visual Studio est disponible dans trois emplacements dans la boîte de dialogue de Nouveau projet :

sous Extensibilité Visual Basic. Le langage par défaut du projet est en Visual Basic.
sous Extensibilité c#. Le langage par défaut du projet est c#.
sous L'autre projet types l'extensibilité. Le langage par défaut du projet est en C++.

créez une fenêtre Outil

pour créer une fenêtre Outil

créez un VSPackage nommé FirstToolWin. Vous pouvez également créer un répertoire de la solution. Cliquez sur OK.
Sur la page d'accueil, cliquez sur Suivant.
Dans la page de Sélectionner un langage de programmation , cliquez sur Visual C# ou cliquez sur générez un nouveau fichier de clé pour signer l'assemblyde Visual Basic , puis cliquez sur Suivant.
prenez un moment pour examiner la page de Les informations de base d'un VSPackage . La valeur de la zone de Nom de la société est utilisée comme espace de noms pour toutes les classes. La zone de Nom VSPackage fournit un nom pour le package compilé final et la zone de Version d'un VSPackage fournit des informations de version. édition minimum de Visual Studio spécifie sur lequel les éditions de Visual Studio le package doivent s'exécuter. Le contenu de la zone de Les informations détaillées apparaît dans la page de propriétés du package fini. Le bouton d' icône de modification vous permet de sélectionner une icône pour représenter le package.

Pour cette procédure pas - à - pas, acceptez uniquement les valeurs par défaut en cliquant sur Suivant.
Dans la page de Sélectionnez les options d'un VSPackage , sélectionnez Commande de menu et fenêtre Outil, puis cliquez sur Suivant.

Notes

L'option de la commande de menu est requise dans la procédure pas - à - pas suivante, Procédure pas - à - pas : étendre la fenêtre Outil (partie de 4), qui repose sur ce projet.
Sur la page d' options de commande de menu , dans la zone de nom de la commande , tapez Windows Media. Dans la zone d' ID de commande , le type cmdidWindowsMedia, puis cliquez sur Suivant.
Sur la page d' options de fenêtre Outil , dans la zone de Nom de la fenêtre , tapez Lecteur Windows Media. Dans le champ d' ID de commande , tapez un identificateur valide, par exemple, cmdidWindowsMediaWin, puis cliquez sur Suivant.
Dans la page de sélectionnez les options de projet de test , projet de test d'intégration clair et projet de test unitaire, puis cliquez sur Terminer.
Dans Explorateur de solutions, double-cliquez sur MyControl.xaml.
Cliquez avec le bouton droit sur le bouton de cliquez sur-moi ! , puis cliquez sur Delete.

incluez un contrôle dans la fenêtre Outil

Ensuite, ajoutez le contrôle de Lecteur Windows Media à boîte à outils puis ajoutez -le à la fenêtre Outil.

pour inclure un contrôle dans la fenêtre Outil

Dans boîte à outils, développez la section de tous les contrôles WPF et recherchez élément multimédia.
Pour ajouter lecteur multimédia à votre fenêtre Outil, faites glisser le contrôle d' élément multimédia de boîte à outils au formulaire de MyControl.
Dans le concepteur, sélectionnez le contrôle d'élément multimédia puis examinez les propriétés disponibles dans la fenêtre de Propriétés . Certaines propriétés sont standard dans tous les contrôles Windows Forms. Toutefois, d'autres sont fournis par le contrôle, par exemple, Source, utilisée pour charger un fichier au moment de l'exécution.
Dans le menu Fichier, cliquez sur Enregistrer tout.

ajoutez une barre d'outils à la fenêtre Outil

En ajoutant une barre d'outils de la manière suivante, vous vous assurez que ses dégradés et couleurs sont compatibles avec le reste de l'IDE.

pour ajouter une barre d'outils à la fenêtre Outil

dans Explorateur de solutions, ouvrez FirstToolWin.vsct. le fichier de .vsct définit les éléments (GUI) d'interface utilisateur graphique dans votre fenêtre Outil à l'aide de XML.
Dans la section d' <Symbols> , recherchez le nœud d' <GuidSymbol> dont l'attribut d' name est guidFirstToolWinCmdSet. Ajoutez les deux éléments suivants d' <IDSymbol> à la liste d'éléments d' <IDSymbol> dans ce nœud pour définir une barre d'outils et un groupe de barre d'outils.
```
<IDSymbol name="ToolbarID" value="0x1000" />
<IDSymbol name="ToolbarGroupID" value="0x1001" />
```
Juste au-dessus de la section d' <Groups> , créez une section d' <Menus> similaire à celui-ci :
```
<Menus>
  <Menu guid="guidFirstToolWinCmdSet" id="ToolbarID"
        priority="0x0000" type="ToolWindowToolbar">
    <Parent guid="guidFirstToolWinCmdSet" id="ToolbarID" />
    <Strings>
      <ButtonText>Tool Window Toolbar</ButtonText>
      <CommandName>Tool Window Toolbar</CommandName>
    </Strings>
  </Menu>
</Menus>
```
Tous les conteneurs pour les commandes sont définis comme différents genres de menus. Par son attribut d' type , celui-ci est défini pour apparaître sous la barre d'outils dans une fenêtre Outil. Les paramètres d' guid et d' id composent l'ID qualifié complet de la barre d'outils. En général, <Parent> d'un menu fait référence au groupe contenant. Toutefois, une barre d'outils est définie comme son propre parent. par conséquent, le même identificateur est utilisé pour les éléments d' <Menu> et d' <Parent> . L'attribut d' priority est simplement « 0 ".
Les barres d'outils ressemblent aux menus de plusieurs façons. Par exemple, tout comme un menu peut avoir des groupes de commandes, les barres d'outils peuvent également avoir des groupes. (Dans les menus, les groupes de commandes sont séparés par des lignes horizontales. Sur les barres d'outils, les groupes ne sont pas séparés par des séparateurs visuels.)

Ajoutez un nouvel élément d' <Group> dans la section de <Groups> pour définir le groupe que vous avez déclaré dans la section d' <Symbols> .
```
<Group guid="guidFirstToolWinCmdSet" id="ToolbarGroupID" priority="0x0000">
  <Parent guid="guidFirstToolWinCmdSet" id="ToolbarID"/>
</Group>
```
En définissant le GUID et l'identificateur au GUID et l'identificateur parents de la barre d'outils, vous placez le groupe dans la barre d'outils.
Enregistrez le fichier.

Ajoutez les commandes de la barre d'outils

Ensuite, ajoutez les commandes de la barre d'outils. Les commandes sont affichées comme boutons et.

Pour ajouter des commandes de la barre d'outils

Dans FirstToolWin.vsct, dans la section d' <Symbols> , déclarez trois commandes qui suit immédiatement la barre d'outils et barre d'outils des déclarations de groupe.
```
<IDSymbol name="cmdidWindowsMediaOpen" value="0x132" />
<IDSymbol name="cmdidWindowsMediaFilename" value="0x133" />
<IDSymbol name="cmdidWindowsMediaFilenameGetList" value="0x134" />
```
Notez que les commandes cmdidWindowsMedia et cmdidWindowsMediaWin sont déjà déclarés.
Dans la section d' <Buttons> , un élément d' <Button> est déjà installé et il contient une définition pour les commandes de cmdidWindowsMedia et de cmdidWindowsMediaWin. Ajoutez un autre élément d' <Button> pour définir l'ordre de cmdidWindowsMediaOpen.
```
  <Button guid="guidFirstToolWinCmdSet"
        id="cmdidWindowsMediaOpen" priority="0x0101"
        type="Button">
  <Parent guid="guidFirstToolWinCmdSet"
          id="ToolbarGroupID"/>
  <Icon guid="guidImages" id="bmpPic1" />
  <Strings>
    <CommandName>cmdidWindowsMediaOpen</CommandName>
    <ButtonText>Load File</ButtonText>
  </Strings>
</Button>
```
Notez que la priorité du deuxième bouton est 0x0101. La zone de liste déroulante qui est ajoutée dans l'étape suivante est prioritaire 0x0100. Par conséquent, la zone de liste déroulante s'affiche dans la première position et le bouton s'affiche dans la deuxième position.

Pour définir un emplacement pour que l'utilisateur tape un texte, ajoutez une zone de liste déroulante. Ajouter une zone de liste déroulante revient à ajouter un bouton, mais vous définissez la zone de liste déroulante dans une section d' <Combos> .

Créez une section d' <Combos> , juste après la balise d' </Buttons> , qui a une entrée pour définir votre zone de liste déroulante.

<Combos>
  <Combo guid="guidFirstToolWinCmdSet"
         id="cmdidWindowsMediaFilename"
         priority="0x0100" type="DynamicCombo"
         idCommandList="cmdidWindowsMediaFilenameGetList"
         defaultWidth="130">
    <Parent guid="guidFirstToolWinCmdSet"
            id="ToolbarGroupID" />
    <CommandFlag>IconAndText</CommandFlag>
    <CommandFlag>CommandWellOnly</CommandFlag>
    <CommandFlag>StretchHorizontally</CommandFlag>
    <Strings>
      <CommandName>Filename</CommandName>
      <ButtonText>Enter a Filename</ButtonText>
    </Strings>
  </Combo>
</Combos>

Enregistrez et fermez FirstToolWin.vsct.

Dans Explorateur de solutions, dans le dossier du projet, PkgCmdID.cs ou PkgCmdID.vb ouverts puis ajoutez les lignes suivantes dans la classe juste après les membres existants.

Public Const cmdidWindowsMediaOpen As Integer = &H132
Public Const cmdidWindowsMediaFilename As Integer = &H133
Public Const cmdidWindowsMediaFilenameGetList As Integer = &H134
Public Const ToolbarID As Integer = &H1000

public const int cmdidWindowsMediaOpen = 0x132;
public const int cmdidWindowsMediaFilename = 0x133;
public const int cmdidWindowsMediaFilenameGetList = 0x134;
public const int ToolbarID = 0x1000;

Faisant cela rend vos commandes disponibles dans le code.

Enregistrez et fermez le fichier.

implémentez les commandes

Écrire le code qui implémente des commandes.

pour implémenter les commandes

Dans Explorateur de solutions, ouvrez MyToolWindow.cs ou MyToolWindow.vb, qui contiennent la classe de la fenêtre Outil elle-même.

Ajoutez le code suivant juste après les instructions using existantes.
```
Imports System.ComponentModel.Design
```
```
using System.ComponentModel.Design;
```
Cette ligne vous permet d'utiliser la classe d' CommandID sans devoir la qualifier pleinement.

Ajoutez le code suivant au constructeur, juste avant la ligne qui indique control = new MyControl() (c#) ou Me.Content = New MyControl() (VB).

' Create the toolbar.  
Me.ToolBar = New CommandID(GuidList.guidFirstToolWinCmdSet, PkgCmdIDList.cmdidWindowsMediaWin)
Me.ToolBarLocation = CInt(VSTWT_LOCATION.VSTWT_TOP)

' Create the handlers for the toolbar commands.  
Dim mcs As OleMenuCommandService = TryCast(GetService(GetType(IMenuCommandService)), OleMenuCommandService)
If mcs IsNot Nothing Then 
    Dim toolbarbtnCmdID As CommandID = New CommandID(GuidList.guidFirstToolWinCmdSet, PkgCmdIDList.cmdidMyCommand)
    Dim menuItem As MenuCommand = New MenuCommand(New EventHandler(AddressOf ButtonHandler), toolbarbtnCmdID)
    mcs.AddCommand(menuItem)

    ' Command for the combo itself  
    Dim menuMyDynamicComboCommandID As CommandID = New CommandID(GuidList.guidFirstToolWinCmdSet, CInt(PkgCmdIDList.cmdidMyCommand))
    Dim menuMyDynamicComboCommand As OleMenuCommand = New OleMenuCommand(New EventHandler(AddressOf ComboHandler), menuMyDynamicComboCommandID)
    mcs.AddCommand(menuMyDynamicComboCommand)

    ' Command for the combo's list  
    Dim comboListCmdID As CommandID = New CommandID(GuidList.guidFirstToolWinCmdSet, PkgCmdIDList.cmdidWindowsMediaWin)
    Dim comboMenuList As OleMenuCommand = New OleMenuCommand(New EventHandler(AddressOf ComboListHandler), comboListCmdID)
    mcs.AddCommand(comboMenuList)
End If

// Create the toolbar. 
this.ToolBar = new CommandID(GuidList.guidFirstToolWinCmdSet,
    PkgCmdIDList.ToolbarID);
this.ToolBarLocation = (int)VSTWT_LOCATION.VSTWT_TOP;

// Create the handlers for the toolbar commands. 
var mcs = GetService(typeof(IMenuCommandService))
    as OleMenuCommandService;
if (null != mcs)
{
    var toolbarbtnCmdID = new CommandID(
        GuidList.guidFirstToolWinCmdSet,
        PkgCmdIDList.cmdidWindowsMediaOpen);
    var menuItem = new MenuCommand(new EventHandler(
        ButtonHandler), toolbarbtnCmdID);
    mcs.AddCommand(menuItem);

    // Command for the combo itself 
    var menuMyDynamicComboCommandID = new CommandID(
        GuidList.guidFirstToolWinCmdSet,
        (int)PkgCmdIDList.cmdidWindowsMediaFilename);
    var menuMyDynamicComboCommand = new OleMenuCommand(
        new EventHandler(ComboHandler),
        menuMyDynamicComboCommandID);
    mcs.AddCommand(menuMyDynamicComboCommand);

    // Command for the combo's list 
    var comboListCmdID = new CommandID(
        GuidList.guidFirstToolWinCmdSet,
        PkgCmdIDList.cmdidWindowsMediaFilenameGetList);
    var comboMenuList = new OleMenuCommand(
        new EventHandler(ComboListHandler), comboListCmdID);
    mcs.AddCommand(comboMenuList);
}

Ce code ajoute trois commandes, une pour le bouton et deux dans la zone de liste déroulante. La zone de liste déroulante requiert deux commandes, une lorsque l'utilisateur effectue une entrée, et une de remplir une liste déroulante.

Les gestionnaires d'événements pour les contrôles de barre d'outils, votre code doit avoir accès au contrôle de lecteur multimédia, qui est un enfant de la classe de MyControl.

Dans Explorateur de solutions, cliquez avec le bouton droit sur MyControl.xaml, cliquez sur Afficher le code, puis ajoutez le code suivant à la classe de MyControl.
```
Public ReadOnly Property MediaPlayer() As System.Windows.Controls.MediaElement
    Get 
        Return MediaElement1
    End Get 
End Property
```
```
public System.Windows.Controls.MediaElement MediaPlayer
{
    get { return mediaElement1; }
}
```
Enregistrez le fichier.

Le retour à MyToolWindow.cs ou à MyToolWindow.vb, puis ajoutez le code suivant à la fin de la classe, juste avant les deux accolades fermantes finales (c#) ou une instruction de classe de fin (Visual Basic).

Private Sub ButtonHandler(ByVal sender As Object, ByVal arguments As EventArgs)
    If comboValue IsNot Nothing AndAlso comboValue.Trim().Length <> 0 Then
        LoadFile(comboValue)
    End If 
End Sub 

Private Sub ComboHandler(ByVal sender As Object, ByVal arguments As EventArgs)
    Dim eventArgs As OleMenuCmdEventArgs = TryCast(arguments, OleMenuCmdEventArgs)
    If eventArgs IsNot Nothing Then 
        Dim output As IntPtr = eventArgs.OutValue
        Dim input As Object = eventArgs.InValue
        If input IsNot Nothing Then
            comboValue = input.ToString()
        ElseIf output <> IntPtr.Zero Then
            Marshal.GetNativeVariantForObject(comboValue, output)
        End If 
    End If 
End Sub 

Public Sub LoadFile(ByVal comboValue As String)
    control.MediaPlayer.Source = New Uri(comboValue)
End Sub 

Private Sub ComboListHandler(ByVal sender As Object, ByVal arguments As EventArgs)
End Sub

    private void ButtonHandler(object sender,
EventArgs arguments)
    {
        if (comboValue != null && comboValue.Trim().Length != 0)
        {
            LoadFile(comboValue);
        }
    }

    private void ComboHandler(object sender, EventArgs arguments)
    {
        var eventArgs = arguments as OleMenuCmdEventArgs;
        if (eventArgs != null)
        {
            IntPtr output = eventArgs.OutValue;
            object input = eventArgs.InValue;
            if (input != null)
            {
                comboValue = input.ToString();
            }
            else if (output != IntPtr.Zero)
            {
                Marshal.GetNativeVariantForObject(comboValue,
                    output);
            }
        }
    }

    public void LoadFile(string comboValue)
    {
        control.MediaPlayer.Source = new System.Uri(comboValue);
    }

    private void ComboListHandler(object sender,
        EventArgs arguments)
    {
    }

Notez que le menuMyDynamicComboCommand et menuItem partagent le même gestionnaire d'événements. Par conséquent, la fenêtre Outil peut lire le fichier spécifié dans la zone de liste déroulante. Dans cette procédure pas - à - pas, vous ne fournissez pas de code pour la fonction de ComboListHandler. Dans la procédure pas - à - pas suivante, Procédure pas - à - pas : étendre la fenêtre Outil (partie de 4), vous ajoutez le code qui remplit une liste déroulante à l'aide de les noms de sélection.

Le gestionnaire modifiable s'enregistre tout texte tapé dans ce dernier dans une variable membre. Pour ajouter cette variable, ajoutez le code suivant en haut de la classe (en Visual Basic, après que hérite de l'instruction). En même temps, ajoutez une variable membre pour contenir le contrôle.
```
Dim control As MyControl
Dim comboValue As String
```
```
private MyControl control;
string comboValue = "";
```
Lorsque l'utilisateur clique sur le bouton, le bouton est la valeur de cette variable locale et la charge dans lecteur multimédia.

Définissez la position par défaut de la fenêtre Outil

Ensuite, spécifiez un emplacement par défaut dans l'IDE de la fenêtre Outil. les données de configuration pour la fenêtre Outil sont dans le fichier de FirstToolWinPackage.cs.

Pour définir l'emplacement par défaut de la fenêtre Outil

dans Explorateur de solutions, ouvrez FirstToolWinPackage.cs ou FirstToolWinPackage.vb. dans ce fichier, recherchez l'attribut d' ProvideToolWindowAttribute sur la classe d' FirstToolWinPackage . ce code passe le type de MyToolWindow au constructeur. Pour spécifier une position par défaut, vous devez ajouter davantage de paramètres à l'exemple suivant de constructeur.
```
<PackageRegistration(UseManagedResourcesOnly:=True), _
InstalledProductRegistration("#110", "#112", "1.0", IconResourceID:=400), _
ProvideMenuResource("Menus.ctmenu", 1), _
ProvideToolWindow(GetType(MyToolWindow), Style:=Microsoft.VisualStudio.Shell.VsDockStyle.Tabbed, Window:="3ae79031-e1bc-11d0-8f78-00a0c9110057"), _
Guid(GuidList.guidFirstToolWinPkgString)> _
Public NotInheritable Class FirstToolWinPackage
    Inherits Package
```
```
[ProvideToolWindow(typeof(MyToolWindow),
    Style = Microsoft.VisualStudio.Shell.VsDockStyle.Tabbed,
    Window = "3ae79031-e1bc-11d0-8f78-00a0c9110057")]
```
Le premier paramètre nommé est style et sa valeur est tabulé, ce qui signifie que la fenêtre sera un onglet dans une fenêtre existante. La fenêtre est indiquée par la fenêtre nommée paramètre ; sa valeur est un GUID. Dans ce cas, un GUID est celui pour Explorateur de solutions.

Notes

Pour plus d'informations sur les GUID pour windows dans l'IDE, consultez vsWindowKind Constants sur le site Web MSDN.
Enregistrez votre travail.

tester la fenêtre Outil

pour tester la fenêtre Outil

appuyez sur F5 pour ouvrir une nouvelle instance de la génération expérimentale de Visual Studio.
Dans le menu d' Afficher , pointez sur Autres fenêtres puis cliquez sur Lecteur Windows Media.

La fenêtre Outil de lecteur multimédia doit s'ouvrir dans la même fenêtre qu' Explorateur de solutions.
Dans la zone de liste déroulante dans la fenêtre Outil de lecteur multimédia, tapez le chemin d'accès complet et le nom de fichier d'un son ou d'un fichier vidéo pris en charge, par exemple, C:\windows\media\chimes.wav, appuyez sur Entrée, puis cliquez sur le bouton contigu.

Notes

Vous devez entrer un nom de fichier dans la zone de texte parce que la fenêtre Outil de lecteur multimédia n'a pas une boîte de dialogue d' Ouvrir .

Quoi d'autre ?

Dans Procédure pas - à - pas : étendre la fenêtre Outil (partie de 4), vous pouvez en apprendre comment ajouter des contrôles à la fenêtre Outil. Vous ajoutez un bouton qui affiche une boîte de dialogue d' Ouvrir , que vous pouvez utiliser pour sélectionner un fichier pour lire dans lecteur multimédia. Vous ajoutez également une liste déroulante des sélections afin de pouvoir sélectionner l'une d'entre elles pour lire.

Voir aussi

Tâches

Procédure pas - à - pas : Ajouter une barre d'outils à l'IDE

Procédure pas - à - pas : Ajouter une barre d'outils à une fenêtre Outil

Autres ressources

commandes, menus, et barres d'outils

Partager via