Serviço de imagem e catálogo

Este livro de receitas contém orientações e práticas recomendadas para adotar o Visual Studio Image Service e o Image Catalog introduzidos no Visual Studio 2015.

O serviço de imagem introduzido no Visual Studio 2015 permite que os desenvolvedores obtenham as melhores imagens para o dispositivo e o tema escolhido pelo usuário para exibir a imagem, incluindo temas corretos para o contexto em que são exibidas. A adoção do serviço de imagem ajudará a eliminar os principais pontos problemáticos relacionados à manutenção de ativos, dimensionamento de HDPI e temas.

Porquê adotar o serviço de imagem?

• Obtenha sempre a versão mais recente e "pixel-perfect" da imagem no Visual Studio

• Você pode enviar e usar suas próprias imagens

• Não há necessidade de testar suas imagens quando o Windows adiciona novo dimensionamento de DPI

• Solucione obstáculos arquitetônicos antigos em suas implementações

  A barra de ferramentas do shell do Visual Studio antes e depois de usar o serviço de imagem:

  

Como funciona

O serviço de imagem pode fornecer uma imagem bitmap adequada para qualquer estrutura de interface do usuário suportada:

• WPF: BitmapSource

• WinForms: System.Drawing.Bitmap

• Win32: HBITMAP

  Diagrama de fluxo do serviço de imagem

  

  Apelidos de imagem

  Um moniker de imagem (ou moniker, para abreviar) é um par GUID/ID que identifica exclusivamente um ativo de imagem ou um ativo de lista de imagens na biblioteca de imagens.

  Apelidos conhecidos

  O conjunto de identificadores de imagem contidos no Catálogo de Imagens do Visual Studio e acessíveis publicamente por qualquer componente ou extensão do Visual Studio.

  Arquivos de manifesto de imagem

  Os arquivos de manifesto de imagem (.imagemanifest) são arquivos XML que definem um conjunto de ativos de imagem, os apelidos que representam esses ativos e a imagem ou imagens reais que representam cada ativo. Os manifestos de imagem podem definir imagens autónomas ou listas de imagens para suporte a interfaces de utilizador legadas. Além disso, há atributos que podem ser definidos no ativo ou nas imagens individuais por trás de cada ativo para alterar quando e como esses ativos são exibidos.

  Esquema de manifesto de imagem

  Um manifesto de imagem completo tem esta aparência:

<ImageManifest>
      <!-- zero or one Symbols elements -->
      <Symbols>
        <!-- zero or more Import, Guid, ID, or String elements -->
      </Symbols>
      <!-- zero or one Images elements -->
      <Images>
        <!-- zero or more Image elements -->
      </Images>
      <!-- zero or one ImageLists elements -->
      <ImageLists>
        <!-- zero or more ImageList elements -->
      </ImageLists>
</ImageManifest>

Símbolos

Como um auxílio de legibilidade e manutenção, o manifesto de imagem pode usar símbolos para valores de atributo. Os símbolos são definidos assim:

<Symbols>
      <Import Manifest="manifest" />
      <Guid Name="ShellCommandGuid" Value="8ee4f65d-bab4-4cde-b8e7-ac412abbda8a" />
      <ID Name="cmdidSaveAll" Value="1000" />
      <String Name="AssemblyName" Value="Microsoft.VisualStudio.Shell.UI.Internal" />
      <!-- If your assembly is strongly named, you'll need the version and public key token as well -->
      <!-- <String Name="AssemblyName" Value="Microsoft.VisualStudio.Shell.UI.Internal;v17.0.0.0;b03f5f7f11d50a3a" /> -->
</Symbols>

Os símbolos são sensíveis a maiúsculas e minúsculas e são referenciados usando a sintaxe $(symbol-name):

<Image Guid="$(ShellCommandGuid)" ID="$(cmdidSaveAll)" >
      <Source Uri="/$(AssemblyName);Component/Resources/image.xaml" />
</Image>

Alguns símbolos são predefinidos para todos os manifestos. Eles podem ser usados no atributo Uri do <elemento Source> ou <Import> para referenciar caminhos na máquina local.

Image

O <elemento Image> define uma imagem que pode ser referenciada por um apelido. O GUID e o ID juntos formam o apelido da imagem. O apelido para a imagem deve ser exclusivo em toda a biblioteca de imagens. Se mais de uma imagem tiver um determinado apelido, a primeira encontrada durante a construção da biblioteca é a que é mantida.

Deve conter pelo menos uma fonte. Fontes neutras em termos de tamanho darão os melhores resultados em uma ampla gama de tamanhos, mas não são necessárias. Se for solicitada ao serviço uma imagem de um tamanho não definido no <elemento Image> e não houver uma fonte neutra em termos de tamanho, o serviço escolherá a melhor fonte específica de tamanho e a dimensionará para o tamanho solicitado.

<Image Guid="guid" ID="int" AllowColorInversion="true/false">
      <Source ... />
      <!-- optional additional Source elements -->
</Image>

Source

O <elemento Source> define uma única origem de recurso de imagem (XAML e PNG).

<Source Uri="uri" Background="background">
      <!-- optional NativeResource element -->
 </Source>

Um <elemento Source> pode ter exatamente um dos seguintes subelementos opcionais:

Um <elemento Source> também pode ter um opcional subelemento <NativeResource>, que define um <Source> que é carregado de um assembly nativo em vez de um assembly gerido.

<NativeResource Type="type" ID="int" />

Lista de imagens

O <elemento ImageList> define uma coleção de imagens que podem ser retornadas em uma única faixa. A faixa é construída sob demanda, conforme necessário.

<ImageList>
      <ContainedImage Guid="guid" ID="int" External="true/false" />
      <!-- optional additional ContainedImage elements -->
 </ImageList>

O apelido para a imagem contida não precisa fazer referência a uma imagem definida no manifesto atual. Se a imagem contida não puder ser encontrada na biblioteca de imagens, uma imagem de espaço reservado em branco será usada em seu lugar.

Utilização do serviço de imagem

Primeiros passos (assistidos)

Para usar o serviço de imagem, você precisa adicionar referências a alguns ou a todos os seguintes assemblies ao seu projeto:

• Microsoft.VisualStudio.ImageCatalog.dll

  • Necessário se você usar o catálogo de imagens interno KnownMonikers.

• Microsoft.VisualStudio.Imaging.dll

  • Necessário se você usar CrispImage e ImageThemingUtilities em sua interface do usuário do WPF.

• Microsoft.VisualStudio.Imaging.Interop.14.0.DesignTime.dll

  • Necessário se você usar os tipos ImageMoniker e ImageAttributes .

  • EmbedInteropTypes deve ser definido como true.

• Microsoft.VisualStudio.Shell.Interop.14.0.DesignTime

  • Necessário se você usar o tipo IVsImageService2 .

  • EmbedInteropTypes deve ser definido como true.

• Microsoft.VisualStudio.Utilities.dll

  • Necessário se você usar o BrushToColorConverter para o ImageThemingUtilities.ImageBackgroundColor em sua interface do usuário do WPF.

• Microsoft.VisualStudio.Shell.<VSVersion>.0

  • Necessário se você usar o tipo IVsUIObject .

• Microsoft.VisualStudio.Shell.Interop.10.0.dll

  • Necessário se você usar os auxiliares de interface do usuário relacionados ao WinForms.

  • EmbedInteropTypes deve ser definido como true

Primeiros passos (nativo)

Para usar o serviço de imagem, você precisa incluir alguns ou todos os cabeçalhos a seguir ao seu projeto:

• KnownImageIds.h

  • Necessário se utilizar o catálogo de imagens interno KnownMonikers, mas não puder usar o tipo ImageMoniker, como ao retornar valores das chamadas IVsHierarchy GetGuidProperty ou GetProperty.

• KnownMonikers.h

  • Necessário se você usar o catálogo de imagens interno KnownMonikers.

• ImageParameters140.h

  • Necessário se você usar os tipos ImageMoniker e ImageAttributes .

• VSShell140.h

  • Necessário se você usar o tipo IVsImageService2 .

• ImageThemingUtilities.h

  • Obrigatório se não conseguires deixar que o serviço de imagem gere a tematização para ti.

  • Não use esse cabeçalho se o serviço de imagem puder lidar com o tema da imagem.

• VsDpiAwareness.h

  • Obrigatório se você usar os auxiliares de conscientização de DPI para obter o DPI atual.

Como faço para escrever uma nova interface do usuário do WPF?

1. Comece por adicionar ao seu projeto as referências de assembly necessárias indicadas na seção de primeiras etapas acima. Você não precisa adicionar todos eles, então adicione apenas as referências que você precisa. (Nota: se estiver a utilizar ou tiver acesso a Cores em vez de Pincéis, pode ignorar a referência a Utilitários, uma vez que não precisará do conversor.)

2. Selecione a imagem desejada e obtenha seu apelido. Use o KnownMoniker ou o seu próprio se tiver as suas próprias imagens e identificadores personalizados.

3. Adicione CrispImages ao seu XAML. (Veja o exemplo abaixo.)

4. Defina a propriedade ImageThemingUtilities.ImageBackgroundColor na hierarquia da interface do usuário. (Isso deve ser definido no local onde a cor do plano de fundo é conhecida, não necessariamente no CrispImage.) (Veja o exemplo abaixo.)

<Window
  x:Class="WpfApplication.MainWindow"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:imaging="clr-namespace:Microsoft.VisualStudio.Imaging;assembly=Microsoft.VisualStudio.Imaging"
  xmlns:theming="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Imaging"
  xmlns:utilities="clr-namespace:Microsoft.VisualStudio.PlatformUI;assembly=Microsoft.VisualStudio.Utilities"
  xmlns:catalog="clr-namespace:Microsoft.VisualStudio.Imaging;assembly=Microsoft.VisualStudio.ImageCatalog"
  Title="MainWindow" Height="350" Width="525" UseLayoutRounding="True">
  <Window.Resources>
    <utilities:BrushToColorConverter x:Key="BrushToColorConverter"/>
  </Window.Resources>
  <StackPanel Background="White" VerticalAlignment="Center"
    theming:ImageThemingUtilities.ImageBackgroundColor="{Binding Background, RelativeSource={RelativeSource Self}, Converter={StaticResource BrushToColorConverter}}">
    <imaging:CrispImage Width="16" Height="16" Moniker="{x:Static catalog:KnownMonikers.MoveUp}" />
  </StackPanel>
</Window>

Como atualizo a interface do usuário existente do WPF?

Atualizar a interface do usuário do WPF existente é um processo relativamente simples que consiste em três etapas básicas:

1. Substitua todos os <elementos Image> em sua interface do usuário por <elementos CrispImage> .

2. Altere todos os atributos Source para atributos Moniker.

   • Se a imagem nunca for alterada e você estiver usando KnownMonikers, vincule estaticamente essa propriedade ao KnownMoniker. (Veja o exemplo acima.)

   • Se a imagem nunca mudar e estiver a usar a sua própria imagem personalizada, então vincule-se estaticamente ao seu próprio identificador.

   • Se a imagem puder ser alterada, vincule o atributo Moniker a uma propriedade code que notifique as alterações de propriedade.

3. Em algum lugar na hierarquia da interface do usuário, defina ImageThemingUtilities.ImageBackgroundColor para garantir que a inversão de cores funcione corretamente.

   • Isso pode exigir o uso da classe BrushToColorConverter . (Veja o exemplo acima.)

Como faço para atualizar a interface do usuário do Win32?

Adicione o seguinte ao seu código sempre que apropriado para substituir o carregamento bruto de imagens. Alterne valores para retornar HBITMAPs, HICONs ou HIMAGELIST conforme necessário.

Obtenha o serviço de imagem

CComPtr<IVsImageService2> spImgSvc;
CGlobalServiceProvider::HrQueryService(SID_SVsImageService, &spImgSvc);

Solicitar a imagem

UINT dpiX, dpiY;
HWND hwnd = // get the HWND where the image will be displayed
VsUI::CDpiAwareness::GetDpiForWindow(hwnd, &dpiX, &dpiY);

ImageAttributes attr = { 0 };
attr.StructSize      = sizeof(attributes);
attr.Format          = DF_Win32;
// IT_Bitmap for HBITMAP, IT_Icon for HICON, IT_ImageList for HIMAGELIST
attr.ImageType       = IT_Bitmap;
attr.LogicalWidth    = 16;
attr.LogicalHeight   = 16;
attr.Dpi             = dpiX;
// Desired RGBA color, if you don't use this, don't set IAF_Background below
attr.Background      = 0xFFFFFFFF;
attr.Flags           = IAF_RequiredFlags | IAF_Background;

CComPtr<IVsUIObject> spImg;
// Replace this KnownMoniker with your desired ImageMoniker
spImgSvc->GetImage(KnownMonikers::Blank, attributes, &spImg);

Como atualizo a interface do usuário do WinForms?

Adicione o seguinte ao seu código sempre que apropriado para substituir o carregamento bruto de imagens. Alterne valores para retornar Bitmaps versus Icons conforme necessário.

Útil usando a instrução

using GelUtilities = Microsoft.Internal.VisualStudio.PlatformUI.Utilities;

Obtenha o serviço de imagem

// This or your preferred way of querying for Visual Studio services
IVsImageService2 imageService = (IVsImageService2)Package.GetGlobalService(typeof(SVsImageService));

Solicite a imagem

Control control = // get the control where the image will be displayed

ImageAttributes attributes = new ImageAttributes
{
    StructSize    = Marshal.SizeOf(typeof(ImageAttributes)),
    // IT_Bitmap for Bitmap, IT_Icon for Icon, IT_ImageList for ImageList
    ImageType     = (uint)_UIImageType.IT_Bitmap,
    Format        = (uint)_UIDataFormat.DF_WinForms,
    LogicalWidth  = 16,
    LogicalHeight = 16,
    Dpi           = (int)DpiAwareness.GetWindowDpi(control.Handle);
    // Desired RGBA color, if you don't use this, don't set IAF_Background below
    Background    = 0xFFFFFFFF,
    Flags         = unchecked((uint)_ImageAttributesFlags.IAF_RequiredFlags | _ImageAttributesFlags.IAF_Background),
};

// Replace this KnownMoniker with your desired ImageMoniker
IVsUIObject uIObj = imageService.GetImage(KnownMonikers.Blank, attributes);

Bitmap bitmap = (Bitmap)GelUtilities.GetObjectData(uiObj); // Use this if you need a bitmap
// Icon icon = (Icon)GelUtilities.GetObjectData(uiObj);    // Use this if you need an icon

Como faço para usar monikers de imagem numa nova janela de ferramentas?

O modelo de projeto do pacote VSIX foi atualizado para o Visual Studio 2015. Para criar uma nova janela de ferramenta, clique com o botão direito do mouse no projeto VSIX e selecione Adicionar>novo item (Ctrl+Shift+A). No nó Extensibilidade para o idioma do projeto, selecione Janela da ferramenta personalizada, dê um nome à janela da ferramenta e pressione o botão Adicionar .

Estes são os principais lugares para usar apelidos em uma janela de ferramenta. Siga as instruções para cada um:

1. A guia da janela da ferramenta quando as guias ficam pequenas o suficiente (também usado no seletor de janela Ctrl+Tab ).

   Adicione esta linha ao construtor para a classe que deriva do tipo ToolWindowPane :

   // Replace this KnownMoniker with your desired ImageMoniker
   this.BitmapImageMoniker = KnownMonikers.Blank;
   

2. O comando para abrir a janela da ferramenta.

   .vsct No arquivo do pacote, edite o botão de comando da janela da ferramenta:

   <Button guid="guidPackageCmdSet" id="CommandId" priority="0x0100" type="Button">
     <Parent guid="guidSHLMainMenu" id="IDG_VS_WNDO_OTRWNDWS1"/>
     <!-- Replace this KnownMoniker with your desired ImageMoniker -->
     <Icon guid="ImageCatalogGuid" id="Blank" />
     <!-- Add this -->
     <CommandFlag>IconIsMoniker</CommandFlag>
     <Strings>
       <ButtonText>MyToolWindow</ButtonText>
     </Strings>
   </Button>
   

   Verifique se o seguinte também existe na parte superior do arquivo, após os <Extern> elementos:

   <Include href="KnownImageIds.vsct"/>
   

Como faço para usar identificadores de imagem numa janela de ferramenta existente?

Atualizar uma janela de ferramenta existente para usar ícones de imagem é semelhante aos passos de criar uma nova janela de ferramenta.

Estes são os principais lugares para usar apelidos em uma janela de ferramenta. Siga as instruções para cada um:

1. A aba da janela de ferramenta quando as abas ficam suficientemente pequenas (também usada no comutador de janelas ativado pelo Ctrl+Tab).

   1. Remova essas linhas (se existirem) no construtor para a classe que deriva do tipo ToolWindowPane :

      this.BitmapResourceID = <Value>;
      this.BitmapIndex = <Value>;
      

   2. Consulte a etapa #1 da seção "Como uso apelidos de imagem em uma nova janela de ferramenta?" acima.

2. O comando para abrir a janela da ferramenta.

   • Consulte a etapa #2 da seção "Como uso apelidos de imagem em uma nova janela de ferramenta?" acima.

Como faço para usar monikers de imagem em um arquivo .vsct?

Atualize seu .vsct arquivo conforme indicado pelas linhas comentadas abaixo:

<?xml version="1.0" encoding="utf-8"?>
<CommandTable xmlns="http://schemas.microsoft.com/VisualStudio/2005-10-18/CommandTable" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <!--  Include the definitions for images included in the VS image catalog -->
  <Include href="KnownImageIds.vsct"/>
  <Commands package="guidMyPackage">
    <Buttons>
      <Button guid="guidMyCommandSet" id="cmdidMyCommand" priority="0x0000" type="Button">
        <!-- Add an Icon element, changing the attributes to match the image moniker you want to use.
             In this case, we're using the Guid for the VS image catalog.
             Change the id attribute to be the ID of the desired image moniker. -->
        <Icon guid="ImageCatalogGuid" id="OpenFolder" />
        <CommandFlag>DynamicVisibility</CommandFlag>
        <CommandFlag>DefaultInvisible</CommandFlag>
        <CommandFlag>DefaultDisabled</CommandFlag>
        <CommandFlag>CommandWellOnly</CommandFlag>
        <CommandFlag>IconAndText</CommandFlag>
        <!-- Add the IconIsMoniker CommandFlag -->
        <CommandFlag>IconIsMoniker</CommandFlag>
        <Strings>
          <ButtonText>Quick Fixes...</ButtonText>
          <CommandName>Show Quick Fixes</CommandName>
          <CanonicalName>ShowQuickFixes</CanonicalName>
          <LocCanonicalName>ShowQuickFixes</LocCanonicalName>
        </Strings>
      </Button>
    </Buttons>
  </Commands>
  <!-- It is recommended that you remove <Bitmap> elements that are no longer used in the vsct file -->
  <Symbols>
    <GuidSymbol name="guidMyPackage"    value="{1491e936-6ffe-474e-8371-30e5920d8fdd}" />
    <GuidSymbol name="guidMyCommandSet" value="{10347de4-69a9-47f4-a950-d3301f6d2bc7}">
      <IDSymbol name="cmdidMyCommand" value="0x9437" />
    </GuidSymbol>
  </Symbols>
</CommandTable>

E se meu arquivo .vsct também precisar ser lido por versões mais antigas do Visual Studio?

Versões mais antigas do Visual Studio não reconhecem o sinalizador de comando IconIsMoniker . Você pode usar imagens do serviço de imagem em versões do Visual Studio que oferecem suporte a ele, mas continuar a usar imagens de estilo antigo em versões mais antigas do Visual Studio. Para fazer isso, deve deixar o arquivo .vsct inalterado (e, portanto, compatível com versões mais antigas do Visual Studio) e criar um arquivo CSV (valores separados por vírgulas) que mapeia pares GUID/ID definidos no elemento <Bitmaps> de um arquivo .vsct para pares GUID/ID de moniker de imagem.

O formato do arquivo CSV de mapeamento é:

Icon guid, Icon id, Moniker guid, Moniker id
b714fcf7-855e-4e4c-802a-1fd87144ccad,1,fda30684-682d-421c-8be4-650a2967058e,100
b714fcf7-855e-4e4c-802a-1fd87144ccad,2,fda30684-682d-421c-8be4-650a2967058e,200

O arquivo CSV é implantado com o pacote e seu local é especificado pela propriedade IconMappingFilename do atributo do pacote ProvideMenuResource :

[ProvideMenuResource("MyPackage.ctmenu", 1, IconMappingFilename="IconMappings.csv")]

O IconMappingFilename é um caminho relativo implicitamente enraizado em $PackageFolder$ (como no exemplo acima), ou um caminho absoluto explicitamente enraizado em um diretório definido por uma variável de ambiente, como @"%UserProfile%\dir1\dir2\MyMappingFile.csv".

Como faço para portar um sistema de projeto?

Como fornecer ImageMonikers para um projeto

1. Implemente VSHPROPID_SupportsIconMonikers no IVsHierarchy do projeto e retorne true.

2. Implemente VSHPROPID_IconMonikerImageList (se o projeto original usou VSHPROPID_IconImgList) ou VSHPROPID_IconMonikerGuid, VSHPROPID_IconMonikerId, VSHPROPID_OpenFolderIconMonikerGuidVSHPROPID_OpenFolderIconMonikerId (se o projeto original usou VSHPROPID_IconHandle e VSHPROPID_OpenFolderIconHandle).

3. Altere a implementação dos VSHPROPIDs originais para ícones para criar versões "legadas" dos ícones se os pontos de extensão o solicitarem. IVsImageService2 fornece a funcionalidade necessária para obter esses ícones

   Requisitos extra para variações de projeto VB/C#

   Só implemente VSHPROPID_SupportsIconMonikers se identificar que o seu projeto está na variante mais externa. Caso contrário, a variação externa real pode não suportar identificadores de imagem na prática, e a sua versão base pode efetivamente "esconder" imagens personalizadas.

   Como faço para usar os identificadores de imagem no CPS?

   A configuração de imagens personalizadas no CPS (Common Project System) pode ser feita manualmente ou por meio de um modelo de item que vem com o SDK de extensibilidade do sistema de projeto.

   Usando o SDK de extensibilidade do sistema de projeto

   Siga as instruções em Fornecer ícones personalizados para o tipo Tipo/Item de projeto para personalizar suas imagens CPS. Mais informações sobre o CPS podem ser encontradas na documentação de extensibilidade do Visual Studio Project System

   Usar manualmente os ImageMonikers

4. Implemente e exporte a interface IProjectTreeModifier em seu sistema de projeto.

5. Determine qual KnownMoniker ou moniker de imagem personalizada você deseja usar.

6. No método ApplyModifications , faça o seguinte em algum lugar no método antes de retornar a nova árvore, semelhante ao exemplo abaixo:

   // Replace this KnownMoniker with your desired ImageMoniker
   tree = tree.SetIcon(KnownMonikers.Blank.ToProjectSystemType());
   

7. Se você estiver criando uma nova árvore, poderá definir as imagens personalizadas passando os apelidos desejados para o método NewTree, semelhante ao exemplo abaixo:

   // Replace this KnownMoniker with your desired ImageMoniker
   ProjectImageMoniker icon         = KnownMonikers.FolderClosed.ToProjectSystemType();
   ProjectImageMoniker expandedIcon = KnownMonikers.FolderOpened.ToProjectSystemType();
   
   return this.ProjectTreeFactory.Value.NewTree(/*caption*/<value>,
                                                /*filePath*/<value>,
                                                /*browseObjectProperties*/<value>,
                                                icon,
                                                expandedIcon);
   

Como faço para converter de uma faixa de imagem real para uma faixa de imagem baseada em apelido?

Preciso de suportar HIMAGELISTs

Se já houver uma faixa de imagem existente para seu código que você deseja atualizar para usar o serviço de imagem, mas você estiver limitado por APIs que exigem a passagem de listas de imagens, você ainda poderá obter os benefícios do serviço de imagem. Para criar uma faixa de imagem baseada em um moniker, siga as etapas abaixo para criar um manifesto a partir de identificadores existentes.

1. Execute a ferramenta ManifestFromResources , passando-lhe a faixa de imagem. Isso gerará um manifesto para a faixa.

   • Recomendado: forneça um nome não padrão para o manifesto para se adequar ao seu uso.

2. Se você estiver usando apenas KnownMonikers, faça o seguinte:

   • Substitua a <seção Imagens> do manifesto por <Imagens/>.

   • Remova todos os IDs de sub-imagem (qualquer ID que contenha <imagestrip name>_##).

   • Recomenda-se renomear o símbolo AssetsGuid e o símbolo de faixa de imagem para se adequarem ao seu uso.

   • Substitua cada GUID de ContainedImage por $(ImageCatalogGuid), substitua cada ID de ContainedImage por $(<moniker>) e adicione o atributo External="true" a cada ContainedImage

     • <moniker> deve ser substituído pelo KnownMoniker que corresponde à imagem, mas com o "KnownMonikers." removido do nome.

   • Adicione <Import Manifest="$(ManifestFolder)\<caminho do diretório de instalação relativo para *>\Microsoft.VisualStudio.ImageCatalog.imagemanifest" /*> na parte superior da seção <Símbolos>.

     • O caminho relativo é determinado pelo local de implantação definido na definição da configuração para o manifesto.

3. Execute a ferramenta ManifestToCode para gerar wrappers para que o código existente tenha um identificador que possa ser usado para consultar o serviço de imagem para a sequência de imagens.

   • Recomendado: forneça nomes não predefinidos para os wrappers e namespaces para adequar-se ao seu uso.

4. Faça todas as adições necessárias, configure a autoria e a implantação, e realize outras alterações de código para trabalhar com o serviço de imagens e os novos arquivos.

   Exemplo de manifesto incluindo imagens internas e externas para ver como ele deve parecer:

<?xml version="1.0"?>
<ImageManifest
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:xsd="http://www.w3.org/2001/XMLSchema"
  xmlns="http://schemas.microsoft.com/VisualStudio/ImageManifestSchema/2014">

  <Symbols>
    <!-- This needs to be the relative path from your manifest to the ImageCatalog's manifest
         where $(ManifestFolder) is the deployed location of this manifest. -->
    <Import Manifest="$(ManifestFolder)\<RelPath>\Microsoft.VisualStudio.ImageCatalog.imagemanifest" />

    <String Name="Resources" Value="/My.Assembly.Name;Component/Resources/ImageStrip" />
    <Guid Name="ImageGuid" Value="{fb41b7ef-6587-480c-aa27-5b559d42cfc9}" />
    <Guid Name="ImageStripGuid" Value="{9c84a570-d9a7-4052-a340-188fb276f973}" />
    <ID Name="MyImage_0" Value="100" />
    <ID Name="MyImage_1" Value="101" />
    <ID Name="InternalList" Value="1001" />
    <ID Name="ExternalList" Value="1002" />
  </Symbols>

  <Images>
    <Image Guid="$(ImageGuid)" ID="$(MyImage_0)">
      <Source Uri="$(Resources)/MyImage_0.png">
        <Size Value="16" />
      </Source>
    </Image>
    <Image Guid="$(ImageGuid)" ID="$(MyImage_1)">
      <Source Uri="$(Resources)/MyImage_1.png">
        <Size Value="16" />
      </Source>
    </Image>
  </Images>

  <ImageLists>
    <ImageList Guid="$(ImageStripGuid)" ID="$(InternalList)">
      <ContainedImage Guid="$(ImageGuid)" ID="$(MyImage_0)" />
      <ContainedImage Guid="$(ImageGuid)" ID="$(MyImage_1)" />
    </ImageList>
    <ImageList Guid="$(ImageStripGuid)" ID="$(ExternalList)">
      <ContainedImage Guid="$(ImageCatalogGuid)" ID="$(StatusError)" External="true" />
      <ContainedImage Guid="$(ImageCatalogGuid)" ID="$(StatusWarning)" External="true" />
      <ContainedImage Guid="$(ImageCatalogGuid)" ID="$(StatusInformation)" External="true" />
    </ImageList>
  </ImageLists>

</ImageManifest>

Eu não preciso suportar HIMAGELISTs

1. Determine o conjunto de KnownMonikers que correspondem às imagens em sua faixa de imagem ou crie seus próprios apelidos para as imagens em sua faixa de imagem.

2. Atualize o mapeamento que utilizou para obter a imagem no índice necessário na faixa de imagens, de forma a usar os identificadores.

3. Atualize seu código para usar o serviço de imagem para solicitar monikers por meio do mapeamento atualizado. (Isso pode significar atualizar para CrispImages para código gerenciado ou solicitar HBITMAPs ou HICONs do serviço de imagem e passá-los para código nativo.)

Testando as suas imagens

Você pode usar a ferramenta Image Library Viewer para testar seus manifestos de imagem para garantir que tudo seja criado corretamente. Você pode encontrar a ferramenta no SDK do Visual Studio 2015. A documentação para esta ferramenta e outras pode ser encontrada aqui.

Recursos adicionais

Samples

Vários dos exemplos do Visual Studio no GitHub foram atualizados para mostrar como usar o serviço de imagem como parte de vários pontos de extensibilidade do Visual Studio.

Verifique http://github.com/Microsoft/VSSDK-Extensibility-Samples as amostras mais recentes.

Tooling

Um conjunto de ferramentas de suporte para o Serviço de Imagem foi criado para ajudar na criação/atualização da interface do usuário que funciona com o Serviço de Imagem. Para obter mais informações sobre cada ferramenta, consulte a documentação que acompanha as ferramentas. As ferramentas estão incluídas como parte do SDK do Visual Studio 2015.

ManifestFromResources

A ferramenta Manifesto de Recursos usa uma lista de recursos de imagem (PNG ou XAML) e gera um arquivo de manifesto de imagem para usar essas imagens com o serviço de imagem.

ManifestToCode

A ferramenta Manifest to Code utiliza um ficheiro de manifesto de imagem e gera um ficheiro wrapper para referenciar os valores de manifesto em código (C++, C# ou VB) ou ficheiros .vsct.

ImageLibraryViewer

A ferramenta Image Library Viewer pode carregar manifestos de imagem e permite que o usuário os manipule da mesma forma que o Visual Studio faria para garantir que o manifesto seja criado corretamente. O usuário pode alterar o plano de fundo, tamanhos, configuração de DPI, Alto Contraste e outras configurações. Ele também exibe informações de carregamento para encontrar erros nos manifestos e exibe informações de origem para cada imagem no manifesto.

FAQ

• Há alguma dependência que você deve incluir ao carregar <Reference Include="Microsoft.VisualStudio.*. Interop.14.0.DesignTime" />?

  • Defina EmbedInteropTypes="true" em todas as DLLs de interoperabilidade.

• Como faço para implantar um manifesto de imagem com minha extensão?

  • Adicione o .imagemanifest arquivo ao seu projeto.

  • Defina "Incluir no VSIX" como Verdadeiro.

• Minhas imagens ainda não estão funcionando, como faço para descobrir o que está errado?

  • Visual Studio pode não conseguir encontrar o seu manifesto de imagem. Por motivos de desempenho, o Visual Studio limita a profundidade de pesquisa da pasta, portanto, é recomendável que o manifesto da imagem seja mantido na pasta raiz da sua extensão.

  • Você pode estar faltando informações de assembly em seu arquivo de manifesto de imagem. Assemblies que são fortemente nomeados exigem informações adicionais para serem carregados pelo Visual Studio. Para carregar um assembly com nome forte, é necessário incluir (além do nome do assembly) a versão do assembly e o token de chave pública nos URIs dos recursos de imagem no manifesto de imagens.

    <ImageManifest xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns="http://schemas.microsoft.com/VisualStudio/ImageManifestSchema/2014">
      <Symbols>
        <String Name="Resources" Value="/Microsoft.VisualStudio.Shell.UI.Internal;v17.0.0.0;b03f5f7f11d50a3a;Component/Resources" />
        ...
      </Symbols>
      ...
    </ImageManifest>
    

  • Você pode estar a faltar uma entrada de código-fonte para a sua compilação de imagem. Se o assembly ainda não estiver carregado no momento em que o Visual Studio precisar dele, ele precisará saber onde encontrar o assembly para carregá-lo. Para adicionar uma base de código para seu assembly, você pode usar o ProvideCodeBaseAttribute para garantir que uma entrada de base de código seja gerada e incluída no pkgdef da sua extensão.

    [assembly: ProvideCodeBase(AssemblyName = "ClassLibrary1", Version = "1.0.0.0", CodeBase = "$PackageFolder$\\ClassLibrary1.dll")]
    

  • Se as opções anteriores não resolverem o problema de carregamento da imagem, você poderá habilitar o registro soltando as seguintes entradas em um pkgdef em sua extensão:

    [$RootKey$\ImageLibrary]
    "TraceLevel"="Verbose"
    "TraceFilename"="ImageLibrary.log"
    

    Isso criará um arquivo de log chamado ImageLibrary.log na pasta %UserProfile%. Certifique-se de executar "devenv /updateConfiguration" a partir de um prompt de comando do desenvolvedor depois de adicionar essas entradas a um pkgdef. Isso garante que os registos de log estejam habilitados e que o Visual Studio atualize o cache do manifesto da imagem para ajudar a localizar quaisquer erros que possam ocorrer ao ler o manifesto da imagem. Se, em seguida, você executar o cenário onde se espera que sua imagem seja carregada, seu arquivo de log conterá o log de registro e o log de solicitação para sua imagem.

• Estou atualizando meu sistema de projetos CPS. O que aconteceu com ImageName e StockIconService?

  • Estes foram removidos quando o CPS foi atualizado para usar apelidos. Você não precisa mais chamar o StockIconService, basta passar o KnownMoniker desejado para o método ou propriedade usando o método de extensão ToProjectSystemType() nos utilitários CPS. Você pode encontrar um mapeamento de ImageName para KnownMonikers abaixo:

    Nome da imagem	KnownMoniker
    ImageName.OfflineWebApp	KnownImageIds.Web
    ImageName.WebReferencesFolder	KnownImageIds.Web
    ImageName.OpenReferenceFolder	IdentificadoresDeImagemConhecidos.PastaAberta
    ImageName.ReferenceFolder	KnownImageIds.Reference
    ImageName.Reference	KnownImageIds.Reference
    ImageName.SdlWebReference	KnownImageIds.WebReferenceFolder
    ImageName.DiscoWebReference	KnownImageIds.DynamicDiscoveryDocument
    ImageName.Folder	KnownImageIds.FolderClosed
    ImageName.OpenFolder	KnownImageIds.FolderOpened
    ImageName.ExcludedFolder	KnownImageIds.HiddenFolderClosed
    ImageName.OpenExcludedFolder	KnownImageIds.HiddenFolderOpened
    ImageName.ExcludedFile	KnownImageIds.HiddenFile
    ImageName.DependentFile	KnownImageIds.GenerateFile
    ImageName.FicheiroEmFalta	KnownImageIds.DocumentWarning
    ImageName.WindowsForm	KnownImageIds.WindowsForm
    ImageName.WindowsUserControl	KnownImageIds.UserControl
    ImageName.WindowsComponent	KnownImageIds.ComponentFile
    ImageName.XmlSchema	KnownImageIds.XMLSchema
    ImageName.XmlFile	KnownImageIds.XMLFile
    ImageName.WebForm	KnownImageIds.Web
    ImageName.WebService	KnownImageIds.WebService
    ImageName.WebUserControl	KnownImageIds.WebUserControl
    ImageName.WebCustomUserControl	KnownImageIds.WebCustomControl
    ImageName.AspPage	KnownImageIds.ASPFile
    ImageName.GlobalApplicationClass	KnownImageIds.SettingsFile
    ImageName.WebConfig	KnownImageIds.ConfigurationFile
    ImageName.HtmlPage	KnownImageIds.HTMLFile
    ImageName.StyleSheet	KnownImageIds.StyleSheet
    ImageName.ScriptFile	KnownImageIds.JSScript
    ImageName.TextFile	KnownImageIds.Document
    ImageName.SettingsFile	KnownImageIds.Settings
    ImageName.Recursos	KnownImageIds.DocumentGroup
    ImageName.Bitmap	KnownImageIds.Image
    ImageName.Icon	KnownImageIds.IconFile
    ImageName.Image	KnownImageIds.Image
    ImageName.ImageMap	KnownImageIds.ImageMapFile
    ImageName.XWorld	KnownImageIds.XWorldFile
    ImageName.Audio	KnownImageIds.Sound
    ImageName.Video	KnownImageIds.Media
    ImageName.Cab	KnownImageIds.CABProject
    ImageName.Jar	KnownImageIds.JARFile
    ImageName.DataEnvironment	KnownImageIds.DataTable
    ImageName.PreviewFile	KnownImageIds.Report
    ImageName.DanglingReference	KnownImageIds.ReferenceWarning
    ImageName.XsltFile	KnownImageIds.XSLTransform
    ImageName.Cursor	KnownImageIds.CursorFile
    ImageName.AppDesignerFolder	KnownImageIds.Property
    ImageName.Data	KnownImageIds.Database
    ImageName.Application	KnownImageIds.Application
    ImageName.DataSet	KnownImageIds.DatabaseGroup
    ImageName.Pfx	KnownImageIds.Certificate
    ImageName.Snk	KnownImageIds.Rule
    ImageName.VisualBasicProject	KnownImageIds.VBProjectNode
    ImageName.CSharpProject	KnownImageIds.CSProjectNode
    ImageName.Empty	KnownImageIds.Blank
    ImageName.MissingFolder	KnownImageIds.FolderOffline
    ImageName.SharedImportReference	KnownImageIds.SharedProject
    ImageName.SharedProjectCs	KnownImageIds.CSSharedProject
    ImageName.SharedProjectVc	KnownImageIds.CPPSharedProject
    ImageName.SharedProjectJs	KnownImageIds.JSSharedProject
    ImageName.CSharpCodeFile	KnownImageIds.CSFileNode
    ImageName.VisualBasicCodeFile	KnownImageIds.VBFileNode

• Estou atualizando meu provedor de lista de conclusão. Quais KnownMonikers correspondem aos antigos valores de StandardGlyphGroup e StandardGlyph?

  Nome	Nome	Nome
  GlyphGroupClass	GlyphItemPublic	ClassPublic
  GlyphGroupClass	GlyphItemInternal	ClasseInterna
  GlyphGroupClass	GlyphItemFriend	ClasseInterna
  GlyphGroupClass	GlyphItemProtected	ClassProtected
  GlyphGroupClass	GlyphItemPrivate	Classe Privada
  GlyphGroupClass	GlyphItemShortcut	ClassShortcut
  GlyphGroupConstant	GlyphItemPublic	ConstantPublic
  GlyphGroupConstant	GlyphItemInternal	ConstantInternal
  GlyphGroupConstant	GlyphItemFriend	ConstanteInterno
  GlyphGroupConstant	GlyphItemProtected	ConstantProtected
  GlyphGroupConstant	GlyphItemPrivate	ConstantPrivate
  GlyphGroupConstant	GlyphItemShortcut	Atalho constante
  GlyphGroupDelegate	GlyphItemPublic	DelegadoPúblico
  GlyphGroupDelegate	GlyphItemInternal	DelegadoInterno
  GlyphGroupDelegate	GlyphItemFriend	DelegadoInterno
  GlyphGroupDelegate	GlyphItemProtected	DelegateProtegido
  GlyphGroupDelegate	GlyphItemPrivate	DelegatePrivate
  GlyphGroupDelegate	GlyphItemShortcut	DelegateShortcut
  GlyphGroupEnum	GlyphItemPublic	EnumeraçãoPública
  GlyphGroupEnum	GlyphItemInternal	EnumeraçãoInterno
  GlyphGroupEnum	GlyphItemFriend	Enumeração Interno
  GlyphGroupEnum	GlyphItemProtected	EnumeraçãoProtegida
  GlyphGroupEnum	GlyphItemPrivate	Enumeração Privada
  GlyphGroupEnum	GlyphItemShortcut	AtalhoDeEnumeração
  GlyphGroupEnumMembro	GlyphItemPublic	ElementoDeEnumeraçãoPúblico
  GlyphGroupEnumMember	GlyphItemInternal	EnumerationItemInternal
  GlyphGroupEnumMember	GlyphItemFriend	EnumerationItemInternal
  GlyphGroupEnumMembro	GlyphItemProtected	ItemDeEnumeraçãoProtegido
  GlyphGroupEnumMembro	GlyphItemPrivate	ElementoEnumeraçãoPrivado
  GlyphGroupEnumMembro	GlyphItemShortcut	AtalhoDeItemDeEnumeração
  GlyphGroupEvent	GlyphItemPublic	EventoPúblico
  GlyphGroupEvent	GlyphItemInternal	EventoInterno
  GlyphGroupEvent	GlyphItemFriend	EventoInterno
  GlyphGroupEvent	GlyphItemProtected	EventoProtegido
  GlyphGroupEvent	GlyphItemPrivate	EventoPrivado
  GlyphGroupEvent	GlyphItemShortcut	Atalho de Evento
  GlyphGroupException	GlyphItemPublic	ExceptionPublic
  GlyphGroupException	GlyphItemInternal	ExceçãoInterna
  GlyphGroupException	GlyphItemFriend	Exceção Interna
  GlyphGroupException	GlyphItemProtected	ProtegidoPorExceção
  GlyphGroupException	GlyphItemPrivate	ExceçãoPrivada
  GlyphGroupException	GlyphItemShortcut	ExceptionShortcut
  GlyphGroupField	GlyphItemPublic	CampoPúblico
  GlyphGroupField	GlyphItemInternal	CampoInterno
  GlyphGroupField	GlyphItemFriend	CampoInterno
  GlyphGroupField	GlyphItemProtected	CampoProtegido
  GlyphGroupField	GlyphItemPrivate	CampoPrivado
  GlyphGroupField	GlyphItemShortcut	FieldShortcut
  GlyphGroupInterface	GlyphItemPublic	InterfacePublic
  GlyphGroupInterface	GlyphItemInternal	InterfaceInterna
  GlyphGroupInterface	GlyphItemFriend	InterfaceInterna
  GlyphGroupInterface	GlyphItemProtected	InterfaceProtected
  GlyphGroupInterface	GlyphItemPrivate	InterfacePrivate
  GlyphGroupInterface	GlyphItemShortcut	Atalho de Interface
  GlyphGroupMacro	GlyphItemPublic	Macropúblico
  GlyphGroupMacro	GlyphItemInternal	MacroInterno
  GlyphGroupMacro	GlyphItemFriend	MacroInterno
  GlyphGroupMacro	GlyphItemProtected	MacroProtegido
  GlyphGroupMacro	GlyphItemPrivate	MacroPrivado
  GlyphGroupMacro	GlyphItemShortcut	Atalho de Macro
  GlyphGroupMap	GlyphItemPublic	MapaPublic
  GlyphGroupMap	GlyphItemInternal	MapaInterno
  GlyphGroup Mapa	GlyphItemFriend	MapaInterno
  GlyphGroupMap	GlyphItemProtected	MapProtected
  GlyphGroupMap	GlyphItemPrivate	MapaPrivate
  GlyphGroupMap	GlyphItemShortcut	MapShortcut
  GlyphGroupMapItem	GlyphItemPublic	MapItemPublic
  GlyphGroupMapItem	GlyphItemInternal	MapItemInternal
  GlyphGroupMapItem	GlyphItemFriend	MapItemInternal
  GlyphGroupMapItem	GlyphItemProtected	MapItemProtected
  GlyphGroupMapItem	GlyphItemPrivate	MapaItemPrivate
  GlyphGroupMapItem	GlyphItemShortcut	Atalho do Item do Mapa
  GlyphGroupMethod	GlyphItemPublic	MethodPublic
  GlyphGroupMethod	GlyphItemInternal	MethodInternal
  GlyphGroupMethod	GlyphItemFriend	MethodInternal
  GlyphGroupMethod	GlyphItemProtected	MethodProtected
  GlyphGroupMethod	GlyphItemPrivate	MethodPrivate
  GlyphGroupMethod	GlyphItemShortcut	MethodShortcut
  GlyphGroupOverload	GlyphItemPublic	MethodPublic
  GlyphGroupOverload	GlyphItemInternal	MethodInternal
  GlyphGroupOverload	GlyphItemFriend	MethodInternal
  GlyphGroupOverload	GlyphItemProtected	MethodProtected
  GlyphGroupOverload	GlyphItemPrivate	MethodPrivate
  GlyphGroupOverload	GlyphItemShortcut	MethodShortcut
  GlyphGroupModule	GlyphItemPublic	MóduloPúblico
  GlyphGroupModule	GlyphItemInternal	MóduloInterno
  GlyphGroupModule	GlyphItemFriend	MóduloInterno
  GlyphGroupModule	GlyphItemProtected	Módulo Protegido
  GlyphGroupModule	GlyphItemPrivate	MóduloPrivado
  GlyphGroupModule	GlyphItemShortcut	ModuleShortcut
  GlyphGroupNamespace	GlyphItemPublic	NamespacePublic
  GlyphGroupNamespace	GlyphItemInternal	NamespaceInternal
  GlyphGroupNamespace	GlyphItemFriend	NamespaceInternal
  GlyphGroupNamespace	GlyphItemProtected	NamespaceProtected
  GlyphGroupNamespace	GlyphItemPrivate	NamespacePrivate
  GlyphGroupNamespace	GlyphItemShortcut	NamespaceShortcut
  GlyphGroupOperator	GlyphItemPublic	Operador Público
  GlyphGroupOperator	GlyphItemInternal	Operador Interno
  GlyphGroupOperator	GlyphItemFriend	OperadorInterno
  GlyphGroupOperator	GlyphItemProtected	Protegido por Operador
  GlyphGroupOperator	GlyphItemPrivate	OperadorPrivate
  GlyphGroupOperator	GlyphItemShortcut	Operador de Atalho
  GlyphGroupProperty	GlyphItemPublic	PropriedadePública
  GlyphGroupProperty	GlyphItemInternal	Propriedade Interna
  GlyphGroupProperty	GlyphItemFriend	Propriedade Interna
  GlyphGroupProperty	GlyphItemProtected	Propriedade Protegida
  GlyphGroupProperty	GlyphItemPrivate	PropriedadePrivada
  GlyphGroupProperty	GlyphItemShortcut	PropertyShortcut
  GlyphGroupStruct	GlyphItemPublic	EstruturaPública
  GlyphGroupStruct	GlyphItemInternal	Estrutura Interna
  GlyphGroupStruct	GlyphItemFriend	Estrutura Interna
  GlyphGroupStruct	GlyphItemProtected	EstruturaProtegida
  GlyphGroupStruct	GlyphItemPrivate	Estrutura Privada
  GlyphGroupStruct	GlyphItemShortcut	Estrutura-Atalho
  GlyphGroupTemplate	GlyphItemPublic	ModeloPúblico
  GlyphGroupTemplate	GlyphItemInternal	ModeloInterno
  GlyphGroupTemplate	GlyphItemFriend	ModeloInterno
  GlyphGroupTemplate	GlyphItemProtected	ModeloProtegido
  GlyphGroupTemplate	GlyphItemPrivate	ModeloPrivado
  GlyphGroupTemplate	GlyphItemShortcut	ModeloAtalho
  GlyphGroupTypedef	GlyphItemPublic	TypeDefinitionPublic
  GlyphGroupTypedef	GlyphItemInternal	TypeDefinitionInternal
  GlyphGroupTypedef	GlyphItemFriend	TypeDefinitionInternal
  GlyphGroupTypedef	GlyphItemProtected	TypeDefinitionProtected
  GlyphGroupTypedef	GlyphItemPrivate	TypeDefinitionPrivate
  GlyphGroupTypedef	GlyphItemShortcut	AtalhoDefiniçãoTipo
  TipoDeGrupoDeGlifo	GlyphItemPublic	TipoPúblico
  TipoDeGrupoDeGlifo	GlyphItemInternal	TipoInterno
  TipoDeGrupoDeGlifo	GlyphItemFriend	Tipo Interno
  TipoDeGrupoDeGlifo	GlyphItemProtected	TipoProtegido
  TipoDeGrupoDeGlifo	GlyphItemPrivate	TipoPrivado
  TipoDeGrupoDeGlifo	GlyphItemShortcut	TipoDeAtalho
  GlyphGroupUnion	GlyphItemPublic	UnionPublic [en]
  GlyphGroupUnion	GlyphItemInternal	UniãoInterna
  GlyphGroupUnion	GlyphItemFriend	Sindicato Interno
  GlyphGroupUnion	GlyphItemProtected	UnionProtected
  GlyphGroupUnion	GlyphItemPrivate	UnionPrivate
  GlyphGroupUnion	GlyphItemShortcut	UnionShortcut
  GlyphGroupVariable	GlyphItemPublic	CampoPúblico
  GlyphGroupVariable	GlyphItemInternal	CampoInterno
  GlyphGroupVariable	GlyphItemFriend	CampoInterno
  GlyphGroupVariable	GlyphItemProtected	CampoProtegido
  GlyphGroupVariable	GlyphItemPrivate	CampoPrivado
  GlyphGroupVariable	GlyphItemShortcut	FieldShortcut
  GlyphGroupValueType	GlyphItemPublic	ValueTypePublic
  GlyphGroupValueType	GlyphItemInternal	ValueTypeInternal
  GlyphGroupValueType	GlyphItemFriend	ValueTypeInternal
  GlyphGroupValueType	GlyphItemProtected	ValueTypeProtected
  GlyphGroupValueType	GlyphItemPrivate	ValueTypePrivate
  GlyphGroupValueType	GlyphItemShortcut	ValueTypeShortcut
  GlyphGroupIntrinsic	GlyphItemPublic	ObjectPublic
  GlyphGroupIntrinsic	GlyphItemInternal	ObjectInternal
  GlyphGroupIntrinsic	GlyphItemFriend	ObjectInternal
  GlyphGroupIntrinsic	GlyphItemProtected	ObjetoProtegido
  GlyphGroupIntrinsic	GlyphItemPrivate	ObjectPrivate
  GlyphGroupIntrinsic	GlyphItemShortcut	ObjectShortcut
  GlyphGroupJSharpMethod	GlyphItemPublic	MethodPublic
  GlyphGroupJSharpMethod	GlyphItemInternal	MethodInternal
  GlyphGroupJSharpMethod	GlyphItemFriend	MethodInternal
  GlyphGroupJSharpMethod	GlyphItemProtected	MethodProtected
  GlyphGroupJSharpMethod	GlyphItemPrivate	MethodPrivate
  GlyphGroupJSharpMethod	GlyphItemShortcut	MethodShortcut
  GlyphGroupJSharpField	GlyphItemPublic	CampoPúblico
  GlyphGroupJSharpField	GlyphItemInternal	CampoInterno
  GlyphGroupJSharpField	GlyphItemFriend	CampoInterno
  GlyphGroupJSharpField	GlyphItemProtected	CampoProtegido
  GlyphGroupJSharpField	GlyphItemPrivate	CampoPrivado
  GlyphGroupJSharpField	GlyphItemShortcut	FieldShortcut
  GlyphGroupJSharpClass	GlyphItemPublic	ClassPublic
  GlyphGroupJSharpClass	GlyphItemInternal	ClasseInterna
  GlyphGroupJSharpClass	GlyphItemFriend	ClasseInterna
  GlyphGroupJSharpClass	GlyphItemProtected	ClassProtected
  GlyphGroupJSharpClass	GlyphItemPrivate	Classe Privada
  GlyphGroupJSharpClass	GlyphItemShortcut	ClassShortcut
  GlyphGroupJSharpNamespace	GlyphItemPublic	NamespacePublic
  GlyphGroupJSharpNamespace	GlyphItemInternal	NamespaceInternal
  GlyphGroupJSharpNamespace	GlyphItemFriend	NamespaceInternal
  GlyphGroupJSharpNamespace	GlyphItemProtected	NamespaceProtected
  GlyphGroupJSharpNamespace	GlyphItemPrivate	NamespacePrivate
  GlyphGroupJSharpNamespace	GlyphItemShortcut	NamespaceShortcut
  GlyphGroupJSharpInterface	GlyphItemPublic	InterfacePublic
  GlyphGroupJSharpInterface	GlyphItemInternal	InterfaceInterna
  GlyphGroupJSharpInterface	GlyphItemFriend	InterfaceInterna
  GlyphGroupJSharpInterface	GlyphItemProtected	InterfaceProtected
  GlyphGroupJSharpInterface	GlyphItemPrivate	InterfacePrivate
  GlyphGroupJSharpInterface	GlyphItemShortcut	Atalho de Interface
  GlyphGroupError		StatusError
  GlyphBscFile		Ficheiro de Classe
  GlyphAssembly		Reference
  Biblioteca de Glifos		Biblioteca
  GlyphVBProject		VBProjectNode
  GlyphCoolProject		CSProjectNode
  GlyphCppProject		CPPProjectNode
  GlyphDialogId		Dialog
  GlyphOpenFolder		Pasta Aberta
  GlyphClosedFolder		PastaFechada
  GlyphArrow		IrParaPróximo
  GlyphCSharpFile		CSFileNode
  GlyphCSharpExpansion		Fragmento
  GlyphKeyword		IntellisensePalavra-chave
  GlyphInformation		Informações de Status
  Glifo Referência		ClassMethodReference
  GlyphRecursion		Recursão
  GlyphXmlItem		Tag
  GlyphJSharpProject		Coleção de Documentos
  GlyphJSharpDocument		Documento
  GlyphForwardType		IrParaPróximo
  GlyphCallersGraph		Ligar para
  GlyphCallGraph		CallFrom
  GlyphWarning		StatusWarning
  GlyphMaybeReference		Ponto de interrogação
  GlyphMaybeCaller		Ligar para
  GlyphMaybeCall		CallFrom
  GlyphExtensionMethod		ExtensionMethod
  GlyphExtensionMethodInternal		ExtensionMethod
  GlyphExtensionMethodFriend		ExtensionMethod
  GlyphExtensionMethodProtected		ExtensionMethod
  MétodoPrivadoDeExtensãoDoGlifo		ExtensionMethod
  GlyphExtensionMethodShortcut		ExtensionMethod
  GlyphXmlAttribute		XmlAttribute
  GlyphXmlChild		XmlElement
  GlyphXmlDescendant		XmlDescendente
  GlyphXmlNamespace		XmlNamespace
  GlyphXmlAttributeQuestion		XmlAttributeLowConfidence
  GlyphXmlAttributeCheck		Atributo XML de Alta Confiança
  GlyphXmlChildQuestion		XmlElementLowConfidence
  GlyphXmlChildCheck		XmlElementHighConfidence
  GlyphXmlDescendantQuestion		XmlDescendantLowConfidence
  GlyphXmlDescendantCheck		DescendenteXmlConfiançaAlta
  GlyphCompletionWarning		IntellisenseWarning