Servicio de imagen y catálogo

Este manual contiene instrucciones y procedimientos recomendados para adoptar Visual Studio Image Service y 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 correctos 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 para pantallas HDPI y la tematización.

¿Por qué adoptar el servicio de imagen?

• Obtenga siempre la imagen más reciente "pixel-perfect" de Visual Studio.

• Puede enviar y usar sus propias imágenes.

• No es necesario verificar tus imágenes cuando Windows añade un nuevo escalado de PPP

• Aborde los obstáculos arquitectónicos antiguos en sus implementaciones

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

  

Cómo funciona

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 de servicio de imagen

  

  Identificadores de imagen

  Un moniker de imagen es un par GUID/ID que identifica de forma única un recurso de imagen o un activo 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 detrás 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 son sensibles a mayúsculas y minúsculas y se hacen referencia usando la sintaxis $(nombre-del-símbolo).

<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 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 nombre determinado, la primera que se encuentra al compilar la biblioteca es la 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>

Fuente

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 opcional <NativeResource>, que define un <Source> que se carga desde un ensamblado nativo en lugar de uno 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 tira se fabrica bajo demanda, según sea necesario.

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

El moniker de la imagen contenida no tiene que hacer referencia a una imagen definida en el manifiesto actual. Si no se encuentra la imagen contenida 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 (gestionados)

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 integrado 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 usas 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 integrado KnownMonikers.

• ImageParameters140.h

  • Obligatorio si usa los tipos ImageMoniker e ImageAttributes .

• VSShell140.h

  • Obligatorio si usa el tipo IVsImageService2 .

• ImageThemingUtilities.h

  • Es necesario si no puede permitir que el servicio de imágenes maneje la tematización 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 ayudantes de compatibilidad con DPI para obtener el DPI actual.

¿Cómo puedo escribir una nueva interfaz de usuario de WPF?

1. Comience por agregar las referencias de ensamblado necesarias que se mencionan en la sección "Primeros pasos" anterior a su 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 uno propio si tiene imágenes y monikers personalizados.

3. Agrega CrispImages a tu XAML. (Vea el ejemplo siguiente).

4. Establezca la propiedad ImageThemingUtilities.ImageBackgroundColor en la jerarquía de la interfaz de usuario. (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 actualizo 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 <Image> en su interfaz de usuario por <los elementos CrispImage>.

2. Cambie todos los atributos source a los atributos Moniker.

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

   • Si la imagen nunca cambia y utiliza su propia imagen personalizada, entonces enlace de forma estática a su propio moniker.

   • Si la imagen puede cambiar, enlace el atributo Moniker a una propiedad de código que notifica 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 actualizo la interfaz de usuario de Win32?

Agregue lo siguiente a su código donde sea apropiado para reemplazar la carga de imágenes de forma directa. Cambie los valores para devolver HBITMAPs en lugar de HICONs o HIMAGELISTs según sea necesario.

Obtener el 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 se actualiza la interfaz de usuario de WinForms?

Agregue lo siguiente al código donde sea apropiado para reemplazar la carga bruta de imágenes. Cambie los valores para devolver mapas de bits o Iconos según sea necesario.

Útil declaración using

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

Obtener el 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 uso monikers de imágenes 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 usa en el alternador de ventanas Ctrl+Tab).

   Agregue esta línea al constructor de la clase que 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 .vsct archivo 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 <Extern> elementos :

   <Include href="KnownImageIds.vsct"/>
   

¿Cómo se usan los iconos de imágenes en una ventana de herramientas existente?

Actualizar una ventana de herramientas existente para usar monikers de imagen es similar a los pasos que se siguen 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 utiliza en el conmutador de ventanas Ctrl+Tab).

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

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

   2. Consulte el paso #1 de la sección "Cómo utilizar identificadores de imágenes en una nueva ventana de herramientas" anterior.

2. Comando para abrir la ventana de herramientas.

   • Consulte el paso número 2 de la sección «¿Cómo uso monikers de imágenes en una nueva ventana de herramientas?» anterior.

¿Cómo uso identificadores de imagen en un archivo .vsct?

Actualice el .vsct archivo 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, pero 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 asigna pares GUID/ID definidos en el elemento <Bitmaps> de un archivo a pares GUID/ID del moniker de imagen.

El formato del archivo CSV de mapeo 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 explícitamente raíz en un directorio definido por una variable de entorno, como @"%UserProfile%\dir1\dir2\MyMappingFile.csv".

¿Cómo se puede migrar un sistema de proyecto?

Cómo proporcionar ImageMonikers para un proyecto

1. Implemente VSHPROPID_SupportsIconMonikers en el 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 para crear versiones "heredadas" de los iconos si los puntos de extensión los solicitan. IVsImageService2 proporciona funcionalidad necesaria para obtener esos iconos

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

   Solo implemente VSHPROPID_SupportsIconMonikers si detecta que su proyecto es el nivel más externo. De lo contrario, es posible que la versión más externa real no soporte identificadores de imagen, y su configuración base podría "ocultar" efectivamente imágenes personalizadas.

   ¿Cómo uso los 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 de Project System.

   Uso del SDK de extensibilidad de Project System

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

   Uso manual de ImageMonikers

4. Implemente y exporte la interfaz IProjectTreeModifier en el sistema del proyecto.

5. Determina 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 puedo convertir de una franja de imágenes real a una franja de imágenes basada en moniker?

Necesito apoyar HIMAGELISTs

Si ya existe una tira de imágenes para su código que desea actualizar para emplear el servicio de imágenes, pero está restringido por APIs que requieren pasar listas de imágenes, aún puede beneficiarse del servicio de imágenes. Para crear una franja de imágenes basada en alias, siga los pasos siguientes para crear un manifiesto a partir de alias existentes.

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

   • 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 subimagen (cualquier elemento con <nombre de tira de imágenes>_##).

   • 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 coincida con la imagen, pero eliminando "KnownMonikers." del nombre.

   • Agregue <Import Manifest="$(ManifestFolder)\<Ruta relativa del directorio de instalación a *>\Microsoft.VisualStudio.ImageCatalog.imagemanifest" /*> en 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 autorización de instalación para el manifiesto.

3. Ejecute la herramienta ManifestToCode para generar envoltorios de manera que el código existente tenga un moniker que pueda usar para consultar el servicio de imágenes por la tira de imágenes.

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

4. Haga todas las adiciones, configure la creación de contenido y la 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 soportar HIMAGELISTs

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

2. Actualice el mapeo que utilizó para obtener la imagen en el índice necesario de la tira de imágenes, utilizando los monikers en su lugar.

3. Actualice el código para utilizar el servicio de imágenes y solicitar monikers a través del mapeo actualizado. (Esto puede significar actualizar a CrispImages para código administrado o solicitar HBITMAPs 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 para asegurarse de que todo está creado correctamente. Puede encontrar la herramienta en el SDK de Visual Studio 2015. La documentación de esta herramienta y otras se puede encontrar aquí.

Recursos adicionales

Samples

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.

Consulte http://github.com/Microsoft/VSSDK-Extensibility-Samples para los últimos ejemplos.

Tooling

Se creó un conjunto de herramientas de soporte técnico para image Service para ayudar a crear o actualizar la interfaz de usuario que funciona con image Service. 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 Manifiesto de recursos 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 Manifiesto a código 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 bibliotecas 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á redactado correctamente. El usuario puede modificar el fondo, los tamaños, la configuración de PPP, el alto contraste y otros ajustes. 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 DLLs de interoperabilidad.

• ¿Cómo se implementa un manifiesto de imagen con mi extensión?

  • Agregue el .imagemanifest archivo al proyecto.

  • Establezca "Incluir en VSIX" en True.

• Mis imágenes todavía no funcionan, ¿cómo puedo averiguar lo que está mal?

  • 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 ensamblajes firmemente nombrados requieren información adicional para que Visual Studio los 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 de su 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 el ensamblado aún no se carga en el momento en que Visual Studio lo necesita, deberá saber dónde encontrar el ensamblado 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 agregando las siguientes entradas en un archivo pkgdef de su 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 una consola de comandos para desarrolladores después de agregar estas entradas al archivo 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 luego realizas el escenario en el que se espera que la imagen se cargue, el archivo de registro contendrá tanto los registros de registro como los de solicitudes para su imagen.

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

  • Estos elementos se quitaron cuando CPS se actualizó para usar identificadores. Ya no es necesario llamar a StockIconService, simplemente pase el KnownMoniker deseado al método o la propiedad utilizando el método de extensión ToProjectSystemType() de 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
    NombreDeImagen.AbrirCarpetaDeReferencia	KnownImageIds.CarpetaAbierta
    NombreDeImagen.CarpetaDeReferencia	KnownImageIds.Reference
    ImageName.Reference	KnownImageIds.Reference
    ImageName.SdlWebReference	KnownImageIds.WebReferenceFolder
    ImageName.DiscoWebReference	KnownImageIds.DynamicDiscoveryDocument
    ImageName.Folder	KnownImageIds.CarpetaCerrada
    ImageName.AbrirCarpeta	KnownImageIds.CarpetaAbierta
    ImageName.ExcludedFolder	KnownImageIds.CarpetaOcultaCerrada
    ImageName.OpenExcludedFolder	IdentificadoresDeImagenConocidos.CarpetaOcultaAbierta
    ImageName.ExcludedFile	KnownImageIds.ArchivoOculto
    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.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.AdvertenciaDeReferencia
    ImageName.XsltFile	KnownImageIds.XSLTransform
    ImageName.Cursor	KnownImageIds.CursorFile
    ImageName.AppDesignerFolder	KnownImageIds.Propiedad
    ImageName.Data	KnownImageIds.Database
    ImageName.Application	KnownImageIds.Application
    NombreDeImagen.ConjuntoDeDatos	KnownImageIds.DatabaseGroup
    ImageName.Pfx	KnownImageIds.Certificate
    ImageName.Snk	KnownImageIds.Rule
    ImageName.VisualBasicProject	KnownImageIds.VBProjectNode
    ImageName.CSharpProject	KnownImageIds.CSProjectNode
    ImageName.Empty	KnownImageIds.Blank
    NombreDeImagen.CarpetaFaltante	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	ClaseProtegida
  GlyphGroupClass	GlyphItemPrivate	ClasePrivada
  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	DelegadoProtegido
  GlyphGroupDelegate	GlyphItemPrivate	DelegatePrivate
  DelegadoDeGrupoDeGlifos	GlyphItemShortcut	DelegateShortcut
  GlyphGroupEnum	GlyphItemPublic	EnumerationPublic
  GlyphGroupEnum	GlyphItemInternal	EnumerationInternal
  GlyphGroupEnum	GlyphItemFriend	EnumerationInternal
  GlyphGroupEnum	GlyphItemProtected	EnumeraciónProtegida
  GlyphGroupEnum	GlyphItemPrivate	EnumerationPrivate
  GlyphGroupEnum	GlyphItemShortcut	EnumerationShortcut
  GlyphGroupEnumMember	GlyphItemPublic	ElementoEnumeraciónPúblico
  GlyphGroupEnumMember	GlyphItemInternal	ElementoEnumeraciónInterno
  GlyphGroupEnumMember	GlyphItemFriend	ElementoEnumeraciónInterno
  GlyphGroupEnumMember	GlyphItemProtected	ElementoDeEnumeraciónProtegido
  GlyphGroupEnumMember	GlyphItemPrivate	EnumerationItemPrivate
  GlyphGroupEnumMember	GlyphItemShortcut	AccesoDirectoElementoEnumeración
  GlyphGroupEvent	GlyphItemPublic	EventPublic
  GlyphGroupEvent	GlyphItemInternal	EventInternal
  GlyphGroupEvent	GlyphItemFriend	EventInternal
  GlyphGroupEvent	GlyphItemProtected	EventoProtegido
  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	CampoProtegido
  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	ElementoDeMapaProtegido
  GlyphGroupMapItem	GlyphItemPrivate	MapItemPrivate
  GlyphGroupMapItem	GlyphItemShortcut	Atajo de Elemento de 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	ModulePublic
  GlyphGroupModule	GlyphItemInternal	MóduloInterno
  GlyphGroupModule	GlyphItemFriend	MóduloInterno
  GlyphGroupModule	GlyphItemProtected	MóduloProtegido
  GlyphGroupModule	GlyphItemPrivate	ModulePrivate
  GlyphGroupModule	GlyphItemShortcut	ModuleShortcut
  GlyphGroupNamespace	GlyphItemPublic	NamespacePublic
  GlyphGroupNamespace	GlyphItemInternal	NamespaceInternal
  GlyphGroupNamespace	GlyphItemFriend	NamespaceInternal
  GlyphGroupNamespace	GlyphItemProtected	Espacio de nombres protegido
  GlyphGroupNamespace	GlyphItemPrivate	NamespacePrivate
  GlyphGroupNamespace	GlyphItemShortcut	NamespaceShortcut
  GlyphGroupOperator	GlyphItemPublic	OperatorPublic
  GlyphGroupOperator	GlyphItemInternal	OperadorInterno
  GlyphGroupOperator	GlyphItemFriend	OperatorInterno
  GlyphGroupOperator	GlyphItemProtected	OperatorProtected
  GlyphGroupOperator	GlyphItemPrivate	OperatorPrivate
  GlyphGroupOperator	GlyphItemShortcut	Atajo de Operador
  GlyphGroupProperty	GlyphItemPublic	PropertyPublic
  GlyphGroupProperty	GlyphItemInternal	PropertyInternal
  GlyphGroupProperty	GlyphItemFriend	PropertyInternal
  GlyphGroupProperty	GlyphItemProtected	PropiedadProtegida
  GlyphGroupProperty	GlyphItemPrivate	PropertyPrivate
  GlyphGroupProperty	GlyphItemShortcut	PropertyShortcut
  GlyphGroupStruct	GlyphItemPublic	EstructuraPública
  GlyphGroupStruct	GlyphItemInternal	EstructuraInterna
  GlyphGroupStruct	GlyphItemFriend	EstructuraInterna
  GlyphGroupStruct	GlyphItemProtected	EstructuraProtegida
  GlyphGroupStruct	GlyphItemPrivate	EstructuraPrivada
  GlyphGroupStruct	GlyphItemShortcut	EstructuraAccesoDirecto
  GlyphGroupTemplate	GlyphItemPublic	TemplatePublic
  GlyphGroupTemplate	GlyphItemInternal	TemplateInternal
  GlyphGroupTemplate	GlyphItemFriend	TemplateInternal
  GlyphGroupTemplate	GlyphItemProtected	PlantillaProtegida
  GlyphGroupTemplate	GlyphItemPrivate	TemplatePrivate
  GlyphGroupTemplate	GlyphItemShortcut	TemplateShortcut
  GlyphGroupTypedef	GlyphItemPublic	TypeDefinitionPublic
  GlyphGroupTypedef	GlyphItemInternal	TypeDefinitionInternal
  GlyphGroupTypedef	GlyphItemFriend	TypeDefinitionInternal
  GlyphGroupTypedef	GlyphItemProtected	TypeDefinitionProtected
  GlyphGroupTypedef	GlyphItemPrivate	DefiniciónDeTipoPrivada
  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	CampoProtegido
  GlyphGroupVariable	GlyphItemPrivate	FieldPrivate
  GlyphGroupVariable	GlyphItemShortcut	FieldShortcut
  GlyphGroupValueType (Tipo de Valor de Grupo de Glifos)	GlyphItemPublic	ValueTypePublic
  GlyphGroupValueType	GlyphItemInternal	ValueTypeInternal
  GlyphGroupValueType	GlyphItemFriend	ValueTypeInternal
  GlyphGroupValueType	GlyphItemProtected	TipoValorProtegido
  GlyphGroupValueType	GlyphItemPrivate	TipoDeValorPrivado
  Tipo de Valor de Grupo de Glifos	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	FieldPublic
  GlyphGroupJSharpField	GlyphItemInternal	FieldInternal
  GlyphGroupJSharpField	GlyphItemFriend	FieldInternal
  GlyphGroupJSharpField	GlyphItemProtected	CampoProtegido
  GlyphGroupJSharpField	GlyphItemPrivate	FieldPrivate
  GlyphGroupJSharpField	GlyphItemShortcut	FieldShortcut
  GlyphGroupJSharpClass	GlyphItemPublic	ClassPublic
  GlyphGroupJSharpClass	GlyphItemInternal	ClassInternal
  GlyphGroupJSharpClass	GlyphItemFriend	ClassInternal
  GlyphGroupJSharpClase	GlyphItemProtected	ClaseProtegida
  GlyphGroupJSharpClass	GlyphItemPrivate	ClasePrivada
  GlyphGroupJSharpClass	GlyphItemShortcut	ClassShortcut
  GlyphGroupJSharpNamespace	GlyphItemPublic	NamespacePublic
  GlyphGroupJSharpNamespace	GlyphItemInternal	NamespaceInternal
  GlyphGroupJSharpNamespace	GlyphItemFriend	NamespaceInternal
  GlyphGroupJSharpNamespace	GlyphItemProtected	Espacio de nombres protegido
  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
  GlifoAssembly		Referencia
  GliphLibrary		Biblioteca
  GlyphVBProject		VBProjectNode
  GlyphCoolProject		CSProjectNode
  GlyphCppProject		CPPProjectNode
  GlyphDialogId		Dialog
  GliphOpenFolder		CarpetaAbierta
  GliphClosedFolder		Carpeta Cerrada
  GlifoArrow		Ir a Siguiente
  GlyphCSharpFile		CSFileNode
  GlyphCSharpExpansion		Fragmento
  GlyphKeyword		IntelliSenseKeyword
  GlyphInformation		StatusInformation
  GliphReference		ClassMethodReference
  GlifoRecursion		Recursividad
  GlyphXmlItem		Etiqueta
  GliphJSharpProject		Colección de Documentos
  GlyphJSharpDocument		Documento
  GlyphForwardType		Ir a Siguiente
  GlyphCallersGraph		CallTo
  GlyphCallGraph		CallFrom
  GlifoWarning		StatusWarning
  GlyphMaybeReference		QuestionMark
  GlyphMaybeCaller		CallTo
  GlyphMaybeCall		CallFrom
  GlyphExtensionMethod		ExtensionMethod
  GlyphExtensionMethodInternal		Método de extensión
  GlyphExtensionMethodFriend		MétodoDeExtensión
  GlyphExtensionMethodProtected		ExtensionMethod
  GlyphExtensionMethodPrivate		ExtensionMethod
  GlyphExtensionMethodShortcut		Método de extensión
  GlyphXmlAttribute		XmlAttribute
  GlyphXmlChild		XmlElement
  GlyphXmlDescendant		XmlDescendant
  GlyphXmlNamespace		XmlNamespace
  GlyphXmlAttributeQuestion		XmlAttributeLowConfidence
  GlyphXmlAttributeCheck		AtributoXmlAltaConfianza
  GlyphXmlChildQuestion		XmlElementLowConfidence
  GlyphXmlChildCheck		ElementoXmlAltaConfianza
  GlyphXmlDescendantQuestion		XmlDescendantLowConfidence
  GlyphXmlDescendantCheck		DescendienteXMLAltaConfianza
  AdvertenciaDeFinalizaciónDeGlifo		IntelliSenseWarning