Exemplarische Vorgehensweise: Ein Toolfenster erstellen (Teil 2 von 4)

Toolfenster sind in der integrierten Entwicklungsumgebung (IDE) von Visual Studio. Einige Beispiele von Toolfenstern, die in Visual Studio enthalten sind, sind Projektmappen-Explorer, Aufgabenliste, Fehlerlisteund das Ausgabe Fenster. Alle Toolfenster haben Gemeinsamkeiten, einige Features kann z. B. alle in der IDE auf die gleiche Weise angedockt werden. Vorhersagbares Andocken können Benutzer ihre Aufgaben und Informationen effizient verwalten.

In dieser exemplarischen Vorgehensweise unterrichtet, wie ein Toolfenster in der IDE von Visual Studio erstellt wird, indem sie die folgenden Schritte:

• Erstellen Sie ein Toolfenster.

• Betten Sie ein Steuerelement im Toolfenster ein.

• Hinzufügen einer Symbolleiste ein Toolfenster.

• Fügen Sie der Symbolleiste Befehle hinzu.

• Implementieren Sie die Befehle.

• Legen Sie die Standardposition für das Toolfenster festgelegt.

Diese exemplarische Vorgehensweise ist Teil einer Zeile, der unterrichtet, wie die Visual Studio-IDE erweitert. Weitere Informationen finden Sie unter Exemplarische Vorgehensweisen zum Anpassen von Visual Studio mithilfe von VSPackages.

Vorbereitungsmaßnahmen

Zum Abschließen dieser exemplarischen Vorgehensweise müssen Sie Visual Studio 2010 SDKinstallieren.

Hinweis

Weitere Informationen über das Visual Studio-SDK finden Sie unter Erweitern von Visual Studio Overview.Um herauszufinden finden Sie unter wie das Visual Studio-SDK, auf Visual Studio Extensibility Developer Center der MSDN-Website herunterlädt.

Speicherorte für die Visual Studio-Paket-Projektvorlage

Die Visual Studio-Paket Projektvorlage ist in drei Positionen im Dialogfeld Neues Projekt verfügbar:

• Die Visual Basic-Erweiterbarkeit. Die Standardsprache des Projekts ist Visual Basic.

• Die C#-Erweiterbarkeit. Die Standardsprache ist C# des Projekts.

• Die Andere Projekttypen/Erweiterungen. Die Standardsprache des Projekts ist C++.

Erstellen Sie ein Toolfenster erstellen

So erstellen Sie ein Toolfenster

1. Erstellen Sie ein VSPackage, das FirstToolWinbenannt ist. Sie können ein Verzeichnis für die Projektmappe erstellen. Klicken Sie auf OK.

2. Wählen Sie auf der Seite Willkommen auf Weiter.

3. Klicken Sie auf der Seite Wählen Sie eine Programmiersprache aus.Visual C# oder klicken Sie auf Visual BasicNeue Schlüsseldatei für die Assemblysignierung generieren, und klicken Sie dann auf Weiter.

4. Sehen Sie sich die Zeit Grundlegende Informationen zum VSPackage Seite zu überprüfen. Der Wert im Firmenname Feld wird als Namespace für alle Klassen im Projekt verwendet. Das VSPackage-Name Feld gibt einen Namen für das letzte kompilierte Paket und das VSPackage-Version Feld stellt Versionsinformationen. Minimum Visual Studio-Edition gibt an, welche Visual Studio-Editionen das Paket ausgeführt werden sollen. Der Inhalt des Felds Ausführliche Informationen werden auf der Eigenschaftenseite des fertigen Pakets. Die Symbol ändern Schaltfläche können Sie ein Symbol auswählen, um das Paket darstellt.

   In dieser exemplarischen Vorgehensweise übernehmen Sie einfach die Standardwerte, indem Sie auf Weiterklicken.

   

5. Wählen Sie auf der Seite Optionen für das VSPackage auswählenMenübefehl und Toolfenster, und klicken Sie dann auf Weiter.

   

   Hinweis

   Die Option Menübefehls ist in der folgenden exemplarischen Vorgehensweise Exemplarische Vorgehensweise: Das Toolfenster erweitern (Teil 3 von 4)erforderlich, die in diesem Projekt erstellt.

6. Auf der Seite MenübefehlsoptionenBefehlsname im Feld Typ Windows Media. Im Befehls-ID Feld cmdidWindowsMediaund klicken Sie dann auf Weiter.

   

7. Auf der Seite Optionen des ToolfenstersFenstername im Feld Typ Windows Media Player. Wählen Sie im Feld Befehls-ID Geben Sie einen gültigen Bezeichner cmdidWindowsMediaWinbeispielsweise ein, und klicken Sie dann auf Weiter.

   

8. Auf der Seite Optionen für das Testprojekt auswählen genau Integrationstestprojekt und Komponententestprojekt, und klicken Sie dann auf Fertig stellen.

9. In Projektmappen-ExplorerDoppelklick MyControl.xaml.

10. Klicken Sie mit der rechten Maustaste auf die Hier klicken! Schaltfläche und klicken Sie dann auf Löschen.

Betten Sie ein Steuerelement in einem Toolfenster

Als Nächstes fügen Sie das Windows Media Player-Steuerelement Toolbox hinzu, und fügen Sie es dann dem Toolfenster hinzu.

So fügen Sie ein Steuerelement im Toolfenster einbetten

1. In Toolboxerweitern Sie den Abschnitt Alle WPF-Steuerelemente und suchen Sie nach Medienelement.

2. Um den Media Player dem Toolfenster Medienelement hinzuzufügen, ziehen Sie das Steuerelement aus dem Toolbox MyControl-Formular.

3. Wählen Sie im Designer das Medienelement die Steuerung aus, und überprüfen Sie dann die verfügbaren Eigenschaften im Fenster Eigenschaften . Einige Eigenschaften sind in allen Windows Forms-Steuerelementen Standardwert. Allerdings werden weitere vom Steuerelement Quellez. B. angegeben, das verwendet wird, um eine Datei zur Laufzeit zu laden.

4. Klicken Sie im Menü Datei auf Alle speichern.

Fügen Sie eine Symbolleiste dem Toolfenster hinzu

Mit einer Symbolleiste in der folgenden Weise hinzufügen, stellen Sie sicher, dass seine Farben und Farbverläufen mit dem Rest der IDE konsistent sind.

So erstellen Sie eine Symbolleiste dem Toolfenster hinzu

1. In Projektmappen-Exploreröffnen Sie FirstToolWin.vsct. Die .vsct-Datei definiert die Elemente der grafischen Benutzeroberfläche (GUI) im Toolfenster, indem XML verwendet.

2. Im <Symbols> Suchen Sie den Abschnitt <GuidSymbol> Knoten, dessen name-Attribut guidFirstToolWinCmdSetist. Fügen Sie die folgenden beiden <IDSymbol>-Elemente der Liste der <IDSymbol>-Elemente in diesem Knoten hinzu, um eine Symbolleiste und eine Gruppe von Symbolleisten zu definieren.

   <IDSymbol name="ToolbarID" value="0x1000" />
   <IDSymbol name="ToolbarGroupID" value="0x1001" />
   

3. Derzeit über dem <Groups>-Abschnitt erstellen Sie einen <Menus> diesem Abschnitt ähnelt:

   <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>
   

   Alle Container für Befehle werden als verschiedene Arten von Menüs definiert. Durch das type Dieses Attribut wird festgelegt, dass als Symbolleiste in einem Toolfenster angezeigt wird. Die guidundid Einstellungen bilden die vollqualifizierte ID der Symbolleiste. In der Regel bezieht sich auf <Parent> eines Menüs die enthaltende Gruppe an. Es wird eine Symbolleiste als ein eigenes übergeordnetes Element definiert. Daher wird der gleiche Bezeichner für die <Menu> und <Parent>-Elemente verwendet. Das priority-Attribut ist „0 ".

4. Symbolleisten ähneln Menüs in vielerlei Hinsicht. Zum Beispiel kann ein Menü nur für Befehle sind möglicherweise Gruppen verfügt außerdem Symbolleisten Gruppen. (Klicken Menüs, werden die horizontale Linien von Befehlsgruppen getrennt. Klicken Sie auf Symbolleisten werden die Gruppen nicht von visuellen teiler) getrennt.

   Fügen Sie ein neues <Group>-Element dem <Groups>-Abschnitt hinzu, um die Gruppe zu definieren, die Sie im <Symbols>-Abschnitt deklarierten.

   <Group guid="guidFirstToolWinCmdSet" id="ToolbarGroupID" priority="0x0000">
     <Parent guid="guidFirstToolWinCmdSet" id="ToolbarID"/>
   </Group>
   

   Mit dem Elemente GUID und ID auf den GUID und ID der Symbolleiste festlegen, setzen Sie die Gruppe in der Symbolleiste ein.

5. Speichern Sie die Datei.

Fügen Sie der Symbolleiste Befehle hinzu

Fügen Sie anschließend der Symbolleiste Befehle hinzu. Die Befehle werden als Schaltflächen und Steuerelemente angezeigt.

Klicken Sie auf der Symbolleiste Befehle hinzufügen

1. In FirstToolWin.vsct im Abschnitt <Symbols> , deklarieren Sie drei Befehle, gleich nachdem die Symbolleiste und die Symbolleiste Deklarationen gruppieren.

   <IDSymbol name="cmdidWindowsMediaOpen" value="0x132" />
   <IDSymbol name="cmdidWindowsMediaFilename" value="0x133" />
   <IDSymbol name="cmdidWindowsMediaFilenameGetList" value="0x134" />
   

   Beachten Sie, dass die Befehle cmdidWindowsMedia und cmdidWindowsMediaWin bereits deklariert werden.

2. Im <Buttons>-Abschnitt enthält ein <Button>-Element bereits vorhanden und enthält eine Definition für die cmdidWindowsMedia und cmdidWindowsMediaWin Befehle. Fügen Sie ein weiteres <Button>-Element hinzu, um den cmdidWindowsMediaOpen Befehl zu definieren.

     <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>
   

   Beachten Sie, dass die Priorität der zweiten Schaltfläche 0x0101ist. Das Kombinationsfeld, das im nächsten Schritt hinzugefügt wird, ist die Priorität 0x0100. Daher wird das Kombinationsfeld an der ersten Position und die Schaltfläche wird in der zweiten Position.

3. Um einen Ort bereitzustellen hinzufügen sodass der Benutzer Text eingibt, fügen Sie ein Kombinationsfeld. Ein Kombinationsfeld hinzugefügt werden, z. B. das Hinzufügen einer Schaltfläche, mit der Ausnahme, dass Sie definieren das Kombinationsfeld in einem <Combos>-Abschnitt.

   Erstellen Sie einen <Combos> direkt nach dem Abschnitt </Buttons>-Tag, das einen Eintrag zum des Kombinationsfelds zu definieren.

   <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>
   

4. Speichern und schließen Sie FirstToolWin.vsct.

5. In Projektmappen-Explorerim Projektordner geöffnet, PkgCmdID.cs oder PkgCmdID.vb und fügen Sie dann die folgenden Zeilen in der Klasse direkt nach den vorhandenen Member hinzu.

   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;
   

   Auf diese Weise werden die Befehle im Code bereit.

6. Speichern und schließen Sie die Datei.

Implementieren Sie die Befehle

Schreiben Sie nun den Code, der die Befehle implementiert.

So implementieren Sie die Befehle

1. In Projektmappen-Exploreröffnen Sie MyToolWindow.cs oder MyToolWindow.vb, die die Klasse für das Toolfenster selbst enthält.

   Fügen Sie folgenden Code direkt nach den vorhandenen using-Anweisungen hinzu.

   Imports System.ComponentModel.Design
   

   using System.ComponentModel.Design;
   

   Diese Zeile können Sie die CommandID-Klasse verwenden, ohne sie vollständig qualifizieren.

2. Fügen Sie dem Konstruktor den folgenden Code direkt vor der Zeile hinzu, die control = new MyControl() (C#) oder Me.Content = New MyControl() (VB) zu lesen ist.

   ' 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);
   } 
   

   Mit diesem Code werden drei Befehle, die für die Schaltfläche und zwei für das Kombinationsfeld hinzu. Das Kombinationsfeld erfordert zwei Befehle, und zwar für, wenn der Benutzer einen Eintrag vornimmt, und einen, die Dropdownliste aus.

3. Von den Ereignishandlern für die Symbolleisten-Steuerelemente, muss der Code in der Lage sein, das Media Player-Steuerelement zuzugreifen, das ein untergeordnetes Element der MyControl-Klasse ist.

   In Projektmappen-Explorermit der rechten Maustaste auf MyControl.xaml, auf Code anzeigen, und fügen Sie den folgenden Code hinzu. MyControl-Klasse

   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; }
   }
   

4. Speichern Sie die Datei.

5. Kehren Sie zu MyToolWindow.cs oder MyToolWindow.vb zurück, und fügen Sie den folgenden Code am Ende der Klasse, unmittelbar vor den letzten zwei schließende geschweifte Klammern (C#) oder der Enden-Klassen Statement (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)
       {
       }
   

   Beachten Sie, dass menuMyDynamicComboCommand und menuItem denselben Ereignishandler verwenden. Daher kann das Toolfenster die Datei, die im Kombinationsfeld angegeben wird. In dieser exemplarischen Vorgehensweise erstellen Sie Code nicht für die ComboListHandler-Funktion bereit. In der folgenden Exemplarische Vorgehensweise: Das Toolfenster erweitern (Teil 3 von 4)exemplarischen Vorgehensweise fügen Sie Code hinzu, der die Dropdownliste ausfüllt, indem Wiedergabelisten Namen verwendet.

6. Der Kombinatione Handler speichert, was in es in einer Membervariablen zugewiesen wird. Um diese Variable hinzufügen möchten, fügen Sie den folgenden Code am Anfang der Klasse hinzu (in Visual Basic, nachdem Anweisung erbt). Gleichzeitig fügen Sie eine Membervariable hinzu, um das Steuerelement enthält.

   Dim control As MyControl
   Dim comboValue As String
   

   private MyControl control;
   string comboValue = "";
   

   Wenn auf die Schaltfläche geklickt wird, liest die Schaltfläche den Wert der lokalen Variablen und lädt sie im Media Player.

Legen Sie die Standardposition für das Toolfenster fest

Anschließend geben Sie einen Standardspeicherort für das Toolfenster in der IDE angezeigt. Konfigurationsinformationen für das Toolfenster sind in der FirstToolWinPackage.cs-Datei.

Um die Standardposition für das Toolfenster festlegen

1. In Projektmappen-Exploreröffnen Sie FirstToolWinPackage.cs oder FirstToolWinPackage.vb. In dieser Datei finden Sie unter ProvideToolWindowAttribute das Attribut der FirstToolWinPackage-Klasse. Dieser Code übergibt den MyToolWindow-Typ an den Konstruktor. Um eine standardmäßige Position anzugeben, müssen Sie mehrere Parameter. B. nach dem Konstruktor hinzufügen.

   <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")]
   

   Der erste Parameter ist mit dem Format, und sein Wert ist im Registerkartenformat. Dies bedeutet, dass das Fenster eine Registerkarte in einem vorhandenen Fenster ist. Das Fenster wird durch den benannten Fenster Parameter angegeben. ihr Wert ist eine GUID. In diesem Fall ist die GUID für das Projektmappen-Explorer.

   Hinweis

   Weitere Informationen über die GUID für Fenster in der IDE finden Sie unter vsWindowKind Constants auf der MSDN-Website.

2. Speichern Sie Ihre Arbeit.

Das Toolfenster testen

So testen Sie das Toolfenster

1. Drücken Sie F5, um eine neue Instanz der experimentellen Build von Visual Studio zu öffnen.

2. Zeigen Sie im Menü Ansicht klicken Sie auf Weitere Fenster , und klicken Sie dann auf Windows Media Player.

   Das Fenster Media Player-Tool sollte sich in demselben Fenster z. B. Projektmappen-Exploreröffnen.

3. Klicken Sie im Fenster Player-Tool Media im Kombinationsfeld, geben Sie den vollständigen Pfad und den Dateinamen eines unterstützten Sounds oder Videodatei zum Beispiel C:\windows\media\chimes.wav, drücken Sie Eingabeein, und klicken Sie dann auf die Schaltfläche benachbarte.

   Hinweis

   Sie müssen einen Dateinamen in das Textfeld eingeben, da das Fenster kein Datei öffnen Media Player-Tool Dialogfeld besitzt.

Weitere Informationen

In Exemplarische Vorgehensweise: Das Toolfenster erweitern (Teil 3 von 4)erfahren Sie, wie Sie dem Toolfenster mehr Steuerelemente hinzugefügt werden. Sie fügen Sie eine Schaltfläche hinzu, mit der ein Datei öffnen Dialogfeld angezeigt, das Sie verwenden können, um die Datei auszuwählen, die im Media Player wiederzugeben. Sie fügen außerdem eine Dropdownliste mit Wiedergabelisten hinzu, damit Sie eine von ihnen festlegen können, um wiederzugeben.

Siehe auch

Aufgaben

Exemplarische Vorgehensweise: Eine Symbolleiste hinzufügen in der IDE

Exemplarische Vorgehensweise: Eine Symbolleiste auf ein Toolfenster hinzu

Weitere Ressourcen

Befehle, Menüs und Symbolleisten