Passo a passo: Criando uma janela de ferramenta (parte 2 de 4)

Artigo
05/18/2015

Janelas de ferramentas são comuns em ambiente de desenvolvimento integrado (IDE) Visual Studio. Veja alguns exemplos de janelas de ferramentas que estão incluídas na Visual Studio Solution Explorer, Lista de tarefas, Error Liste o saída janela. Todas as janelas de ferramentas têm alguns recursos em comum, por exemplo, todos podem ser encaixados no IDE da mesma maneira. Encaixe previsível permite que os usuários a gerenciar suas tarefas e informações com eficiência.

Esta explicação passo a passo ensina como criar uma janela de ferramentas no IDE Visual Studio usando as seguintes etapas:

Crie uma janela de ferramenta.
Incorpore um controle na janela da ferramenta.
Adicione uma barra de ferramentas para uma janela de ferramenta.
Adicione comandos à barra de ferramentas.
Implemente os comandos.
Defina a posição padrão para a janela da ferramenta.

Esta explicação passo a passo é parte de uma série que ensina como estender o IDE de Visual Studio. Para obter mais informações, consulte Explicações passo a passo para personalizar Visual Studio usando VSPackages.

Pré-requisitos

Para concluir este passo a passo, você deve instalar o SDL do Visual Studio 2010.

Dica

Para obter mais informações sobre o SDK de Visual Studio, consulte Ampliando a visão geral de Visual Studio.Para descobrir como fazer o download do SDK do Visual Studio, consulte Visual Studio extensibilidade Developer Center no site do MSDN.

Locais para o modelo de projeto de pacote de Visual Studio

O modelo de projeto do pacote de Visual Studio está disponível nos três locais, o Novo projeto caixa de diálogo:

Em Visual Basic extensibilidade. O idioma padrão do projeto é Visual Basic.
Em C# extensibilidade. O idioma padrão do projeto é C#.
Em outra extensibilidade de tipos de projeto. O idioma padrão do projeto é C++.

Criar uma janela de ferramenta

Para criar uma janela de ferramenta

Criar um VSPackage chamado FirstToolWin. Você também pode criar um diretório para a solução. Clique em OK.
Na página Bem-vindo, clique em próximo.
Sobre o Select a Programming Language página, clique em C# Visual ou Visual Basic clique em gerar um novo arquivo de chave para assinar o conjuntoe, em seguida, clique em próximo.
Reserve um tempo para examinar o Informações básicas de VSPackage página. O valor de Nome da empresa caixa é usada como o espaço para nome para todas as classes no projeto. O nome VSPackage caixa fornece um nome para o pacote compilado final e o versão VSPackage caixa fornece informações de versão. Mínimo edition de Visual Studio Especifica quais edições do Visual Studio o pacote deve ser executado no. O conteúdo do informações detalhadas caixa aparecerá na página Propriedades do pacote concluído. O Alterar ícone botão permite que você selecione um ícone para representar um pacote.

Para esta explicação, apenas aceite os valores padrão, clicando em próximo.
Sobre o Selecionar opções de VSPackage , selecione Comando de Menu e Janela da ferramentae, em seguida, clique em próximo.

Dica

A opção de comando de Menu é necessário o próximo passo a passo, Passo a passo: Estendendo a janela da ferramenta (parte 3 de 4), que se baseia neste projeto.
Sobre o Opções de comando de Menu página, o nome do comando , digite Windows Media. No ID do comando , digite cmdidWindowsMediae, em seguida, clique em próximo.
Sobre o Opções da janela de ferramenta página, o nome da janela , digite De Windows Media Player. No ID do comando de campo, digite um identificador válido, por exemplo, cmdidWindowsMediaWine, em seguida, clique em próximo.
Sobre o Selecionar opções de projeto de teste página, limpar Projeto de teste de integração e Projeto de teste de unidadee, em seguida, clique em Concluir.
Em Solution Explorer, clique duas vezes em MyControl.xaml.
Com o botão direito do clique em mim! e, em seguida, clique Excluir.

Incorporar um controle na janela da ferramenta

Em seguida, adicione o controle de Windows Media Player a caixa de ferramentas e, em seguida, adicioná-lo para a janela da ferramenta.

Para incorporar um controle na janela da ferramenta

No caixa de ferramentas, expanda o Todos os controles do WPF seção e procure por Elemento de mídia.
Para adicionar o Media Player para sua janela de ferramentas, arraste o Elemento de mídia controlar a partir de Toolbox ao formulário MeuControle.
No designer, selecione o controle do elemento de mídia e, em seguida, examine as propriedades disponíveis na Propriedades janela. Algumas das propriedades são padronizadas em todos os controles Windows Forms. No entanto, outros são fornecidos pelo controle, por exemplo, origem, que é usado para carregar um arquivo em tempo de execução.
No menu File, clique em Save All.

Adicionar uma barra de ferramentas para a janela de ferramenta

Adicionando uma barra de ferramentas da seguinte maneira, você garante que suas cores e gradientes são consistentes com o restante do IDE.

Para adicionar uma barra de ferramentas para a janela de ferramenta

Em Solution Explorer, abra FirstToolWin.vsct. O arquivo de .vsct define elementos graphical user interface (GUI) na sua janela de ferramenta usando o XML.
No <Symbols> seção, encontrar o <GuidSymbol> nó cujo name atributo é guidFirstToolWinCmdSet. Adicione os seguintes dois <IDSymbol> elementos à lista de <IDSymbol> elementos nesse nó para definir uma barra de ferramentas e um grupo da barra de ferramentas.
```
<IDSymbol name="ToolbarID" value="0x1000" />
<IDSymbol name="ToolbarGroupID" value="0x1001" />
```
Anteriormente a <Groups> seção, criar um <Menus> seção parecida com isto:
```
<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>
```
Todos os recipientes para comandos são definidos como diferentes tipos de menus. Por sua type atributo, esta é definida para aparecer como uma barra de ferramentas em uma janela de ferramenta. O guid e id configurações constituem a identificação totalmente qualificada da barra de ferramentas. Normalmente, o <Parent> de um menu refere-se ao grupo que o contém. No entanto, uma barra de ferramentas é definida como seu próprio pai. Portanto, o mesmo identificador é usado para o <Menu> e <Parent> elementos. O priority atributo está apenas ' 0'.
Barras de ferramentas são semelhantes a menus de várias maneiras. Por exemplo, assim como um menu pode ter grupos de comandos, barras de ferramentas também podem ter grupos. (Nos menus, os grupos de comando são separados por linhas horizontais. Nas barras de ferramentas, os grupos não estiverem separados por divisores visual.)

Adicionar um novo <Group> elemento para o <Groups> seção para definir o grupo que você declarado na <Symbols> seção.
```
<Group guid="guidFirstToolWinCmdSet" id="ToolbarGroupID" priority="0x0000">
  <Parent guid="guidFirstToolWinCmdSet" id="ToolbarID"/>
</Group>
```
Definindo o pai guid e id para o guid e a identificação da barra de ferramentas, você pode colocar o grupo na barra de ferramentas.
Salve o arquivo.

Adicionar comandos à barra de ferramentas

Em seguida, adicione comandos da barra de ferramentas. Os comandos serão exibidos como botões e controles.

Para adicionar comandos à barra de ferramentas

No FirstToolWin.vsct, no <Symbols> seção, declare os três comandos logo após a barra de ferramentas e a barra de ferramentas declarações de grupo.
```
<IDSymbol name="cmdidWindowsMediaOpen" value="0x132" />
<IDSymbol name="cmdidWindowsMediaFilename" value="0x133" />
<IDSymbol name="cmdidWindowsMediaFilenameGetList" value="0x134" />
```
Observe que os comandos cmdidWindowsMedia e cmdidWindowsMediaWin já foi declarado.
No <Buttons> seção, uma <Button> elemento já está presente e contém uma definição para os comandos cmdidWindowsMedia e cmdidWindowsMediaWin. Adicionar outro <Button> elemento para definir o comando 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>
```
Observe que a prioridade do segundo botão é 0x0101. A caixa de combinação é adicionada na próxima etapa tem a prioridade 0x0100. Portanto, a caixa de combinação é exibida na primeira posição e o botão será exibido na segunda posição.

Para fornecer um local para que o usuário digite algum texto, adicione uma caixa de combinação. Adicionar uma caixa de combinação é como adicionar um botão, exceto que você define a combinação caixa de um <Combos> seção.

Criar um <Combos> seção, logo após o </Buttons> marca, que tem uma entrada para definir a caixa de combinação.

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

Salve e feche o FirstToolWin.vsct.

Em Solution Explorer, na pasta do projeto, abra PkgCmdID.cs ou PkgCmdID.vb e, em seguida, adicione as seguintes linhas na classe logo após os membros existentes.

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;

Isso faz com que seus comandos disponíveis no código.

Salve e feche o arquivo.

Implementar os comandos

Agora, escreva o código que implementa os comandos.

Para implementar os comandos

Em Solution Explorer, abra MyToolWindow.cs ou MyToolWindow.vb, que contém a classe para a janela da ferramenta.

Adicione o seguinte código logo após o existente usando as instruções.
```
Imports System.ComponentModel.Design
```
```
using System.ComponentModel.Design;
```
Esta linha permite que você use o CommandID classe sem precisar qualificar totalmente-lo.

Adicione o seguinte código ao construtor, antes da linha que diz 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);
}

Este código adiciona três comandos, um para o botão e dois para a caixa de combinação. A caixa de combinação requer dois comandos, um para quando o usuário fizer uma entrada e outra para preencher a lista drop-down.

Os manipuladores de eventos para os controles da barra de ferramentas, seu código deve ser capaz de acessar o controle do Media Player, que é filho da classe MeuControle.

Em Solution Explorer, MyControl.xaml com o botão direito, clique em Exibir códigoe adicione o seguinte código à classe MeuControle.
```
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; }
}
```
Salve o arquivo.

Retorne para MyToolWindow.cs ou MyToolWindow.vb e adicione o seguinte código no final da classe, antes das duas chaves de fechamento finais (C#) ou a instrução End Class (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)
    {
    }

Observe que menuMyDynamicComboCommand e menuItem compartilham o mesmo manipulador de eventos. Portanto, a janela da ferramenta pode reproduzir o arquivo especificado na caixa de combinação. Esta explicação passo a passo, você não fornecer o código para a função ComboListHandler. O próximo passo a passo, Passo a passo: Estendendo a janela da ferramenta (parte 3 de 4), adicione o código que preenche a lista drop-down usando nomes da lista de reprodução.

O manipulador de combinação salva que é digitado em uma variável de membro para ela. Para adicionar essa variável, adicione o seguinte código na parte superior da classe (em Visual Basic, após a declaração Inherits). Ao mesmo tempo, adicione uma variável de membro para manter o controle.
```
Dim control As MyControl
Dim comboValue As String
```
```
private MyControl control;
string comboValue = "";
```
Quando o botão é clicado, o botão lê o valor dessa variável local e o carrega no Media Player.

Definir a posição padrão para a janela da ferramenta

Em seguida, especifique um local padrão no IDE para a janela da ferramenta. Informações de configuração para a janela da ferramenta estão no arquivo FirstToolWinPackage.cs.

Para definir a posição padrão para a janela da ferramenta

Em Solution Explorer, abra FirstToolWinPackage.cs ou FirstToolWinPackage.vb. Nesse arquivo, localize o ProvideToolWindowAttribute atributo sobre o FirstToolWinPackage classe. Esse código está passando o tipo de MyToolWindow para o construtor. Para especificar uma posição padrão, você deve adicionar mais parâmetros para o seguinte exemplo de construtor.
```
<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")]
```
O primeiro parâmetro nomeado é o estilo e seu valor será tabulado, o que significa que a janela será uma guia em uma janela existente. A janela é fornecida pela janela denominada parâmetro; seu valor é um GUID. Nesse caso, o GUID é aquele do Solution Explorer.

Dica

Para obter mais informações sobre as GUIDs para janelas do IDE, consulte vsWindowKind constantes no site do MSDN.
Salve seu trabalho.

A janela da ferramenta de teste.

Para testar a janela da ferramenta

Pressione F5 para abrir uma nova instância do Visual Studio experimental de compilação.
Sobre o Exibir , aponte para Other Windows e, em seguida, clique em De Windows Media Player.

A janela de ferramenta do media player deve ser aberto na mesma janela como Solution Explorer.
Na caixa de combinação, na janela de ferramenta do media player, digite o caminho e o nome completo do pressionamento de um arquivo com suporte de som ou vídeo, o, por exemplo, C:\windows\media\chimes.wav, Entere então clique no botão adjacente.

Dica

Você precisa inserir um nome de arquivo na caixa de texto, porque a janela de ferramenta do media player não tem um Abrir arquivo caixa de diálogo.

O Que Mais Há

Na Passo a passo: Estendendo a janela da ferramenta (parte 3 de 4), você pode aprender a adicionar mais controles para a janela da ferramenta. Você adiciona um botão que exibe um Abrir arquivo caixa de diálogo que você pode usar para selecionar o arquivo para reprodução no Media Player. Também é possível adicionar uma lista drop-down de listas de reprodução para que você possa selecionar um para reproduzir.

Consulte também

Tarefas

Passo a passo: Adicionando uma barra de ferramentas ao IDE

Passo a passo: Adicionando uma barra de ferramentas para uma janela de ferramenta

Outros recursos

Comandos, Menus e barras de ferramentas

Compartilhar via