Catálogo y servicio de imágenes

Esta guía paso a paso contiene instrucciones y procedimientos recomendados para adoptar Visual Studio Image Service e Image Catalog introducidos en Visual Studio 2015.

El servicio de imagen introducido en Visual Studio 2015 permite a los desarrolladores obtener las mejores imágenes para el dispositivo y el tema elegido por el usuario para mostrar la imagen, incluida la creación de temas correcta para el contexto en el que se muestran. La adopción del servicio de imágenes ayudará a eliminar los principales puntos débiles relacionados con el mantenimiento de recursos, el escalado de HDPI y los temas.

¿Por qué adoptar el servicio de imagen?

• Obtenga siempre la imagen "perfecta para píxeles" más reciente de Visual Studio

• Puede enviar y usar sus propias imágenes

• No es necesario probar las imágenes cuando Windows agrega un nuevo ajuste de PPP

• Abordar los obstáculos arquitectónicos antiguos en las implementaciones

  Barra de herramientas del shell de Visual Studio antes y después de usar el servicio de imagen:

  

Funcionamiento

El servicio de imagen puede proporcionar una imagen de mapa de bits adecuada para cualquier marco de interfaz de usuario compatible:

• WPF: BitmapSource

• WinForms: System.Drawing.Bitmap

• Win32: HBITMAP

  Diagrama de flujo del servicio de imágenes

  

  Monikers de imagen

  Un moniker de imagen (o moniker para abreviar) es un par GUID/ID que identifica de forma única un recurso de imagen o un recurso de lista de imágenes en la biblioteca de imágenes.

  Monikers conocidos

  Conjunto de monikers de imagen contenidos en el Catálogo de imágenes de Visual Studio y consumibles públicamente por cualquier componente o extensión de Visual Studio.

  Archivos de manifiesto de imagen

  Los archivos de manifiesto de imagen (.imagemanifest) son archivos XML que definen un conjunto de recursos de imagen, los monikers que representan esos recursos y la imagen o imágenes reales que representan cada recurso. Los manifiestos de imagen pueden definir imágenes independientes o listas de imágenes para la compatibilidad con la interfaz de usuario heredada. Además, hay atributos que se pueden establecer en el recurso o en las imágenes individuales de cada recurso para cambiar cuándo y cómo se muestran esos recursos.

  Esquema de manifiesto de imagen

  Un manifiesto de imagen completo tiene este aspecto:

<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 ayuda de legibilidad y mantenimiento, el manifiesto de imagen puede usar símbolos para los valores de atributo. Los símbolos se definen de la siguiente manera:

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

Los símbolos distinguen mayúsculas de minúsculas y se hace referencia a ellos con la sintaxis $(symbol-name):

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

Algunos símbolos están predefinidos para todos los manifiestos. Se pueden usar en el atributo URI del elemento <Source> o <Import> para hacer referencia a rutas de acceso en el equipo local.

Imagen

El elemento <Image> define una imagen a la que puede hacer referencia un moniker. El GUID y el identificador tomados juntos forman el moniker de imagen. El moniker de la imagen debe ser único en toda la biblioteca de imágenes. Si más de una imagen tiene un moniker determinado, el primero encontrado al compilar la biblioteca es el que se conserva.

Debe contener al menos un origen. Los orígenes neutros de tamaño proporcionarán los mejores resultados en una amplia gama de tamaños, pero no son necesarios. Si se solicita al servicio una imagen de un tamaño no definido en el elemento <Image> y no hay ningún origen independiente del tamaño, el servicio elegirá el mejor origen específico del tamaño y lo escalará al tamaño solicitado.

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

Origen

El elemento <Source> define un único recurso de origen de imagen (XAML y PNG).

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

Un elemento <Source> puede tener exactamente uno de los siguientes subelementos opcionales:

Un elemento <Source> también puede tener un subelemento <NativeResource> opcional, que define un <origen> que se carga desde un ensamblado nativo en lugar de un ensamblado administrado.

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

ImageList

El elemento <ImageList> define una colección de imágenes que se pueden devolver en una sola franja. La franja se basa en la demanda, según sea necesario.

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

El moniker de la imagen de contenedor no tiene que hacer referencia a una imagen definida en el manifiesto actual. Si no se encuentra la imagen de contenedor en la biblioteca de imágenes, se usará una imagen de marcador de posición en blanco en su lugar.

Uso del servicio de imágenes

Primeros pasos (administrados)

Para usar el servicio de imágenes, debe agregar referencias a algunos o todos los ensamblados siguientes al proyecto:

• Microsoft.VisualStudio.ImageCatalog.dll

  • Obligatorio si usa el catálogo de imágenes integradas KnownMonikers.

• Microsoft.VisualStudio.Imaging.dll

  • Obligatorio si usa CrispImage e ImageThemingUtilities en la interfaz de usuario de WPF.

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

  • Obligatorio si usa los tipos ImageMoniker e ImageAttributes.

  • EmbedInteropTypes debe establecerse en true.

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

  • Obligatorio si usa el tipo IVsImageService2.

  • EmbedInteropTypes debe establecerse en true.

• Microsoft.VisualStudio.Utilities.dll

  • Obligatorio si usa BrushToColorConverter para ImageThemingUtilities.ImageBackgroundColor en la interfaz de usuario de WPF.

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

  • Obligatorio si usa el tipo IVsUIObject.

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

  • Obligatorio si usa los asistentes de interfaz de usuario relacionados con WinForms.

  • EmbedInteropTypes debe establecerse en true

Primeros pasos (nativo)

Para usar el servicio de imagen, debe incluir algunos o todos los encabezados siguientes en el proyecto:

• KnownImageIds.h

  • Obligatorio si usa el catálogo de imágenes integrado KnownMonikers, pero no puede usar el tipo ImageMoniker, como al devolver valores de las llamadas IVsHierarchy GetGuidProperty o GetProperty.

• KnownMonikers.h

  • Obligatorio si usa el catálogo de imágenes integradas KnownMonikers.

• ImageParameters140.h

  • Obligatorio si usa los tipos ImageMoniker e ImageAttributes.

• VSShell140.h

  • Obligatorio si usa el tipo IVsImageService2.

• ImageThemingUtilities.h

  • Obligatorio si no puede permitir que el servicio de imágenes controle las temáticas por usted.

  • No use este encabezado si el servicio de imágenes puede controlar el tema de la imagen.

• VsDpiAwareness.h

  • Obligatorio si usa los asistentes de reconocimiento de PPP para obtener el PPP actual.

Cómo escribir una nueva interfaz de usuario de WPF

1. Empiece agregando las referencias de ensamblado necesarias en la sección de primeros pasos anterior al proyecto. No es necesario agregar todos ellos, así que agregue solo las referencias que necesita. (Nota: si usa o tiene acceso a Colores en lugar de Pinceles, puede omitir la referencia a utilidades, ya que no necesitará el convertidor).

2. Seleccione la imagen deseada y obtenga su moniker. Use un KnownMoniker o use el suyo propio si tiene sus propias imágenes personalizadas y monikers.

3. Agregue CrispImages a su XAML. (Consulte el ejemplo siguiente.)

4. Establezca la propiedad ImageThemingUtilities.ImageBackgroundColor en la jerarquía de la interfaz de usuario. (Esto debe establecerse en la ubicación donde se conoce el color de fondo, no necesariamente en CrispImage.) (Vea el ejemplo siguiente.)

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

Cómo actualizar la interfaz de usuario de WPF existente

La actualización de la interfaz de usuario de WPF existente es un proceso relativamente sencillo que consta de tres pasos básicos:

1. Reemplace todos los elementos de <imagen> de la interfaz de usuario por los elementos <CrispImage>.

2. Cambie todos los atributos de origen a los atributos Moniker.

   • Si la imagen nunca cambia y usa KnownMonikers, enlace estáticamente esa propiedad al KnownMoniker. (Vea el ejemplo anterior.)

   • Si la imagen nunca cambia y usa su propia imagen personalizada, enlace estáticamente a su propio moniker.

   • Si la imagen puede cambiar, enlace el atributo Moniker a una propiedad de código que notifique los cambios de propiedad.

3. En algún lugar de la jerarquía de la interfaz de usuario, establezca ImageThemingUtilities.ImageBackgroundColor para asegurarse de que la inversión de color funciona correctamente.

   • Esto puede requerir el uso de la clase BrushToColorConverter. (Vea el ejemplo anterior.)

Cómo actualizar la interfaz de usuario de Win32

Agregue lo siguiente al código siempre que sea necesario para reemplazar la carga sin procesar de imágenes. Cambie los valores para devolver HBITMAPs frente a HICON frente a HIMAGELIST según sea necesario.

Obtención del servicio de imágenes

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

Solicitud de la imagen

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

Cómo actualizar la interfaz de usuario de WinForms

Agregue lo siguiente al código siempre que sea necesario para reemplazar la carga sin procesar de imágenes. Cambie los valores para devolver mapas de bits frente a Iconos según sea necesario.

Útil usando la instrucción

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

Obtención del servicio de imágenes

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

Solicitud de la imagen

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

Cómo usar monikers de imagen en una nueva ventana de herramientas

La plantilla de proyecto de paquete VSIX se actualizó para Visual Studio 2015. Para crear una nueva ventana de herramientas, haga clic con el botón derecho en el proyecto VSIX y seleccione Agregar>nuevo elemento (Ctrl+Mayús+A). En el nodo Extensibilidad del lenguaje del proyecto, seleccione Ventana de herramientas personalizada, asigne un nombre a la ventana de herramientas y presione el botón Agregar.

Estos son los lugares clave para usar monikers en una ventana de herramientas. Siga las instrucciones para cada una de ellas:

1. La pestaña de la ventana de herramientas cuando las pestañas son lo suficientemente pequeñas (también se usan en el modificador de ventana Ctrl+Tab).

   Agregue esta línea al constructor de la clase que se deriva del tipo ToolWindowPane:

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

2. Comando para abrir la ventana de herramientas.

   En el archivo .vsct del paquete, edite el botón de comando de la ventana de herramientas:

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

   Asegúrese de que lo siguiente también existe en la parte superior del archivo, después de los elementos <Extern>:

   <Include href="KnownImageIds.vsct"/>
   

Cómo usar monikers de imagen en una ventana de herramientas existente

Actualizar una ventana de herramientas existente para usar monikers de imagen es similar a los pasos para crear una nueva ventana de herramientas.

Estos son los lugares clave para usar monikers en una ventana de herramientas. Siga las instrucciones para cada una de ellas:

1. La pestaña de la ventana de herramientas cuando las pestañas son lo suficientemente pequeñas (también se usan en el modificador de ventana Ctrl+Tab).

   1. Quite estas líneas (si existen) en el constructor de la clase que se deriva del tipo ToolWindowPane:

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

   2. Consulte el paso 1 de la sección "Cómo usar monikers de imagen en una nueva ventana de herramientas" anterior.

2. Comando para abrir la ventana de herramientas.

   • Consulte el paso 2 de la sección "Cómo usar monikers de imagen en una nueva ventana de herramientas" anterior.

Cómo usar monikers de imagen en un archivo .vsct

Actualice el archivo .vsct como se indica en las líneas comentadas siguientes:

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

¿Qué ocurre si el archivo .vsct también debe leerse en versiones anteriores de Visual Studio?

Las versiones anteriores de Visual Studio no reconocen la marca de comandos IconIsMoniker. Puede usar imágenes del servicio de imágenes en versiones de Visual Studio que lo admitan, y seguir usando imágenes de estilo antiguo en versiones anteriores de Visual Studio. Para ello, dejaría el archivo .vsct sin cambios (y, por tanto, compatible con versiones anteriores de Visual Studio) y crearía un archivo CSV (valores separados por comas) que se asigna de pares GUID/ID definidos en el elemento <Bitmaps> de un archivo .vsct a pares GUID/ID del moniker de imagen.

El formato del archivo CSV de asignación es:

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

El archivo CSV se implementa con el paquete y su ubicación se especifica mediante la propiedad IconMappingFilename del atributo de paquete ProvideMenuResource:

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

IconMappingFilename es una ruta de acceso relativa basada implícitamente en $PackageFolder$ (como en el ejemplo anterior) o una ruta de acceso absoluta basada explícitamente en un directorio definido por una variable de entorno, como @"%UserProfile%\dir1\dir2\MyMappingFile.csv".

Cómo portar un sistema de proyecto

Cómo proporcionar ImageMonikers para un proyecto

1. Implemente VSHPROPID_SupportsIconMonikers en las IVsHierarchy del proyecto y devuelva true.

2. Implemente VSHPROPID_IconMonikerImageList (si el proyecto original usó VSHPROPID_IconImgList) o VSHPROPID_IconMonikerGuid, VSHPROPID_IconMonikerId, VSHPROPID_OpenFolderIconMonikerGuid, VSHPROPID_OpenFolderIconMonikerId (si el proyecto original usó VSHPROPID_IconHandle y VSHPROPID_OpenFolderIconHandle).

3. Cambie la implementación de los VSHPROPID originales para los iconos a fin de crear versiones "heredadas" de los iconos si los puntos de extensión los solicitan. IVsImageService2 proporciona la funcionalidad necesaria para obtener esos iconos

   Requisitos adicionales para los tipos de proyecto de VB/C#

   Implemente solo VSHPROPID_SupportsIconMonikers si detecta que el proyecto es el tipo más externo. De lo contrario, es posible que el tipo más externo real no admita monikers de imagen en realidad, y su tipo base podría "ocultar" imágenes personalizadas de forma eficaz.

   Cómo usar monikers de imágenes en CPS

   Establecer imágenes personalizadas en CPS (Common Project System) se puede realizar manualmente o a través de una plantilla de elemento que se incluye con el SDK de extensibilidad del sistema de proyectos.

   Uso del SDK de extensibilidad del sistema de proyectos

   Siga las instrucciones de Proporcionar iconos personalizados para el tipo de proyecto o el tipo de elemento a fin de personalizar las imágenes de CPS. Puede encontrar más información sobre CPS en la documentación de extensibilidad del sistema de proyectos de Visual Studio

   Uso manual de ImageMonikers

4. Implemente y exporte la interfaz IProjectTreeModifier en el sistema de proyectos.

5. Determine qué KnownMoniker o moniker de imagen personalizado desea usar.

6. En el método ApplyModifications, haga lo siguiente en algún lugar del método antes de devolver el nuevo árbol, similar al ejemplo siguiente:

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

7. Si va a crear un nuevo árbol, puede establecer las imágenes personalizadas pasando los monikers deseados al método NewTree, similar al ejemplo siguiente:

   // 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);
   

Cómo convertir de una franja de imágenes real a una franja de imágenes basada en moniker

Necesito admitir HIMAGELISTs

Si ya hay una franja de imágenes existente para el código que desea actualizar a fin de usar el servicio de imágenes, pero está restringido por las API que requieren pasar listas de imágenes, sigue pudiendo obtener las ventajas del servicio de imágenes. Para crear una franja de imágenes basada en moniker, siga los pasos siguientes para crear un manifiesto a partir de monikers existentes.

1. Ejecute la herramienta ManifestFromResources y pase la franja de imágenes. Esto generará un manifiesto para la franja.

   • Recomendado: proporcione un nombre no predeterminado para que el manifiesto se adapte a su uso.

2. Si solo usa KnownMonikers, haga lo siguiente:

   • Reemplace la sección <Imágenes> del manifiesto por <Imágenes/>.

   • Quite todos los identificadores de subimage (cualquier elemento con <imagestrip name>_##).

   • Recomendado: cambie el nombre del símbolo AssetsGuid y del símbolo de la franja de imágenes para adaptarse a su uso.

   • Reemplace cada GUID de ContainedImage por $(ImageCatalogGuid), reemplace cada identificador de ContainedImage por $(<moniker>) y agregue el atributo External="true" a cada ContainedImage

     • El <moniker> debe reemplazarse por el KnownMoniker que coincide con la imagen, pero con "KnownMonikers" quitado del nombre.

   • Agregue <Import Manifest="$(ManifestFolder)\<Instale la ruta relativa dir en *>\Microsoft.VisualStudio.ImageCatalog.imagemanifest" /*> a la parte superior de la sección <Símbolos>.

     • La ruta de acceso relativa viene determinada por la ubicación de implementación definida en la creación de la configuración para el manifiesto.

3. Ejecute la herramienta ManifestToCode para generar encapsuladores a fin de que el código existente tenga un moniker que pueda usar para consultar el servicio de imágenes de la franja de imágenes.

   • Recomendado: proporcione nombres no predeterminados para los encapsuladores y espacios de nombres que se adapten a su uso.

4. Realice todas las agregaciones, configure la creación o implementación y otros cambios de código para trabajar con el servicio de imágenes y los nuevos archivos.

   Manifiesto de ejemplo que incluye imágenes internas y externas para ver el aspecto que debe tener:

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

No necesito admitir HIMAGELISTs

1. Determine el conjunto de KnownMonikers que coinciden con las imágenes de la franja de imágenes o cree sus propios monikers para las imágenes de la franja de imágenes.

2. Actualice la asignación que usó para obtener la imagen en el índice necesario de la franja de imágenes para usar los monikers en su lugar.

3. Actualice el código para usar el servicio de imágenes a fin de solicitar monikers a través de la asignación actualizada. (Esto puede significar actualizar a CrispImages para código administrado o solicitar HBITMAP o HICON desde el servicio de imágenes y pasarlos para código nativo).

Prueba de las imágenes

Puede usar la herramienta Visor de bibliotecas de imágenes para probar los manifiestos de imagen a fin de asegurarse de que todo está creado correctamente. Puede encontrar la herramienta en el SDK de Visual Studio 2015. La documentación para esta herramienta y otras se puede encontrar aquí.

Recursos adicionales

Ejemplos

Se han actualizado varios ejemplos de Visual Studio en GitHub para mostrar cómo usar el servicio de imágenes como parte de varios puntos de extensibilidad de Visual Studio.

Busque los ejemplos más recientes en http://github.com/Microsoft/VSSDK-Extensibility-Samples.

Herramientas

Se creó un conjunto de herramientas de soporte técnico para el servicio de imágenes a fin de ayudar a crear o actualizar la interfaz de usuario que funciona con el servicio de imágenes. Para obtener más información sobre cada herramienta, consulte la documentación que se incluye con las herramientas. Las herramientas se incluyen como parte del SDK de Visual Studio 2015.

ManifestFromResources

La herramienta Manifest from Resources toma una lista de recursos de imagen (PNG o XAML) y genera un archivo de manifiesto de imagen para usar esas imágenes con el servicio de imágenes.

ManifestToCode

La herramienta Manifest to Code toma un archivo de manifiesto de imagen y genera un archivo contenedor para hacer referencia a los valores de manifiesto en el código (C++, C# o VB) o archivos .vsct.

ImageLibraryViewer

La herramienta Visor de la biblioteca de imágenes puede cargar manifiestos de imagen y permite al usuario manipularlos de la misma manera que lo haría Visual Studio para asegurarse de que el manifiesto está creado correctamente. El usuario puede modificar el fondo, los tamaños, la configuración de PPP, el contraste alto y otros valores. También muestra información de carga para buscar errores en los manifiestos y muestra información de origen para cada imagen del manifiesto.

Preguntas más frecuentes

• Hay dependencias que debe incluir al cargar <Reference Include="Microsoft.VisualStudio.*. Interop.14.0.DesignTime" />?

  • Establezca EmbedInteropTypes="true" en todos los archivos DLL de interop.

• Cómo implementar un manifiesto de imagen con mi extensión

  • Agregue un archivo .imagemanifest al proyecto.

  • Establezca "Incluir en VSIX" en true.

• Mis imágenes siguen sin funcionar, ¿cómo puedo averiguar cuál es el problema?

  • Es posible que Visual Studio no encuentre el manifiesto de imagen. Por motivos de rendimiento, Visual Studio limita la profundidad de búsqueda de carpetas, por lo que se recomienda mantener el manifiesto de imagen en la carpeta raíz de la extensión.

  • Es posible que falte información de ensamblado en el archivo de manifiesto de imagen. Los ensamblados con nombre seguro requieren información adicional para que Visual Studio lo cargue. Para cargar un ensamblado con nombre seguro, debe incluir (además del nombre del ensamblado) la versión del ensamblado y el token de clave pública en los URI de recursos para las imágenes del manifiesto de imagen.

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

  • Es posible que falte una entrada de código base para el ensamblado de imagen. Si su ensamblado aún no está cargado cuando Visual Studio lo necesite, necesitará saber dónde encontrarlo para cargarlo. Para agregar un código base para el ensamblado, puede usar ProvideCodeBaseAttribute para asegurarse de que se genera una entrada de código base y se incluye en la pkgdef de la extensión.

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

  • Si las opciones anteriores no resuelven el problema de carga de imágenes, puede habilitar el registro quitando las siguientes entradas en una pkgdef en la extensión:

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

    Esto creará un archivo de registro denominado ImageLibrary.log en la carpeta %UserProfile% . Asegúrese de ejecutar "devenv /updateConfiguration" desde un símbolo del sistema para desarrolladores después de agregar estas entradas a pkgdef. Esto garantiza que las entradas de registro están habilitadas y que VS actualiza la memoria caché del manifiesto de imagen para ayudar a encontrar los errores que pueden producirse al leer el manifiesto de imagen. Si, a continuación, recorre el escenario en el que se espera que la imagen se cargue, el archivo de registro contendrá tanto el registro del registro como el de solicitudes de la imagen.

• Estoy actualizando mi sistema de proyectos de CPS. ¿Qué ha ocurrido con ImageName y StockIconService?

  • Estos se quitaron cuando CPS se actualizó para usar monikers. Ya no es necesario llamar a StockIconService, simplemente pase el knownMoniker deseado al método o la propiedad mediante el método de extensión ToProjectSystemType() en las utilidades de CPS. Puede encontrar una asignación de ImageName a KnownMonikers a continuación:

    ImageName	KnownMoniker
    ImageName.OfflineWebApp	KnownImageIds.Web
    ImageName.WebReferencesFolder	KnownImageIds.Web
    ImageName.OpenReferenceFolder	KnownImageIds.FolderOpened
    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.MissingFile	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.Resources	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

• Estoy actualizando mi proveedor de listas de finalización. ¿Qué valores KnownMonikers coinciden con los valores StandardGlyphGroup y StandardGlyph antiguos?

  Nombre	Nombre	Nombre
  GlyphGroupClass	GlyphItemPublic	ClassPublic
  GlyphGroupClass	GlyphItemInternal	ClassInternal
  GlyphGroupClass	GlyphItemFriend	ClassInternal
  GlyphGroupClass	GlyphItemProtected	ClassProtected
  GlyphGroupClass	GlyphItemPrivate	ClassPrivate
  GlyphGroupClass	GlyphItemShortcut	ClassShortcut
  GlyphGroupConstant	GlyphItemPublic	ConstantPublic
  GlyphGroupConstant	GlyphItemInternal	ConstantInternal
  GlyphGroupConstant	GlyphItemFriend	ConstantInternal
  GlyphGroupConstant	GlyphItemProtected	ConstantProtected
  GlyphGroupConstant	GlyphItemPrivate	ConstantPrivate
  GlyphGroupConstant	GlyphItemShortcut	ConstantShortcut
  GlyphGroupDelegate	GlyphItemPublic	DelegatePublic
  GlyphGroupDelegate	GlyphItemInternal	DelegateInternal
  GlyphGroupDelegate	GlyphItemFriend	DelegateInternal
  GlyphGroupDelegate	GlyphItemProtected	DelegateProtected
  GlyphGroupDelegate	GlyphItemPrivate	DelegatePrivate
  GlyphGroupDelegate	GlyphItemShortcut	DelegateShortcut
  GlyphGroupEnum	GlyphItemPublic	EnumerationPublic
  GlyphGroupEnum	GlyphItemInternal	EnumerationInternal
  GlyphGroupEnum	GlyphItemFriend	EnumerationInternal
  GlyphGroupEnum	GlyphItemProtected	EnumerationProtected
  GlyphGroupEnum	GlyphItemPrivate	EnumerationPrivate
  GlyphGroupEnum	GlyphItemShortcut	EnumerationShortcut
  GlyphGroupEnumMember	GlyphItemPublic	EnumerationItemPublic
  GlyphGroupEnumMember	GlyphItemInternal	EnumerationItemInternal
  GlyphGroupEnumMember	GlyphItemFriend	EnumerationItemInternal
  GlyphGroupEnumMember	GlyphItemProtected	EnumerationItemProtected
  GlyphGroupEnumMember	GlyphItemPrivate	EnumerationItemPrivate
  GlyphGroupEnumMember	GlyphItemShortcut	EnumerationItemShortcut
  GlyphGroupEvent	GlyphItemPublic	EventPublic
  GlyphGroupEvent	GlyphItemInternal	EventInternal
  GlyphGroupEvent	GlyphItemFriend	EventInternal
  GlyphGroupEvent	GlyphItemProtected	EventProtected
  GlyphGroupEvent	GlyphItemPrivate	EventPrivate
  GlyphGroupEvent	GlyphItemShortcut	EventShortcut
  GlyphGroupException	GlyphItemPublic	ExceptionPublic
  GlyphGroupException	GlyphItemInternal	ExceptionInternal
  GlyphGroupException	GlyphItemFriend	ExceptionInternal
  GlyphGroupException	GlyphItemProtected	ExceptionProtected
  GlyphGroupException	GlyphItemPrivate	ExceptionPrivate
  GlyphGroupException	GlyphItemShortcut	ExceptionShortcut
  GlyphGroupField	GlyphItemPublic	FieldPublic
  GlyphGroupField	GlyphItemInternal	FieldInternal
  GlyphGroupField	GlyphItemFriend	FieldInternal
  GlyphGroupField	GlyphItemProtected	FieldProtected
  GlyphGroupField	GlyphItemPrivate	FieldPrivate
  GlyphGroupField	GlyphItemShortcut	FieldShortcut
  GlyphGroupInterface	GlyphItemPublic	InterfacePublic
  GlyphGroupInterface	GlyphItemInternal	InterfaceInternal
  GlyphGroupInterface	GlyphItemFriend	InterfaceInternal
  GlyphGroupInterface	GlyphItemProtected	InterfaceProtected
  GlyphGroupInterface	GlyphItemPrivate	InterfacePrivate
  GlyphGroupInterface	GlyphItemShortcut	InterfaceShortcut
  GlyphGroupMacro	GlyphItemPublic	MacroPublic
  GlyphGroupMacro	GlyphItemInternal	MacroInternal
  GlyphGroupMacro	GlyphItemFriend	MacroInternal
  GlyphGroupMacro	GlyphItemProtected	MacroProtected
  GlyphGroupMacro	GlyphItemPrivate	MacroPrivate
  GlyphGroupMacro	GlyphItemShortcut	MacroShortcut
  GlyphGroupMap	GlyphItemPublic	MapPublic
  GlyphGroupMap	GlyphItemInternal	MapInternal
  GlyphGroupMap	GlyphItemFriend	MapInternal
  GlyphGroupMap	GlyphItemProtected	MapProtected
  GlyphGroupMap	GlyphItemPrivate	MapPrivate
  GlyphGroupMap	GlyphItemShortcut	MapShortcut
  GlyphGroupMapItem	GlyphItemPublic	MapItemPublic
  GlyphGroupMapItem	GlyphItemInternal	MapItemInternal
  GlyphGroupMapItem	GlyphItemFriend	MapItemInternal
  GlyphGroupMapItem	GlyphItemProtected	MapItemProtected
  GlyphGroupMapItem	GlyphItemPrivate	MapItemPrivate
  GlyphGroupMapItem	GlyphItemShortcut	MapItemShortcut
  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	ModulePublic
  GlyphGroupModule	GlyphItemInternal	ModuleInternal
  GlyphGroupModule	GlyphItemFriend	ModuleInternal
  GlyphGroupModule	GlyphItemProtected	ModuleProtected
  GlyphGroupModule	GlyphItemPrivate	ModulePrivate
  GlyphGroupModule	GlyphItemShortcut	ModuleShortcut
  GlyphGroupNamespace	GlyphItemPublic	NamespacePublic
  GlyphGroupNamespace	GlyphItemInternal	NamespaceInternal
  GlyphGroupNamespace	GlyphItemFriend	NamespaceInternal
  GlyphGroupNamespace	GlyphItemProtected	NamespaceProtected
  GlyphGroupNamespace	GlyphItemPrivate	NamespacePrivate
  GlyphGroupNamespace	GlyphItemShortcut	NamespaceShortcut
  GlyphGroupOperator	GlyphItemPublic	OperatorPublic
  GlyphGroupOperator	GlyphItemInternal	OperatorInternal
  GlyphGroupOperator	GlyphItemFriend	OperatorInternal
  GlyphGroupOperator	GlyphItemProtected	OperatorProtected
  GlyphGroupOperator	GlyphItemPrivate	OperatorPrivate
  GlyphGroupOperator	GlyphItemShortcut	OperatorShortcut
  GlyphGroupProperty	GlyphItemPublic	PropertyPublic
  GlyphGroupProperty	GlyphItemInternal	PropertyInternal
  GlyphGroupProperty	GlyphItemFriend	PropertyInternal
  GlyphGroupProperty	GlyphItemProtected	PropertyProtected
  GlyphGroupProperty	GlyphItemPrivate	PropertyPrivate
  GlyphGroupProperty	GlyphItemShortcut	PropertyShortcut
  GlyphGroupStruct	GlyphItemPublic	StructurePublic
  GlyphGroupStruct	GlyphItemInternal	StructureInternal
  GlyphGroupStruct	GlyphItemFriend	StructureInternal
  GlyphGroupStruct	GlyphItemProtected	StructureProtected
  GlyphGroupStruct	GlyphItemPrivate	StructurePrivate
  GlyphGroupStruct	GlyphItemShortcut	StructureShortcut
  GlyphGroupTemplate	GlyphItemPublic	TemplatePublic
  GlyphGroupTemplate	GlyphItemInternal	TemplateInternal
  GlyphGroupTemplate	GlyphItemFriend	TemplateInternal
  GlyphGroupTemplate	GlyphItemProtected	TemplateProtected
  GlyphGroupTemplate	GlyphItemPrivate	TemplatePrivate
  GlyphGroupTemplate	GlyphItemShortcut	TemplateShortcut
  GlyphGroupTypedef	GlyphItemPublic	TypeDefinitionPublic
  GlyphGroupTypedef	GlyphItemInternal	TypeDefinitionInternal
  GlyphGroupTypedef	GlyphItemFriend	TypeDefinitionInternal
  GlyphGroupTypedef	GlyphItemProtected	TypeDefinitionProtected
  GlyphGroupTypedef	GlyphItemPrivate	TypeDefinitionPrivate
  GlyphGroupTypedef	GlyphItemShortcut	TypeDefinitionShortcut
  GlyphGroupType	GlyphItemPublic	TypePublic
  GlyphGroupType	GlyphItemInternal	TypeInternal
  GlyphGroupType	GlyphItemFriend	TypeInternal
  GlyphGroupType	GlyphItemProtected	TypeProtected
  GlyphGroupType	GlyphItemPrivate	TypePrivate
  GlyphGroupType	GlyphItemShortcut	TypeShortcut
  GlyphGroupUnion	GlyphItemPublic	UnionPublic
  GlyphGroupUnion	GlyphItemInternal	UnionInternal
  GlyphGroupUnion	GlyphItemFriend	UnionInternal
  GlyphGroupUnion	GlyphItemProtected	UnionProtected
  GlyphGroupUnion	GlyphItemPrivate	UnionPrivate
  GlyphGroupUnion	GlyphItemShortcut	UnionShortcut
  GlyphGroupVariable	GlyphItemPublic	FieldPublic
  GlyphGroupVariable	GlyphItemInternal	FieldInternal
  GlyphGroupVariable	GlyphItemFriend	FieldInternal
  GlyphGroupVariable	GlyphItemProtected	FieldProtected
  GlyphGroupVariable	GlyphItemPrivate	FieldPrivate
  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	ObjectProtected
  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	FieldPublic
  GlyphGroupJSharpField	GlyphItemInternal	FieldInternal
  GlyphGroupJSharpField	GlyphItemFriend	FieldInternal
  GlyphGroupJSharpField	GlyphItemProtected	FieldProtected
  GlyphGroupJSharpField	GlyphItemPrivate	FieldPrivate
  GlyphGroupJSharpField	GlyphItemShortcut	FieldShortcut
  GlyphGroupJSharpClass	GlyphItemPublic	ClassPublic
  GlyphGroupJSharpClass	GlyphItemInternal	ClassInternal
  GlyphGroupJSharpClass	GlyphItemFriend	ClassInternal
  GlyphGroupJSharpClass	GlyphItemProtected	ClassProtected
  GlyphGroupJSharpClass	GlyphItemPrivate	ClassPrivate
  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	InterfaceInternal
  GlyphGroupJSharpInterface	GlyphItemFriend	InterfaceInternal
  GlyphGroupJSharpInterface	GlyphItemProtected	InterfaceProtected
  GlyphGroupJSharpInterface	GlyphItemPrivate	InterfacePrivate
  GlyphGroupJSharpInterface	GlyphItemShortcut	InterfaceShortcut
  GlyphGroupError		StatusError
  GlyphBscFile		ClassFile
  GlyphAssembly		Referencia
  GliphLibrary		Biblioteca
  GlyphVBProject		VBProjectNode
  GlyphCoolProject		CSProjectNode
  GlyphCppProject		CPPProjectNode
  GlyphDialogId		Dialog
  GliphOpenFolder		FolderOpened
  GlyphClosedFolder		FolderClosed
  GlyphArrow		GoToNext
  GlyphCSharpFile		CSFileNode
  GliphCSharpExpansion		Snippet
  GlyphKeyword		IntellisenseKeyword
  GlyphInformation		StatusInformation
  GliphReference		ClassMethodReference
  GlyphRecursion		Recursion
  GlyphXmlItem		Tag
  GliphJSharpProject		DocumentCollection
  GlyphJSharpDocument		Document
  GlyphForwardType		GoToNext
  GlifoCallersGraph		CallTo
  GlifoCallGraph		CallFrom
  GlyphWarning		StatusWarning
  GlifoMaybeReference		QuestionMark
  GlifoMaybeCaller		CallTo
  GlyphMaybeCall		CallFrom
  GlyphExtensionMethod		ExtensionMethod
  GlyphExtensionMethodInternal		ExtensionMethod
  GlyphExtensionMethodFriend		ExtensionMethod
  GlyphExtensionMethodProtected		ExtensionMethod
  GlyphExtensionMethodPrivate		ExtensionMethod
  GlyphExtensionMethodShortcut		ExtensionMethod
  GlyphXmlAttribute		XmlAttribute
  GlyphXmlChild		XmlElement
  GliphXmlDescendant		XmlDescendant
  GlyphXmlNamespace		xmlNamespace
  GlyphXmlAttributeQuestion		XmlAttributeLowConfidence
  GlyphXmlAttributeCheck		XmlAttributeHighConfidence
  GlyphXmlChildQuestion		XmlElementLowConfidence
  GlyphXmlChildCheck		XmlElementHighConfidence
  GlyphXmlDescendantQuestion		XmlDescendantLowConfidence
  GlyphXmlDescendantCheck		XmlDescendantHighConfidence
  GlyphCompletionWarning		IntellisenseWarning