Procédure pas - à - pas : étendre la fenêtre Outil (partie de 4)

Dans cette procédure pas - à - pas, vous ajoutez à la fenêtre Outil que vous avez créée dans Procédure pas - à - pas : créer une fenêtre Outil (partie de 4). Vous ajoutez un bouton qui affiche une boîte de dialogue d' Ouvrir un fichier afin de pouvoir sélectionner un fichier pour lire dans lecteur multimédia.

Cette procédure pas - à - pas montre comment ajouter la visibilité dynamique à une commande de menu.

Cette procédure pas - à - pas est une série qui explique comment étendre l'environnement de développement intégré Visual (IDE) Studio. Pour plus d'informations, consultez Procédures pas - à - pas pour personnaliser Visual Studio à l'aide de les VSPackages.

ajoutez la visibilité dynamique à une commande de menu

Par défaut, les commandes de menu sont résolues en place et ne peuvent pas être masquées après qu'elles soient affichées. Toutefois, la création dans cette procédure pas - à - pas est que le package décide au moment de l'exécution si la commande doit être visible, selon que la fenêtre Outil de lecteur multimédia est actif.

Vous devez d'abord remplacer FirstToolWin.vsct pour activer la visibilité dynamique, puis implémentez la logique pour définir la visibilité dans le code. Vous créez une classe pour gérer les événements de fenêtre Outil, puis modifiez le package pour rendre l'objet de commande de menu accessible, puis les attachez ensemble.

pour activer la visibilité dynamique

1. Ouvrez le projet « FirstToolWin », que vous avez créé dans Procédure pas - à - pas : créer une fenêtre Outil (partie de 4).

2. dans Explorateur de solutions, ouvrez FirstToolWin.vsct.

3. Recherchez l'élément d' <Button> dont l'ID EST, cmdidWindowsMedia. entre la définition d' <icon> et la section d' <Strings> , ajoutez deux balises de commande, comme suit.

   <CommandFlag>DefaultInvisible</CommandFlag>
   <CommandFlag>DynamicVisibility</CommandFlag>
   

4. Enregistrez le fichier.

Pour créer les événements de fenêtre Outil

1. Dans Explorateur de solutions, cliquez avec le bouton droit sur le nom du projet, pointez sur Ajouter, puis cliquez sur Classe.

2. Dans la boîte de dialogue d' Ajouter un nouvel élément , nommez le fichier ToolWindowEvents.cs ou ToolWindowEvents.vb puis cliquez sur Ajouter.

3. Ouvrez ToolWindowEvents.cs ou ToolWindowEvents.vb et ajoutez le code suivant après tous les using instructions ou existant d' Imports .

   Imports System
   Imports System.Collections.Generic
   Imports System.Linq
   Imports System.Text
   Imports Microsoft.VisualStudio.Shell.Interop
   Imports System.ComponentModel.Design
   Imports System.Security.Permissions
   

   using Microsoft.VisualStudio.Shell.Interop;
   using System.ComponentModel.Design;
   using System.Security.Permissions;
   

4. Modifiez la déclaration de classe afin d'être public et sealed, (Public et NotInheritable en Visual Basic) et la héritez de l'interface d' IVsWindowFrameNotify3 , comme suit.

   Public NotInheritable Class ToolWindowEvents
       Implements IVsWindowFrameNotify3
   

   public sealed class ToolWindowEvents : IVsWindowFrameNotify3
   

5. Si vous utilisez c#, cliquez avec le bouton droit sur IVsWindowFrameNotify3, pointez sur Implémenter l'interface, puis cliquez sur Implémenter l'interface pour ajouter automatiquement les méthodes qui sont requises pour l'interface.

   Si vous utilisez Visual Basic, ignorez cette étape.

6. Implémentez la méthode d' OnShow , comme suit.

   Public Function OnShow(ByVal fShow As Integer) As Integer Implements VisualStudio.Shell.Interop.IVsWindowFrameNotify3.OnShow
       If Not fShow = __FRAMESHOW.FRAMESHOW_WinHidden Then
           package.toolMenuItem1.visible = True 
       End If 
       Return Microsoft.VisualStudio.VSConstants.S_OK
   End Function
   

   [PrincipalPermission(SecurityAction.Demand)]
   public int OnShow(int fShow)
   {
       package.toolMenuItem1.Visible
           = ((__FRAMESHOW)fShow
           != __FRAMESHOW.FRAMESHOW_WinHidden);
       return Microsoft.VisualStudio.VSConstants.S_OK;
   }
   

7. Remplissez le contenu des membres d'interface restants d' IVsWindowFrameNotify3 à l'aide de l'instruction return suivante.

   Return Microsoft.VisualStudio.VSConstants.S_OK
   

   return Microsoft.VisualStudio.VSConstants.S_OK;
   

   Avertissement

   En c#, les membres d'interface sont remplis avec les instructions d' throw , que vous devez remplacer.En Visual Basic, les fonctions videront.

   Ajout de code déclare une classe qui recevra les événements de la fenêtre Outil. L'événement utilisé ici est OnShow, dans lequel la visibilité de la commande de menu est définie en fonction de la valeur qui est passée dans l'événement. La valeur passée est une énumération du type __FRAMESHOW. Bien que cette énumération a plusieurs valeurs possibles, dans ce cas, vous devez tester si est égal à FRAMESHOW_WinHidden. S'il n'est pas égal, affectez comme visible valeur true. S'il est égal, affectez comme visible false.

   Toutefois, notez que ce code utilise une variable nommée « package ». Cette variable est passée au constructeur.

8. Ajoutez le code suivant en haut de la classe, au-dessus de la zone où les membres d'interface d' IVsWindowFrameNotify3 sont définis.

   Private package As FirstToolWinPackage
   Public Sub New(ByVal apackage As FirstToolWinPackage)
       package = apackage
   End Sub
   

   private FirstToolWinPackage package;
   public ToolWindowEvents(FirstToolWinPackage apackage)
   {
       package = apackage;
   }
   

   la valeur passée dans ce constructeur est le package lui-même, l'instance de FirstToolWin. Dans l'événement d'OnShow, la commande de menu doit être accessible. Par défaut, cette commande de menu est une variable locale est définie dans la méthode initialize de package.

9. Enregistrez le fichier.

pour accéder à la commande de menu

1. Dans Explorateur de solutions, ouvrez FirstToolWinPackage.cs ou FirstToolWinPackage.vb afin que vous puissiez modifier la classe de FirstToolWin pour rendre l'objet de commande de menu accessible.

2. déclarez un objet d' MenuCommand en haut de la classe pour représenter votre commande de menu.

   Public toolMenuItem1 As MenuCommand
   

   public MenuCommand toolMenuItem1;
   

3. Défilement à la méthode initialize. Recherchez les deux lignes suivantes, qui crée la première commande.

   Dim menuItem As New MenuCommand(New EventHandler(AddressOf MenuItemCallback), menuCommandID)
   mcs.AddCommand(menuItem)
   

   MenuCommand menuItem = new MenuCommand(MenuItemCallback, menuCommandID);
   mcs.AddCommand(menuItem);
   

4. Remplacez l'objet par défaut d' MenuCommand à l'aide de la variable publique qui a été déclarée.

   Dim toolMenuItem1 As New MenuCommand(New EventHandler(AddressOf MenuItemCallback), menuCommandID)
   mcs.AddCommand(toolMenuItem1)
   

   toolMenuItem1 = new MenuCommand(MenuItemCallback, menuCommandID);
   mcs.AddCommand(toolMenuItem1);                
   

5. Enregistrez le fichier.

Ensuite, vous allez créer une instance de la fenêtre Outil et une instance de la classe que vous venez de créer pour recevoir les événements. Vous pouvez joindre l'instance de la classe à l'instance de fenêtre Outil.

Pour joindre des événements

1. dans Explorateur de solutions, ouvrez MyToolWindow.cs ou MyToolWindow.vb. Substituez la méthode d'OnToolWindowCreated en ajoutant le code suivant à la fin de le fichier, avant l'accolade fermante de la définition de classe.

   Public Overrides Sub OnToolWindowCreated()
       MyBase.OnToolWindowCreated()
   
       Dim handler As FirstToolWinPackage = CType( _
           Me.Package, FirstToolWinPackage)
       CType(Me.Frame, IVsWindowFrame).SetProperty( _
           CInt(__VSFPROPID.VSFPROPID_ViewHelper), handler)
   End Sub
   

   public override void OnToolWindowCreated()
   {
       base.OnToolWindowCreated();
   
       var handler = new ToolWindowEvents(
           (FirstToolWinPackage)this.Package);
       ((IVsWindowFrame)this.Frame).SetProperty(
           (int)__VSFPROPID.VSFPROPID_ViewHelper, handler);
   }
   

   Ce code crée une nouvelle instance de la classe qui a été ajoutée précédemment. Elle ajoute ensuite l'instance aux propriétés du frame de sorte que l'instance puisse recevoir des événements. La méthode de SetProperty effectue ceci lorsque vous passez la valeur d'énumération VSFPROPID_ViewHelper pour le premier paramètre, et la nouvelle instance du gestionnaire pour le deuxième paramètre.

2. Enregistrez le fichier.

Pour tester le code

1. Appuyez sur F5 pour compiler le projet et de l'exécuter dans la génération expérimentale de Visual Studio.

2. Cliquez sur le menu Outils.

   La commande de menu de WindowsMedia ne doit pas s'afficher.

3. Dans le menu d' Afficher , pointez sur Autres fenêtres puis cliquez sur Lecteur Windows Media pour afficher la fenêtre de lecteur multimédia.

4. cliquez sur le menu d' Outils de nouveau.

   Maintenant, la commande de menu de WindowsMedia doit apparaître car il a la visibilité dynamique ; autrement dit, si elle est visible est basé sur si la fenêtre de lecteur multimédia est visible.

5. Fermez la fenêtre de lecteur multimédia puis activez le menu d' Outils de nouveau.

   Maintenant, la commande de menu de WindowsMedia ne doit pas s'afficher.

6. Fermez la génération expérimentale.

Ajoutez le code Windows Forms pour interagir avec la fenêtre Outil

Maintenant, ajoutez du code à la classe du package qui répond à la commande de menu. Ce code ouvre une boîte de dialogue d' Ouvrir un fichier puis appeler la nouvelle méthode de LoadFile pour charger un fichier dans lecteur multimédia.

Pour activer la fenêtre Outil dans le code

1. ouvrez FirstToolWinPackage.cs.

2. Ajoutez l'espace de noms d' System.Windows.Forms juste après les instructions using existantes, comme suit.

   Imports System.Windows.Forms
   

   using System.Windows.Forms;
   

3. Recherchez le gestionnaire d' MenuItemCallback . Il s'agit du gestionnaire d'événements en cliquant sur la commande de menu. Remplacez le corps de ce gestionnaire de menu en utilisant le code suivant.

   Dim openFileDialog As System.Windows.Forms.OpenFileDialog = New System.Windows.Forms.OpenFileDialog()
   Dim result As DialogResult = openFileDialog.ShowDialog()
   If (result = DialogResult.OK) Then 
       Dim window As MyToolWindow = TryCast(Me.FindToolWindow(GetType(MyToolWindow), 0, True), MyToolWindow)
       If (window IsNot Nothing) Then
           window.LoadFile(openFileDialog.FileName)
       End If 
   End If
   

   System.Windows.Forms.OpenFileDialog openFileDialog = new System.Windows.Forms.OpenFileDialog();
   DialogResult result = openFileDialog.ShowDialog();
   if (result == DialogResult.OK)
   {
       MyToolWindow window = (MyToolWindow)(this.FindToolWindow(
           typeof(MyToolWindow), 0, true));
       if (window != null)
       {
           window.LoadFile(openFileDialog.FileName);
       }
   }
   

4. Enregistrez votre travail.

Ce code ouvre une boîte de dialogue d' Ouvrir un fichier afin que vous puissiez accéder au fichier multimédia à charger dans lecteur multimédia. Elle localise l'instance de MyToolWindow et appelle la méthode de LoadFile, que vous avez créée précédemment, pour charger le fichier multimédia.

Pour tester le code

1. Appuyez sur F5 pour compiler le projet et de l'exécuter dans l'instance expérimentale de Visual Studio.

2. Dans le menu d' Outils , cliquez sur WindowsMedia.

   La boîte de dialogue d' Ouvrir un fichier doit apparaître.

3. Dans la boîte de dialogue d' Ouvrir un fichier , sélectionnez un fichier multimédia valide puis cliquez sur OK.

   Le fichier doit jouer dans lecteur multimédia.

4. Fermez l'instance expérimentale.

Quoi d'autre ?

Cette procédure pas - à - pas montre comment ajouter des commandes de menu qui ont la visibilité dynamique. Elle indique également comment ajouter des contrôles à une fenêtre Outil qui interagissent avec d'autres contrôles de la fenêtre Outil. Ces concepts s'appliquent généralement aux fenêtres Outil. Les contrôles que vous ajoutez aux fenêtres Outil étroitement ressemblent aux contrôles utilisateur que vous utiliseriez dans une application Windows Forms.

Dans la procédure pas - à - pas suivante, Procédure pas - à - pas : Intégrant dans la fenêtre Propriétés, la liste des tâches, la fenêtre Sortie, et la boîte de dialogue options (partie de 4), vous pouvez en apprendre comment intégrer votre fenêtre Outil avec des fenêtres Outil existantes dans Visual Studio, tels que la fenêtre de Propriétés , la fenêtre de Sortie , et la fenêtre de Liste des tâches .

Voir aussi

Autres ressources

Étendre la présentation de Visual Studio