Comparteix a través de

Catálogo y servicio de imágenes

  • Article

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.

Problemas en la actualidad Soluciones
Combinación de colores de fondo Combinación alfa integrada
Creación de temáticas de (algunas) imágenes Metadatos del tema
Modo de contraste alto Recursos alternativos de contraste alto
Necesidad de varios recursos para distintos modos de PPP Recursos seleccionables con reserva basada en vectores
Imágenes duplicadas Un identificador por concepto de imagen

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

    Servicio de imagen antes y después

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

    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>

Symbols

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" />
</Symbols>
Subelemento Definición
Importar Importa los símbolos del archivo de manifiesto especificado para su uso en el manifiesto actual.
GUID El símbolo representa un GUID y debe coincidir con el formato GUID.
ID El símbolo representa un identificador y debe ser un entero no negativo.
Cadena El símbolo representa un valor de cadena arbitrario

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.

Símbolo Descripción
CommonProgramFiles Valor de la variable de entorno %CommonProgramFiles%
LocalAppData Valor de la variable de entorno %LocalAppData%
ManifestFolder Carpeta que contiene el archivo de manifiesto
MyDocuments Ruta de acceso completa de la carpeta Mis documentos del usuario actual
ProgramFiles Valor de la variable de entorno %ProgramFiles%
Sistema Carpeta Windows\System32
WinDir Valor de la variable de entorno %WinDir%

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>
Atributo Definición
Guid [Obligatorio] Parte GUID del moniker de imagen
ID [Obligatorio] Parte del identificador del moniker de imagen
AllowColorInversion [Opcional, valor predeterminado true] Indica si la imagen puede invertir sus colores mediante programación cuando se usa en un fondo oscuro.

Origen

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

<Source Uri="uri" Background="background">
      <!-- optional NativeResource element -->
 </Source>
Atributo Definición
Identificador URI [Obligatorio] Un URI que define dónde se puede cargar la imagen. Puede tener uno de los valores siguientes:

- Un URI de paquete mediante la autoridad de application:///
- Referencia de recursos de componente absoluto
- Ruta de acceso a un archivo que contiene un recurso nativo
Fondo [Opcional] Indica en qué tipo de fondo está diseñado el origen para usarse.

Puede tener uno de los valores siguientes:

Claro: el origen se puede usar en un fondo claro.

Oscuro: el origen se puede usar en un fondo oscuro.

HighContrast: el origen se puede usar en cualquier fondo en modo contraste alto.

HighContrastLight: el origen se puede usar en un fondo claro en modo contraste alto.

HighContrastDark: el origen se puede usar en un fondo oscuro en modo contraste alto.

Si se omite el atributo Background, el origen se puede usar en cualquier fondo.

Si el fondo es Claro, Oscuro, HighContrastLight o HighContrastDark, los colores del origen nunca se invierten. Si se omite el fondo o se establece en HighContrast, la inversión de los colores del origen se controla mediante el atributo AllowColorInversion de la imagen.

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

Element Atributos (todos obligatorios) Definición
<Tamaño> Valor El origen se usará para las imágenes del tamaño especificado (en unidades de dispositivo). La imagen será cuadrada.
<SizeRange> MinSize, MaxSize El origen se usará para imágenes de MinSize a MaxSize (en unidades de dispositivo) de forma inclusiva. La imagen será cuadrada.
<Dimensiones> Ancho, alto El origen se usará para las imágenes del ancho y alto especificados (en unidades de dispositivo).
<DimensionRange> MinWidth, MinHeight,

MaxWidth, MaxHeight		 El origen se usará para las imágenes desde el ancho o alto mínimo hasta el ancho o alto máximo (en unidades de dispositivo) de forma inclusiva.

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" />
Atributo Definición
Tipo [Obligatorio] Tipo del recurso nativo, ya sea XAML o PNG
ID [Obligatorio] Parte del identificador entero del recurso nativo

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>
Atributo Definición
Guid [Obligatorio] Parte GUID del moniker de imagen
ID [Obligatorio] Parte del identificador del moniker de imagen
Externos [Opcional, valor predeterminado false] Indica si el moniker de imagen hace referencia a una imagen en el manifiesto actual.

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.

  • 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