| /* Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| /* From trusted/ppb_browser_font_trusted.idl, |
| * modified Thu Mar 28 10:14:27 2013. |
| */ |
| |
| #ifndef PPAPI_C_TRUSTED_PPB_BROWSER_FONT_TRUSTED_H_ |
| #define PPAPI_C_TRUSTED_PPB_BROWSER_FONT_TRUSTED_H_ |
| |
| #include "ppapi/c/pp_bool.h" |
| #include "ppapi/c/pp_instance.h" |
| #include "ppapi/c/pp_macros.h" |
| #include "ppapi/c/pp_point.h" |
| #include "ppapi/c/pp_rect.h" |
| #include "ppapi/c/pp_resource.h" |
| #include "ppapi/c/pp_size.h" |
| #include "ppapi/c/pp_stdint.h" |
| #include "ppapi/c/pp_var.h" |
| |
| #define PPB_BROWSERFONT_TRUSTED_INTERFACE_1_0 "PPB_BrowserFont_Trusted;1.0" |
| #define PPB_BROWSERFONT_TRUSTED_INTERFACE PPB_BROWSERFONT_TRUSTED_INTERFACE_1_0 |
| |
| /** |
| * @file |
| * This file defines the <code>PPB_BrowserFont_Trusted</code> interface. |
| */ |
| |
| |
| /** |
| * @addtogroup Enums |
| * @{ |
| */ |
| typedef enum { |
| /** |
| * Uses the user's default web page font (normally either the default serif |
| * or sans serif font). |
| */ |
| PP_BROWSERFONT_TRUSTED_FAMILY_DEFAULT = 0, |
| /** |
| * These families will use the default web page font corresponding to the |
| * given family. |
| */ |
| PP_BROWSERFONT_TRUSTED_FAMILY_SERIF = 1, |
| PP_BROWSERFONT_TRUSTED_FAMILY_SANSSERIF = 2, |
| PP_BROWSERFONT_TRUSTED_FAMILY_MONOSPACE = 3 |
| } PP_BrowserFont_Trusted_Family; |
| PP_COMPILE_ASSERT_SIZE_IN_BYTES(PP_BrowserFont_Trusted_Family, 4); |
| |
| /** |
| * Specifies the font weight. Normally users will only use NORMAL or BOLD. |
| */ |
| typedef enum { |
| PP_BROWSERFONT_TRUSTED_WEIGHT_100 = 0, |
| PP_BROWSERFONT_TRUSTED_WEIGHT_200 = 1, |
| PP_BROWSERFONT_TRUSTED_WEIGHT_300 = 2, |
| PP_BROWSERFONT_TRUSTED_WEIGHT_400 = 3, |
| PP_BROWSERFONT_TRUSTED_WEIGHT_500 = 4, |
| PP_BROWSERFONT_TRUSTED_WEIGHT_600 = 5, |
| PP_BROWSERFONT_TRUSTED_WEIGHT_700 = 6, |
| PP_BROWSERFONT_TRUSTED_WEIGHT_800 = 7, |
| PP_BROWSERFONT_TRUSTED_WEIGHT_900 = 8, |
| PP_BROWSERFONT_TRUSTED_WEIGHT_NORMAL = PP_BROWSERFONT_TRUSTED_WEIGHT_400, |
| PP_BROWSERFONT_TRUSTED_WEIGHT_BOLD = PP_BROWSERFONT_TRUSTED_WEIGHT_700 |
| } PP_BrowserFont_Trusted_Weight; |
| PP_COMPILE_ASSERT_SIZE_IN_BYTES(PP_BrowserFont_Trusted_Weight, 4); |
| /** |
| * @} |
| */ |
| |
| /** |
| * @addtogroup Structs |
| * @{ |
| */ |
| struct PP_BrowserFont_Trusted_Description { |
| /** |
| * Font face name as a string. This can also be an undefined var, in which |
| * case the generic family will be obeyed. If the face is not available on |
| * the system, the browser will attempt to do font fallback or pick a default |
| * font. |
| */ |
| struct PP_Var face; |
| /** |
| * When Create()ing a font and the face is an undefined var, the family |
| * specifies the generic font family type to use. If the face is specified, |
| * this will be ignored. |
| * |
| * When Describe()ing a font, the family will be the value you passed in when |
| * the font was created. In other words, if you specify a face name, the |
| * family will not be updated to reflect whether the font name you requested |
| * is serif or sans serif. |
| */ |
| PP_BrowserFont_Trusted_Family family; |
| /** |
| * Size in pixels. |
| * |
| * You can specify 0 to get the default font size. The default font size |
| * may vary depending on the requested font. The typical example is that |
| * the user may have a different font size for the default monospace font to |
| * give it a similar optical size to the proportionally spaced fonts. |
| */ |
| uint32_t size; |
| /** |
| * Normally you will use either normal or bold. |
| */ |
| PP_BrowserFont_Trusted_Weight weight; |
| PP_Bool italic; |
| PP_Bool small_caps; |
| /** |
| * Adjustment to apply to letter and word spacing, respectively. Initialize |
| * to 0 to get normal spacing. Negative values bring letters/words closer |
| * together, positive values separate them. |
| */ |
| int32_t letter_spacing; |
| int32_t word_spacing; |
| /** |
| * Ensure that this struct is 48-bytes wide by padding the end. In some |
| * compilers, PP_Var is 8-byte aligned, so those compilers align this struct |
| * on 8-byte boundaries as well and pad it to 16 bytes even without this |
| * padding attribute. This padding makes its size consistent across |
| * compilers. |
| */ |
| int32_t padding; |
| }; |
| PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_BrowserFont_Trusted_Description, 48); |
| |
| struct PP_BrowserFont_Trusted_Metrics { |
| int32_t height; |
| int32_t ascent; |
| int32_t descent; |
| int32_t line_spacing; |
| int32_t x_height; |
| }; |
| PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_BrowserFont_Trusted_Metrics, 20); |
| |
| struct PP_BrowserFont_Trusted_TextRun { |
| /** |
| * This var must either be a string or a null/undefined var (which will be |
| * treated as a 0-length string). |
| */ |
| struct PP_Var text; |
| /** |
| * Set to PP_TRUE if the text is right-to-left. |
| */ |
| PP_Bool rtl; |
| /** |
| * Set to PP_TRUE to force the directionality of the text regardless of |
| * content |
| */ |
| PP_Bool override_direction; |
| }; |
| PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_BrowserFont_Trusted_TextRun, 24); |
| /** |
| * @} |
| */ |
| |
| /** |
| * @addtogroup Interfaces |
| * @{ |
| */ |
| /** |
| * Provides an interface for native browser text rendering. |
| * |
| * This API is "trusted" not for security reasons, but because it can not be |
| * implemented efficiently when running out-of-process in Browser Client. In |
| * this case, WebKit is in another process and every text call would require a |
| * synchronous IPC to the renderer. It is, however, available to native |
| * (non-NaCl) out-of-process PPAPI plugins since WebKit is available in the |
| * plugin process. |
| */ |
| struct PPB_BrowserFont_Trusted_1_0 { |
| /** |
| * Returns a list of all available font families on the system. You can use |
| * this list to decide whether to Create() a font. |
| * |
| * The return value will be a single string with null characters delimiting |
| * the end of each font name. For example: "Arial\0Courier\0Times\0". |
| * |
| * Returns an undefined var on failure (this typically means you passed an |
| * invalid instance). |
| */ |
| struct PP_Var (*GetFontFamilies)(PP_Instance instance); |
| /** |
| * Returns a font which best matches the given description. The return value |
| * will have a non-zero ID on success, or zero on failure. |
| */ |
| PP_Resource (*Create)( |
| PP_Instance instance, |
| const struct PP_BrowserFont_Trusted_Description* description); |
| /** |
| * Returns PP_TRUE if the given resource is a Font. Returns PP_FALSE if the |
| * resource is invalid or some type other than a Font. |
| */ |
| PP_Bool (*IsFont)(PP_Resource resource); |
| /** |
| * Loads the description and metrics of the font into the given structures. |
| * The description will be different than the description the font was |
| * created with since it will be filled with the real values from the font |
| * that was actually selected. |
| * |
| * The PP_Var in the description should be of type Void on input. On output, |
| * this will contain the string and will have a reference count of 1. The |
| * plugin is responsible for calling Release on this var. |
| * |
| * Returns PP_TRUE on success, PP_FALSE if the font is invalid or if the Var |
| * in the description isn't Null (to prevent leaks). |
| */ |
| PP_Bool (*Describe)(PP_Resource font, |
| struct PP_BrowserFont_Trusted_Description* description, |
| struct PP_BrowserFont_Trusted_Metrics* metrics); |
| /** |
| * Draws the text to the image buffer. |
| * |
| * The given point represents the baseline of the left edge of the font, |
| * regardless of whether it is left-to-right or right-to-left (in the case of |
| * RTL text, this will actually represent the logical end of the text). |
| * |
| * The clip is optional and may be NULL. In this case, the text will be |
| * clipped to the image. |
| * |
| * The image_data_is_opaque flag indicates whether subpixel antialiasing can |
| * be performed, if it is supported. When the image below the text is |
| * opaque, subpixel antialiasing is supported and you should set this to |
| * PP_TRUE to pick up the user's default preferences. If your plugin is |
| * partially transparent, then subpixel antialiasing is not possible and |
| * grayscale antialiasing will be used instead (assuming the user has |
| * antialiasing enabled at all). |
| */ |
| PP_Bool (*DrawTextAt)(PP_Resource font, |
| PP_Resource image_data, |
| const struct PP_BrowserFont_Trusted_TextRun* text, |
| const struct PP_Point* position, |
| uint32_t color, |
| const struct PP_Rect* clip, |
| PP_Bool image_data_is_opaque); |
| /** |
| * Returns the width of the given string. If the font is invalid or the var |
| * isn't a valid string, this will return -1. |
| * |
| * Note that this function handles complex scripts such as Arabic, combining |
| * accents, etc. so that adding the width of substrings won't necessarily |
| * produce the correct width of the entire string. |
| * |
| * Returns -1 on failure. |
| */ |
| int32_t (*MeasureText)(PP_Resource font, |
| const struct PP_BrowserFont_Trusted_TextRun* text); |
| /** |
| * Returns the character at the given pixel X position from the beginning of |
| * the string. This handles complex scripts such as Arabic, where characters |
| * may be combined or replaced depending on the context. Returns (uint32)-1 |
| * on failure. |
| * |
| * TODO(brettw) this function may be broken. See the CharPosRTL test. It |
| * seems to tell you "insertion point" rather than painting position. This |
| * is useful but maybe not what we intended here. |
| */ |
| uint32_t (*CharacterOffsetForPixel)( |
| PP_Resource font, |
| const struct PP_BrowserFont_Trusted_TextRun* text, |
| int32_t pixel_position); |
| /** |
| * Returns the horizontal advance to the given character if the string was |
| * placed at the given position. This handles complex scripts such as Arabic, |
| * where characters may be combined or replaced depending on context. Returns |
| * -1 on error. |
| */ |
| int32_t (*PixelOffsetForCharacter)( |
| PP_Resource font, |
| const struct PP_BrowserFont_Trusted_TextRun* text, |
| uint32_t char_offset); |
| }; |
| |
| typedef struct PPB_BrowserFont_Trusted_1_0 PPB_BrowserFont_Trusted; |
| /** |
| * @} |
| */ |
| |
| #endif /* PPAPI_C_TRUSTED_PPB_BROWSER_FONT_TRUSTED_H_ */ |
| |