Compartilhar via

Passo a passo: Estendendo a janela da ferramenta (parte 3 de 4)

  • Artigo

Esta explicação passo a passo, você adiciona para a janela de ferramenta que você criou na Passo a passo: Criando uma janela de ferramenta (parte 2 de 4). Você adiciona um botão que exibe um Abrir arquivo de caixa de diálogo para que você possa selecionar o arquivo para reprodução no Media Player.

Esta explicação passo a passo mostra como adicionar visibilidade dinâmica a um comando de menu.

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

Adicionar a visibilidade dinâmica a um comando de Menu

Por padrão, os comandos de menu são fixos no lugar e não podem ser ocultados depois que eles são mostrados. No entanto, o design desta explicação passo a passo é que decide o pacote em tempo de execução se o comando deve ser visível, com base em se a janela de ferramenta do Media Player está ativa.

Primeiro, você deve modificar o FirstToolWin.vsct para ativar a visibilidade dinâmica e implementar a lógica para definir a visibilidade no código. Você cria uma classe de eventos de janela de ferramenta de manutenção, em seguida, modificar o pacote para disponibilizar o objeto de comando de menu e, em seguida, vinculá-los juntos.

Para ativar a visibilidade dinâmica

  1. Abra o projeto de "FirstToolWin", que você criou na Passo a passo: Criando uma janela de ferramenta (parte 2 de 4).

  2. Em Solution Explorer, abra FirstToolWin.vsct.

  3. Encontrar o <Button> elemento que possui a identificação, cmdidWindowsMedia. Entre os <icon> definição e o <Strings> seção, adicione dois sinalizadores de comando, da seguinte maneira.

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

  4. Salve o arquivo.

Para criar eventos da janela de ferramenta

  1. Em Solution Explorer, o botão direito do mouse no nome do projeto, aponte para Adde, em seguida, clique em classe.

  2. No Add New Item caixa de diálogo, nomeie o arquivo ToolWindowEvents.cs ou ToolWindowEvents.vb e, em seguida, clique em Add.

  3. Abra ToolWindowEvents.cs ou ToolWindowEvents.vb e adicione o seguinte código após todos os existentes using ou Imports instruções.

    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. Altere a declaração de classe para que ele seja public e sealed, (Public e NotInheritable em Visual Basic) e herda a partir de IVsWindowFrameNotify3 interface, da seguinte maneira.

    Public NotInheritable Class ToolWindowEvents
    Implements IVsWindowFrameNotify3

    public sealed class ToolWindowEvents : IVsWindowFrameNotify3

  5. Se você estiver usando o C#, IVsWindowFrameNotify3 com o botão direito, aponte para Implementar Interfacee, em seguida, clique em Implementar Interface para adicionar automaticamente os métodos que são necessários para a interface.

    Se você estiver usando Visual Basic, ignore esta etapa.

  6. Implementar a OnShow método, da seguinte maneira.

    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. Preencha o conteúdo restante da IVsWindowFrameNotify3 membros de uma interface, usando a seguinte instrução return.

    Return Microsoft.VisualStudio.VSConstants.S_OK

    return Microsoft.VisualStudio.VSConstants.S_OK;

    Aviso

    No C#, os membros de interface serão preenchidos com throw instruções, que você deve substituir.No Visual Basic, as funções serão vazio.

    O código adicionado declara uma classe que receberá os eventos da janela de ferramenta. O evento usado aqui é OnShow, no qual a visibilidade do comando de menu será definida com base no valor que é passado para o evento. O valor transmitido é uma enumeração do tipo __FRAMESHOW. Embora esta enumeração tem vários valores possíveis, nesse caso, você deve testar se ele é igual a FRAMESHOW_WinHidden. Se não for igual, em seguida, defina Visible como true. Se ele for igual, em seguida, defina Visible como false.

    No entanto, observe que esse código usa uma variável chamada "pacote". Essa variável é passada para o construtor.

  8. Adicione o seguinte código na parte superior da classe, acima da região onde o IVsWindowFrameNotify3 membros de interface são definidos.

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

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

    Valor passado para esse construtor é o pacote propriamente dito, a instância de FirstToolWin. No evento OnShow, o comando de menu deve ser acessado. Por padrão, esse comando de menu é uma variável de escopo local no método Initialize do pacote.

  9. Salve o arquivo.

Para acessar o comando de menu

  1. Em Solution Explorer, abra FirstToolWinPackage.cs ou FirstToolWinPackage.vb, para que você possa modificar a classe FirstToolWin para disponibilizar o objeto de comando de menu.

  2. Declarar um MenuCommand o objeto na parte superior da classe para representar o comando de menu.

    Public toolMenuItem1 As MenuCommand

    public MenuCommand toolMenuItem1;

  3. Role para o método Initialize. Localize as duas linhas a seguir, que cria o primeiro comando.

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

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

  4. Substituir o padrão MenuCommand o objeto usando a variável pública que foi declarada anteriormente.

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

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

  5. Salve o arquivo.

Em seguida, você criará uma instância da janela de ferramenta e também uma instância da classe recém-criado para receber os eventos. Em seguida, você pode anexar a instância da classe para a instância da janela de ferramenta.

Para anexar os eventos

  1. Em Solution Explorer, abra MyToolWindow.cs ou MyToolWindow.vb. Substitua o método OnToolWindowCreated, adicionando o seguinte código no final do arquivo, antes da chave de fechamento da definição 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);
}

    Esse código cria uma nova instância da classe que tenha sido adicionada anteriormente. Em seguida, ele adiciona a instância para as propriedades do quadro para que a instância possa receber eventos. O método SetProperty realiza isso quando você passar o valor de enumeração VSFPROPID_ViewHelper para o primeiro parâmetro e a nova instância de manipulador para o segundo parâmetro.

  2. Salve o arquivo.

Para testar o código

  1. Pressione F5 para compilar o projeto e executá-lo na compilação experimental de Visual Studio.

  2. Clique no Ferramentas menu.

    O WindowsMedia comando de menu não deverá aparecer.

  3. Sobre o Exibir , aponte para Other Windows e, em seguida, clique em De Windows Media Player para exibir a janela do Media Player.

  4. Clique no Ferramentas menu novamente.

    Agora, o WindowsMedia comando de menu deve ser exibida porque ela tem visibilidade dinâmica; ou seja, se ela está visível se baseia se a janela do Media Player está visível.

  5. Feche a janela do Media Player e em seguida, verifique o Ferramentas menu novamente.

    Agora, o WindowsMedia comando de menu não deverá aparecer.

  6. Feche a compilação experimental.

Adicione o código do Windows Forms para interagir com a janela da ferramenta

Agora, adicione código à classe de pacote que responde ao comando de menu. Esse código abre uma Abrir arquivo de caixa de diálogo e, em seguida, chama o novo método LoadFile para carregar um arquivo no Media Player.

Para ativar a janela de ferramenta no código

  1. Abra FirstToolWinPackage.cs.

  2. Adicionar o System.Windows.Forms namespace logo após o existente usando instruções, como a seguir.

    Imports System.Windows.Forms

    using System.Windows.Forms;

  3. Encontrar o MenuItemCallback manipulador do menu. Este é o manipulador de eventos para um clique no comando de menu. Substitua o corpo desse manipulador de menu usando o código a seguir.

    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. Salve seu trabalho.

Esse código abre uma Abrir arquivo de caixa de diálogo para que você possa procurar o arquivo de mídia que você deseja carregar no Media Player. Em seguida, ele localiza a ocorrência de MyToolWindow e chama o método LoadFile, que você criou anteriormente, para carregar o arquivo de mídia.

Para testar o código

  1. Pressione F5 para compilar o projeto e execute-o na instância experimental do Visual Studio.

  2. Sobre o Ferramentas menu, clique em WindowsMedia.

    O Abrir arquivo de caixa de diálogo será exibida.

  3. No Abrir arquivo de caixa de diálogo Selecione um arquivo de mídia válida e, em seguida, clique em OK.

    O arquivo deve ser reproduzido no Media Player.

  4. Feche a instância experimental.

O Que Mais Há

Esta explicação passo a passo mostra como adicionar comandos de menu com visibilidade dinâmica. Ele também mostra como adicionar controles a uma janela de ferramenta que interagem com outros controles na janela da ferramenta. Esses conceitos se aplicam em geral para janelas de ferramentas. Os controles que você adicionar a ferramenta windows intimamente se parecem com os controles de usuário que você deseja usar em um aplicativo Windows Forms.

O próximo passo a passo, Passo a passo: Integrando a janela Propriedades, lista de tarefas, a janela de saída e caixa de diálogo Opções (parte 4 de 4), você pode aprender como integrar sua janela de ferramenta em conjunto com a ferramenta windows existentes no Visual Studio, como o Propriedades janela, o saída janela e o Lista de tarefas janela.

Consulte também

Outros recursos

Ampliando a visão geral de Visual Studio