Control de fuente
Para simplificar la integración y la configuración de la compatibilidad con fuentes en aplicaciones que requieren funcionalidades de edición de texto y procesamiento de texto, el marco de la cinta de opciones de Windows proporciona un control de fuentes especializado que expone una amplia gama de propiedades de fuente, como el nombre de tipo, el estilo, el tamaño de punto y los efectos.
- Introducción
- Una experiencia coherente
- Integración y configuración fáciles
- Alineación con estructuras de texto GDI comunes
- Agregar un FontControl
- Definir un controlador de comandos FontControl
- Temas relacionados
Introducción
El Control de fuente es un control compuesto que consta de botones, botones de alternancia, cuadros de lista desplegable y cuadros combinados, todos los cuales se usan para especificar una propiedad o opción de formato de fuente determinada.
En la captura de pantalla siguiente se muestra el Control de fuente de la cinta en WordPad para Windows 7.
Una experiencia coherente
Como control de cinta de opciones integrado, el Control de fuentes mejora la administración general de fuentes, la selección y la funcionalidad de formato, y proporciona una experiencia de usuario enriquecida y coherente en todas las aplicaciones de cinta.
Esta experiencia coherente incluye
Formato estandarizado y selección de fuentes en aplicaciones de cinta de opciones.
Representación de fuente estandarizada en aplicaciones de cinta de opciones.
Automático, en Windows 7, activación de fuente basada en la configuración Mostrar u Ocultar para cada fuente del panel de control Fuentes . El control de fuente solo muestra las fuentes que se establecen en Mostrar.
Nota
En Windows Vista, el panel de control Fuentes no ofrece la funcionalidad Mostrar u Ocultar , por lo que se activan todas las fuentes.
Administración de fuentes que está disponible directamente desde el control.
En la captura de pantalla siguiente se muestra que se puede acceder al panel de control Fuentes directamente desde el Control de fuentes.
Compatibilidad con la versión preliminar automática.
Exposición de fuentes más relevantes para un usuario, como
- Listas de fuentes localizadas para usuarios internacionales.
- Listas de fuentes basadas en el dispositivo de entrada.
Nota
La compatibilidad con esta funcionalidad no está disponible en ninguna plataforma anterior a Windows 7.
Integración y configuración fáciles
Al proporcionar funcionalidad estándar, reutilizable y fácil de consumir, el control de fuentes de la cinta facilita la carga de integrar la compatibilidad con fuentes en una aplicación.
Los detalles de la selección y el formato de fuente se encapsulan en un elemento lógico autocontenido que
- Elimina la compleja administración de las interdependencias de control típicas de las implementaciones de control de fuentes.
- Requiere un único controlador de comandos para todas las funciones expuestas por los subcontroles de control de fuentes.
Este único controlador de comandos permite que el Control de fuentes administre la funcionalidad de varios subcontroles internamente; Un subcontrol nunca interactúa directamente con la aplicación, independientemente de su función.
Otras características del control de fuentes incluyen
Generación automática y compatible con PPP de una representación de mapa de bits WYSIWYG (lo que ve es lo que obtiene) para cada fuente en el menú Familia de fuentes.
Integración de la interfaz de dispositivo gráfico (GDI) de Windows .
Mapas de bits y información sobre herramientas de la familia de fuentes localizadas.
Enumeración de fuentes, agrupación y metadatos para administrar y presentar fuentes.
Nota:
La compatibilidad con esta funcionalidad no está disponible en ninguna plataforma anterior a Windows 7.
Los selectores de color desplegable Color de resaltado de texto y Color de resaltado de texto que reflejan el comportamiento del Selector de colores desplegable de la cinta de opciones.
Compatibilidad con la vista previa automática de todos los subcontroles basados en la galería de Font Control: familia de fuentes, Tamaño de fuente, Color de texto y Color de resaltado de texto.
Alineación con estructuras de texto GDI comunes
Los componentes de pila de texto de la Interfaz de dispositivo gráfico de Windows (GDI) se usan para exponer la selección de fuentes y la funcionalidad de formato a través del control de fuentes de la cinta de opciones. Las distintas características de fuente compatibles con la estructura LOGFONT, la estructura CHOOSEFONT y la estructura CHARFORMAT2 se exponen a través de los subcontroles que se incluyen en el control de fuentes.
Los subcontroles que se muestran en el control de fuentes dependen de la plantilla FontType declarada en el marcado de la cinta de opciones. Las plantillas FontType (que se describen con más detalle en la sección siguiente) están diseñadas para alinearse con las estructuras de texto comunes de la Interfaz de dispositivo gráfico de Windows (GDI ).
Agregar un FontControl
En esta sección se describen los pasos básicos para agregar un control de fuente a una aplicación de cinta de opciones.
Declarar un FontControl en el marcado
Al igual que otros controles de cinta de opciones, el control de fuentes se declara en marcado con un elemento FontControl y se asocia a una declaración Command a través de un identificador de comando. Cuando se compila la aplicación, el identificador de comando se usa para enlazar el comando a un controlador de comandos en la aplicación host.
Nota:
Si no se declara ningún identificador de comando con FontControl en el marcado, el marco genera uno.
Dado que los subcontroles del Control de fuentes no se exponen directamente, la personalización del control de fuentes se limita a tres plantillas de diseño FontType definidas por el marco.
Se puede realizar una mayor personalización del control de fuentes combinando la plantilla de diseño con atributos FontControl como IsHighlightButtonVisible, IsStrikethroughButtonVisible e IsUnderlineButtonVisible.
Nota
La funcionalidad de fuente más allá de la expuesta por las plantillas y atributos estándar de Control de fuentes requiere una implementación de control de fuentes personalizada que esté fuera del ámbito de este artículo.
En la tabla siguiente se enumeran las plantillas de Control de fuentes y el tipo de control de edición con el que está alineada cada plantilla.
| Plantilla | Es compatible con |
|---|---|
| FontOnly | LogFONT (estructura) |
| FontWithColor | CHOOSEFONT (estructura) |
| RichFont | CHARFORMAT2 (estructura) |
En la tabla siguiente se enumeran los controles asociados a cada plantilla e identifica los controles que son opcionales para una plantilla asociada.
Controles
Plantillas
RichFont
FontWithColor
FontOnly
Valor predeterminado
Opcional
Valor predeterminado
Opcional
Valor predeterminado
Opcionales
Cuadro combinado tamaño de fuente
Sí
No
Sí
No
Sí
No
Cuadro combinado familia de fuentes
Sí
No
Sí
No
Sí
No
Botón Aumentar fuente
Sí
Sí
Sí
Sí
-
-
Botón Reducir fuente
Sí
Sí
Sí
Sí
-
-
Botón Negrita
Sí
No
Sí
No
Sí
No
Botón cursiva
Sí
No
Sí
No
Sí
No
Botón Subrayado
Sí
No
Sí
Sí
Sí
Sí
Botón Tachado
Sí
No
Sí
Sí
Sí
Sí
Botón Subíndice
Sí
No
-
-
-
-
Botón Superíndice
Sí
No
-
-
-
-
Botón color de resaltado de texto
Sí
No
Sí
Sí
-
-
Botón Color de texto
Sí
No
Sí
No
-
-
Cuando se declara el comportamiento de diseño de un control de fuente, el marco de la cinta proporciona una plantilla de diseño SizeDefinition opcional, OneFontControl, que define dos configuraciones de subcontrol basadas en el tamaño de la cinta de opciones y el espacio disponible para el control de fuentes. Para obtener más información, vea Personalización de una cinta de opciones mediante definiciones de tamaño y directivas de escalado.
Agregar un FontControl a una cinta de opciones
En los ejemplos de código siguientes se muestran los requisitos básicos de marcado para agregar un control de fuente a una cinta de opciones:
En esta sección de código se muestra el marcado de declaración Comando FontControl , incluidos los comandos Tab y Group necesarios para mostrar un control en la cinta de opciones.
<Command Name="cmdTab1"
Comment="These comments are optional and are inserted into the header file."
Symbol="cmdTab1" Id="10000" >
<Command.LabelTitle>Tab 1</Command.LabelTitle>
</Command>
<Command Name="cmdGroup1" Comment="Group #1" Symbol="cmdGroup1" Id="20000">
<!-- This image is used when the group scales to a pop-up. -->
<Command.SmallImages>
<Image>res/Button_Image.bmp</Image>
</Command.SmallImages>
</Command>
<Command Name="cmdFontControl" Symbol="cmdFontControl" Comment="FontControl" Id="25001" Keytip="F" />
En esta sección de código se muestra el marcado necesario para declarar y asociar un FontControl con un comando a través de un identificador de comando. En este ejemplo concreto se incluyen las declaraciones Tab y Group , con preferencias de escalado.
<Ribbon.Tabs>
<Tab CommandName="cmdTab1">
<Tab.ScalingPolicy>
<ScalingPolicy>
<ScalingPolicy.IdealSizes>
<Scale Group="cmdGroup1" Size="Large" />
</ScalingPolicy.IdealSizes>
<!-- Describe how the FontControl group scales. -->
<Scale Group="cmdGroup1" Size="Medium" />
<Scale Group="cmdGroup1" Size="Popup" />
</ScalingPolicy>
<Group CommandName="cmdGroup1" SizeDefinition="OneFontControl">
<FontControl CommandName="cmdFontControl" FontType="RichFont" />
</Group>
</Tab>
</Ribbon.Tabs>
Agregar un FontControl a contextPopup
Agregar un control de fuente a un elemento emergente de contexto requiere un procedimiento similar al de agregar un control de fuente a la cinta de opciones. Sin embargo, un control de fuente en una MiniToolbar está restringido al conjunto de subcontroles predeterminados que son comunes a todas las plantillas de Control de fuentes: familia de fuentes, Tamaño de fuente, Negrita y Cursiva.
En los ejemplos de código siguientes se muestran los requisitos básicos de marcado para agregar un control de fuente a un elemento emergente de contexto:
En esta sección de código se muestra el marcado de declaración FontControl Command necesario para mostrar un FontControl en ContextPopup.
<Command Name="cmdFontControl" Symbol="cmdFontControl" Comment="FontControl" Id="25001" />
En esta sección de código se muestra el marcado necesario para declarar y asociar un FontControl con un comando a través de un identificador de comando.
<ContextPopup.MiniToolbars>
<MiniToolBar Name="MiniToolbar1">
<MenuCategory Class="StandardItems">
<FontControl CommandName="cmdFontControl" />
</MenuCategory>
</MiniToolBar>
</ContextPopup.MiniToolbars>
Keytips
Cada subcontrol del control fuente de la cinta es accesible a través de un método abreviado de teclado o información sobre teclas. Esta información sobre claves está predefinida y asignada a cada subcontrol por el marco.
Si se asigna un valor de atributo Keytip al elemento FontControl en el marcado, este valor se agrega como prefijo a la información sobre claves definida por el marco.
Nota:
La aplicación debe aplicar una regla de un solo carácter para este prefijo.
En la tabla siguiente se enumeran las informaciones sobre claves definidas por el marco de trabajo.
| Subcontrol | Información sobre claves |
|---|---|
| Familia de fuentes | F |
| Estilo de fuente | T |
| Tamaño de fuente | S |
| Aumentar fuente | G |
| Reducir fuente | K |
| Bold | B |
| Cursiva | I |
| Subrayado | U |
| Tachado | X |
| Superscript | Y o Z Nota: Si el atributo Keytip no se declara en el marcado, la información sobre claves predeterminada es Y; de lo contrario, la información sobre claves predeterminada es Keytip + Z. |
| Subscript | A |
| Color de fuente | C |
| Resaltado de fuente | H |
El prefijo recomendado para una cinta de opciones de interfaz de usuario multilingüe (MUI) EN-US es "F", como se muestra en el ejemplo siguiente.
<Command Name="cmdFontControl" Symbol="cmdFontControl" Comment="FontControl" Id="25001" Keytip="F" />
En la captura de pantalla siguiente se muestran las informaciones sobre teclas del control de fuentes tal como se definen en el ejemplo anterior.
El archivo de recursos de la cinta de opciones
Cuando se compila el archivo de marcado, se genera un archivo de recursos que contiene todas las referencias de recursos para la aplicación ribbon.
Ejemplo de un archivo de recursos simple:
// ******************************************************************************
// * This is an automatically generated file containing the ribbon resource for *
// * your application. *
// ******************************************************************************
#include ".\ids.h"
STRINGTABLE
BEGIN
cmdTab1_LabelTitle_RESID L"Tab 1"
/* LabelTitle cmdTab1_LabelTitle_RESID: These comments are optional and are
inserted into the header file. */
END
cmdGroup1_SmallImages_RESID BITMAP "res\\Button_Image.bmp"
/* SmallImages cmdGroup1_SmallImages_RESID: Group #1 */
STRINGTABLE
BEGIN
cmdFontControl_Keytip_RESID L"F" /* Keytip cmdFontControl_Keytip_RESID: FontControl */
END
FCSAMPLE_RIBBON UIFILE "Debug\\FCSample.bml"
Propiedades del control de fuente
El marco de la cinta define una colección de claves de propiedad para el Control de fuentes y sus subcontroles constituyentes.
Normalmente, una propiedad Control de fuentes se actualiza en la interfaz de usuario de la cinta de opciones invalidando el comando asociado al control a través de una llamada al método IUIFramework::InvalidateUICommand . El evento de invalidación se controla y la propiedad se actualiza definida por el método de devolución de llamada IUICommandHandler::UpdateProperty .
El método de devolución de llamada IUICommandHandler::UpdateProperty no se ejecuta y la aplicación consulta para obtener un valor de propiedad actualizado, hasta que el marco requiera la propiedad. Por ejemplo, cuando se activa una pestaña y se muestra un control en la interfaz de usuario de la cinta de opciones, o cuando se muestra una información sobre herramientas.
Nota:
En algunos casos, se puede recuperar una propiedad a través del método IUIFramework::GetUICommandProperty y establecer con el método IUIFramework::SetUICommandProperty .
En la tabla siguiente se enumeran las claves de propiedad asociadas al control de fuentes.
| Clave de propiedad | Notas |
|---|---|
| UI_PKEY_FontProperties | Expone, en agregado como un objeto IPropertyStore , todas las propiedades de subcontrol de Control de fuentes. El marco consulta esta propiedad cuando UI_INVALIDATIONS_VALUE se pasa como el valor de las marcas de la llamada a IUIFramework::InvalidateUICommand. |
| UI_PKEY_FontProperties_ChangedProperties | Expone, en agregado como un objeto IUISimplePropertySet , solo las propiedades de subcontrol de Control de fuentes que han cambiado. |
| UI_PKEY_Keytip | Solo se puede actualizar a través de la invalidación. |
| UI_PKEY_Enabled | Admite IUIFramework::GetUICommandProperty e IUIFramework::SetUICommandProperty. |
Además de las propiedades admitidas por el propio Control de fuentes, el marco de la cinta de opciones también define una clave de propiedad para cada subcontrol de control de fuente. Estas claves de propiedad y sus valores se exponen mediante el marco a través de una implementación de la interfaz IPropertyStore que define los métodos para administrar una colección, también denominada contenedor de propiedades, de pares nombre y valor.
La aplicación traduce las estructuras de fuente a las propiedades a las que se puede acceder a través de los métodos de interfaz IPropertyStore . Este modelo destaca la distinción entre el Control de fuentes y los componentes de la pila de texto de la Interfaz de dispositivo gráfico (GDI) de Windows (ESTRUCTURA LOGFONT, ESTRUCTURA CHOOSEFONT y Estructura CHARFORMAT2) compatibles con el marco de trabajo.
En la tabla siguiente se enumeran los controles individuales y sus claves de propiedad asociadas.
| Controles | Clave de propiedad | Notas |
|---|---|---|
| Tamaño de fuente | UI_PKEY_FontProperties_Size | Cuando se resalta una ejecución de texto de tamaño heterogéneo, el marco de la cinta establece el control Tamaño de fuente en blanco y el valor de UI_PKEY_FontProperties_Size en 0. Cuando se hace clic en el botón Aumentar fuente o Reducir fuente , se cambia el tamaño de todo el texto resaltado, pero se conserva la diferencia relativa en los tamaños de texto. |
| Familia de fuentes | UI_PKEY_FontProperties_Family | Los nombres de familia de fuentes GDI varían con la configuración regional del sistema. Por lo tanto, si el valor de UI_PKEY_FontProperties_Family se conserva en todas las sesiones de la aplicación, ese valor se debe recuperar en cada nueva sesión. |
| Aumentar fuente | UI_PKEY_FontProperties_Size | Consulte Tamaño de fuente. |
| Reducir fuente | UI_PKEY_FontProperties_Size | Consulte Tamaño de fuente. |
| Negrita | UI_PKEY_FontProperties_Bold | |
| Cursiva | UI_PKEY_FontProperties_Italic | |
| Subrayar | UI_PKEY_FontProperties_Underline | |
| Tachado | UI_PKEY_FontProperties_Strikethrough | |
| Subscript | UI_PKEY_FontProperties_VerticalPositioning | Si se establece el botón Subíndice , no se puede establecer el Superíndice . |
| Superscript | UI_PKEY_FontProperties_VerticalPositioning | Si se establece el botón Superíndice , no se puede establecer también subíndice . |
| Color de resaltado de texto | UI_PKEY_FontProperties_BackgroundColor, UI_PKEY_FontProperties_BackgroundColorType | Proporciona la misma funcionalidad que la HighlightColors plantilla del elemento DropDownColorPicker .Se recomienda encarecidamente que la aplicación establezca solo un valor de color de resaltado de texto inicial. El último valor seleccionado debe conservarse y no establecerse cuando el cursor se cambia la posición dentro de un documento. Esto permite el acceso rápido a la última selección del usuario y no es necesario volver a abrir el selector de colores. No se pueden personalizar las muestras de color. |
| Color del texto | UI_PKEY_FontProperties_ForegroundColor, UI_PKEY_FontProperties_ForegroundColorType | Proporciona la misma funcionalidad que la StandardColors plantilla del elemento DropDownColorPicker .Se recomienda encarecidamente que la aplicación establezca solo un valor de color de texto inicial. El último valor seleccionado debe conservarse y no establecerse cuando el cursor se cambia la posición dentro de un documento. Esto permite el acceso rápido a la última selección del usuario y no es necesario volver a abrir el selector de colores. No se pueden personalizar las muestras de color. |
Definir un controlador de comandos FontControl
En esta sección se describen los pasos necesarios para enlazar un control de fuente a un controlador de comandos.
Advertencia
Cualquier intento de seleccionar una muestra de color del selector de colores de un control de fuentes puede producir una infracción de acceso si no hay ningún controlador de comandos asociado al control.
En el ejemplo de código siguiente se muestra cómo enlazar comandos declarados en marcado a un controlador de comandos.
//
// FUNCTION: OnCreateUICommand(UINT, UI_COMMANDTYPE, IUICommandHandler)
//
// PURPOSE: Called by the Ribbon framework for each command specified in markup, to allow
// the host application to bind a command handler to that command.
//
STDMETHODIMP CApplication::OnCreateUICommand(
UINT nCmdID,
__in UI_COMMANDTYPE typeID,
__deref_out IUICommandHandler** ppCommandHandler)
{
UNREFERENCED_PARAMETER(typeID);
UNREFERENCED_PARAMETER(nCmdID);
if (NULL == m_pCommandHandler)
{
HRESULT hr = CCommandHandler::CreateInstance(&m_pCommandHandler);
if (FAILED(hr))
{
return hr;
}
}
return m_pCommandHandler->QueryInterface(IID_PPV_ARGS(ppCommandHandler));
}
En el ejemplo de código siguiente se muestra cómo implementar el método IUICommandHandler::Execute para un control de fuentes.
//
// FUNCTION: Execute()
//
// PURPOSE: Called by the Ribbon framework when a command is executed
// by the user. For example, when a button is pressed.
//
STDMETHODIMP CCommandHandler::Execute(
UINT nCmdID,
UI_EXECUTIONVERB verb,
__in_opt const PROPERTYKEY* key,
__in_opt const PROPVARIANT* ppropvarValue,
__in_opt IUISimplePropertySet* pCommandExecutionProperties)
{
UNREFERENCED_PARAMETER(nCmdID);
HRESULT hr = E_NOTIMPL;
if ((key) && (*key == UI_PKEY_FontProperties))
{
// Font properties have changed.
switch (verb)
{
case UI_EXECUTIONVERB_EXECUTE:
{
hr = E_POINTER;
if (pCommandExecutionProperties != NULL)
{
// Get the changed properties.
PROPVARIANT varChanges;
hr = pCommandExecutionProperties->GetValue(UI_PKEY_FontProperties_ChangedProperties, &varChanges);
if (SUCCEEDED(hr))
{
IPropertyStore *pChanges;
hr = UIPropertyToInterface(UI_PKEY_FontProperties, varChanges, &pChanges);
if (SUCCEEDED(hr))
{
// Using the changed properties, set the new font on the selection on RichEdit control.
g_pFCSampleAppManager->SetValues(pChanges);
pChanges->Release();
}
PropVariantClear(&varChanges);
}
}
break;
}
case UI_EXECUTIONVERB_PREVIEW:
{
hr = E_POINTER;
if (pCommandExecutionProperties != NULL)
{
// Get the changed properties for the preview event.
PROPVARIANT varChanges;
hr = pCommandExecutionProperties->GetValue(UI_PKEY_FontProperties_ChangedProperties, &varChanges);
if (SUCCEEDED(hr))
{
IPropertyStore *pChanges;
hr = UIPropertyToInterface(UI_PKEY_FontProperties, varChanges, &pChanges);
if (SUCCEEDED(hr))
{
// Set the previewed values on the RichEdit control.
g_pFCSampleAppManager->SetPreviewValues(pChanges);
pChanges->Release();
}
PropVariantClear(&varChanges);
}
}
break;
}
case UI_EXECUTIONVERB_CANCELPREVIEW:
{
hr = E_POINTER;
if (ppropvarValue != NULL)
{
// Cancel the preview.
IPropertyStore *pValues;
hr = UIPropertyToInterface(UI_PKEY_FontProperties, *ppropvarValue, &pValues);
if (SUCCEEDED(hr))
{
g_pFCSampleAppManager->CancelPreview(pValues);
pValues->Release();
}
}
break;
}
}
}
return hr;
}
En el ejemplo de código siguiente se muestra cómo implementar el método IUICommandHandler::UpdateProperty para un control de fuentes.
//
// FUNCTION: UpdateProperty()
//
// PURPOSE: Called by the Ribbon framework when a command property (PKEY) needs to be updated.
//
// COMMENTS:
//
// This function is used to provide new command property values, such as labels, icons, or
// tooltip information, when requested by the Ribbon framework.
//
//
STDMETHODIMP CCommandHandler::UpdateProperty(
UINT nCmdID,
__in REFPROPERTYKEY key,
__in_opt const PROPVARIANT* ppropvarCurrentValue,
__out PROPVARIANT* ppropvarNewValue)
{
UNREFERENCED_PARAMETER(nCmdID);
HRESULT hr = E_NOTIMPL;
if (key == UI_PKEY_FontProperties)
{
hr = E_POINTER;
if (ppropvarCurrentValue != NULL)
{
// Get the font values for the selected text in the font control.
IPropertyStore *pValues;
hr = UIPropertyToInterface(UI_PKEY_FontProperties, *ppropvarCurrentValue, &pValues);
if (SUCCEEDED(hr))
{
g_pFCSampleAppManager->GetValues(pValues);
// Provide the new values to the font control.
hr = UIInitPropertyFromInterface(UI_PKEY_FontProperties, pValues, ppropvarNewValue);
pValues->Release();
}
}
}
return hr;
}
Temas relacionados
Comentarios
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea: https://aka.ms/ContentUserFeedback.
Enviar y ver comentarios de