andre/30-seconds-of-code
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

WIP - add extractor, generate snippet_data

Browse Source
This commit is contained in:
Stefan Fejes
2019-08-20 15:52:05 +02:00
parent 88084d3d30
commit cc8f1d8a7a
37396 changed files with 4588842 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files

598
node_modules/sharp/vendor/include/pango/pango-attributes.h generated vendored Normal file
View File

@ -0,0 +1,598 @@
/* Pango
* pango-attributes.h: Attributed text
*
* Copyright (C) 2000 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_ATTRIBUTES_H__
#define __PANGO_ATTRIBUTES_H__
#include <pango/pango-font.h>
#include <glib-object.h>
G_BEGIN_DECLS
/* PangoColor */
typedef struct _PangoColor PangoColor;
/**
* PangoColor:
* @red: value of red component
* @green: value of green component
* @blue: value of blue component
*
* The #PangoColor structure is used to
* represent a color in an uncalibrated RGB color-space.
*/
struct _PangoColor
{
guint16 red;
guint16 green;
guint16 blue;
};
/**
* PANGO_TYPE_COLOR:
*
* The #GObject type for #PangoColor.
*/
#define PANGO_TYPE_COLOR pango_color_get_type ()
PANGO_AVAILABLE_IN_ALL
GType pango_color_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_ALL
PangoColor *pango_color_copy (const PangoColor *src);
PANGO_AVAILABLE_IN_ALL
void pango_color_free (PangoColor *color);
PANGO_AVAILABLE_IN_ALL
gboolean pango_color_parse (PangoColor *color,
const char *spec);
PANGO_AVAILABLE_IN_1_16
gchar *pango_color_to_string(const PangoColor *color);
/* Attributes */
typedef struct _PangoAttribute PangoAttribute;
typedef struct _PangoAttrClass PangoAttrClass;
typedef struct _PangoAttrString PangoAttrString;
typedef struct _PangoAttrLanguage PangoAttrLanguage;
typedef struct _PangoAttrInt PangoAttrInt;
typedef struct _PangoAttrSize PangoAttrSize;
typedef struct _PangoAttrFloat PangoAttrFloat;
typedef struct _PangoAttrColor PangoAttrColor;
typedef struct _PangoAttrFontDesc PangoAttrFontDesc;
typedef struct _PangoAttrShape PangoAttrShape;
typedef struct _PangoAttrFontFeatures PangoAttrFontFeatures;
/**
* PANGO_TYPE_ATTR_LIST:
*
* The #GObject type for #PangoAttrList.
*/
#define PANGO_TYPE_ATTR_LIST pango_attr_list_get_type ()
/**
* PangoAttrIterator:
*
* The #PangoAttrIterator structure is used to represent an
* iterator through a #PangoAttrList. A new iterator is created
* with pango_attr_list_get_iterator(). Once the iterator
* is created, it can be advanced through the style changes
* in the text using pango_attr_iterator_next(). At each
* style change, the range of the current style segment and the
* attributes currently in effect can be queried.
*/
/**
* PangoAttrList:
*
* The #PangoAttrList structure represents a list of attributes
* that apply to a section of text. The attributes are, in general,
* allowed to overlap in an arbitrary fashion, however, if the
* attributes are manipulated only through pango_attr_list_change(),
* the overlap between properties will meet stricter criteria.
*
* Since the #PangoAttrList structure is stored as a linear list,
* it is not suitable for storing attributes for large amounts
* of text. In general, you should not use a single #PangoAttrList
* for more than one paragraph of text.
*/
typedef struct _PangoAttrList PangoAttrList;
typedef struct _PangoAttrIterator PangoAttrIterator;
/**
* PangoAttrType:
* @PANGO_ATTR_INVALID: does not happen
* @PANGO_ATTR_LANGUAGE: language (#PangoAttrLanguage)
* @PANGO_ATTR_FAMILY: font family name list (#PangoAttrString)
* @PANGO_ATTR_STYLE: font slant style (#PangoAttrInt)
* @PANGO_ATTR_WEIGHT: font weight (#PangoAttrInt)
* @PANGO_ATTR_VARIANT: font variant (normal or small caps) (#PangoAttrInt)
* @PANGO_ATTR_STRETCH: font stretch (#PangoAttrInt)
* @PANGO_ATTR_SIZE: font size in points scaled by %PANGO_SCALE (#PangoAttrInt)
* @PANGO_ATTR_FONT_DESC: font description (#PangoAttrFontDesc)
* @PANGO_ATTR_FOREGROUND: foreground color (#PangoAttrColor)
* @PANGO_ATTR_BACKGROUND: background color (#PangoAttrColor)
* @PANGO_ATTR_UNDERLINE: whether the text has an underline (#PangoAttrInt)
* @PANGO_ATTR_STRIKETHROUGH: whether the text is struck-through (#PangoAttrInt)
* @PANGO_ATTR_RISE: baseline displacement (#PangoAttrInt)
* @PANGO_ATTR_SHAPE: shape (#PangoAttrShape)
* @PANGO_ATTR_SCALE: font size scale factor (#PangoAttrFloat)
* @PANGO_ATTR_FALLBACK: whether fallback is enabled (#PangoAttrInt)
* @PANGO_ATTR_LETTER_SPACING: letter spacing (#PangoAttrInt)
* @PANGO_ATTR_UNDERLINE_COLOR: underline color (#PangoAttrColor)
* @PANGO_ATTR_STRIKETHROUGH_COLOR: strikethrough color (#PangoAttrColor)
* @PANGO_ATTR_ABSOLUTE_SIZE: font size in pixels scaled by %PANGO_SCALE (#PangoAttrInt)
* @PANGO_ATTR_GRAVITY: base text gravity (#PangoAttrInt)
* @PANGO_ATTR_GRAVITY_HINT: gravity hint (#PangoAttrInt)
* @PANGO_ATTR_FONT_FEATURES: OpenType font features (#PangoAttrString). Since 1.38
* @PANGO_ATTR_FOREGROUND_ALPHA: foreground alpha (#PangoAttrInt). Since 1.38
* @PANGO_ATTR_BACKGROUND_ALPHA: background alpha (#PangoAttrInt). Since 1.38
*
* The #PangoAttrType
* distinguishes between different types of attributes. Along with the
* predefined values, it is possible to allocate additional values
* for custom attributes using pango_attr_type_register(). The predefined
* values are given below. The type of structure used to store the
* attribute is listed in parentheses after the description.
*/
typedef enum
{
PANGO_ATTR_INVALID, /* 0 is an invalid attribute type */
PANGO_ATTR_LANGUAGE, /* PangoAttrLanguage */
PANGO_ATTR_FAMILY, /* PangoAttrString */
PANGO_ATTR_STYLE, /* PangoAttrInt */
PANGO_ATTR_WEIGHT, /* PangoAttrInt */
PANGO_ATTR_VARIANT, /* PangoAttrInt */
PANGO_ATTR_STRETCH, /* PangoAttrInt */
PANGO_ATTR_SIZE, /* PangoAttrSize */
PANGO_ATTR_FONT_DESC, /* PangoAttrFontDesc */
PANGO_ATTR_FOREGROUND, /* PangoAttrColor */
PANGO_ATTR_BACKGROUND, /* PangoAttrColor */
PANGO_ATTR_UNDERLINE, /* PangoAttrInt */
PANGO_ATTR_STRIKETHROUGH, /* PangoAttrInt */
PANGO_ATTR_RISE, /* PangoAttrInt */
PANGO_ATTR_SHAPE, /* PangoAttrShape */
PANGO_ATTR_SCALE, /* PangoAttrFloat */
PANGO_ATTR_FALLBACK, /* PangoAttrInt */
PANGO_ATTR_LETTER_SPACING, /* PangoAttrInt */
PANGO_ATTR_UNDERLINE_COLOR, /* PangoAttrColor */
PANGO_ATTR_STRIKETHROUGH_COLOR,/* PangoAttrColor */
PANGO_ATTR_ABSOLUTE_SIZE, /* PangoAttrSize */
PANGO_ATTR_GRAVITY, /* PangoAttrInt */
PANGO_ATTR_GRAVITY_HINT, /* PangoAttrInt */
PANGO_ATTR_FONT_FEATURES, /* PangoAttrString */
PANGO_ATTR_FOREGROUND_ALPHA, /* PangoAttrInt */
PANGO_ATTR_BACKGROUND_ALPHA /* PangoAttrInt */
} PangoAttrType;
/**
* PangoUnderline:
* @PANGO_UNDERLINE_NONE: no underline should be drawn
* @PANGO_UNDERLINE_SINGLE: a single underline should be drawn
* @PANGO_UNDERLINE_DOUBLE: a double underline should be drawn
* @PANGO_UNDERLINE_LOW: a single underline should be drawn at a position
* beneath the ink extents of the text being
* underlined. This should be used only for underlining
* single characters, such as for keyboard
* accelerators. %PANGO_UNDERLINE_SINGLE should
* be used for extended portions of text.
* @PANGO_UNDERLINE_ERROR: a wavy underline should be drawn below.
* This underline is typically used to indicate
* an error such as a possilble mispelling; in some
* cases a contrasting color may automatically
* be used. This type of underlining is available since Pango 1.4.
*
* The #PangoUnderline enumeration is used to specify
* whether text should be underlined, and if so, the type
* of underlining.
*/
typedef enum {
PANGO_UNDERLINE_NONE,
PANGO_UNDERLINE_SINGLE,
PANGO_UNDERLINE_DOUBLE,
PANGO_UNDERLINE_LOW,
PANGO_UNDERLINE_ERROR
} PangoUnderline;
/**
* PANGO_ATTR_INDEX_FROM_TEXT_BEGINNING:
*
* This value can be used to set the start_index member of a #PangoAttribute
* such that the attribute covers from the beginning of the text.
*
* Since: 1.24
*/
/**
* PANGO_ATTR_INDEX_TO_TEXT_END:
*
* This value can be used to set the end_index member of a #PangoAttribute
* such that the attribute covers to the end of the text.
*
* Since: 1.24
*/
#define PANGO_ATTR_INDEX_FROM_TEXT_BEGINNING 0
#define PANGO_ATTR_INDEX_TO_TEXT_END G_MAXUINT
/**
* PangoAttribute:
* @klass: the class structure holding information about the type of the attribute
* @start_index: the start index of the range (in bytes).
* @end_index: end index of the range (in bytes). The character at this index
* is not included in the range.
*
* The #PangoAttribute structure represents the common portions of all
* attributes. Particular types of attributes include this structure
* as their initial portion. The common portion of the attribute holds
* the range to which the value in the type-specific part of the attribute
* applies and should be initialized using pango_attribute_init().
* By default an attribute will have an all-inclusive range of [0,%G_MAXUINT].
*/
struct _PangoAttribute
{
const PangoAttrClass *klass;
guint start_index; /* in bytes */
guint end_index; /* in bytes. The character at this index is not included */
};
/**
* PangoAttrFilterFunc:
* @attribute: a Pango attribute
* @user_data: user data passed to the function
*
* Type of a function filtering a list of attributes.
*
* Return value: %TRUE if the attribute should be selected for
* filtering, %FALSE otherwise.
**/
typedef gboolean (*PangoAttrFilterFunc) (PangoAttribute *attribute,
gpointer user_data);
/**
* PangoAttrDataCopyFunc:
* @user_data: user data to copy
*
* Type of a function that can duplicate user data for an attribute.
*
* Return value: new copy of @user_data.
**/
typedef gpointer (*PangoAttrDataCopyFunc) (gconstpointer user_data);
/**
* PangoAttrClass:
* @type: the type ID for this attribute
* @copy: function to duplicate an attribute of this type (see pango_attribute_copy())
* @destroy: function to free an attribute of this type (see pango_attribute_destroy())
* @equal: function to check two attributes of this type for equality (see pango_attribute_equal())
*
* The #PangoAttrClass structure stores the type and operations for
* a particular type of attribute. The functions in this structure should
* not be called directly. Instead, one should use the wrapper functions
* provided for #PangoAttribute.
*/
struct _PangoAttrClass
{
/*< public >*/
PangoAttrType type;
PangoAttribute * (*copy) (const PangoAttribute *attr);
void (*destroy) (PangoAttribute *attr);
gboolean (*equal) (const PangoAttribute *attr1, const PangoAttribute *attr2);
};
/**
* PangoAttrString:
* @attr: the common portion of the attribute
* @value: the string which is the value of the attribute
*
* The #PangoAttrString structure is used to represent attributes with
* a string value.
*/
struct _PangoAttrString
{
PangoAttribute attr;
char *value;
};
/**
* PangoAttrLanguage:
* @attr: the common portion of the attribute
* @value: the #PangoLanguage which is the value of the attribute
*
* The #PangoAttrLanguage structure is used to represent attributes that
* are languages.
*/
struct _PangoAttrLanguage
{
PangoAttribute attr;
PangoLanguage *value;
};
/**
* PangoAttrInt:
* @attr: the common portion of the attribute
* @value: the value of the attribute
*
* The #PangoAttrInt structure is used to represent attributes with
* an integer or enumeration value.
*/
struct _PangoAttrInt
{
PangoAttribute attr;
int value;
};
/**
* PangoAttrFloat:
* @attr: the common portion of the attribute
* @value: the value of the attribute
*
* The #PangoAttrFloat structure is used to represent attributes with
* a float or double value.
*/
struct _PangoAttrFloat
{
PangoAttribute attr;
double value;
};
/**
* PangoAttrColor:
* @attr: the common portion of the attribute
* @color: the #PangoColor which is the value of the attribute
*
* The #PangoAttrColor structure is used to represent attributes that
* are colors.
*/
struct _PangoAttrColor
{
PangoAttribute attr;
PangoColor color;
};
/**
* PangoAttrSize:
* @attr: the common portion of the attribute
* @size: size of font, in units of 1/%PANGO_SCALE of a point (for
* %PANGO_ATTR_SIZE) or of a device uni (for %PANGO_ATTR_ABSOLUTE_SIZE)
* @absolute: whether the font size is in device units or points.
* This field is only present for compatibility with Pango-1.8.0
* (%PANGO_ATTR_ABSOLUTE_SIZE was added in 1.8.1); and always will
* be %FALSE for %PANGO_ATTR_SIZE and %TRUE for %PANGO_ATTR_ABSOLUTE_SIZE.
*
* The #PangoAttrSize structure is used to represent attributes which
* set font size.
*/
struct _PangoAttrSize
{
PangoAttribute attr;
int size;
guint absolute : 1;
};
/**
* PangoAttrShape:
* @attr: the common portion of the attribute
* @ink_rect: the ink rectangle to restrict to
* @logical_rect: the logical rectangle to restrict to
* @data: user data set (see pango_attr_shape_new_with_data())
* @copy_func: copy function for the user data
* @destroy_func: destroy function for the user data
*
* The #PangoAttrShape structure is used to represent attributes which
* impose shape restrictions.
*/
struct _PangoAttrShape
{
PangoAttribute attr;
PangoRectangle ink_rect;
PangoRectangle logical_rect;
gpointer data;
PangoAttrDataCopyFunc copy_func;
GDestroyNotify destroy_func;
};
/**
* PangoAttrFontDesc:
* @attr: the common portion of the attribute
* @desc: the font description which is the value of this attribute
*
* The #PangoAttrFontDesc structure is used to store an attribute that
* sets all aspects of the font description at once.
*/
struct _PangoAttrFontDesc
{
PangoAttribute attr;
PangoFontDescription *desc;
};
/**
* PangoAttrFontFeatures:
* @attr: the common portion of the attribute
* @features: the featues, as a string in CSS syntax
*
* The #PangoAttrFontFeatures structure is used to represent OpenType
* font features as an attribute.
*
* Since: 1.38
*/
struct _PangoAttrFontFeatures
{
PangoAttribute attr;
gchar *features;
};
PANGO_AVAILABLE_IN_ALL
PangoAttrType pango_attr_type_register (const gchar *name);
PANGO_AVAILABLE_IN_1_22
const char * pango_attr_type_get_name (PangoAttrType type) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_20
void pango_attribute_init (PangoAttribute *attr,
const PangoAttrClass *klass);
PANGO_AVAILABLE_IN_ALL
PangoAttribute * pango_attribute_copy (const PangoAttribute *attr);
PANGO_AVAILABLE_IN_ALL
void pango_attribute_destroy (PangoAttribute *attr);
PANGO_AVAILABLE_IN_ALL
gboolean pango_attribute_equal (const PangoAttribute *attr1,
const PangoAttribute *attr2) G_GNUC_PURE;
PANGO_AVAILABLE_IN_ALL
PangoAttribute *pango_attr_language_new (PangoLanguage *language);
PANGO_AVAILABLE_IN_ALL
PangoAttribute *pango_attr_family_new (const char *family);
PANGO_AVAILABLE_IN_ALL
PangoAttribute *pango_attr_foreground_new (guint16 red,
guint16 green,
guint16 blue);
PANGO_AVAILABLE_IN_ALL
PangoAttribute *pango_attr_background_new (guint16 red,
guint16 green,
guint16 blue);
PANGO_AVAILABLE_IN_ALL
PangoAttribute *pango_attr_size_new (int size);
PANGO_AVAILABLE_IN_1_8
PangoAttribute *pango_attr_size_new_absolute (int size);
PANGO_AVAILABLE_IN_ALL
PangoAttribute *pango_attr_style_new (PangoStyle style);
PANGO_AVAILABLE_IN_ALL
PangoAttribute *pango_attr_weight_new (PangoWeight weight);
PANGO_AVAILABLE_IN_ALL
PangoAttribute *pango_attr_variant_new (PangoVariant variant);
PANGO_AVAILABLE_IN_ALL
PangoAttribute *pango_attr_stretch_new (PangoStretch stretch);
PANGO_AVAILABLE_IN_ALL
PangoAttribute *pango_attr_font_desc_new (const PangoFontDescription *desc);
PANGO_AVAILABLE_IN_ALL
PangoAttribute *pango_attr_underline_new (PangoUnderline underline);
PANGO_AVAILABLE_IN_1_8
PangoAttribute *pango_attr_underline_color_new (guint16 red,
guint16 green,
guint16 blue);
PANGO_AVAILABLE_IN_ALL
PangoAttribute *pango_attr_strikethrough_new (gboolean strikethrough);
PANGO_AVAILABLE_IN_1_8
PangoAttribute *pango_attr_strikethrough_color_new (guint16 red,
guint16 green,
guint16 blue);
PANGO_AVAILABLE_IN_ALL
PangoAttribute *pango_attr_rise_new (int rise);
PANGO_AVAILABLE_IN_ALL
PangoAttribute *pango_attr_scale_new (double scale_factor);
PANGO_AVAILABLE_IN_1_4
PangoAttribute *pango_attr_fallback_new (gboolean enable_fallback);
PANGO_AVAILABLE_IN_1_6
PangoAttribute *pango_attr_letter_spacing_new (int letter_spacing);
PANGO_AVAILABLE_IN_ALL
PangoAttribute *pango_attr_shape_new (const PangoRectangle *ink_rect,
const PangoRectangle *logical_rect);
PANGO_AVAILABLE_IN_1_8
PangoAttribute *pango_attr_shape_new_with_data (const PangoRectangle *ink_rect,
const PangoRectangle *logical_rect,
gpointer data,
PangoAttrDataCopyFunc copy_func,
GDestroyNotify destroy_func);
PANGO_AVAILABLE_IN_1_16
PangoAttribute *pango_attr_gravity_new (PangoGravity gravity);
PANGO_AVAILABLE_IN_1_16
PangoAttribute *pango_attr_gravity_hint_new (PangoGravityHint hint);
PANGO_AVAILABLE_IN_1_38
PangoAttribute *pango_attr_font_features_new (const gchar *features);
PANGO_AVAILABLE_IN_1_38
PangoAttribute *pango_attr_foreground_alpha_new (guint16 alpha);
PANGO_AVAILABLE_IN_1_38
PangoAttribute *pango_attr_background_alpha_new (guint16 alpha);
PANGO_AVAILABLE_IN_ALL
GType pango_attr_list_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_ALL
PangoAttrList * pango_attr_list_new (void);
PANGO_AVAILABLE_IN_1_10
PangoAttrList * pango_attr_list_ref (PangoAttrList *list);
PANGO_AVAILABLE_IN_ALL
void pango_attr_list_unref (PangoAttrList *list);
PANGO_AVAILABLE_IN_ALL
PangoAttrList * pango_attr_list_copy (PangoAttrList *list);
PANGO_AVAILABLE_IN_ALL
void pango_attr_list_insert (PangoAttrList *list,
PangoAttribute *attr);
PANGO_AVAILABLE_IN_ALL
void pango_attr_list_insert_before (PangoAttrList *list,
PangoAttribute *attr);
PANGO_AVAILABLE_IN_ALL
void pango_attr_list_change (PangoAttrList *list,
PangoAttribute *attr);
PANGO_AVAILABLE_IN_ALL
void pango_attr_list_splice (PangoAttrList *list,
PangoAttrList *other,
gint pos,
gint len);
PANGO_AVAILABLE_IN_1_2
PangoAttrList *pango_attr_list_filter (PangoAttrList *list,
PangoAttrFilterFunc func,
gpointer data);
PANGO_AVAILABLE_IN_ALL
PangoAttrIterator *pango_attr_list_get_iterator (PangoAttrList *list);
PANGO_AVAILABLE_IN_ALL
void pango_attr_iterator_range (PangoAttrIterator *iterator,
gint *start,
gint *end);
PANGO_AVAILABLE_IN_ALL
gboolean pango_attr_iterator_next (PangoAttrIterator *iterator);
PANGO_AVAILABLE_IN_ALL
PangoAttrIterator *pango_attr_iterator_copy (PangoAttrIterator *iterator);
PANGO_AVAILABLE_IN_ALL
void pango_attr_iterator_destroy (PangoAttrIterator *iterator);
PANGO_AVAILABLE_IN_ALL
PangoAttribute * pango_attr_iterator_get (PangoAttrIterator *iterator,
PangoAttrType type);
PANGO_AVAILABLE_IN_ALL
void pango_attr_iterator_get_font (PangoAttrIterator *iterator,
PangoFontDescription *desc,
PangoLanguage **language,
GSList **extra_attrs);
PANGO_AVAILABLE_IN_1_2
GSList * pango_attr_iterator_get_attrs (PangoAttrIterator *iterator);
PANGO_AVAILABLE_IN_ALL
gboolean pango_parse_markup (const char *markup_text,
int length,
gunichar accel_marker,
PangoAttrList **attr_list,
char **text,
gunichar *accel_char,
GError **error);
PANGO_AVAILABLE_IN_1_32
GMarkupParseContext * pango_markup_parser_new (gunichar accel_marker);
PANGO_AVAILABLE_IN_1_32
gboolean pango_markup_parser_finish (GMarkupParseContext *context,
PangoAttrList **attr_list,
char **text,
gunichar *accel_char,
GError **error);
G_END_DECLS
#endif /* __PANGO_ATTRIBUTES_H__ */

140
node_modules/sharp/vendor/include/pango/pango-bidi-type.h generated vendored Normal file
View File

@ -0,0 +1,140 @@
/* Pango
* pango-bidi-type.h: Bidirectional Character Types
*
* Copyright (C) 2008 Jürg Billeter <j@bitron.ch>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_BIDI_TYPE_H__
#define __PANGO_BIDI_TYPE_H__
#include <glib.h>
#include <pango/pango-version-macros.h>
G_BEGIN_DECLS
/**
* PangoBidiType:
* @PANGO_BIDI_TYPE_L: Left-to-Right
* @PANGO_BIDI_TYPE_LRE: Left-to-Right Embedding
* @PANGO_BIDI_TYPE_LRO: Left-to-Right Override
* @PANGO_BIDI_TYPE_R: Right-to-Left
* @PANGO_BIDI_TYPE_AL: Right-to-Left Arabic
* @PANGO_BIDI_TYPE_RLE: Right-to-Left Embedding
* @PANGO_BIDI_TYPE_RLO: Right-to-Left Override
* @PANGO_BIDI_TYPE_PDF: Pop Directional Format
* @PANGO_BIDI_TYPE_EN: European Number
* @PANGO_BIDI_TYPE_ES: European Number Separator
* @PANGO_BIDI_TYPE_ET: European Number Terminator
* @PANGO_BIDI_TYPE_AN: Arabic Number
* @PANGO_BIDI_TYPE_CS: Common Number Separator
* @PANGO_BIDI_TYPE_NSM: Nonspacing Mark
* @PANGO_BIDI_TYPE_BN: Boundary Neutral
* @PANGO_BIDI_TYPE_B: Paragraph Separator
* @PANGO_BIDI_TYPE_S: Segment Separator
* @PANGO_BIDI_TYPE_WS: Whitespace
* @PANGO_BIDI_TYPE_ON: Other Neutrals
*
* The #PangoBidiType type represents the bidirectional character
* type of a Unicode character as specified by the
* <ulink url="http://www.unicode.org/reports/tr9/">Unicode bidirectional algorithm</ulink>.
*
* Since: 1.22
**/
typedef enum {
/* Strong types */
PANGO_BIDI_TYPE_L,
PANGO_BIDI_TYPE_LRE,
PANGO_BIDI_TYPE_LRO,
PANGO_BIDI_TYPE_R,
PANGO_BIDI_TYPE_AL,
PANGO_BIDI_TYPE_RLE,
PANGO_BIDI_TYPE_RLO,
/* Weak types */
PANGO_BIDI_TYPE_PDF,
PANGO_BIDI_TYPE_EN,
PANGO_BIDI_TYPE_ES,
PANGO_BIDI_TYPE_ET,
PANGO_BIDI_TYPE_AN,
PANGO_BIDI_TYPE_CS,
PANGO_BIDI_TYPE_NSM,
PANGO_BIDI_TYPE_BN,
/* Neutral types */
PANGO_BIDI_TYPE_B,
PANGO_BIDI_TYPE_S,
PANGO_BIDI_TYPE_WS,
PANGO_BIDI_TYPE_ON
} PangoBidiType;
PANGO_AVAILABLE_IN_1_22
PangoBidiType pango_bidi_type_for_unichar (gunichar ch) G_GNUC_CONST;
/**
* PangoDirection:
* @PANGO_DIRECTION_LTR: A strong left-to-right direction
* @PANGO_DIRECTION_RTL: A strong right-to-left direction
* @PANGO_DIRECTION_TTB_LTR: Deprecated value; treated the
* same as %PANGO_DIRECTION_RTL.
* @PANGO_DIRECTION_TTB_RTL: Deprecated value; treated the
* same as %PANGO_DIRECTION_LTR
* @PANGO_DIRECTION_WEAK_LTR: A weak left-to-right direction
* @PANGO_DIRECTION_WEAK_RTL: A weak right-to-left direction
* @PANGO_DIRECTION_NEUTRAL: No direction specified
*
* The #PangoDirection type represents a direction in the
* Unicode bidirectional algorithm; not every value in this
* enumeration makes sense for every usage of #PangoDirection;
* for example, the return value of pango_unichar_direction()
* and pango_find_base_dir() cannot be %PANGO_DIRECTION_WEAK_LTR
* or %PANGO_DIRECTION_WEAK_RTL, since every character is either
* neutral or has a strong direction; on the other hand
* %PANGO_DIRECTION_NEUTRAL doesn't make sense to pass
* to pango_itemize_with_base_dir().
*
* The %PANGO_DIRECTION_TTB_LTR, %PANGO_DIRECTION_TTB_RTL
* values come from an earlier interpretation of this
* enumeration as the writing direction of a block of
* text and are no longer used; See #PangoGravity for how
* vertical text is handled in Pango.
**/
typedef enum {
PANGO_DIRECTION_LTR,
PANGO_DIRECTION_RTL,
PANGO_DIRECTION_TTB_LTR,
PANGO_DIRECTION_TTB_RTL,
PANGO_DIRECTION_WEAK_LTR,
PANGO_DIRECTION_WEAK_RTL,
PANGO_DIRECTION_NEUTRAL
} PangoDirection;
PANGO_AVAILABLE_IN_ALL
PangoDirection pango_unichar_direction (gunichar ch) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_4
PangoDirection pango_find_base_dir (const gchar *text,
gint length);
#ifndef PANGO_DISABLE_DEPRECATED
PANGO_DEPRECATED_FOR(g_unichar_get_mirror_char)
gboolean pango_get_mirror_char (gunichar ch,
gunichar *mirrored_ch);
#endif
G_END_DECLS
#endif /* __PANGO_BIDI_TYPE_H__ */

177
node_modules/sharp/vendor/include/pango/pango-break.h generated vendored Normal file
View File

@ -0,0 +1,177 @@
/* Pango
* pango-break.h:
*
* Copyright (C) 1999 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_BREAK_H__
#define __PANGO_BREAK_H__
#include <glib.h>
G_BEGIN_DECLS
#include <pango/pango-item.h>
/* Logical attributes of a character.
*/
/**
* PangoLogAttr:
* @is_line_break: if set, can break line in front of character
* @is_mandatory_break: if set, must break line in front of character
* @is_char_break: if set, can break here when doing character wrapping
* @is_white: is whitespace character
* @is_cursor_position: if set, cursor can appear in front of character.
* i.e. this is a grapheme boundary, or the first character
* in the text.
* This flag implements Unicode's
* <ulink url="http://www.unicode.org/reports/tr29/">Grapheme
* Cluster Boundaries</ulink> semantics.
* @is_word_start: is first character in a word
* @is_word_end: is first non-word char after a word
* Note that in degenerate cases, you could have both @is_word_start
* and @is_word_end set for some character.
* @is_sentence_boundary: is a sentence boundary.
* There are two ways to divide sentences. The first assigns all
* inter-sentence whitespace/control/format chars to some sentence,
* so all chars are in some sentence; @is_sentence_boundary denotes
* the boundaries there. The second way doesn't assign
* between-sentence spaces, etc. to any sentence, so
* @is_sentence_start/@is_sentence_end mark the boundaries of those sentences.
* @is_sentence_start: is first character in a sentence
* @is_sentence_end: is first char after a sentence.
* Note that in degenerate cases, you could have both @is_sentence_start
* and @is_sentence_end set for some character. (e.g. no space after a
* period, so the next sentence starts right away)
* @backspace_deletes_character: if set, backspace deletes one character
* rather than the entire grapheme cluster. This
* field is only meaningful on grapheme
* boundaries (where @is_cursor_position is
* set). In some languages, the full grapheme
* (e.g. letter + diacritics) is considered a
* unit, while in others, each decomposed
* character in the grapheme is a unit. In the
* default implementation of pango_break(), this
* bit is set on all grapheme boundaries except
* those following Latin, Cyrillic or Greek base characters.
* @is_expandable_space: is a whitespace character that can possibly be
* expanded for justification purposes. (Since: 1.18)
* @is_word_boundary: is a word boundary.
* More specifically, means that this is not a position in the middle
* of a word. For example, both sides of a punctuation mark are
* considered word boundaries. This flag is particularly useful when
* selecting text word-by-word.
* This flag implements Unicode's
* <ulink url="http://www.unicode.org/reports/tr29/">Word
* Boundaries</ulink> semantics. (Since: 1.22)
*
* The #PangoLogAttr structure stores information
* about the attributes of a single character.
*/
struct _PangoLogAttr
{
guint is_line_break : 1; /* Can break line in front of character */
guint is_mandatory_break : 1; /* Must break line in front of character */
guint is_char_break : 1; /* Can break here when doing char wrap */
guint is_white : 1; /* Whitespace character */
/* Cursor can appear in front of character (i.e. this is a grapheme
* boundary, or the first character in the text).
*/
guint is_cursor_position : 1;
/* Note that in degenerate cases, you could have both start/end set on
* some text, most likely for sentences (e.g. no space after a period, so
* the next sentence starts right away).
*/
guint is_word_start : 1; /* first character in a word */
guint is_word_end : 1; /* is first non-word char after a word */
/* There are two ways to divide sentences. The first assigns all
* intersentence whitespace/control/format chars to some sentence,
* so all chars are in some sentence; is_sentence_boundary denotes
* the boundaries there. The second way doesn't assign
* between-sentence spaces, etc. to any sentence, so
* is_sentence_start/is_sentence_end mark the boundaries of those
* sentences.
*/
guint is_sentence_boundary : 1;
guint is_sentence_start : 1; /* first character in a sentence */
guint is_sentence_end : 1; /* first non-sentence char after a sentence */
/* If set, backspace deletes one character rather than
* the entire grapheme cluster.
*/
guint backspace_deletes_character : 1;
/* Only few space variants (U+0020 and U+00A0) have variable
* width during justification.
*/
guint is_expandable_space : 1;
/* Word boundary as defined by UAX#29 */
guint is_word_boundary : 1; /* is NOT in the middle of a word */
};
/* Determine information about cluster/word/line breaks in a string
* of Unicode text.
*/
PANGO_AVAILABLE_IN_ALL
void pango_break (const gchar *text,
int length,
PangoAnalysis *analysis,
PangoLogAttr *attrs,
int attrs_len);
PANGO_AVAILABLE_IN_ALL
void pango_find_paragraph_boundary (const gchar *text,
gint length,
gint *paragraph_delimiter_index,
gint *next_paragraph_start);
PANGO_AVAILABLE_IN_ALL
void pango_get_log_attrs (const char *text,
int length,
int level,
PangoLanguage *language,
PangoLogAttr *log_attrs,
int attrs_len);
#ifdef PANGO_ENABLE_ENGINE
/* This is the default break algorithm, used if no language
* engine overrides it. Normally you should use pango_break()
* instead; this function is mostly useful for chaining up
* from a language engine override.
*/
PANGO_AVAILABLE_IN_ALL
void pango_default_break (const gchar *text,
int length,
PangoAnalysis *analysis,
PangoLogAttr *attrs,
int attrs_len);
#endif /* PANGO_ENABLE_ENGINE */
G_END_DECLS
#endif /* __PANGO_BREAK_H__ */

137
node_modules/sharp/vendor/include/pango/pango-context.h generated vendored Normal file
View File

@ -0,0 +1,137 @@
/* Pango
* pango-context.h: Rendering contexts
*
* Copyright (C) 2000 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_CONTEXT_H__
#define __PANGO_CONTEXT_H__
#include <pango/pango-font.h>
#include <pango/pango-fontmap.h>
#include <pango/pango-attributes.h>
G_BEGIN_DECLS
/* Sort of like a GC - application set information about how
* to handle scripts
*/
/* PangoContext typedefed in pango-fontmap.h */
typedef struct _PangoContextClass PangoContextClass;
#define PANGO_TYPE_CONTEXT (pango_context_get_type ())
#define PANGO_CONTEXT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_CONTEXT, PangoContext))
#define PANGO_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_CONTEXT, PangoContextClass))
#define PANGO_IS_CONTEXT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_CONTEXT))
#define PANGO_IS_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_CONTEXT))
#define PANGO_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_CONTEXT, PangoContextClass))
/* The PangoContext and PangoContextClass structs are private; if you
* need to create a subclass of these, file a bug.
*/
PANGO_AVAILABLE_IN_ALL
GType pango_context_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_ALL
PangoContext *pango_context_new (void);
PANGO_AVAILABLE_IN_1_32
void pango_context_changed (PangoContext *context);
PANGO_AVAILABLE_IN_ALL
void pango_context_set_font_map (PangoContext *context,
PangoFontMap *font_map);
PANGO_AVAILABLE_IN_1_6
PangoFontMap *pango_context_get_font_map (PangoContext *context);
PANGO_AVAILABLE_IN_1_32
guint pango_context_get_serial (PangoContext *context);
PANGO_AVAILABLE_IN_ALL
void pango_context_list_families (PangoContext *context,
PangoFontFamily ***families,
int *n_families);
PANGO_AVAILABLE_IN_ALL
PangoFont * pango_context_load_font (PangoContext *context,
const PangoFontDescription *desc);
PANGO_AVAILABLE_IN_ALL
PangoFontset *pango_context_load_fontset (PangoContext *context,
const PangoFontDescription *desc,
PangoLanguage *language);
PANGO_AVAILABLE_IN_ALL
PangoFontMetrics *pango_context_get_metrics (PangoContext *context,
const PangoFontDescription *desc,
PangoLanguage *language);
PANGO_AVAILABLE_IN_ALL
void pango_context_set_font_description (PangoContext *context,
const PangoFontDescription *desc);
PANGO_AVAILABLE_IN_ALL
PangoFontDescription * pango_context_get_font_description (PangoContext *context);
PANGO_AVAILABLE_IN_ALL
PangoLanguage *pango_context_get_language (PangoContext *context);
PANGO_AVAILABLE_IN_ALL
void pango_context_set_language (PangoContext *context,
PangoLanguage *language);
PANGO_AVAILABLE_IN_ALL
void pango_context_set_base_dir (PangoContext *context,
PangoDirection direction);
PANGO_AVAILABLE_IN_ALL
PangoDirection pango_context_get_base_dir (PangoContext *context);
PANGO_AVAILABLE_IN_1_16
void pango_context_set_base_gravity (PangoContext *context,
PangoGravity gravity);
PANGO_AVAILABLE_IN_1_16
PangoGravity pango_context_get_base_gravity (PangoContext *context);
PANGO_AVAILABLE_IN_1_16
PangoGravity pango_context_get_gravity (PangoContext *context);
PANGO_AVAILABLE_IN_1_16
void pango_context_set_gravity_hint (PangoContext *context,
PangoGravityHint hint);
PANGO_AVAILABLE_IN_1_16
PangoGravityHint pango_context_get_gravity_hint (PangoContext *context);
PANGO_AVAILABLE_IN_1_6
void pango_context_set_matrix (PangoContext *context,
const PangoMatrix *matrix);
PANGO_AVAILABLE_IN_1_6
const PangoMatrix * pango_context_get_matrix (PangoContext *context);
/* Break a string of Unicode characters into segments with
* consistent shaping/language engine and bidrectional level.
* Returns a #GList of #PangoItem's
*/
PANGO_AVAILABLE_IN_ALL
GList *pango_itemize (PangoContext *context,
const char *text,
int start_index,
int length,
PangoAttrList *attrs,
PangoAttrIterator *cached_iter);
PANGO_AVAILABLE_IN_1_4
GList *pango_itemize_with_base_dir (PangoContext *context,
PangoDirection base_dir,
const char *text,
int start_index,
int length,
PangoAttrList *attrs,
PangoAttrIterator *cached_iter);
G_END_DECLS
#endif /* __PANGO_CONTEXT_H__ */

90
node_modules/sharp/vendor/include/pango/pango-coverage.h generated vendored Normal file
View File

@ -0,0 +1,90 @@
/* Pango
* pango-coverage.h: Coverage sets for fonts
*
* Copyright (C) 2000 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_COVERAGE_H__
#define __PANGO_COVERAGE_H__
#include <glib.h>
#include <pango/pango-version-macros.h>
G_BEGIN_DECLS
/**
* PangoCoverage:
*
* The #PangoCoverage structure represents a map from Unicode characters
* to #PangoCoverageLevel. It is an opaque structure with no public fields.
*/
typedef struct _PangoCoverage PangoCoverage;
/**
* PangoCoverageLevel:
* @PANGO_COVERAGE_NONE: The character is not representable with the font.
* @PANGO_COVERAGE_FALLBACK: The character is represented in a way that may be
* comprehensible but is not the correct graphical form.
* For instance, a Hangul character represented as a
* a sequence of Jamos, or a Latin transliteration of a Cyrillic word.
* @PANGO_COVERAGE_APPROXIMATE: The character is represented as basically the correct
* graphical form, but with a stylistic variant inappropriate for
* the current script.
* @PANGO_COVERAGE_EXACT: The character is represented as the correct graphical form.
*
* Used to indicate how well a font can represent a particular Unicode
* character point for a particular script.
*/
typedef enum {
PANGO_COVERAGE_NONE,
PANGO_COVERAGE_FALLBACK,
PANGO_COVERAGE_APPROXIMATE,
PANGO_COVERAGE_EXACT
} PangoCoverageLevel;
PANGO_AVAILABLE_IN_ALL
PangoCoverage * pango_coverage_new (void);
PANGO_AVAILABLE_IN_ALL
PangoCoverage * pango_coverage_ref (PangoCoverage *coverage);
PANGO_AVAILABLE_IN_ALL
void pango_coverage_unref (PangoCoverage *coverage);
PANGO_AVAILABLE_IN_ALL
PangoCoverage * pango_coverage_copy (PangoCoverage *coverage);
PANGO_AVAILABLE_IN_ALL
PangoCoverageLevel pango_coverage_get (PangoCoverage *coverage,
int index_);
PANGO_AVAILABLE_IN_ALL
void pango_coverage_set (PangoCoverage *coverage,
int index_,
PangoCoverageLevel level);
PANGO_AVAILABLE_IN_ALL
void pango_coverage_max (PangoCoverage *coverage,
PangoCoverage *other);
PANGO_AVAILABLE_IN_ALL
void pango_coverage_to_bytes (PangoCoverage *coverage,
guchar **bytes,
int *n_bytes);
PANGO_AVAILABLE_IN_ALL
PangoCoverage *pango_coverage_from_bytes (guchar *bytes,
int n_bytes);
G_END_DECLS
#endif /* __PANGO_COVERAGE_H__ */

451
node_modules/sharp/vendor/include/pango/pango-engine.h generated vendored Normal file
View File

@ -0,0 +1,451 @@
/* Pango
* pango-engine.h: Engines for script and language specific processing
*
* Copyright (C) 2000,2003 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_ENGINE_H__
#define __PANGO_ENGINE_H__
#include <pango/pango-types.h>
#include <pango/pango-item.h>
#include <pango/pango-font.h>
#include <pango/pango-glyph.h>
#include <pango/pango-script.h>
G_BEGIN_DECLS
#ifdef PANGO_ENABLE_ENGINE
/**
* PANGO_RENDER_TYPE_NONE:
*
* A string constant defining the render type
* for engines that are not rendering-system specific.
*
* Deprecated: 1.38
*/
#define PANGO_RENDER_TYPE_NONE "PangoRenderNone"
#define PANGO_TYPE_ENGINE (pango_engine_get_type ())
#define PANGO_ENGINE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_ENGINE, PangoEngine))
#define PANGO_IS_ENGINE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_ENGINE))
#define PANGO_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_ENGINE, PangoEngineClass))
#define PANGO_IS_ENGINE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_ENGINE))
#define PANGO_ENGINE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_ENGINE, PangoEngineClass))
typedef struct _PangoEngine PangoEngine;
typedef struct _PangoEngineClass PangoEngineClass;
/**
* PangoEngine:
*
* #PangoEngine is the base class for all types of language and
* script specific engines. It has no functionality by itself.
*
* Deprecated: 1.38
**/
struct _PangoEngine
{
/*< private >*/
GObject parent_instance;
};
/**
* PangoEngineClass:
*
* Class structure for #PangoEngine
*
* Deprecated: 1.38
**/
struct _PangoEngineClass
{
/*< private >*/
GObjectClass parent_class;
};
PANGO_DEPRECATED_IN_1_38
GType pango_engine_get_type (void) G_GNUC_CONST;
/**
* PANGO_ENGINE_TYPE_LANG:
*
* A string constant defining the engine type for language engines.
* These engines derive from #PangoEngineLang.
*
* Deprecated: 1.38
*/
#define PANGO_ENGINE_TYPE_LANG "PangoEngineLang"
#define PANGO_TYPE_ENGINE_LANG (pango_engine_lang_get_type ())
#define PANGO_ENGINE_LANG(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_ENGINE_LANG, PangoEngineLang))
#define PANGO_IS_ENGINE_LANG(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_ENGINE_LANG))
#define PANGO_ENGINE_LANG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_ENGINE_LANG, PangoEngineLangClass))
#define PANGO_IS_ENGINE_LANG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_ENGINE_LANG))
#define PANGO_ENGINE_LANG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_ENGINE_LANG, PangoEngineLangClass))
typedef struct _PangoEngineLangClass PangoEngineLangClass;
/**
* PangoEngineLang:
*
* The #PangoEngineLang class is implemented by engines that
* customize the rendering-system independent part of the
* Pango pipeline for a particular script or language. For
* instance, a custom #PangoEngineLang could be provided for
* Thai to implement the dictionary-based word boundary
* lookups needed for that language.
*
* Deprecated: 1.38
**/
struct _PangoEngineLang
{
/*< private >*/
PangoEngine parent_instance;
};
/**
* PangoEngineLangClass:
* @script_break: (nullable): Provides a custom implementation of
* pango_break(). If %NULL, pango_default_break() is used instead. If
* not %NULL, for Pango versions before 1.16 (module interface version
* before 1.6.0), this was called instead of pango_default_break(),
* but in newer versions, pango_default_break() is always called and
* this is called after that to allow tailoring the breaking results.
*
* Class structure for #PangoEngineLang
*
* Deprecated: 1.38
**/
struct _PangoEngineLangClass
{
/*< private >*/
PangoEngineClass parent_class;
/*< public >*/
void (*script_break) (PangoEngineLang *engine,
const char *text,
int len,
PangoAnalysis *analysis,
PangoLogAttr *attrs,
int attrs_len);
};
PANGO_DEPRECATED_IN_1_38
GType pango_engine_lang_get_type (void) G_GNUC_CONST;
/**
* PANGO_ENGINE_TYPE_SHAPE:
*
* A string constant defining the engine type for shaping engines.
* These engines derive from #PangoEngineShape.
*
* Deprecated: 1.38
*/
#define PANGO_ENGINE_TYPE_SHAPE "PangoEngineShape"
#define PANGO_TYPE_ENGINE_SHAPE (pango_engine_shape_get_type ())
#define PANGO_ENGINE_SHAPE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_ENGINE_SHAPE, PangoEngineShape))
#define PANGO_IS_ENGINE_SHAPE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_ENGINE_SHAPE))
#define PANGO_ENGINE_SHAPE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_ENGINE_SHAPE, PangoEngine_ShapeClass))
#define PANGO_IS_ENGINE_SHAPE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_ENGINE_SHAPE))
#define PANGO_ENGINE_SHAPE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_ENGINE_SHAPE, PangoEngineShapeClass))
typedef struct _PangoEngineShapeClass PangoEngineShapeClass;
/**
* PangoEngineShape:
*
* The #PangoEngineShape class is implemented by engines that
* customize the rendering-system dependent part of the
* Pango pipeline for a particular script or language.
* A #PangoEngineShape implementation is then specific to both
* a particular rendering system or group of rendering systems
* and to a particular script. For instance, there is one
* #PangoEngineShape implementation to handle shaping Arabic
* for Fontconfig-based backends.
*
* Deprecated: 1.38
**/
struct _PangoEngineShape
{
PangoEngine parent_instance;
};
/**
* PangoEngineShapeClass:
* @script_shape: Given a font, a piece of text, and a #PangoAnalysis
* structure, converts characters to glyphs and positions the
* resulting glyphs. The results are stored in the #PangoGlyphString
* that is passed in. (The implementation should resize it
* appropriately using pango_glyph_string_set_size()). All fields
* of the @log_clusters and @glyphs array must be filled in, with
* the exception that Pango will automatically generate
* <literal>glyphs->glyphs[i].attr.is_cluster_start</literal>
* using the @log_clusters array. Each input character must occur in one
* of the output logical clusters;
* if no rendering is desired for a character, this may involve
* inserting glyphs with the #PangoGlyph ID #PANGO_GLYPH_EMPTY, which
* is guaranteed never to render. If the shaping fails for any reason,
* the shaper should return with an empty (zero-size) glyph string.
* If the shaper has not set the size on the glyph string yet, simply
* returning signals the failure too.
* @covers: Returns the characters that this engine can cover
* with a given font for a given language. If not overridden, the default
* implementation simply returns the coverage information for the
* font itself unmodified.
*
* Class structure for #PangoEngineShape
*
* Deprecated: 1.38
**/
struct _PangoEngineShapeClass
{
/*< private >*/
PangoEngineClass parent_class;
/*< public >*/
void (*script_shape) (PangoEngineShape *engine,
PangoFont *font,
const char *item_text,
unsigned int item_length,
const PangoAnalysis *analysis,
PangoGlyphString *glyphs,
const char *paragraph_text,
unsigned int paragraph_length);
PangoCoverageLevel (*covers) (PangoEngineShape *engine,
PangoFont *font,
PangoLanguage *language,
gunichar wc);
};
PANGO_DEPRECATED_IN_1_38
GType pango_engine_shape_get_type (void) G_GNUC_CONST;
typedef struct _PangoEngineInfo PangoEngineInfo;
typedef struct _PangoEngineScriptInfo PangoEngineScriptInfo;
/**
* PangoEngineScriptInfo:
* @script: a #PangoScript. The value %PANGO_SCRIPT_COMMON has
* the special meaning here of "all scripts"
* @langs: a semicolon separated list of languages that this
* engine handles for this script. This may be empty,
* in which case the engine is saying that it is a
* fallback choice for all languages for this range,
* but should not be used if another engine
* indicates that it is specific for the language for
* a given code point. An entry in this list of "*"
* indicates that this engine is specific to all
* languages for this range.
*
* The #PangoEngineScriptInfo structure contains
* information about how the shaper covers a particular script.
*
* Deprecated: 1.38
*/
struct _PangoEngineScriptInfo
{
PangoScript script;
const gchar *langs;
};
/**
* PangoEngineInfo:
* @id: a unique string ID for the engine.
* @engine_type: a string identifying the engine type.
* @render_type: a string identifying the render type.
* @scripts: array of scripts this engine supports.
* @n_scripts: number of items in @scripts.
*
* The #PangoEngineInfo structure contains information about a particular
* engine. It contains the following fields:
*
* Deprecated: 1.38
*/
struct _PangoEngineInfo
{
const gchar *id;
const gchar *engine_type;
const gchar *render_type;
PangoEngineScriptInfo *scripts;
gint n_scripts;
};
/**
* script_engine_list: (skip)
* @engines: location to store a pointer to an array of engines.
* @n_engines: location to store the number of elements in @engines.
*
* Do not use.
*
* Deprecated: 1.38
**/
PANGO_DEPRECATED_IN_1_38
void script_engine_list (PangoEngineInfo **engines,
int *n_engines);
/**
* script_engine_init: (skip)
* @module: a #GTypeModule structure used to associate any
* GObject types created in this module with the module.
*
* Do not use.
*
* Deprecated: 1.38
**/
PANGO_DEPRECATED_IN_1_38
void script_engine_init (GTypeModule *module);
/**
* script_engine_exit: (skip)
*
* Do not use.
*
* Deprecated: 1.38
**/
PANGO_DEPRECATED_IN_1_38
void script_engine_exit (void);
/**
* script_engine_create: (skip)
* @id: the ID of an engine as reported by script_engine_list.
*
* Do not use.
*
* Deprecated: 1.38
**/
PANGO_DEPRECATED_IN_1_38
PangoEngine *script_engine_create (const char *id);
/* Utility macro used by PANGO_ENGINE_LANG_DEFINE_TYPE and
* PANGO_ENGINE_LANG_DEFINE_TYPE
*/
#define PANGO_ENGINE_DEFINE_TYPE(name, prefix, class_init, instance_init, parent_type) \
static GType prefix ## _type; \
static void \
prefix ## _register_type (GTypeModule *module) \
{ \
const GTypeInfo object_info = \
{ \
sizeof (name ## Class), \
(GBaseInitFunc) NULL, \
(GBaseFinalizeFunc) NULL, \
(GClassInitFunc) class_init, \
(GClassFinalizeFunc) NULL, \
NULL, /* class_data */ \
sizeof (name), \
0, /* n_prelocs */ \
(GInstanceInitFunc) instance_init, \
NULL /* value_table */ \
}; \
\
prefix ## _type = g_type_module_register_type (module, parent_type, \
# name, \
&object_info, 0); \
}
/**
* PANGO_ENGINE_LANG_DEFINE_TYPE:
* @name: Name of the the type to register (for example:, <literal>ArabicEngineFc</literal>
* @prefix: Prefix for symbols that will be defined (for example:, <literal>arabic_engine_fc</literal>
* @class_init: (nullable): Class initialization function for the new type, or %NULL
* @instance_init: (nullable): Instance initialization function for the new type, or %NULL
*
* Outputs the necessary code for GObject type registration for a
* #PangoEngineLang class defined in a module. Two static symbols
* are defined.
*
* <programlisting>
* static GType <replaceable>prefix</replaceable>_type;
* static void <replaceable>prefix</replaceable>_register_type (GTypeModule module);
* </programlisting>
*
* The <function><replaceable>prefix</replaceable>_register_type()</function>
* function should be called in your script_engine_init() function for
* each type that your module implements, and then your script_engine_create()
* function can create instances of the object as follows:
*
* <informalexample><programlisting>
* PangoEngine *engine = g_object_new (<replaceable>prefix</replaceable>_type, NULL);
* </programlisting></informalexample>
*
* Deprecated: 1.38
**/
#define PANGO_ENGINE_LANG_DEFINE_TYPE(name, prefix, class_init, instance_init) \
PANGO_ENGINE_DEFINE_TYPE (name, prefix, \
class_init, instance_init, \
PANGO_TYPE_ENGINE_LANG)
/**
* PANGO_ENGINE_SHAPE_DEFINE_TYPE:
* @name: Name of the the type to register (for example:, <literal>ArabicEngineFc</literal>
* @prefix: Prefix for symbols that will be defined (for example:, <literal>arabic_engine_fc</literal>
* @class_init: (nullable): Class initialization function for the new type, or %NULL
* @instance_init: (nullable): Instance initialization function for the new type, or %NULL
*
* Outputs the necessary code for GObject type registration for a
* #PangoEngineShape class defined in a module. Two static symbols
* are defined.
*
* <programlisting>
* static GType <replaceable>prefix</replaceable>_type;
* static void <replaceable>prefix</replaceable>_register_type (GTypeModule module);
* </programlisting>
*
* The <function><replaceable>prefix</replaceable>_register_type()</function>
* function should be called in your script_engine_init() function for
* each type that your module implements, and then your script_engine_create()
* function can create instances of the object as follows:
*
* <informalexample><programlisting>
* PangoEngine *engine = g_object_new (<replaceable>prefix</replaceable>_type, NULL);
* </programlisting></informalexample>
*
* Deprecated: 1.38
**/
#define PANGO_ENGINE_SHAPE_DEFINE_TYPE(name, prefix, class_init, instance_init) \
PANGO_ENGINE_DEFINE_TYPE (name, prefix, \
class_init, instance_init, \
PANGO_TYPE_ENGINE_SHAPE)
/* Macro used for possibly builtin Pango modules. Not useful
* for externally build modules. If we are compiling a module standalone,
* then we name the entry points script_engine_list, etc. But if we
* are compiling it for inclusion directly in Pango, then we need them to
* to have distinct names for this module, so we prepend a prefix.
*
* The two intermediate macros are to deal with details of the C
* preprocessor; token pasting tokens must be function arguments,
* and macro substitution isn't used on function arguments that
* are used for token pasting.
*/
#ifdef PANGO_MODULE_PREFIX
#define PANGO_MODULE_ENTRY(func) _PANGO_MODULE_ENTRY2(PANGO_MODULE_PREFIX,func)
#define _PANGO_MODULE_ENTRY2(prefix,func) _PANGO_MODULE_ENTRY3(prefix,func)
#define _PANGO_MODULE_ENTRY3(prefix,func) prefix##_script_engine_##func
#else
#define PANGO_MODULE_ENTRY(func) script_engine_##func
#endif
#endif /* PANGO_ENABLE_ENGINE */
G_END_DECLS
#endif /* __PANGO_ENGINE_H__ */

89
node_modules/sharp/vendor/include/pango/pango-enum-types.h generated vendored Normal file
View File

@ -0,0 +1,89 @@
/* This file is generated by glib-mkenums, do not modify it. This code is licensed under the same license as the containing project. Note that it links to GLib, so must comply with the LGPL linking clauses. */
#ifndef __PANGO_ENUM_TYPES_H__
#define __PANGO_ENUM_TYPES_H__
#include <glib-object.h>
#include <pango/pango-version-macros.h>
G_BEGIN_DECLS
/* enumerations from "pango-attributes.h" */
PANGO_AVAILABLE_IN_ALL
GType pango_attr_type_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_ATTR_TYPE (pango_attr_type_get_type ())
PANGO_AVAILABLE_IN_ALL
GType pango_underline_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_UNDERLINE (pango_underline_get_type ())
/* enumerations from "pango-bidi-type.h" */
PANGO_AVAILABLE_IN_ALL
GType pango_bidi_type_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_BIDI_TYPE (pango_bidi_type_get_type ())
PANGO_AVAILABLE_IN_ALL
GType pango_direction_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_DIRECTION (pango_direction_get_type ())
/* enumerations from "pango-coverage.h" */
PANGO_AVAILABLE_IN_ALL
GType pango_coverage_level_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_COVERAGE_LEVEL (pango_coverage_level_get_type ())
/* enumerations from "pango-font.h" */
PANGO_AVAILABLE_IN_ALL
GType pango_style_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_STYLE (pango_style_get_type ())
PANGO_AVAILABLE_IN_ALL
GType pango_variant_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_VARIANT (pango_variant_get_type ())
PANGO_AVAILABLE_IN_ALL
GType pango_weight_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_WEIGHT (pango_weight_get_type ())
PANGO_AVAILABLE_IN_ALL
GType pango_stretch_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_STRETCH (pango_stretch_get_type ())
PANGO_AVAILABLE_IN_ALL
GType pango_font_mask_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_FONT_MASK (pango_font_mask_get_type ())
/* enumerations from "pango-gravity.h" */
PANGO_AVAILABLE_IN_ALL
GType pango_gravity_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_GRAVITY (pango_gravity_get_type ())
PANGO_AVAILABLE_IN_ALL
GType pango_gravity_hint_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_GRAVITY_HINT (pango_gravity_hint_get_type ())
/* enumerations from "pango-layout.h" */
PANGO_AVAILABLE_IN_ALL
GType pango_alignment_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_ALIGNMENT (pango_alignment_get_type ())
PANGO_AVAILABLE_IN_ALL
GType pango_wrap_mode_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_WRAP_MODE (pango_wrap_mode_get_type ())
PANGO_AVAILABLE_IN_ALL
GType pango_ellipsize_mode_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_ELLIPSIZE_MODE (pango_ellipsize_mode_get_type ())
/* enumerations from "pango-renderer.h" */
PANGO_AVAILABLE_IN_ALL
GType pango_render_part_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_RENDER_PART (pango_render_part_get_type ())
/* enumerations from "pango-script.h" */
PANGO_AVAILABLE_IN_ALL
GType pango_script_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_SCRIPT (pango_script_get_type ())
/* enumerations from "pango-tabs.h" */
PANGO_AVAILABLE_IN_ALL
GType pango_tab_align_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_TAB_ALIGN (pango_tab_align_get_type ())
G_END_DECLS
#endif /* __PANGO_ENUM_TYPES_H__ */
/* Generated data ends here */

12
node_modules/sharp/vendor/include/pango/pango-features.h generated vendored Normal file
View File

@ -0,0 +1,12 @@
/* Generated by configure. Do not edit */
#ifndef PANGO_FEATURES_H
#define PANGO_FEATURES_H
#define PANGO_VERSION_MAJOR 1
#define PANGO_VERSION_MINOR 42
#define PANGO_VERSION_MICRO 4
#define PANGO_VERSION_STRING "1.42.4"
#endif

696
node_modules/sharp/vendor/include/pango/pango-font.h generated vendored Normal file
View File

@ -0,0 +1,696 @@
/* Pango
* pango-font.h: Font handling
*
* Copyright (C) 2000 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_FONT_H__
#define __PANGO_FONT_H__
#include <pango/pango-coverage.h>
#include <pango/pango-types.h>
#include <glib-object.h>
G_BEGIN_DECLS
/**
* PangoFontDescription:
*
* The #PangoFontDescription structure represents the description
* of an ideal font. These structures are used both to list
* what fonts are available on the system and also for specifying
* the characteristics of a font to load.
*/
typedef struct _PangoFontDescription PangoFontDescription;
/**
* PangoFontMetrics:
*
* A #PangoFontMetrics structure holds the overall metric information
* for a font (possibly restricted to a script). The fields of this
* structure are private to implementations of a font backend. See
* the documentation of the corresponding getters for documentation
* of their meaning.
*/
typedef struct _PangoFontMetrics PangoFontMetrics;
/**
* PangoStyle:
* @PANGO_STYLE_NORMAL: the font is upright.
* @PANGO_STYLE_OBLIQUE: the font is slanted, but in a roman style.
* @PANGO_STYLE_ITALIC: the font is slanted in an italic style.
*
* An enumeration specifying the various slant styles possible for a font.
**/
typedef enum {
PANGO_STYLE_NORMAL,
PANGO_STYLE_OBLIQUE,
PANGO_STYLE_ITALIC
} PangoStyle;
/**
* PangoVariant:
* @PANGO_VARIANT_NORMAL: A normal font.
* @PANGO_VARIANT_SMALL_CAPS: A font with the lower case characters
* replaced by smaller variants of the capital characters.
*
* An enumeration specifying capitalization variant of the font.
*/
typedef enum {
PANGO_VARIANT_NORMAL,
PANGO_VARIANT_SMALL_CAPS
} PangoVariant;
/**
* PangoWeight:
* @PANGO_WEIGHT_THIN: the thin weight (= 100; Since: 1.24)
* @PANGO_WEIGHT_ULTRALIGHT: the ultralight weight (= 200)
* @PANGO_WEIGHT_LIGHT: the light weight (= 300)
* @PANGO_WEIGHT_SEMILIGHT: the semilight weight (= 350; Since: 1.36.7)
* @PANGO_WEIGHT_BOOK: the book weight (= 380; Since: 1.24)
* @PANGO_WEIGHT_NORMAL: the default weight (= 400)
* @PANGO_WEIGHT_MEDIUM: the normal weight (= 500; Since: 1.24)
* @PANGO_WEIGHT_SEMIBOLD: the semibold weight (= 600)
* @PANGO_WEIGHT_BOLD: the bold weight (= 700)
* @PANGO_WEIGHT_ULTRABOLD: the ultrabold weight (= 800)
* @PANGO_WEIGHT_HEAVY: the heavy weight (= 900)
* @PANGO_WEIGHT_ULTRAHEAVY: the ultraheavy weight (= 1000; Since: 1.24)
*
* An enumeration specifying the weight (boldness) of a font. This is a numerical
* value ranging from 100 to 1000, but there are some predefined values:
*/
typedef enum {
PANGO_WEIGHT_THIN = 100,
PANGO_WEIGHT_ULTRALIGHT = 200,
PANGO_WEIGHT_LIGHT = 300,
PANGO_WEIGHT_SEMILIGHT = 350,
PANGO_WEIGHT_BOOK = 380,
PANGO_WEIGHT_NORMAL = 400,
PANGO_WEIGHT_MEDIUM = 500,
PANGO_WEIGHT_SEMIBOLD = 600,
PANGO_WEIGHT_BOLD = 700,
PANGO_WEIGHT_ULTRABOLD = 800,
PANGO_WEIGHT_HEAVY = 900,
PANGO_WEIGHT_ULTRAHEAVY = 1000
} PangoWeight;
/**
* PangoStretch:
* @PANGO_STRETCH_ULTRA_CONDENSED: ultra condensed width
* @PANGO_STRETCH_EXTRA_CONDENSED: extra condensed width
* @PANGO_STRETCH_CONDENSED: condensed width
* @PANGO_STRETCH_SEMI_CONDENSED: semi condensed width
* @PANGO_STRETCH_NORMAL: the normal width
* @PANGO_STRETCH_SEMI_EXPANDED: semi expanded width
* @PANGO_STRETCH_EXPANDED: expanded width
* @PANGO_STRETCH_EXTRA_EXPANDED: extra expanded width
* @PANGO_STRETCH_ULTRA_EXPANDED: ultra expanded width
*
* An enumeration specifying the width of the font relative to other designs
* within a family.
*/
typedef enum {
PANGO_STRETCH_ULTRA_CONDENSED,
PANGO_STRETCH_EXTRA_CONDENSED,
PANGO_STRETCH_CONDENSED,
PANGO_STRETCH_SEMI_CONDENSED,
PANGO_STRETCH_NORMAL,
PANGO_STRETCH_SEMI_EXPANDED,
PANGO_STRETCH_EXPANDED,
PANGO_STRETCH_EXTRA_EXPANDED,
PANGO_STRETCH_ULTRA_EXPANDED
} PangoStretch;
/**
* PangoFontMask:
* @PANGO_FONT_MASK_FAMILY: the font family is specified.
* @PANGO_FONT_MASK_STYLE: the font style is specified.
* @PANGO_FONT_MASK_VARIANT: the font variant is specified.
* @PANGO_FONT_MASK_WEIGHT: the font weight is specified.
* @PANGO_FONT_MASK_STRETCH: the font stretch is specified.
* @PANGO_FONT_MASK_SIZE: the font size is specified.
* @PANGO_FONT_MASK_GRAVITY: the font gravity is specified (Since: 1.16.)
* @PANGO_FONT_MASK_VARIATIONS: OpenType font variations are specified (Since: 1.42)
*
* The bits in a #PangoFontMask correspond to fields in a
* #PangoFontDescription that have been set.
*/
typedef enum {
PANGO_FONT_MASK_FAMILY = 1 << 0,
PANGO_FONT_MASK_STYLE = 1 << 1,
PANGO_FONT_MASK_VARIANT = 1 << 2,
PANGO_FONT_MASK_WEIGHT = 1 << 3,
PANGO_FONT_MASK_STRETCH = 1 << 4,
PANGO_FONT_MASK_SIZE = 1 << 5,
PANGO_FONT_MASK_GRAVITY = 1 << 6,
PANGO_FONT_MASK_VARIATIONS = 1 << 7,
} PangoFontMask;
/* CSS scale factors (1.2 factor between each size) */
/**
* PANGO_SCALE_XX_SMALL:
*
* The scale factor for three shrinking steps (1 / (1.2 * 1.2 * 1.2)).
*/
/**
* PANGO_SCALE_X_SMALL:
*
* The scale factor for two shrinking steps (1 / (1.2 * 1.2)).
*/
/**
* PANGO_SCALE_SMALL:
*
* The scale factor for one shrinking step (1 / 1.2).
*/
/**
* PANGO_SCALE_MEDIUM:
*
* The scale factor for normal size (1.0).
*/
/**
* PANGO_SCALE_LARGE:
*
* The scale factor for one magnification step (1.2).
*/
/**
* PANGO_SCALE_X_LARGE:
*
* The scale factor for two magnification steps (1.2 * 1.2).
*/
/**
* PANGO_SCALE_XX_LARGE:
*
* The scale factor for three magnification steps (1.2 * 1.2 * 1.2).
*/
#define PANGO_SCALE_XX_SMALL ((double)0.5787037037037)
#define PANGO_SCALE_X_SMALL ((double)0.6444444444444)
#define PANGO_SCALE_SMALL ((double)0.8333333333333)
#define PANGO_SCALE_MEDIUM ((double)1.0)
#define PANGO_SCALE_LARGE ((double)1.2)
#define PANGO_SCALE_X_LARGE ((double)1.4399999999999)
#define PANGO_SCALE_XX_LARGE ((double)1.728)
/*
* PangoFontDescription
*/
/**
* PANGO_TYPE_FONT_DESCRIPTION:
*
* The #GObject type for #PangoFontDescription.
*/
#define PANGO_TYPE_FONT_DESCRIPTION (pango_font_description_get_type ())
PANGO_AVAILABLE_IN_ALL
GType pango_font_description_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_ALL
PangoFontDescription *pango_font_description_new (void);
PANGO_AVAILABLE_IN_ALL
PangoFontDescription *pango_font_description_copy (const PangoFontDescription *desc);
PANGO_AVAILABLE_IN_ALL
PangoFontDescription *pango_font_description_copy_static (const PangoFontDescription *desc);
PANGO_AVAILABLE_IN_ALL
guint pango_font_description_hash (const PangoFontDescription *desc) G_GNUC_PURE;
PANGO_AVAILABLE_IN_ALL
gboolean pango_font_description_equal (const PangoFontDescription *desc1,
const PangoFontDescription *desc2) G_GNUC_PURE;
PANGO_AVAILABLE_IN_ALL
void pango_font_description_free (PangoFontDescription *desc);
PANGO_AVAILABLE_IN_ALL
void pango_font_descriptions_free (PangoFontDescription **descs,
int n_descs);
PANGO_AVAILABLE_IN_ALL
void pango_font_description_set_family (PangoFontDescription *desc,
const char *family);
PANGO_AVAILABLE_IN_ALL
void pango_font_description_set_family_static (PangoFontDescription *desc,
const char *family);
PANGO_AVAILABLE_IN_ALL
const char *pango_font_description_get_family (const PangoFontDescription *desc) G_GNUC_PURE;
PANGO_AVAILABLE_IN_ALL
void pango_font_description_set_style (PangoFontDescription *desc,
PangoStyle style);
PANGO_AVAILABLE_IN_ALL
PangoStyle pango_font_description_get_style (const PangoFontDescription *desc) G_GNUC_PURE;
PANGO_AVAILABLE_IN_ALL
void pango_font_description_set_variant (PangoFontDescription *desc,
PangoVariant variant);
PANGO_AVAILABLE_IN_ALL
PangoVariant pango_font_description_get_variant (const PangoFontDescription *desc) G_GNUC_PURE;
PANGO_AVAILABLE_IN_ALL
void pango_font_description_set_weight (PangoFontDescription *desc,
PangoWeight weight);
PANGO_AVAILABLE_IN_ALL
PangoWeight pango_font_description_get_weight (const PangoFontDescription *desc) G_GNUC_PURE;
PANGO_AVAILABLE_IN_ALL
void pango_font_description_set_stretch (PangoFontDescription *desc,
PangoStretch stretch);
PANGO_AVAILABLE_IN_ALL
PangoStretch pango_font_description_get_stretch (const PangoFontDescription *desc) G_GNUC_PURE;
PANGO_AVAILABLE_IN_ALL
void pango_font_description_set_size (PangoFontDescription *desc,
gint size);
PANGO_AVAILABLE_IN_ALL
gint pango_font_description_get_size (const PangoFontDescription *desc) G_GNUC_PURE;
PANGO_AVAILABLE_IN_1_8
void pango_font_description_set_absolute_size (PangoFontDescription *desc,
double size);
PANGO_AVAILABLE_IN_1_8
gboolean pango_font_description_get_size_is_absolute (const PangoFontDescription *desc) G_GNUC_PURE;
PANGO_AVAILABLE_IN_1_16
void pango_font_description_set_gravity (PangoFontDescription *desc,
PangoGravity gravity);
PANGO_AVAILABLE_IN_1_16
PangoGravity pango_font_description_get_gravity (const PangoFontDescription *desc) G_GNUC_PURE;
PANGO_AVAILABLE_IN_1_42
void pango_font_description_set_variations_static (PangoFontDescription *desc,
const char *settings);
PANGO_AVAILABLE_IN_1_42
void pango_font_description_set_variations (PangoFontDescription *desc,
const char *settings);
PANGO_AVAILABLE_IN_1_42
const char *pango_font_description_get_variations (const PangoFontDescription *desc) G_GNUC_PURE;
PANGO_AVAILABLE_IN_ALL
PangoFontMask pango_font_description_get_set_fields (const PangoFontDescription *desc) G_GNUC_PURE;
PANGO_AVAILABLE_IN_ALL
void pango_font_description_unset_fields (PangoFontDescription *desc,
PangoFontMask to_unset);
PANGO_AVAILABLE_IN_ALL
void pango_font_description_merge (PangoFontDescription *desc,
const PangoFontDescription *desc_to_merge,
gboolean replace_existing);
PANGO_AVAILABLE_IN_ALL
void pango_font_description_merge_static (PangoFontDescription *desc,
const PangoFontDescription *desc_to_merge,
gboolean replace_existing);
PANGO_AVAILABLE_IN_ALL
gboolean pango_font_description_better_match (const PangoFontDescription *desc,
const PangoFontDescription *old_match,
const PangoFontDescription *new_match) G_GNUC_PURE;
PANGO_AVAILABLE_IN_ALL
PangoFontDescription *pango_font_description_from_string (const char *str);
PANGO_AVAILABLE_IN_ALL
char * pango_font_description_to_string (const PangoFontDescription *desc);
PANGO_AVAILABLE_IN_ALL
char * pango_font_description_to_filename (const PangoFontDescription *desc);
/*
* PangoFontMetrics
*/
/**
* PANGO_TYPE_FONT_METRICS:
*
* The #GObject type for #PangoFontMetrics.
*/
#define PANGO_TYPE_FONT_METRICS (pango_font_metrics_get_type ())
PANGO_AVAILABLE_IN_ALL
GType pango_font_metrics_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_ALL
PangoFontMetrics *pango_font_metrics_ref (PangoFontMetrics *metrics);
PANGO_AVAILABLE_IN_ALL
void pango_font_metrics_unref (PangoFontMetrics *metrics);
PANGO_AVAILABLE_IN_ALL
int pango_font_metrics_get_ascent (PangoFontMetrics *metrics) G_GNUC_PURE;
PANGO_AVAILABLE_IN_ALL
int pango_font_metrics_get_descent (PangoFontMetrics *metrics) G_GNUC_PURE;
PANGO_AVAILABLE_IN_ALL
int pango_font_metrics_get_approximate_char_width (PangoFontMetrics *metrics) G_GNUC_PURE;
PANGO_AVAILABLE_IN_ALL
int pango_font_metrics_get_approximate_digit_width (PangoFontMetrics *metrics) G_GNUC_PURE;
PANGO_AVAILABLE_IN_1_6
int pango_font_metrics_get_underline_position (PangoFontMetrics *metrics) G_GNUC_PURE;
PANGO_AVAILABLE_IN_1_6
int pango_font_metrics_get_underline_thickness (PangoFontMetrics *metrics) G_GNUC_PURE;
PANGO_AVAILABLE_IN_1_6
int pango_font_metrics_get_strikethrough_position (PangoFontMetrics *metrics) G_GNUC_PURE;
PANGO_AVAILABLE_IN_1_6
int pango_font_metrics_get_strikethrough_thickness (PangoFontMetrics *metrics) G_GNUC_PURE;
#ifdef PANGO_ENABLE_BACKEND
PANGO_AVAILABLE_IN_ALL
PangoFontMetrics *pango_font_metrics_new (void);
struct _PangoFontMetrics
{
/* <private> */
guint ref_count;
int ascent;
int descent;
int approximate_char_width;
int approximate_digit_width;
int underline_position;
int underline_thickness;
int strikethrough_position;
int strikethrough_thickness;
};
#endif /* PANGO_ENABLE_BACKEND */
/*
* PangoFontFamily
*/
/**
* PANGO_TYPE_FONT_FAMILY:
*
* The #GObject type for #PangoFontFamily.
*/
/**
* PANGO_FONT_FAMILY:
* @object: a #GObject.
*
* Casts a #GObject to a #PangoFontFamily.
*/
/**
* PANGO_IS_FONT_FAMILY:
* @object: a #GObject.
*
* Returns: %TRUE if @object is a #PangoFontFamily.
*/
#define PANGO_TYPE_FONT_FAMILY (pango_font_family_get_type ())
#define PANGO_FONT_FAMILY(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_FAMILY, PangoFontFamily))
#define PANGO_IS_FONT_FAMILY(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_FAMILY))
typedef struct _PangoFontFamily PangoFontFamily;
typedef struct _PangoFontFace PangoFontFace;
PANGO_AVAILABLE_IN_ALL
GType pango_font_family_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_ALL
void pango_font_family_list_faces (PangoFontFamily *family,
PangoFontFace ***faces,
int *n_faces);
PANGO_AVAILABLE_IN_ALL
const char *pango_font_family_get_name (PangoFontFamily *family) G_GNUC_PURE;
PANGO_AVAILABLE_IN_1_4
gboolean pango_font_family_is_monospace (PangoFontFamily *family) G_GNUC_PURE;
#ifdef PANGO_ENABLE_BACKEND
#define PANGO_FONT_FAMILY_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT_FAMILY, PangoFontFamilyClass))
#define PANGO_IS_FONT_FAMILY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT_FAMILY))
#define PANGO_FONT_FAMILY_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT_FAMILY, PangoFontFamilyClass))
typedef struct _PangoFontFamilyClass PangoFontFamilyClass;
/**
* PangoFontFamily:
*
* The #PangoFontFamily structure is used to represent a family of related
* font faces. The faces in a family share a common design, but differ in
* slant, weight, width and other aspects.
*/
struct _PangoFontFamily
{
GObject parent_instance;
};
struct _PangoFontFamilyClass
{
GObjectClass parent_class;
/*< public >*/
void (*list_faces) (PangoFontFamily *family,
PangoFontFace ***faces,
int *n_faces);
const char * (*get_name) (PangoFontFamily *family);
gboolean (*is_monospace) (PangoFontFamily *family);
/*< private >*/
/* Padding for future expansion */
void (*_pango_reserved2) (void);
void (*_pango_reserved3) (void);
void (*_pango_reserved4) (void);
};
#endif /* PANGO_ENABLE_BACKEND */
/*
* PangoFontFace
*/
/**
* PANGO_TYPE_FONT_FACE:
*
* The #GObject type for #PangoFontFace.
*/
/**
* PANGO_FONT_FACE:
* @object: a #GObject.
*
* Casts a #GObject to a #PangoFontFace.
*/
/**
* PANGO_IS_FONT_FACE:
* @object: a #GObject.
*
* Returns: %TRUE if @object is a #PangoFontFace.
*/
#define PANGO_TYPE_FONT_FACE (pango_font_face_get_type ())
#define PANGO_FONT_FACE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_FACE, PangoFontFace))
#define PANGO_IS_FONT_FACE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_FACE))
PANGO_AVAILABLE_IN_ALL
GType pango_font_face_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_ALL
PangoFontDescription *pango_font_face_describe (PangoFontFace *face);
PANGO_AVAILABLE_IN_ALL
const char *pango_font_face_get_face_name (PangoFontFace *face) G_GNUC_PURE;
PANGO_AVAILABLE_IN_1_4
void pango_font_face_list_sizes (PangoFontFace *face,
int **sizes,
int *n_sizes);
PANGO_AVAILABLE_IN_1_18
gboolean pango_font_face_is_synthesized (PangoFontFace *face) G_GNUC_PURE;
#ifdef PANGO_ENABLE_BACKEND
#define PANGO_FONT_FACE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT_FACE, PangoFontFaceClass))
#define PANGO_IS_FONT_FACE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT_FACE))
#define PANGO_FONT_FACE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT_FACE, PangoFontFaceClass))
typedef struct _PangoFontFaceClass PangoFontFaceClass;
/**
* PangoFontFace:
*
* The #PangoFontFace structure is used to represent a group of fonts with
* the same family, slant, weight, width, but varying sizes.
*/
struct _PangoFontFace
{
GObject parent_instance;
};
struct _PangoFontFaceClass
{
GObjectClass parent_class;
/*< public >*/
const char * (*get_face_name) (PangoFontFace *face);
PangoFontDescription * (*describe) (PangoFontFace *face);
void (*list_sizes) (PangoFontFace *face,
int **sizes,
int *n_sizes);
gboolean (*is_synthesized) (PangoFontFace *face);
/*< private >*/
/* Padding for future expansion */
void (*_pango_reserved3) (void);
void (*_pango_reserved4) (void);
};
#endif /* PANGO_ENABLE_BACKEND */
/*
* PangoFont
*/
/**
* PANGO_TYPE_FONT:
*
* The #GObject type for #PangoFont.
*/
/**
* PANGO_FONT:
* @object: a #GObject.
*
* Casts a #GObject to a #PangoFont.
*/
/**
* PANGO_IS_FONT:
* @object: a #GObject.
*
* Returns: %TRUE if @object is a #PangoFont.
*/
#define PANGO_TYPE_FONT (pango_font_get_type ())
#define PANGO_FONT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT, PangoFont))
#define PANGO_IS_FONT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT))
PANGO_AVAILABLE_IN_ALL
GType pango_font_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_ALL
PangoFontDescription *pango_font_describe (PangoFont *font);
PANGO_AVAILABLE_IN_1_14
PangoFontDescription *pango_font_describe_with_absolute_size (PangoFont *font);
PANGO_AVAILABLE_IN_ALL
PangoCoverage * pango_font_get_coverage (PangoFont *font,
PangoLanguage *language);
PANGO_AVAILABLE_IN_ALL
PangoEngineShape * pango_font_find_shaper (PangoFont *font,
PangoLanguage *language,
guint32 ch);
PANGO_AVAILABLE_IN_ALL
PangoFontMetrics * pango_font_get_metrics (PangoFont *font,
PangoLanguage *language);
PANGO_AVAILABLE_IN_ALL
void pango_font_get_glyph_extents (PangoFont *font,
PangoGlyph glyph,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
PANGO_AVAILABLE_IN_1_10
PangoFontMap *pango_font_get_font_map (PangoFont *font);
#ifdef PANGO_ENABLE_BACKEND
#define PANGO_FONT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT, PangoFontClass))
#define PANGO_IS_FONT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT))
#define PANGO_FONT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT, PangoFontClass))
typedef struct _PangoFontClass PangoFontClass;
/**
* PangoFont:
*
* The #PangoFont structure is used to represent
* a font in a rendering-system-independent matter.
* To create an implementation of a #PangoFont,
* the rendering-system specific code should allocate
* a larger structure that contains a nested
* #PangoFont, fill in the <structfield>klass</structfield> member of
* the nested #PangoFont with a pointer to
* a appropriate #PangoFontClass, then call
* pango_font_init() on the structure.
*
* The #PangoFont structure contains one member
* which the implementation fills in.
*/
struct _PangoFont
{
GObject parent_instance;
};
struct _PangoFontClass
{
GObjectClass parent_class;
/*< public >*/
PangoFontDescription *(*describe) (PangoFont *font);
PangoCoverage * (*get_coverage) (PangoFont *font,
PangoLanguage *language);
PangoEngineShape * (*find_shaper) (PangoFont *font,
PangoLanguage *language,
guint32 ch);
void (*get_glyph_extents) (PangoFont *font,
PangoGlyph glyph,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
PangoFontMetrics * (*get_metrics) (PangoFont *font,
PangoLanguage *language);
PangoFontMap * (*get_font_map) (PangoFont *font);
PangoFontDescription *(*describe_absolute) (PangoFont *font);
/*< private >*/
/* Padding for future expansion */
void (*_pango_reserved1) (void);
void (*_pango_reserved2) (void);
};
/* used for very rare and miserable situtations that we cannot even
* draw a hexbox
*/
#define PANGO_UNKNOWN_GLYPH_WIDTH 10
#define PANGO_UNKNOWN_GLYPH_HEIGHT 14
#endif /* PANGO_ENABLE_BACKEND */
/**
* PANGO_GLYPH_EMPTY:
*
* The %PANGO_GLYPH_EMPTY macro represents a #PangoGlyph value that has a
* special meaning, which is a zero-width empty glyph. This is useful for
* example in shaper modules, to use as the glyph for various zero-width
* Unicode characters (those passing pango_is_zero_width()).
*/
/**
* PANGO_GLYPH_INVALID_INPUT:
*
* The %PANGO_GLYPH_INVALID_INPUT macro represents a #PangoGlyph value that has a
* special meaning of invalid input. #PangoLayout produces one such glyph
* per invalid input UTF-8 byte and such a glyph is rendered as a crossed
* box.
*
* Note that this value is defined such that it has the %PANGO_GLYPH_UNKNOWN_FLAG
* on.
*
* Since: 1.20
*/
/**
* PANGO_GLYPH_UNKNOWN_FLAG:
*
* The %PANGO_GLYPH_UNKNOWN_FLAG macro is a flag value that can be added to
* a #gunichar value of a valid Unicode character, to produce a #PangoGlyph
* value, representing an unknown-character glyph for the respective #gunichar.
*/
/**
* PANGO_GET_UNKNOWN_GLYPH:
* @wc: a Unicode character
*
* The way this unknown glyphs are rendered is backend specific. For example,
* a box with the hexadecimal Unicode code-point of the character written in it
* is what is done in the most common backends.
*
* Returns: a #PangoGlyph value that means no glyph was found for @wc.
*/
#define PANGO_GLYPH_EMPTY ((PangoGlyph)0x0FFFFFFF)
#define PANGO_GLYPH_INVALID_INPUT ((PangoGlyph)0xFFFFFFFF)
#define PANGO_GLYPH_UNKNOWN_FLAG ((PangoGlyph)0x10000000)
#define PANGO_GET_UNKNOWN_GLYPH(wc) ((PangoGlyph)(wc)|PANGO_GLYPH_UNKNOWN_FLAG)
G_END_DECLS
#endif /* __PANGO_FONT_H__ */

175
node_modules/sharp/vendor/include/pango/pango-fontmap.h generated vendored Normal file
View File

@ -0,0 +1,175 @@
/* Pango
* pango-font.h: Font handling
*
* Copyright (C) 2000 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_FONTMAP_H__
#define __PANGO_FONTMAP_H__
#include <pango/pango-font.h>
#include <pango/pango-fontset.h>
G_BEGIN_DECLS
/**
* PANGO_TYPE_FONT_MAP:
*
* The #GObject type for #PangoFontMap.
*/
/**
* PANGO_FONT_MAP:
* @object: a #GObject.
*
* Casts a #GObject to a #PangoFontMap.
*/
/**
* PANGO_IS_FONT_MAP:
* @object: a #GObject.
*
* Returns: %TRUE if @object is a #PangoFontMap.
*/
#define PANGO_TYPE_FONT_MAP (pango_font_map_get_type ())
#define PANGO_FONT_MAP(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONT_MAP, PangoFontMap))
#define PANGO_IS_FONT_MAP(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONT_MAP))
typedef struct _PangoContext PangoContext;
PANGO_AVAILABLE_IN_ALL
GType pango_font_map_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_22
PangoContext * pango_font_map_create_context (PangoFontMap *fontmap);
PANGO_AVAILABLE_IN_ALL
PangoFont * pango_font_map_load_font (PangoFontMap *fontmap,
PangoContext *context,
const PangoFontDescription *desc);
PANGO_AVAILABLE_IN_ALL
PangoFontset *pango_font_map_load_fontset (PangoFontMap *fontmap,
PangoContext *context,
const PangoFontDescription *desc,
PangoLanguage *language);
PANGO_AVAILABLE_IN_ALL
void pango_font_map_list_families (PangoFontMap *fontmap,
PangoFontFamily ***families,
int *n_families);
PANGO_AVAILABLE_IN_1_32
guint pango_font_map_get_serial (PangoFontMap *fontmap);
PANGO_AVAILABLE_IN_1_34
void pango_font_map_changed (PangoFontMap *fontmap);
#ifdef PANGO_ENABLE_BACKEND
/**
* PANGO_FONT_MAP_CLASS:
* @klass: a #GObject.
*
* Casts a #GObject to a #PangoFontMapClass.
*/
/**
* PANGO_IS_FONT_MAP_CLASS:
* @klass: a #GObject.
*
* Returns: %TRUE if @klass is a subtype of #PangoFontMapClass.
*/
/**
* PANGO_FONT_MAP_GET_CLASS:
* @obj: a #PangoFontMap.
*
* Returns: class of @obj
*/
#define PANGO_FONT_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONT_MAP, PangoFontMapClass))
#define PANGO_IS_FONT_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONT_MAP))
#define PANGO_FONT_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONT_MAP, PangoFontMapClass))
typedef struct _PangoFontMapClass PangoFontMapClass;
/**
* PangoFontMap:
*
* The #PangoFontMap represents the set of fonts available for a
* particular rendering system. This is a virtual object with
* implementations being specific to particular rendering systems. To
* create an implementation of a #PangoFontMap, the rendering-system
* specific code should allocate a larger structure that contains a nested
* #PangoFontMap, fill in the <structfield>klass</structfield> member of the nested #PangoFontMap with a
* pointer to a appropriate #PangoFontMapClass, then call
* pango_font_map_init() on the structure.
*
* The #PangoFontMap structure contains one member which the implementation
* fills in.
*/
struct _PangoFontMap
{
GObject parent_instance;
};
/**
* PangoFontMapClass:
* @parent_class: parent #GObjectClass.
* @load_font: a function to load a font with a given description. See
* pango_font_map_load_font().
* @list_families: A function to list available font families. See
* pango_font_map_list_families().
* @load_fontset: a function to load a fontset with a given given description
* suitable for a particular language. See pango_font_map_load_fontset().
* @shape_engine_type: the type of rendering-system-dependent engines that
* can handle fonts of this fonts loaded with this fontmap.
* @get_serial: a function to get the serial number of the fontmap.
* See pango_font_map_get_serial().
* @changed: See pango_font_map_changed()
*
* The #PangoFontMapClass structure holds the virtual functions for
* a particular #PangoFontMap implementation.
*/
struct _PangoFontMapClass
{
GObjectClass parent_class;
/*< public >*/
PangoFont * (*load_font) (PangoFontMap *fontmap,
PangoContext *context,
const PangoFontDescription *desc);
void (*list_families) (PangoFontMap *fontmap,
PangoFontFamily ***families,
int *n_families);
PangoFontset *(*load_fontset) (PangoFontMap *fontmap,
PangoContext *context,
const PangoFontDescription *desc,
PangoLanguage *language);
const char *shape_engine_type;
guint (*get_serial) (PangoFontMap *fontmap);
void (*changed) (PangoFontMap *fontmap);
/*< private >*/
/* Padding for future expansion */
void (*_pango_reserved1) (void);
void (*_pango_reserved2) (void);
};
PANGO_DEPRECATED_IN_1_38
const char *pango_font_map_get_shape_engine_type (PangoFontMap *fontmap);
#endif /* PANGO_ENABLE_BACKEND */
G_END_DECLS
#endif /* __PANGO_FONTMAP_H__ */

177
node_modules/sharp/vendor/include/pango/pango-fontset.h generated vendored Normal file
View File

@ -0,0 +1,177 @@
/* Pango
* pango-fontset.h: Font set handling
*
* Copyright (C) 2001 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_FONTSET_H__
#define __PANGO_FONTSET_H__
#include <pango/pango-coverage.h>
#include <pango/pango-types.h>
#include <glib-object.h>
G_BEGIN_DECLS
/*
* PangoFontset
*/
/**
* PANGO_TYPE_FONTSET:
*
* The #GObject type for #PangoFontset.
*/
#define PANGO_TYPE_FONTSET (pango_fontset_get_type ())
#define PANGO_FONTSET(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONTSET, PangoFontset))
#define PANGO_IS_FONTSET(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONTSET))
PANGO_AVAILABLE_IN_ALL
GType pango_fontset_get_type (void) G_GNUC_CONST;
typedef struct _PangoFontset PangoFontset;
/**
* PangoFontsetForeachFunc:
* @fontset: a #PangoFontset
* @font: a font from @fontset
* @user_data: callback data
*
* A callback function used by pango_fontset_foreach() when enumerating
* the fonts in a fontset.
*
* Returns: if %TRUE, stop iteration and return immediately.
*
* Since: 1.4
**/
typedef gboolean (*PangoFontsetForeachFunc) (PangoFontset *fontset,
PangoFont *font,
gpointer user_data);
PANGO_AVAILABLE_IN_ALL
PangoFont * pango_fontset_get_font (PangoFontset *fontset,
guint wc);
PANGO_AVAILABLE_IN_ALL
PangoFontMetrics *pango_fontset_get_metrics (PangoFontset *fontset);
PANGO_AVAILABLE_IN_1_4
void pango_fontset_foreach (PangoFontset *fontset,
PangoFontsetForeachFunc func,
gpointer data);
#ifdef PANGO_ENABLE_BACKEND
typedef struct _PangoFontsetClass PangoFontsetClass;
#define PANGO_FONTSET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FONTSET, PangoFontsetClass))
#define PANGO_IS_FONTSET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FONTSET))
#define PANGO_FONTSET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FONTSET, PangoFontsetClass))
/**
* PangoFontset:
*
* A #PangoFontset represents a set of #PangoFont to use
* when rendering text. It is the result of resolving a
* #PangoFontDescription against a particular #PangoContext.
* It has operations for finding the component font for
* a particular Unicode character, and for finding a composite
* set of metrics for the entire fontset.
*/
struct _PangoFontset
{
GObject parent_instance;
};
/**
* PangoFontsetClass:
* @parent_class: parent #GObjectClass.
* @get_font: a function to get the font in the fontset that contains the
* best glyph for the given Unicode character; see pango_fontset_get_font().
* @get_metrics: a function to get overall metric information for the fonts
* in the fontset; see pango_fontset_get_metrics().
* @get_language: a function to get the language of the fontset.
* @foreach: a function to loop over the fonts in the fontset. See
* pango_fontset_foreach().
*
* The #PangoFontsetClass structure holds the virtual functions for
* a particular #PangoFontset implementation.
*/
struct _PangoFontsetClass
{
GObjectClass parent_class;
/*< public >*/
PangoFont * (*get_font) (PangoFontset *fontset,
guint wc);
PangoFontMetrics *(*get_metrics) (PangoFontset *fontset);
PangoLanguage * (*get_language) (PangoFontset *fontset);
void (*foreach) (PangoFontset *fontset,
PangoFontsetForeachFunc func,
gpointer data);
/*< private >*/
/* Padding for future expansion */
void (*_pango_reserved1) (void);
void (*_pango_reserved2) (void);
void (*_pango_reserved3) (void);
void (*_pango_reserved4) (void);
};
/*
* PangoFontsetSimple
*/
/**
* PANGO_TYPE_FONTSET_SIMPLE:
*
* The #GObject type for #PangoFontsetSimple.
*/
/**
* PangoFontsetSimple:
*
* #PangoFontsetSimple is a implementation of the abstract
* #PangoFontset base class in terms of an array of fonts,
* which the creator provides when constructing the
* #PangoFontsetSimple.
*/
#define PANGO_TYPE_FONTSET_SIMPLE (pango_fontset_simple_get_type ())
#define PANGO_FONTSET_SIMPLE(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FONTSET_SIMPLE, PangoFontsetSimple))
#define PANGO_IS_FONTSET_SIMPLE(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FONTSET_SIMPLE))
typedef struct _PangoFontsetSimple PangoFontsetSimple;
typedef struct _PangoFontsetSimpleClass PangoFontsetSimpleClass;
PANGO_AVAILABLE_IN_ALL
GType pango_fontset_simple_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_ALL
PangoFontsetSimple * pango_fontset_simple_new (PangoLanguage *language);
PANGO_AVAILABLE_IN_ALL
void pango_fontset_simple_append (PangoFontsetSimple *fontset,
PangoFont *font);
PANGO_AVAILABLE_IN_ALL
int pango_fontset_simple_size (PangoFontsetSimple *fontset);
#endif /* PANGO_ENABLE_BACKEND */
G_END_DECLS
#endif /* __PANGO_FONTSET_H__ */

174
node_modules/sharp/vendor/include/pango/pango-glyph-item.h generated vendored Normal file
View File

@ -0,0 +1,174 @@
/* Pango
* pango-glyph-item.h: Pair of PangoItem and a glyph string
*
* Copyright (C) 2002 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_GLYPH_ITEM_H__
#define __PANGO_GLYPH_ITEM_H__
#include <pango/pango-attributes.h>
#include <pango/pango-break.h>
#include <pango/pango-item.h>
#include <pango/pango-glyph.h>
G_BEGIN_DECLS
/**
* PangoGlyphItem:
* @item: corresponding #PangoItem.
* @glyphs: corresponding #PangoGlyphString.
*
* A #PangoGlyphItem is a pair of a #PangoItem and the glyphs
* resulting from shaping the text corresponding to an item.
* As an example of the usage of #PangoGlyphItem, the results
* of shaping text with #PangoLayout is a list of #PangoLayoutLine,
* each of which contains a list of #PangoGlyphItem.
*/
typedef struct _PangoGlyphItem PangoGlyphItem;
struct _PangoGlyphItem
{
PangoItem *item;
PangoGlyphString *glyphs;
};
/**
* PANGO_TYPE_GLYPH_ITEM:
*
* The #GObject type for #PangoGlyphItem.
*/
#define PANGO_TYPE_GLYPH_ITEM (pango_glyph_item_get_type ())
PANGO_AVAILABLE_IN_ALL
GType pango_glyph_item_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_2
PangoGlyphItem *pango_glyph_item_split (PangoGlyphItem *orig,
const char *text,
int split_index);
PANGO_AVAILABLE_IN_1_20
PangoGlyphItem *pango_glyph_item_copy (PangoGlyphItem *orig);
PANGO_AVAILABLE_IN_1_6
void pango_glyph_item_free (PangoGlyphItem *glyph_item);
PANGO_AVAILABLE_IN_1_2
GSList * pango_glyph_item_apply_attrs (PangoGlyphItem *glyph_item,
const char *text,
PangoAttrList *list);
PANGO_AVAILABLE_IN_1_6
void pango_glyph_item_letter_space (PangoGlyphItem *glyph_item,
const char *text,
PangoLogAttr *log_attrs,
int letter_spacing);
PANGO_AVAILABLE_IN_1_26
void pango_glyph_item_get_logical_widths (PangoGlyphItem *glyph_item,
const char *text,
int *logical_widths);
/**
* PangoGlyphItemIter:
*
* A #PangoGlyphItemIter is an iterator over the clusters in a
* #PangoGlyphItem. The <firstterm>forward direction</firstterm> of the
* iterator is the logical direction of text. That is, with increasing
* @start_index and @start_char values. If @glyph_item is right-to-left
* (that is, if <literal>@glyph_item->item->analysis.level</literal> is odd),
* then @start_glyph decreases as the iterator moves forward. Moreover,
* in right-to-left cases, @start_glyph is greater than @end_glyph.
*
* An iterator should be initialized using either of
* pango_glyph_item_iter_init_start() and
* pango_glyph_item_iter_init_end(), for forward and backward iteration
* respectively, and walked over using any desired mixture of
* pango_glyph_item_iter_next_cluster() and
* pango_glyph_item_iter_prev_cluster(). A common idiom for doing a
* forward iteration over the clusters is:
* <programlisting>
* PangoGlyphItemIter cluster_iter;
* gboolean have_cluster;
*
* for (have_cluster = pango_glyph_item_iter_init_start (&amp;cluster_iter,
* glyph_item, text);
* have_cluster;
* have_cluster = pango_glyph_item_iter_next_cluster (&amp;cluster_iter))
* {
* ...
* }
* </programlisting>
*
* Note that @text is the start of the text for layout, which is then
* indexed by <literal>@glyph_item->item->offset</literal> to get to the
* text of @glyph_item. The @start_index and @end_index values can directly
* index into @text. The @start_glyph, @end_glyph, @start_char, and @end_char
* values however are zero-based for the @glyph_item. For each cluster, the
* item pointed at by the start variables is included in the cluster while
* the one pointed at by end variables is not.
*
* None of the members of a #PangoGlyphItemIter should be modified manually.
*
* Since: 1.22
*/
typedef struct _PangoGlyphItemIter PangoGlyphItemIter;
struct _PangoGlyphItemIter
{
PangoGlyphItem *glyph_item;
const gchar *text;
int start_glyph;
int start_index;
int start_char;
int end_glyph;
int end_index;
int end_char;
};
/**
* PANGO_TYPE_GLYPH_ITEM_ITER:
*
* The #GObject type for #PangoGlyphItemIter.
*
* Since: 1.22
*/
#define PANGO_TYPE_GLYPH_ITEM_ITER (pango_glyph_item_iter_get_type ())
PANGO_AVAILABLE_IN_1_22
GType pango_glyph_item_iter_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_22
PangoGlyphItemIter *pango_glyph_item_iter_copy (PangoGlyphItemIter *orig);
PANGO_AVAILABLE_IN_1_22
void pango_glyph_item_iter_free (PangoGlyphItemIter *iter);
PANGO_AVAILABLE_IN_1_22
gboolean pango_glyph_item_iter_init_start (PangoGlyphItemIter *iter,
PangoGlyphItem *glyph_item,
const char *text);
PANGO_AVAILABLE_IN_1_22
gboolean pango_glyph_item_iter_init_end (PangoGlyphItemIter *iter,
PangoGlyphItem *glyph_item,
const char *text);
PANGO_AVAILABLE_IN_1_22
gboolean pango_glyph_item_iter_next_cluster (PangoGlyphItemIter *iter);
PANGO_AVAILABLE_IN_1_22
gboolean pango_glyph_item_iter_prev_cluster (PangoGlyphItemIter *iter);
G_END_DECLS
#endif /* __PANGO_GLYPH_ITEM_H__ */

216
node_modules/sharp/vendor/include/pango/pango-glyph.h generated vendored Normal file
View File

@ -0,0 +1,216 @@
/* Pango
* pango-glyph.h: Glyph storage
*
* Copyright (C) 2000 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_GLYPH_H__
#define __PANGO_GLYPH_H__
#include <pango/pango-types.h>
#include <pango/pango-item.h>
G_BEGIN_DECLS
typedef struct _PangoGlyphGeometry PangoGlyphGeometry;
typedef struct _PangoGlyphVisAttr PangoGlyphVisAttr;
typedef struct _PangoGlyphInfo PangoGlyphInfo;
typedef struct _PangoGlyphString PangoGlyphString;
/* 1024ths of a device unit */
/**
* PangoGlyphUnit:
*
* The #PangoGlyphUnit type is used to store dimensions within
* Pango. Dimensions are stored in 1/%PANGO_SCALE of a device unit.
* (A device unit might be a pixel for screen display, or
* a point on a printer.) %PANGO_SCALE is currently 1024, and
* may change in the future (unlikely though), but you should not
* depend on its exact value. The PANGO_PIXELS() macro can be used
* to convert from glyph units into device units with correct rounding.
*/
typedef gint32 PangoGlyphUnit;
/* Positioning information about a glyph
*/
/**
* PangoGlyphGeometry:
* @width: the logical width to use for the the character.
* @x_offset: horizontal offset from nominal character position.
* @y_offset: vertical offset from nominal character position.
*
* The #PangoGlyphGeometry structure contains width and positioning
* information for a single glyph.
*/
struct _PangoGlyphGeometry
{
PangoGlyphUnit width;
PangoGlyphUnit x_offset;
PangoGlyphUnit y_offset;
};
/* Visual attributes of a glyph
*/
/**
* PangoGlyphVisAttr:
* @is_cluster_start: set for the first logical glyph in each cluster. (Clusters
* are stored in visual order, within the cluster, glyphs
* are always ordered in logical order, since visual
* order is meaningless; that is, in Arabic text, accent glyphs
* follow the glyphs for the base character.)
*
* The PangoGlyphVisAttr is used to communicate information between
* the shaping phase and the rendering phase. More attributes may be
* added in the future.
*/
struct _PangoGlyphVisAttr
{
guint is_cluster_start : 1;
};
/* A single glyph
*/
/**
* PangoGlyphInfo:
* @glyph: the glyph itself.
* @geometry: the positional information about the glyph.
* @attr: the visual attributes of the glyph.
*
* The #PangoGlyphInfo structure represents a single glyph together with
* positioning information and visual attributes.
* It contains the following fields.
*/
struct _PangoGlyphInfo
{
PangoGlyph glyph;
PangoGlyphGeometry geometry;
PangoGlyphVisAttr attr;
};
/* A string of glyphs with positional information and visual attributes -
* ready for drawing
*/
/**
* PangoGlyphString:
* @num_glyphs: number of the glyphs in this glyph string.
* @glyphs: (array length=num_glyphs): array of glyph information
* for the glyph string.
* @log_clusters: logical cluster info, indexed by the byte index
* within the text corresponding to the glyph string.
*
* The #PangoGlyphString structure is used to store strings
* of glyphs with geometry and visual attribute information.
* The storage for the glyph information is owned
* by the structure which simplifies memory management.
*/
struct _PangoGlyphString {
gint num_glyphs;
PangoGlyphInfo *glyphs;
/* This is a memory inefficient way of representing the information
* here - each value gives the byte index within the text
* corresponding to the glyph string of the start of the cluster to
* which the glyph belongs.
*/
gint *log_clusters;
/*< private >*/
gint space;
};
/**
* PANGO_TYPE_GLYPH_STRING:
*
* The #GObject type for #PangoGlyphString.
*/
#define PANGO_TYPE_GLYPH_STRING (pango_glyph_string_get_type ())
PANGO_AVAILABLE_IN_ALL
PangoGlyphString *pango_glyph_string_new (void);
PANGO_AVAILABLE_IN_ALL
void pango_glyph_string_set_size (PangoGlyphString *string,
gint new_len);
PANGO_AVAILABLE_IN_ALL
GType pango_glyph_string_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_ALL
PangoGlyphString *pango_glyph_string_copy (PangoGlyphString *string);
PANGO_AVAILABLE_IN_ALL
void pango_glyph_string_free (PangoGlyphString *string);
PANGO_AVAILABLE_IN_ALL
void pango_glyph_string_extents (PangoGlyphString *glyphs,
PangoFont *font,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
PANGO_AVAILABLE_IN_1_14
int pango_glyph_string_get_width(PangoGlyphString *glyphs);
PANGO_AVAILABLE_IN_ALL
void pango_glyph_string_extents_range (PangoGlyphString *glyphs,
int start,
int end,
PangoFont *font,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
PANGO_AVAILABLE_IN_ALL
void pango_glyph_string_get_logical_widths (PangoGlyphString *glyphs,
const char *text,
int length,
int embedding_level,
int *logical_widths);
PANGO_AVAILABLE_IN_ALL
void pango_glyph_string_index_to_x (PangoGlyphString *glyphs,
char *text,
int length,
PangoAnalysis *analysis,
int index_,
gboolean trailing,
int *x_pos);
PANGO_AVAILABLE_IN_ALL
void pango_glyph_string_x_to_index (PangoGlyphString *glyphs,
char *text,
int length,
PangoAnalysis *analysis,
int x_pos,
int *index_,
int *trailing);
/* Turn a string of characters into a string of glyphs
*/
PANGO_AVAILABLE_IN_ALL
void pango_shape (const gchar *text,
gint length,
const PangoAnalysis *analysis,
PangoGlyphString *glyphs);
PANGO_AVAILABLE_IN_1_32
void pango_shape_full (const gchar *item_text,
gint item_length,
const gchar *paragraph_text,
gint paragraph_length,
const PangoAnalysis *analysis,
PangoGlyphString *glyphs);
PANGO_AVAILABLE_IN_ALL
GList *pango_reorder_items (GList *logical_items);
G_END_DECLS
#endif /* __PANGO_GLYPH_H__ */

132
node_modules/sharp/vendor/include/pango/pango-gravity.h generated vendored Normal file
View File

@ -0,0 +1,132 @@
/* Pango
* pango-gravity.h: Gravity routines
*
* Copyright (C) 2006, 2007 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_GRAVITY_H__
#define __PANGO_GRAVITY_H__
#include <glib.h>
G_BEGIN_DECLS
/**
* PangoGravity:
* @PANGO_GRAVITY_SOUTH: Glyphs stand upright (default)
* @PANGO_GRAVITY_EAST: Glyphs are rotated 90 degrees clockwise
* @PANGO_GRAVITY_NORTH: Glyphs are upside-down
* @PANGO_GRAVITY_WEST: Glyphs are rotated 90 degrees counter-clockwise
* @PANGO_GRAVITY_AUTO: Gravity is resolved from the context matrix
*
* The #PangoGravity type represents the orientation of glyphs in a segment
* of text. This is useful when rendering vertical text layouts. In
* those situations, the layout is rotated using a non-identity PangoMatrix,
* and then glyph orientation is controlled using #PangoGravity.
* Not every value in this enumeration makes sense for every usage of
* #PangoGravity; for example, %PANGO_GRAVITY_AUTO only can be passed to
* pango_context_set_base_gravity() and can only be returned by
* pango_context_get_base_gravity().
*
* See also: #PangoGravityHint
*
* Since: 1.16
**/
typedef enum {
PANGO_GRAVITY_SOUTH,
PANGO_GRAVITY_EAST,
PANGO_GRAVITY_NORTH,
PANGO_GRAVITY_WEST,
PANGO_GRAVITY_AUTO
} PangoGravity;
/**
* PangoGravityHint:
* @PANGO_GRAVITY_HINT_NATURAL: scripts will take their natural gravity based
* on the base gravity and the script. This is the default.
* @PANGO_GRAVITY_HINT_STRONG: always use the base gravity set, regardless of
* the script.
* @PANGO_GRAVITY_HINT_LINE: for scripts not in their natural direction (eg.
* Latin in East gravity), choose per-script gravity such that every script
* respects the line progression. This means, Latin and Arabic will take
* opposite gravities and both flow top-to-bottom for example.
*
* The #PangoGravityHint defines how horizontal scripts should behave in a
* vertical context. That is, English excerpt in a vertical paragraph for
* example.
*
* See #PangoGravity.
*
* Since: 1.16
**/
typedef enum {
PANGO_GRAVITY_HINT_NATURAL,
PANGO_GRAVITY_HINT_STRONG,
PANGO_GRAVITY_HINT_LINE
} PangoGravityHint;
/**
* PANGO_GRAVITY_IS_VERTICAL:
* @gravity: the #PangoGravity to check
*
* Whether a #PangoGravity represents vertical writing directions.
*
* Returns: %TRUE if @gravity is %PANGO_GRAVITY_EAST or %PANGO_GRAVITY_WEST,
* %FALSE otherwise.
*
* Since: 1.16
**/
#define PANGO_GRAVITY_IS_VERTICAL(gravity) \
((gravity) == PANGO_GRAVITY_EAST || (gravity) == PANGO_GRAVITY_WEST)
/**
* PANGO_GRAVITY_IS_IMPROPER:
* @gravity: the #PangoGravity to check
*
* Whether a #PangoGravity represents a gravity that results in reversal of text direction.
*
* Returns: %TRUE if @gravity is %PANGO_GRAVITY_WEST or %PANGO_GRAVITY_NORTH,
* %FALSE otherwise.
*
* Since: 1.32
**/
#define PANGO_GRAVITY_IS_IMPROPER(gravity) \
((gravity) == PANGO_GRAVITY_WEST || (gravity) == PANGO_GRAVITY_NORTH)
#include <pango/pango-matrix.h>
#include <pango/pango-script.h>
PANGO_AVAILABLE_IN_1_16
double pango_gravity_to_rotation (PangoGravity gravity) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_16
PangoGravity pango_gravity_get_for_matrix (const PangoMatrix *matrix) G_GNUC_PURE;
PANGO_AVAILABLE_IN_1_16
PangoGravity pango_gravity_get_for_script (PangoScript script,
PangoGravity base_gravity,
PangoGravityHint hint) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_26
PangoGravity pango_gravity_get_for_script_and_width
(PangoScript script,
gboolean wide,
PangoGravity base_gravity,
PangoGravityHint hint) G_GNUC_CONST;
G_END_DECLS
#endif /* __PANGO_GRAVITY_H__ */

118
node_modules/sharp/vendor/include/pango/pango-item.h generated vendored Normal file
View File

@ -0,0 +1,118 @@
/* Pango
* pango-item.h: Structure for storing run information
*
* Copyright (C) 2000 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_ITEM_H__
#define __PANGO_ITEM_H__
#include <pango/pango-types.h>
G_BEGIN_DECLS
typedef struct _PangoAnalysis PangoAnalysis;
typedef struct _PangoItem PangoItem;
/**
* PANGO_ANALYSIS_FLAG_CENTERED_BASELINE:
*
* Whether the segment should be shifted to center around the baseline.
* Used in vertical writing directions mostly.
*
* Since: 1.16
*/
#define PANGO_ANALYSIS_FLAG_CENTERED_BASELINE (1 << 0)
/**
* PANGO_ANALYSIS_FLAG_IS_ELLIPSIS:
*
* This flag is used to mark runs that hold ellipsized text,
* in an ellipsized layout.
*
* Since: 1.36.7
*/
#define PANGO_ANALYSIS_FLAG_IS_ELLIPSIS (1 << 1)
/**
* PangoAnalysis:
* @shape_engine: the engine for doing rendering-system-dependent processing.
* @lang_engine: the engine for doing rendering-system-independent processing.
* @font: the font for this segment.
* @level: the bidirectional level for this segment.
* @gravity: the glyph orientation for this segment (A #PangoGravity).
* @flags: boolean flags for this segment (currently only one) (Since: 1.16).
* @script: the detected script for this segment (A #PangoScript) (Since: 1.18).
* @language: the detected language for this segment.
* @extra_attrs: extra attributes for this segment.
*
* The #PangoAnalysis structure stores information about
* the properties of a segment of text.
*/
struct _PangoAnalysis
{
PangoEngineShape *shape_engine;
PangoEngineLang *lang_engine;
PangoFont *font;
guint8 level;
guint8 gravity; /* PangoGravity */
guint8 flags;
guint8 script; /* PangoScript */
PangoLanguage *language;
GSList *extra_attrs;
};
/**
* PangoItem:
* @offset: byte offset of the start of this item in text.
* @length: length of this item in bytes.
* @num_chars: number of Unicode characters in the item.
* @analysis: analysis results for the item.
*
* The #PangoItem structure stores information about a segment of text.
*/
struct _PangoItem
{
gint offset;
gint length;
gint num_chars;
PangoAnalysis analysis;
};
#define PANGO_TYPE_ITEM (pango_item_get_type ())
PANGO_AVAILABLE_IN_ALL
GType pango_item_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_ALL
PangoItem *pango_item_new (void);
PANGO_AVAILABLE_IN_ALL
PangoItem *pango_item_copy (PangoItem *item);
PANGO_AVAILABLE_IN_ALL
void pango_item_free (PangoItem *item);
PANGO_AVAILABLE_IN_ALL
PangoItem *pango_item_split (PangoItem *orig,
int split_index,
int split_offset);
G_END_DECLS
#endif /* __PANGO_ITEM_H__ */

71
node_modules/sharp/vendor/include/pango/pango-language.h generated vendored Normal file
View File

@ -0,0 +1,71 @@
/* Pango
* pango-language.h: Language handling routines
*
* Copyright (C) 1999 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_LANGUAGE_H__
#define __PANGO_LANGUAGE_H__
#include <glib.h>
#include <glib-object.h>
#include <pango/pango-version-macros.h>
G_BEGIN_DECLS
typedef struct _PangoLanguage PangoLanguage;
/**
* PANGO_TYPE_LANGUAGE:
*
* The #GObject type for #PangoLanguage.
*/
#define PANGO_TYPE_LANGUAGE (pango_language_get_type ())
PANGO_AVAILABLE_IN_ALL
GType pango_language_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_ALL
PangoLanguage *pango_language_from_string (const char *language);
PANGO_AVAILABLE_IN_ALL
const char *pango_language_to_string (PangoLanguage *language) G_GNUC_CONST;
/* For back compat. Will have to keep indefinitely. */
#define pango_language_to_string(language) ((const char *)language)
PANGO_AVAILABLE_IN_ALL
const char *pango_language_get_sample_string (PangoLanguage *language) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_16
PangoLanguage *pango_language_get_default (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_ALL
gboolean pango_language_matches (PangoLanguage *language,
const char *range_list) G_GNUC_PURE;
#include <pango/pango-script.h>
PANGO_AVAILABLE_IN_1_4
gboolean pango_language_includes_script (PangoLanguage *language,
PangoScript script) G_GNUC_PURE;
PANGO_AVAILABLE_IN_1_22
const PangoScript *pango_language_get_scripts (PangoLanguage *language,
int *num_scripts);
G_END_DECLS
#endif /* __PANGO_LANGUAGE_H__ */

430
node_modules/sharp/vendor/include/pango/pango-layout.h generated vendored Normal file
View File

@ -0,0 +1,430 @@
/* Pango
* pango-layout.h: High-level layout driver
*
* Copyright (C) 2000 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_LAYOUT_H__
#define __PANGO_LAYOUT_H__
#include <pango/pango-attributes.h>
#include <pango/pango-context.h>
#include <pango/pango-glyph-item.h>
#include <pango/pango-tabs.h>
G_BEGIN_DECLS
typedef struct _PangoLayout PangoLayout;
typedef struct _PangoLayoutClass PangoLayoutClass;
typedef struct _PangoLayoutLine PangoLayoutLine;
/**
* PangoLayoutRun:
*
* The #PangoLayoutRun structure represents a single run within
* a #PangoLayoutLine; it is simply an alternate name for
* #PangoGlyphItem.
* See the #PangoGlyphItem docs for details on the fields.
*/
typedef PangoGlyphItem PangoLayoutRun;
/**
* PangoAlignment:
* @PANGO_ALIGN_LEFT: Put all available space on the right
* @PANGO_ALIGN_CENTER: Center the line within the available space
* @PANGO_ALIGN_RIGHT: Put all available space on the left
*
* A #PangoAlignment describes how to align the lines of a #PangoLayout within the
* available space. If the #PangoLayout is set to justify
* using pango_layout_set_justify(), this only has effect for partial lines.
*/
typedef enum {
PANGO_ALIGN_LEFT,
PANGO_ALIGN_CENTER,
PANGO_ALIGN_RIGHT
} PangoAlignment;
/**
* PangoWrapMode:
* @PANGO_WRAP_WORD: wrap lines at word boundaries.
* @PANGO_WRAP_CHAR: wrap lines at character boundaries.
* @PANGO_WRAP_WORD_CHAR: wrap lines at word boundaries, but fall back to character boundaries if there is not
* enough space for a full word.
*
* A #PangoWrapMode describes how to wrap the lines of a #PangoLayout to the desired width.
*/
typedef enum {
PANGO_WRAP_WORD,
PANGO_WRAP_CHAR,
PANGO_WRAP_WORD_CHAR
} PangoWrapMode;
/**
* PangoEllipsizeMode:
* @PANGO_ELLIPSIZE_NONE: No ellipsization
* @PANGO_ELLIPSIZE_START: Omit characters at the start of the text
* @PANGO_ELLIPSIZE_MIDDLE: Omit characters in the middle of the text
* @PANGO_ELLIPSIZE_END: Omit characters at the end of the text
*
* The #PangoEllipsizeMode type describes what sort of (if any)
* ellipsization should be applied to a line of text. In
* the ellipsization process characters are removed from the
* text in order to make it fit to a given width and replaced
* with an ellipsis.
*/
typedef enum {
PANGO_ELLIPSIZE_NONE,
PANGO_ELLIPSIZE_START,
PANGO_ELLIPSIZE_MIDDLE,
PANGO_ELLIPSIZE_END
} PangoEllipsizeMode;
/**
* PangoLayoutLine:
* @layout: (allow-none): the layout this line belongs to, might be %NULL
* @start_index: start of line as byte index into layout->text
* @length: length of line in bytes
* @runs: (allow-none) (element-type Pango.LayoutRun): list of runs in the
* line, from left to right
* @is_paragraph_start: #TRUE if this is the first line of the paragraph
* @resolved_dir: #Resolved PangoDirection of line
*
* The #PangoLayoutLine structure represents one of the lines resulting
* from laying out a paragraph via #PangoLayout. #PangoLayoutLine
* structures are obtained by calling pango_layout_get_line() and
* are only valid until the text, attributes, or settings of the
* parent #PangoLayout are modified.
*
* Routines for rendering PangoLayout objects are provided in
* code specific to each rendering system.
*/
struct _PangoLayoutLine
{
PangoLayout *layout;
gint start_index; /* start of line as byte index into layout->text */
gint length; /* length of line in bytes */
GSList *runs;
guint is_paragraph_start : 1; /* TRUE if this is the first line of the paragraph */
guint resolved_dir : 3; /* Resolved PangoDirection of line */
};
#define PANGO_TYPE_LAYOUT (pango_layout_get_type ())
#define PANGO_LAYOUT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_LAYOUT, PangoLayout))
#define PANGO_LAYOUT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_LAYOUT, PangoLayoutClass))
#define PANGO_IS_LAYOUT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_LAYOUT))
#define PANGO_IS_LAYOUT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_LAYOUT))
#define PANGO_LAYOUT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_LAYOUT, PangoLayoutClass))
/* The PangoLayout and PangoLayoutClass structs are private; if you
* need to create a subclass of these, file a bug.
*/
PANGO_AVAILABLE_IN_ALL
GType pango_layout_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_ALL
PangoLayout *pango_layout_new (PangoContext *context);
PANGO_AVAILABLE_IN_ALL
PangoLayout *pango_layout_copy (PangoLayout *src);
PANGO_AVAILABLE_IN_ALL
PangoContext *pango_layout_get_context (PangoLayout *layout);
PANGO_AVAILABLE_IN_ALL
void pango_layout_set_attributes (PangoLayout *layout,
PangoAttrList *attrs);
PANGO_AVAILABLE_IN_ALL
PangoAttrList *pango_layout_get_attributes (PangoLayout *layout);
PANGO_AVAILABLE_IN_ALL
void pango_layout_set_text (PangoLayout *layout,
const char *text,
int length);
PANGO_AVAILABLE_IN_ALL
const char *pango_layout_get_text (PangoLayout *layout);
PANGO_AVAILABLE_IN_1_30
gint pango_layout_get_character_count (PangoLayout *layout);
PANGO_AVAILABLE_IN_ALL
void pango_layout_set_markup (PangoLayout *layout,
const char *markup,
int length);
PANGO_AVAILABLE_IN_ALL
void pango_layout_set_markup_with_accel (PangoLayout *layout,
const char *markup,
int length,
gunichar accel_marker,
gunichar *accel_char);
PANGO_AVAILABLE_IN_ALL
void pango_layout_set_font_description (PangoLayout *layout,
const PangoFontDescription *desc);
PANGO_AVAILABLE_IN_1_8
const PangoFontDescription *pango_layout_get_font_description (PangoLayout *layout);
PANGO_AVAILABLE_IN_ALL
void pango_layout_set_width (PangoLayout *layout,
int width);
PANGO_AVAILABLE_IN_ALL
int pango_layout_get_width (PangoLayout *layout);
PANGO_AVAILABLE_IN_1_20
void pango_layout_set_height (PangoLayout *layout,
int height);
PANGO_AVAILABLE_IN_1_20
int pango_layout_get_height (PangoLayout *layout);
PANGO_AVAILABLE_IN_ALL
void pango_layout_set_wrap (PangoLayout *layout,
PangoWrapMode wrap);
PANGO_AVAILABLE_IN_ALL
PangoWrapMode pango_layout_get_wrap (PangoLayout *layout);
PANGO_AVAILABLE_IN_1_16
gboolean pango_layout_is_wrapped (PangoLayout *layout);
PANGO_AVAILABLE_IN_ALL
void pango_layout_set_indent (PangoLayout *layout,
int indent);
PANGO_AVAILABLE_IN_ALL
int pango_layout_get_indent (PangoLayout *layout);
PANGO_AVAILABLE_IN_ALL
void pango_layout_set_spacing (PangoLayout *layout,
int spacing);
PANGO_AVAILABLE_IN_ALL
int pango_layout_get_spacing (PangoLayout *layout);
PANGO_AVAILABLE_IN_ALL
void pango_layout_set_justify (PangoLayout *layout,
gboolean justify);
PANGO_AVAILABLE_IN_ALL
gboolean pango_layout_get_justify (PangoLayout *layout);
PANGO_AVAILABLE_IN_1_4
void pango_layout_set_auto_dir (PangoLayout *layout,
gboolean auto_dir);
PANGO_AVAILABLE_IN_1_4
gboolean pango_layout_get_auto_dir (PangoLayout *layout);
PANGO_AVAILABLE_IN_ALL
void pango_layout_set_alignment (PangoLayout *layout,
PangoAlignment alignment);
PANGO_AVAILABLE_IN_ALL
PangoAlignment pango_layout_get_alignment (PangoLayout *layout);
PANGO_AVAILABLE_IN_ALL
void pango_layout_set_tabs (PangoLayout *layout,
PangoTabArray *tabs);
PANGO_AVAILABLE_IN_ALL
PangoTabArray* pango_layout_get_tabs (PangoLayout *layout);
PANGO_AVAILABLE_IN_ALL
void pango_layout_set_single_paragraph_mode (PangoLayout *layout,
gboolean setting);
PANGO_AVAILABLE_IN_ALL
gboolean pango_layout_get_single_paragraph_mode (PangoLayout *layout);
PANGO_AVAILABLE_IN_1_6
void pango_layout_set_ellipsize (PangoLayout *layout,
PangoEllipsizeMode ellipsize);
PANGO_AVAILABLE_IN_1_6
PangoEllipsizeMode pango_layout_get_ellipsize (PangoLayout *layout);
PANGO_AVAILABLE_IN_1_16
gboolean pango_layout_is_ellipsized (PangoLayout *layout);
PANGO_AVAILABLE_IN_1_16
int pango_layout_get_unknown_glyphs_count (PangoLayout *layout);
PANGO_AVAILABLE_IN_ALL
void pango_layout_context_changed (PangoLayout *layout);
PANGO_AVAILABLE_IN_1_32
guint pango_layout_get_serial (PangoLayout *layout);
PANGO_AVAILABLE_IN_ALL
void pango_layout_get_log_attrs (PangoLayout *layout,
PangoLogAttr **attrs,
gint *n_attrs);
PANGO_AVAILABLE_IN_1_30
const PangoLogAttr *pango_layout_get_log_attrs_readonly (PangoLayout *layout,
gint *n_attrs);
PANGO_AVAILABLE_IN_ALL
void pango_layout_index_to_pos (PangoLayout *layout,
int index_,
PangoRectangle *pos);
PANGO_AVAILABLE_IN_ALL
void pango_layout_index_to_line_x (PangoLayout *layout,
int index_,
gboolean trailing,
int *line,
int *x_pos);
PANGO_AVAILABLE_IN_ALL
void pango_layout_get_cursor_pos (PangoLayout *layout,
int index_,
PangoRectangle *strong_pos,
PangoRectangle *weak_pos);
PANGO_AVAILABLE_IN_ALL
void pango_layout_move_cursor_visually (PangoLayout *layout,
gboolean strong,
int old_index,
int old_trailing,
int direction,
int *new_index,
int *new_trailing);
PANGO_AVAILABLE_IN_ALL
gboolean pango_layout_xy_to_index (PangoLayout *layout,
int x,
int y,
int *index_,
int *trailing);
PANGO_AVAILABLE_IN_ALL
void pango_layout_get_extents (PangoLayout *layout,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
PANGO_AVAILABLE_IN_ALL
void pango_layout_get_pixel_extents (PangoLayout *layout,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
PANGO_AVAILABLE_IN_ALL
void pango_layout_get_size (PangoLayout *layout,
int *width,
int *height);
PANGO_AVAILABLE_IN_ALL
void pango_layout_get_pixel_size (PangoLayout *layout,
int *width,
int *height);
PANGO_AVAILABLE_IN_1_22
int pango_layout_get_baseline (PangoLayout *layout);
PANGO_AVAILABLE_IN_ALL
int pango_layout_get_line_count (PangoLayout *layout);
PANGO_AVAILABLE_IN_ALL
PangoLayoutLine *pango_layout_get_line (PangoLayout *layout,
int line);
PANGO_AVAILABLE_IN_1_16
PangoLayoutLine *pango_layout_get_line_readonly (PangoLayout *layout,
int line);
PANGO_AVAILABLE_IN_ALL
GSList * pango_layout_get_lines (PangoLayout *layout);
PANGO_AVAILABLE_IN_1_16
GSList * pango_layout_get_lines_readonly (PangoLayout *layout);
#define PANGO_TYPE_LAYOUT_LINE (pango_layout_line_get_type ())
PANGO_AVAILABLE_IN_ALL
GType pango_layout_line_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_10
PangoLayoutLine *pango_layout_line_ref (PangoLayoutLine *line);
PANGO_AVAILABLE_IN_ALL
void pango_layout_line_unref (PangoLayoutLine *line);
PANGO_AVAILABLE_IN_ALL
gboolean pango_layout_line_x_to_index (PangoLayoutLine *line,
int x_pos,
int *index_,
int *trailing);
PANGO_AVAILABLE_IN_ALL
void pango_layout_line_index_to_x (PangoLayoutLine *line,
int index_,
gboolean trailing,
int *x_pos);
PANGO_AVAILABLE_IN_ALL
void pango_layout_line_get_x_ranges (PangoLayoutLine *line,
int start_index,
int end_index,
int **ranges,
int *n_ranges);
PANGO_AVAILABLE_IN_ALL
void pango_layout_line_get_extents (PangoLayoutLine *line,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
PANGO_AVAILABLE_IN_ALL
void pango_layout_line_get_pixel_extents (PangoLayoutLine *layout_line,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
typedef struct _PangoLayoutIter PangoLayoutIter;
#define PANGO_TYPE_LAYOUT_ITER (pango_layout_iter_get_type ())
PANGO_AVAILABLE_IN_ALL
GType pango_layout_iter_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_ALL
PangoLayoutIter *pango_layout_get_iter (PangoLayout *layout);
PANGO_AVAILABLE_IN_1_20
PangoLayoutIter *pango_layout_iter_copy (PangoLayoutIter *iter);
PANGO_AVAILABLE_IN_ALL
void pango_layout_iter_free (PangoLayoutIter *iter);
PANGO_AVAILABLE_IN_ALL
int pango_layout_iter_get_index (PangoLayoutIter *iter);
PANGO_AVAILABLE_IN_ALL
PangoLayoutRun *pango_layout_iter_get_run (PangoLayoutIter *iter);
PANGO_AVAILABLE_IN_1_16
PangoLayoutRun *pango_layout_iter_get_run_readonly (PangoLayoutIter *iter);
PANGO_AVAILABLE_IN_ALL
PangoLayoutLine *pango_layout_iter_get_line (PangoLayoutIter *iter);
PANGO_AVAILABLE_IN_1_16
PangoLayoutLine *pango_layout_iter_get_line_readonly (PangoLayoutIter *iter);
PANGO_AVAILABLE_IN_ALL
gboolean pango_layout_iter_at_last_line (PangoLayoutIter *iter);
PANGO_AVAILABLE_IN_1_20
PangoLayout *pango_layout_iter_get_layout (PangoLayoutIter *iter);
PANGO_AVAILABLE_IN_ALL
gboolean pango_layout_iter_next_char (PangoLayoutIter *iter);
PANGO_AVAILABLE_IN_ALL
gboolean pango_layout_iter_next_cluster (PangoLayoutIter *iter);
PANGO_AVAILABLE_IN_ALL
gboolean pango_layout_iter_next_run (PangoLayoutIter *iter);
PANGO_AVAILABLE_IN_ALL
gboolean pango_layout_iter_next_line (PangoLayoutIter *iter);
PANGO_AVAILABLE_IN_ALL
void pango_layout_iter_get_char_extents (PangoLayoutIter *iter,
PangoRectangle *logical_rect);
PANGO_AVAILABLE_IN_ALL
void pango_layout_iter_get_cluster_extents (PangoLayoutIter *iter,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
PANGO_AVAILABLE_IN_ALL
void pango_layout_iter_get_run_extents (PangoLayoutIter *iter,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
PANGO_AVAILABLE_IN_ALL
void pango_layout_iter_get_line_extents (PangoLayoutIter *iter,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
/* All the yranges meet, unlike the logical_rect's (i.e. the yranges
* assign between-line spacing to the nearest line)
*/
PANGO_AVAILABLE_IN_ALL
void pango_layout_iter_get_line_yrange (PangoLayoutIter *iter,
int *y0_,
int *y1_);
PANGO_AVAILABLE_IN_ALL
void pango_layout_iter_get_layout_extents (PangoLayoutIter *iter,
PangoRectangle *ink_rect,
PangoRectangle *logical_rect);
PANGO_AVAILABLE_IN_ALL
int pango_layout_iter_get_baseline (PangoLayoutIter *iter);
G_END_DECLS
#endif /* __PANGO_LAYOUT_H__ */

132
node_modules/sharp/vendor/include/pango/pango-matrix.h generated vendored Normal file
View File

@ -0,0 +1,132 @@
/* Pango
* pango-matrix.h: Matrix manipulation routines
*
* Copyright (C) 2002, 2006 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_MATRIX_H__
#define __PANGO_MATRIX_H__
#include <glib.h>
#include <glib-object.h>
G_BEGIN_DECLS
typedef struct _PangoMatrix PangoMatrix;
/**
* PangoMatrix:
* @xx: 1st component of the transformation matrix
* @xy: 2nd component of the transformation matrix
* @yx: 3rd component of the transformation matrix
* @yy: 4th component of the transformation matrix
* @x0: x translation
* @y0: y translation
*
* A structure specifying a transformation between user-space
* coordinates and device coordinates. The transformation
* is given by
*
* <programlisting>
* x_device = x_user * matrix->xx + y_user * matrix->xy + matrix->x0;
* y_device = x_user * matrix->yx + y_user * matrix->yy + matrix->y0;
* </programlisting>
*
* Since: 1.6
**/
struct _PangoMatrix
{
double xx;
double xy;
double yx;
double yy;
double x0;
double y0;
};
/**
* PANGO_TYPE_MATRIX:
*
* The GObject type for #PangoMatrix
**/
#define PANGO_TYPE_MATRIX (pango_matrix_get_type ())
/**
* PANGO_MATRIX_INIT:
*
* Constant that can be used to initialize a PangoMatrix to
* the identity transform.
*
* <informalexample><programlisting>
* PangoMatrix matrix = PANGO_MATRIX_INIT;
* pango_matrix_rotate (&amp;matrix, 45.);
* </programlisting></informalexample>
*
* Since: 1.6
**/
#define PANGO_MATRIX_INIT { 1., 0., 0., 1., 0., 0. }
/* for PangoRectangle */
#include <pango/pango-types.h>
PANGO_AVAILABLE_IN_1_6
GType pango_matrix_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_6
PangoMatrix *pango_matrix_copy (const PangoMatrix *matrix);
PANGO_AVAILABLE_IN_1_6
void pango_matrix_free (PangoMatrix *matrix);
PANGO_AVAILABLE_IN_1_6
void pango_matrix_translate (PangoMatrix *matrix,
double tx,
double ty);
PANGO_AVAILABLE_IN_1_6
void pango_matrix_scale (PangoMatrix *matrix,
double scale_x,
double scale_y);
PANGO_AVAILABLE_IN_1_6
void pango_matrix_rotate (PangoMatrix *matrix,
double degrees);
PANGO_AVAILABLE_IN_1_6
void pango_matrix_concat (PangoMatrix *matrix,
const PangoMatrix *new_matrix);
PANGO_AVAILABLE_IN_1_16
void pango_matrix_transform_point (const PangoMatrix *matrix,
double *x,
double *y);
PANGO_AVAILABLE_IN_1_16
void pango_matrix_transform_distance (const PangoMatrix *matrix,
double *dx,
double *dy);
PANGO_AVAILABLE_IN_1_16
void pango_matrix_transform_rectangle (const PangoMatrix *matrix,
PangoRectangle *rect);
PANGO_AVAILABLE_IN_1_16
void pango_matrix_transform_pixel_rectangle (const PangoMatrix *matrix,
PangoRectangle *rect);
PANGO_AVAILABLE_IN_1_12
double pango_matrix_get_font_scale_factor (const PangoMatrix *matrix) G_GNUC_PURE;
PANGO_AVAILABLE_IN_1_38
void pango_matrix_get_font_scale_factors (const PangoMatrix *matrix,
double *xscale, double *yscale);
G_END_DECLS
#endif /* __PANGO_MATRIX_H__ */

77
node_modules/sharp/vendor/include/pango/pango-modules.h generated vendored Normal file
View File

@ -0,0 +1,77 @@
/* Pango
* pango-modules.h:
*
* Copyright (C) 1999 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_MODULES_H__
#define __PANGO_MODULES_H__
#include <pango/pango-engine.h>
G_BEGIN_DECLS
#ifdef PANGO_ENABLE_BACKEND
typedef struct _PangoMap PangoMap;
typedef struct _PangoMapEntry PangoMapEntry;
typedef struct _PangoIncludedModule PangoIncludedModule;
/**
* PangoIncludedModule:
* @list: a function that lists the engines defined in this module.
* @init: a function to initialize the module.
* @exit: a function to finalize the module.
* @create: a function to create an engine, given the engine name.
*
* The #PangoIncludedModule structure for a statically linked module
* contains the functions that would otherwise be loaded from a dynamically
* loaded module.
*
* Deprecated: 1.38
*/
struct _PangoIncludedModule
{
void (*list) (PangoEngineInfo **engines,
int *n_engines);
void (*init) (GTypeModule *module);
void (*exit) (void);
PangoEngine *(*create) (const char *id);
};
PANGO_DEPRECATED_IN_1_38
PangoMap * pango_find_map (PangoLanguage *language,
guint engine_type_id,
guint render_type_id);
PANGO_DEPRECATED_IN_1_38
PangoEngine * pango_map_get_engine (PangoMap *map,
PangoScript script);
PANGO_DEPRECATED_IN_1_38
void pango_map_get_engines (PangoMap *map,
PangoScript script,
GSList **exact_engines,
GSList **fallback_engines);
PANGO_DEPRECATED_IN_1_38
void pango_module_register (PangoIncludedModule *module);
#endif /* PANGO_ENABLE_BACKEND */
G_END_DECLS
#endif /* __PANGO_MODULES_H__ */

396
node_modules/sharp/vendor/include/pango/pango-ot.h generated vendored Normal file
View File

@ -0,0 +1,396 @@
/* Pango
* pango-ot.h:
*
* Copyright (C) 2000,2007 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_OT_H__
#define __PANGO_OT_H__
/* Deprecated. Use HarfBuzz directly! */
#include <pango/pangofc-font.h>
#include <pango/pango-glyph.h>
#include <pango/pango-font.h>
#include <pango/pango-script.h>
#include <pango/pango-language.h>
G_BEGIN_DECLS
#ifdef PANGO_ENABLE_ENGINE
/**
* PangoOTTag:
*
* The #PangoOTTag typedef is used to represent TrueType and OpenType
* four letter tags inside Pango. Use PANGO_OT_TAG_MAKE()
* or PANGO_OT_TAG_MAKE_FROM_STRING() macros to create <type>PangoOTTag</type>s manually.
*/
typedef guint32 PangoOTTag;
/**
* PANGO_OT_TAG_MAKE:
* @c1: First character.
* @c2: Second character.
* @c3: Third character.
* @c4: Fourth character.
*
* Creates a #PangoOTTag from four characters. This is similar and
* compatible with the <function>FT_MAKE_TAG()</function> macro from FreeType.
*/
/**
* PANGO_OT_TAG_MAKE_FROM_STRING:
* @s: The string representation of the tag.
*
* Creates a #PangoOTTag from a string. The string should be at least
* four characters long (pad with space characters if needed), and need
* not be nul-terminated. This is a convenience wrapper around
* PANGO_OT_TAG_MAKE(), but cannot be used in certain situations, for
* example, as a switch expression, as it dereferences pointers.
*/
#define PANGO_OT_TAG_MAKE(c1,c2,c3,c4) ((PangoOTTag) FT_MAKE_TAG (c1, c2, c3, c4))
#define PANGO_OT_TAG_MAKE_FROM_STRING(s) (PANGO_OT_TAG_MAKE(((const char *) s)[0], \
((const char *) s)[1], \
((const char *) s)[2], \
((const char *) s)[3]))
typedef struct _PangoOTInfo PangoOTInfo;
typedef struct _PangoOTBuffer PangoOTBuffer;
typedef struct _PangoOTGlyph PangoOTGlyph;
typedef struct _PangoOTRuleset PangoOTRuleset;
typedef struct _PangoOTFeatureMap PangoOTFeatureMap;
typedef struct _PangoOTRulesetDescription PangoOTRulesetDescription;
/**
* PangoOTTableType:
* @PANGO_OT_TABLE_GSUB: The GSUB table.
* @PANGO_OT_TABLE_GPOS: The GPOS table.
*
* The <type>PangoOTTableType</type> enumeration values are used to
* identify the various OpenType tables in the
* <function>pango_ot_info_*</function> functions.
*/
typedef enum
{
PANGO_OT_TABLE_GSUB,
PANGO_OT_TABLE_GPOS
} PangoOTTableType;
/**
* PANGO_OT_ALL_GLYPHS:
*
* This is used as the property bit in pango_ot_ruleset_add_feature() when a
* feature should be applied to all glyphs.
*
* Since: 1.16
*/
/**
* PANGO_OT_NO_FEATURE:
*
* This is used as a feature index that represent no feature, that is, should be
* skipped. It may be returned as feature index by pango_ot_info_find_feature()
* if the feature is not found, and pango_ot_ruleset_add_feature() function
* automatically skips this value, so no special handling is required by the user.
*
* Since: 1.18
*/
/**
* PANGO_OT_NO_SCRIPT:
*
* This is used as a script index that represent no script, that is, when the
* requested script was not found, and a default ('DFLT') script was not found
* either. It may be returned as script index by pango_ot_info_find_script()
* if the script or a default script are not found, all other functions
* taking a script index essentially return if the input script index is
* this value, so no special handling is required by the user.
*
* Since: 1.18
*/
/**
* PANGO_OT_DEFAULT_LANGUAGE:
*
* This is used as the language index in pango_ot_info_find_feature() when
* the default language system of the script is desired.
*
* It is also returned by pango_ot_info_find_language() if the requested language
* is not found, or the requested language tag was PANGO_OT_TAG_DEFAULT_LANGUAGE.
* The end result is that one can always call pango_ot_tag_from_language()
* followed by pango_ot_info_find_language() and pass the result to
* pango_ot_info_find_feature() without having to worry about falling back to
* default language system explicitly.
*
* Since: 1.16
*/
#define PANGO_OT_ALL_GLYPHS ((guint) 0xFFFF)
#define PANGO_OT_NO_FEATURE ((guint) 0xFFFF)
#define PANGO_OT_NO_SCRIPT ((guint) 0xFFFF)
#define PANGO_OT_DEFAULT_LANGUAGE ((guint) 0xFFFF)
/**
* PANGO_OT_TAG_DEFAULT_SCRIPT:
*
* This is a #PangoOTTag representing the special script tag 'DFLT'. It is
* returned as script tag by pango_ot_tag_from_script() if the requested script
* is not found.
*
* Since: 1.18
*/
/**
* PANGO_OT_TAG_DEFAULT_LANGUAGE:
*
* This is a #PangoOTTag representing a special language tag 'dflt'. It is
* returned as language tag by pango_ot_tag_from_language() if the requested
* language is not found. It is safe to pass this value to
* pango_ot_info_find_language() as that function falls back to returning default
* language-system if the requested language tag is not found.
*
* Since: 1.18
*/
#define PANGO_OT_TAG_DEFAULT_SCRIPT PANGO_OT_TAG_MAKE ('D', 'F', 'L', 'T')
#define PANGO_OT_TAG_DEFAULT_LANGUAGE PANGO_OT_TAG_MAKE ('d', 'f', 'l', 't')
/* Note that this must match hb_glyph_info_t */
/**
* PangoOTGlyph:
* @glyph: the glyph itself.
* @properties: the properties value, identifying which features should be
* applied on this glyph. See pango_ot_ruleset_add_feature().
* @cluster: the cluster that this glyph belongs to.
* @component: a component value, set by the OpenType layout engine.
* @ligID: a ligature index value, set by the OpenType layout engine.
* @internal: for Pango internal use
*
* The #PangoOTGlyph structure represents a single glyph together with
* information used for OpenType layout processing of the glyph.
* It contains the following fields.
*/
struct _PangoOTGlyph
{
guint32 glyph;
guint properties;
guint cluster;
gushort component;
gushort ligID;
guint internal;
};
/**
* PangoOTFeatureMap:
* @feature_name: feature tag in represented as four-letter ASCII string.
* @property_bit: the property bit to use for this feature. See
* pango_ot_ruleset_add_feature() for details.
*
* The #PangoOTFeatureMap typedef is used to represent an OpenType
* feature with the property bit associated with it. The feature tag is
* represented as a char array instead of a #PangoOTTag for convenience.
*
* Since: 1.18
*/
struct _PangoOTFeatureMap
{
char feature_name[5];
gulong property_bit;
};
/**
* PangoOTRulesetDescription:
* @script: a #PangoScript.
* @language: a #PangoLanguage.
* @static_gsub_features: (nullable): static map of GSUB features,
* or %NULL.
* @n_static_gsub_features: length of @static_gsub_features, or 0.
* @static_gpos_features: (nullable): static map of GPOS features,
* or %NULL.
* @n_static_gpos_features: length of @static_gpos_features, or 0.
* @other_features: (nullable): map of extra features to add to both
* GSUB and GPOS, or %NULL. Unlike the static maps, this pointer
* need not live beyond the life of function calls taking this
* struct.
* @n_other_features: length of @other_features, or 0.
*
* The #PangoOTRuleset structure holds all the information needed
* to build a complete #PangoOTRuleset from an OpenType font.
* The main use of this struct is to act as the key for a per-font
* hash of rulesets. The user populates a ruleset description and
* gets the ruleset using pango_ot_ruleset_get_for_description()
* or create a new one using pango_ot_ruleset_new_from_description().
*
* Since: 1.18
*/
struct _PangoOTRulesetDescription {
PangoScript script;
PangoLanguage *language;
const PangoOTFeatureMap *static_gsub_features;
guint n_static_gsub_features;
const PangoOTFeatureMap *static_gpos_features;
guint n_static_gpos_features;
const PangoOTFeatureMap *other_features;
guint n_other_features;
};
#define PANGO_TYPE_OT_INFO (pango_ot_info_get_type ())
#define PANGO_OT_INFO(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_OT_INFO, PangoOTInfo))
#define PANGO_IS_OT_INFO(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_OT_INFO))
PANGO_DEPRECATED
GType pango_ot_info_get_type (void) G_GNUC_CONST;
#define PANGO_TYPE_OT_RULESET (pango_ot_ruleset_get_type ())
#define PANGO_OT_RULESET(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_OT_RULESET, PangoOTRuleset))
#define PANGO_IS_OT_RULESET(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_OT_RULESET))
PANGO_DEPRECATED
GType pango_ot_ruleset_get_type (void) G_GNUC_CONST;
PANGO_DEPRECATED
PangoOTInfo *pango_ot_info_get (FT_Face face);
PANGO_DEPRECATED
gboolean pango_ot_info_find_script (PangoOTInfo *info,
PangoOTTableType table_type,
PangoOTTag script_tag,
guint *script_index);
PANGO_DEPRECATED
gboolean pango_ot_info_find_language (PangoOTInfo *info,
PangoOTTableType table_type,
guint script_index,
PangoOTTag language_tag,
guint *language_index,
guint *required_feature_index);
PANGO_DEPRECATED
gboolean pango_ot_info_find_feature (PangoOTInfo *info,
PangoOTTableType table_type,
PangoOTTag feature_tag,
guint script_index,
guint language_index,
guint *feature_index);
PANGO_DEPRECATED
PangoOTTag *pango_ot_info_list_scripts (PangoOTInfo *info,
PangoOTTableType table_type);
PANGO_DEPRECATED
PangoOTTag *pango_ot_info_list_languages (PangoOTInfo *info,
PangoOTTableType table_type,
guint script_index,
PangoOTTag language_tag);
PANGO_DEPRECATED
PangoOTTag *pango_ot_info_list_features (PangoOTInfo *info,
PangoOTTableType table_type,
PangoOTTag tag,
guint script_index,
guint language_index);
PANGO_DEPRECATED
PangoOTBuffer *pango_ot_buffer_new (PangoFcFont *font);
PANGO_DEPRECATED
void pango_ot_buffer_destroy (PangoOTBuffer *buffer);
PANGO_DEPRECATED
void pango_ot_buffer_clear (PangoOTBuffer *buffer);
PANGO_DEPRECATED
void pango_ot_buffer_set_rtl (PangoOTBuffer *buffer,
gboolean rtl);
PANGO_DEPRECATED
void pango_ot_buffer_add_glyph (PangoOTBuffer *buffer,
guint glyph,
guint properties,
guint cluster);
PANGO_DEPRECATED
void pango_ot_buffer_get_glyphs (const PangoOTBuffer *buffer,
PangoOTGlyph **glyphs,
int *n_glyphs);
PANGO_DEPRECATED
void pango_ot_buffer_output (const PangoOTBuffer *buffer,
PangoGlyphString *glyphs);
PANGO_DEPRECATED
void pango_ot_buffer_set_zero_width_marks (PangoOTBuffer *buffer,
gboolean zero_width_marks);
PANGO_DEPRECATED
const PangoOTRuleset *pango_ot_ruleset_get_for_description (PangoOTInfo *info,
const PangoOTRulesetDescription *desc);
PANGO_DEPRECATED
PangoOTRuleset *pango_ot_ruleset_new (PangoOTInfo *info);
PANGO_DEPRECATED
PangoOTRuleset *pango_ot_ruleset_new_for (PangoOTInfo *info,
PangoScript script,
PangoLanguage *language);
PANGO_DEPRECATED
PangoOTRuleset *pango_ot_ruleset_new_from_description (PangoOTInfo *info,
const PangoOTRulesetDescription *desc);
PANGO_DEPRECATED
void pango_ot_ruleset_add_feature (PangoOTRuleset *ruleset,
PangoOTTableType table_type,
guint feature_index,
gulong property_bit);
PANGO_DEPRECATED
gboolean pango_ot_ruleset_maybe_add_feature (PangoOTRuleset *ruleset,
PangoOTTableType table_type,
PangoOTTag feature_tag,
gulong property_bit);
PANGO_DEPRECATED
guint pango_ot_ruleset_maybe_add_features (PangoOTRuleset *ruleset,
PangoOTTableType table_type,
const PangoOTFeatureMap *features,
guint n_features);
PANGO_DEPRECATED
guint pango_ot_ruleset_get_feature_count (const PangoOTRuleset *ruleset,
guint *n_gsub_features,
guint *n_gpos_features);
PANGO_DEPRECATED
void pango_ot_ruleset_substitute (const PangoOTRuleset *ruleset,
PangoOTBuffer *buffer);
PANGO_DEPRECATED
void pango_ot_ruleset_position (const PangoOTRuleset *ruleset,
PangoOTBuffer *buffer);
PANGO_DEPRECATED
PangoScript pango_ot_tag_to_script (PangoOTTag script_tag) G_GNUC_CONST;
PANGO_DEPRECATED
PangoOTTag pango_ot_tag_from_script (PangoScript script) G_GNUC_CONST;
PANGO_DEPRECATED
PangoLanguage *pango_ot_tag_to_language (PangoOTTag language_tag) G_GNUC_CONST;
PANGO_DEPRECATED
PangoOTTag pango_ot_tag_from_language (PangoLanguage *language) G_GNUC_CONST;
PANGO_DEPRECATED
guint pango_ot_ruleset_description_hash (const PangoOTRulesetDescription *desc) G_GNUC_PURE;
PANGO_DEPRECATED
gboolean pango_ot_ruleset_description_equal (const PangoOTRulesetDescription *desc1,
const PangoOTRulesetDescription *desc2) G_GNUC_PURE;
PANGO_DEPRECATED
PangoOTRulesetDescription *pango_ot_ruleset_description_copy (const PangoOTRulesetDescription *desc);
PANGO_DEPRECATED
void pango_ot_ruleset_description_free (PangoOTRulesetDescription *desc);
#endif /* PANGO_ENABLE_ENGINE */
G_END_DECLS
#endif /* __PANGO_OT_H__ */

287
node_modules/sharp/vendor/include/pango/pango-renderer.h generated vendored Normal file
View File

@ -0,0 +1,287 @@
/* Pango
* pango-renderer.h: Base class for rendering
*
* Copyright (C) 2004, Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_RENDERER_H_
#define __PANGO_RENDERER_H_
#include <pango/pango-layout.h>
G_BEGIN_DECLS
#define PANGO_TYPE_RENDERER (pango_renderer_get_type())
#define PANGO_RENDERER(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_RENDERER, PangoRenderer))
#define PANGO_IS_RENDERER(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_RENDERER))
#define PANGO_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_RENDERER, PangoRendererClass))
#define PANGO_IS_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_RENDERER))
#define PANGO_RENDERER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_RENDERER, PangoRendererClass))
typedef struct _PangoRenderer PangoRenderer;
typedef struct _PangoRendererClass PangoRendererClass;
typedef struct _PangoRendererPrivate PangoRendererPrivate;
/**
* PangoRenderPart:
* @PANGO_RENDER_PART_FOREGROUND: the text itself
* @PANGO_RENDER_PART_BACKGROUND: the area behind the text
* @PANGO_RENDER_PART_UNDERLINE: underlines
* @PANGO_RENDER_PART_STRIKETHROUGH: strikethrough lines
*
* #PangoRenderPart defines different items to render for such
* purposes as setting colors.
*
* Since: 1.8
**/
/* When extending, note N_RENDER_PARTS #define in pango-renderer.c */
typedef enum
{
PANGO_RENDER_PART_FOREGROUND,
PANGO_RENDER_PART_BACKGROUND,
PANGO_RENDER_PART_UNDERLINE,
PANGO_RENDER_PART_STRIKETHROUGH
} PangoRenderPart;
/**
* PangoRenderer:
* @matrix: (nullable): the current transformation matrix for
* the Renderer; may be %NULL, which should be treated the
* same as the identity matrix.
*
* #PangoRenderer is a base class for objects that are used to
* render Pango objects such as #PangoGlyphString and
* #PangoLayout.
*
* Since: 1.8
**/
struct _PangoRenderer
{
/*< private >*/
GObject parent_instance;
PangoUnderline underline;
gboolean strikethrough;
int active_count;
/*< public >*/
PangoMatrix *matrix; /* May be NULL */
/*< private >*/
PangoRendererPrivate *priv;
};
/**
* PangoRendererClass:
* @draw_glyphs: draws a #PangoGlyphString
* @draw_rectangle: draws a rectangle
* @draw_error_underline: draws a squiggly line that approximately
* covers the given rectangle in the style of an underline used to
* indicate a spelling error.
* @draw_shape: draw content for a glyph shaped with #PangoAttrShape.
* @x, @y are the coordinates of the left edge of the baseline,
* in user coordinates.
* @draw_trapezoid: draws a trapezoidal filled area
* @draw_glyph: draws a single glyph
* @part_changed: do renderer specific processing when rendering
* attributes change
* @begin: Do renderer-specific initialization before drawing
* @end: Do renderer-specific cleanup after drawing
* @prepare_run: updates the renderer for a new run
* @draw_glyph_item: draws a #PangoGlyphItem
*
* Class structure for #PangoRenderer.
*
* Since: 1.8
**/
struct _PangoRendererClass
{
/*< private >*/
GObjectClass parent_class;
/* vtable - not signals */
/*< public >*/
/* All of the following have default implementations
* and take as coordinates user coordinates in Pango units
*/
void (*draw_glyphs) (PangoRenderer *renderer,
PangoFont *font,
PangoGlyphString *glyphs,
int x,
int y);
void (*draw_rectangle) (PangoRenderer *renderer,
PangoRenderPart part,
int x,
int y,
int width,
int height);
void (*draw_error_underline) (PangoRenderer *renderer,
int x,
int y,
int width,
int height);
/* Nothing is drawn for shaped glyphs unless this is implemented */
void (*draw_shape) (PangoRenderer *renderer,
PangoAttrShape *attr,
int x,
int y);
/* These two must be implemented and take coordinates in
* device space as doubles.
*/
void (*draw_trapezoid) (PangoRenderer *renderer,
PangoRenderPart part,
double y1_,
double x11,
double x21,
double y2,
double x12,
double x22);
void (*draw_glyph) (PangoRenderer *renderer,
PangoFont *font,
PangoGlyph glyph,
double x,
double y);
/* Notification of change in rendering attributes
*/
void (*part_changed) (PangoRenderer *renderer,
PangoRenderPart part);
/* Paired around drawing operations
*/
void (*begin) (PangoRenderer *renderer);
void (*end) (PangoRenderer *renderer);
/* Hooks into the details of layout rendering
*/
void (*prepare_run) (PangoRenderer *renderer,
PangoLayoutRun *run);
/* All of the following have default implementations
* and take as coordinates user coordinates in Pango units
*/
void (*draw_glyph_item) (PangoRenderer *renderer,
const char *text,
PangoGlyphItem *glyph_item,
int x,
int y);
/*< private >*/
/* Padding for future expansion */
void (*_pango_reserved2) (void);
void (*_pango_reserved3) (void);
void (*_pango_reserved4) (void);
};
PANGO_AVAILABLE_IN_1_8
GType pango_renderer_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_8
void pango_renderer_draw_layout (PangoRenderer *renderer,
PangoLayout *layout,
int x,
int y);
PANGO_AVAILABLE_IN_1_8
void pango_renderer_draw_layout_line (PangoRenderer *renderer,
PangoLayoutLine *line,
int x,
int y);
PANGO_AVAILABLE_IN_1_8
void pango_renderer_draw_glyphs (PangoRenderer *renderer,
PangoFont *font,
PangoGlyphString *glyphs,
int x,
int y);
PANGO_AVAILABLE_IN_1_22
void pango_renderer_draw_glyph_item (PangoRenderer *renderer,
const char *text,
PangoGlyphItem *glyph_item,
int x,
int y);
PANGO_AVAILABLE_IN_1_8
void pango_renderer_draw_rectangle (PangoRenderer *renderer,
PangoRenderPart part,
int x,
int y,
int width,
int height);
PANGO_AVAILABLE_IN_1_8
void pango_renderer_draw_error_underline (PangoRenderer *renderer,
int x,
int y,
int width,
int height);
PANGO_AVAILABLE_IN_1_8
void pango_renderer_draw_trapezoid (PangoRenderer *renderer,
PangoRenderPart part,
double y1_,
double x11,
double x21,
double y2,
double x12,
double x22);
PANGO_AVAILABLE_IN_1_8
void pango_renderer_draw_glyph (PangoRenderer *renderer,
PangoFont *font,
PangoGlyph glyph,
double x,
double y);
PANGO_AVAILABLE_IN_1_8
void pango_renderer_activate (PangoRenderer *renderer);
PANGO_AVAILABLE_IN_1_8
void pango_renderer_deactivate (PangoRenderer *renderer);
PANGO_AVAILABLE_IN_1_8
void pango_renderer_part_changed (PangoRenderer *renderer,
PangoRenderPart part);
PANGO_AVAILABLE_IN_1_8
void pango_renderer_set_color (PangoRenderer *renderer,
PangoRenderPart part,
const PangoColor *color);
PANGO_AVAILABLE_IN_1_8
PangoColor *pango_renderer_get_color (PangoRenderer *renderer,
PangoRenderPart part);
PANGO_AVAILABLE_IN_1_38
void pango_renderer_set_alpha (PangoRenderer *renderer,
PangoRenderPart part,
guint16 alpha);
PANGO_AVAILABLE_IN_1_38
guint16 pango_renderer_get_alpha (PangoRenderer *renderer,
PangoRenderPart part);
PANGO_AVAILABLE_IN_1_8
void pango_renderer_set_matrix (PangoRenderer *renderer,
const PangoMatrix *matrix);
PANGO_AVAILABLE_IN_1_8
const PangoMatrix *pango_renderer_get_matrix (PangoRenderer *renderer);
PANGO_AVAILABLE_IN_1_20
PangoLayout *pango_renderer_get_layout (PangoRenderer *renderer);
PANGO_AVAILABLE_IN_1_20
PangoLayoutLine *pango_renderer_get_layout_line (PangoRenderer *renderer);
G_END_DECLS
#endif /* __PANGO_RENDERER_H_ */

330
node_modules/sharp/vendor/include/pango/pango-script.h generated vendored Normal file
View File

@ -0,0 +1,330 @@
/* Pango
* pango-script.h: Script tag handling
*
* Copyright (C) 2002 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_SCRIPT_H__
#define __PANGO_SCRIPT_H__
#include <glib.h>
G_BEGIN_DECLS
/**
* PangoScriptIter:
*
* A #PangoScriptIter is used to iterate through a string
* and identify ranges in different scripts.
**/
typedef struct _PangoScriptIter PangoScriptIter;
/**
* PangoScript:
* @PANGO_SCRIPT_INVALID_CODE: a value never returned from pango_script_for_unichar()
* @PANGO_SCRIPT_COMMON: a character used by multiple different scripts
* @PANGO_SCRIPT_INHERITED: a mark glyph that takes its script from the
* base glyph to which it is attached
* @PANGO_SCRIPT_ARABIC: Arabic
* @PANGO_SCRIPT_ARMENIAN: Armenian
* @PANGO_SCRIPT_BENGALI: Bengali
* @PANGO_SCRIPT_BOPOMOFO: Bopomofo
* @PANGO_SCRIPT_CHEROKEE: Cherokee
* @PANGO_SCRIPT_COPTIC: Coptic
* @PANGO_SCRIPT_CYRILLIC: Cyrillic
* @PANGO_SCRIPT_DESERET: Deseret
* @PANGO_SCRIPT_DEVANAGARI: Devanagari
* @PANGO_SCRIPT_ETHIOPIC: Ethiopic
* @PANGO_SCRIPT_GEORGIAN: Georgian
* @PANGO_SCRIPT_GOTHIC: Gothic
* @PANGO_SCRIPT_GREEK: Greek
* @PANGO_SCRIPT_GUJARATI: Gujarati
* @PANGO_SCRIPT_GURMUKHI: Gurmukhi
* @PANGO_SCRIPT_HAN: Han
* @PANGO_SCRIPT_HANGUL: Hangul
* @PANGO_SCRIPT_HEBREW: Hebrew
* @PANGO_SCRIPT_HIRAGANA: Hiragana
* @PANGO_SCRIPT_KANNADA: Kannada
* @PANGO_SCRIPT_KATAKANA: Katakana
* @PANGO_SCRIPT_KHMER: Khmer
* @PANGO_SCRIPT_LAO: Lao
* @PANGO_SCRIPT_LATIN: Latin
* @PANGO_SCRIPT_MALAYALAM: Malayalam
* @PANGO_SCRIPT_MONGOLIAN: Mongolian
* @PANGO_SCRIPT_MYANMAR: Myanmar
* @PANGO_SCRIPT_OGHAM: Ogham
* @PANGO_SCRIPT_OLD_ITALIC: Old Italic
* @PANGO_SCRIPT_ORIYA: Oriya
* @PANGO_SCRIPT_RUNIC: Runic
* @PANGO_SCRIPT_SINHALA: Sinhala
* @PANGO_SCRIPT_SYRIAC: Syriac
* @PANGO_SCRIPT_TAMIL: Tamil
* @PANGO_SCRIPT_TELUGU: Telugu
* @PANGO_SCRIPT_THAANA: Thaana
* @PANGO_SCRIPT_THAI: Thai
* @PANGO_SCRIPT_TIBETAN: Tibetan
* @PANGO_SCRIPT_CANADIAN_ABORIGINAL: Canadian Aboriginal
* @PANGO_SCRIPT_YI: Yi
* @PANGO_SCRIPT_TAGALOG: Tagalog
* @PANGO_SCRIPT_HANUNOO: Hanunoo
* @PANGO_SCRIPT_BUHID: Buhid
* @PANGO_SCRIPT_TAGBANWA: Tagbanwa
* @PANGO_SCRIPT_BRAILLE: Braille
* @PANGO_SCRIPT_CYPRIOT: Cypriot
* @PANGO_SCRIPT_LIMBU: Limbu
* @PANGO_SCRIPT_OSMANYA: Osmanya
* @PANGO_SCRIPT_SHAVIAN: Shavian
* @PANGO_SCRIPT_LINEAR_B: Linear B
* @PANGO_SCRIPT_TAI_LE: Tai Le
* @PANGO_SCRIPT_UGARITIC: Ugaritic
* @PANGO_SCRIPT_NEW_TAI_LUE: New Tai Lue. Since 1.10
* @PANGO_SCRIPT_BUGINESE: Buginese. Since 1.10
* @PANGO_SCRIPT_GLAGOLITIC: Glagolitic. Since 1.10
* @PANGO_SCRIPT_TIFINAGH: Tifinagh. Since 1.10
* @PANGO_SCRIPT_SYLOTI_NAGRI: Syloti Nagri. Since 1.10
* @PANGO_SCRIPT_OLD_PERSIAN: Old Persian. Since 1.10
* @PANGO_SCRIPT_KHAROSHTHI: Kharoshthi. Since 1.10
* @PANGO_SCRIPT_UNKNOWN: an unassigned code point. Since 1.14
* @PANGO_SCRIPT_BALINESE: Balinese. Since 1.14
* @PANGO_SCRIPT_CUNEIFORM: Cuneiform. Since 1.14
* @PANGO_SCRIPT_PHOENICIAN: Phoenician. Since 1.14
* @PANGO_SCRIPT_PHAGS_PA: Phags-pa. Since 1.14
* @PANGO_SCRIPT_NKO: N'Ko. Since 1.14
* @PANGO_SCRIPT_KAYAH_LI: Kayah Li. Since 1.20.1
* @PANGO_SCRIPT_LEPCHA: Lepcha. Since 1.20.1
* @PANGO_SCRIPT_REJANG: Rejang. Since 1.20.1
* @PANGO_SCRIPT_SUNDANESE: Sundanese. Since 1.20.1
* @PANGO_SCRIPT_SAURASHTRA: Saurashtra. Since 1.20.1
* @PANGO_SCRIPT_CHAM: Cham. Since 1.20.1
* @PANGO_SCRIPT_OL_CHIKI: Ol Chiki. Since 1.20.1
* @PANGO_SCRIPT_VAI: Vai. Since 1.20.1
* @PANGO_SCRIPT_CARIAN: Carian. Since 1.20.1
* @PANGO_SCRIPT_LYCIAN: Lycian. Since 1.20.1
* @PANGO_SCRIPT_LYDIAN: Lydian. Since 1.20.1
* @PANGO_SCRIPT_BATAK: Batak. Since 1.32
* @PANGO_SCRIPT_BRAHMI: Brahmi. Since 1.32
* @PANGO_SCRIPT_MANDAIC: Mandaic. Since 1.32
* @PANGO_SCRIPT_CHAKMA: Chakma. Since: 1.32
* @PANGO_SCRIPT_MEROITIC_CURSIVE: Meroitic Cursive. Since: 1.32
* @PANGO_SCRIPT_MEROITIC_HIEROGLYPHS: Meroitic Hieroglyphs. Since: 1.32
* @PANGO_SCRIPT_MIAO: Miao. Since: 1.32
* @PANGO_SCRIPT_SHARADA: Sharada. Since: 1.32
* @PANGO_SCRIPT_SORA_SOMPENG: Sora Sompeng. Since: 1.32
* @PANGO_SCRIPT_TAKRI: Takri. Since: 1.32
* @PANGO_SCRIPT_BASSA_VAH: Bassa. Since: 1.40
* @PANGO_SCRIPT_CAUCASIAN_ALBANIAN: Caucasian Albanian. Since: 1.40
* @PANGO_SCRIPT_DUPLOYAN: Duployan. Since: 1.40
* @PANGO_SCRIPT_ELBASAN: Elbasan. Since: 1.40
* @PANGO_SCRIPT_GRANTHA: Grantha. Since: 1.40
* @PANGO_SCRIPT_KHOJKI: Kjohki. Since: 1.40
* @PANGO_SCRIPT_KHUDAWADI: Khudawadi, Sindhi. Since: 1.40
* @PANGO_SCRIPT_LINEAR_A: Linear A. Since: 1.40
* @PANGO_SCRIPT_MAHAJANI: Mahajani. Since: 1.40
* @PANGO_SCRIPT_MANICHAEAN: Manichaean. Since: 1.40
* @PANGO_SCRIPT_MENDE_KIKAKUI: Mende Kikakui. Since: 1.40
* @PANGO_SCRIPT_MODI: Modi. Since: 1.40
* @PANGO_SCRIPT_MRO: Mro. Since: 1.40
* @PANGO_SCRIPT_NABATAEAN: Nabataean. Since: 1.40
* @PANGO_SCRIPT_OLD_NORTH_ARABIAN: Old North Arabian. Since: 1.40
* @PANGO_SCRIPT_OLD_PERMIC: Old Permic. Since: 1.40
* @PANGO_SCRIPT_PAHAWH_HMONG: Pahawh Hmong. Since: 1.40
* @PANGO_SCRIPT_PALMYRENE: Palmyrene. Since: 1.40
* @PANGO_SCRIPT_PAU_CIN_HAU: Pau Cin Hau. Since: 1.40
* @PANGO_SCRIPT_PSALTER_PAHLAVI: Psalter Pahlavi. Since: 1.40
* @PANGO_SCRIPT_SIDDHAM: Siddham. Since: 1.40
* @PANGO_SCRIPT_TIRHUTA: Tirhuta. Since: 1.40
* @PANGO_SCRIPT_WARANG_CITI: Warang Citi. Since: 1.40
* @PANGO_SCRIPT_AHOM: Ahom. Since: 1.40
* @PANGO_SCRIPT_ANATOLIAN_HIEROGLYPHS: Anatolian Hieroglyphs. Since: 1.40
* @PANGO_SCRIPT_HATRAN: Hatran. Since: 1.40
* @PANGO_SCRIPT_MULTANI: Multani. Since: 1.40
* @PANGO_SCRIPT_OLD_HUNGARIAN: Old Hungarian. Since: 1.40
* @PANGO_SCRIPT_SIGNWRITING: Signwriting. Since: 1.40
*
* The #PangoScript enumeration identifies different writing
* systems. The values correspond to the names as defined in the
* Unicode standard.
* Note that new types may be added in the future. Applications should be ready
* to handle unknown values. This enumeration is interchangeable with
* #GUnicodeScript. See <ulink
* url="http://www.unicode.org/reports/tr24/">Unicode Standard Annex
* #24: Script names</ulink>.
*/
typedef enum { /* ISO 15924 code */
PANGO_SCRIPT_INVALID_CODE = -1,
PANGO_SCRIPT_COMMON = 0, /* Zyyy */
PANGO_SCRIPT_INHERITED, /* Qaai */
PANGO_SCRIPT_ARABIC, /* Arab */
PANGO_SCRIPT_ARMENIAN, /* Armn */
PANGO_SCRIPT_BENGALI, /* Beng */
PANGO_SCRIPT_BOPOMOFO, /* Bopo */
PANGO_SCRIPT_CHEROKEE, /* Cher */
PANGO_SCRIPT_COPTIC, /* Qaac */
PANGO_SCRIPT_CYRILLIC, /* Cyrl (Cyrs) */
PANGO_SCRIPT_DESERET, /* Dsrt */
PANGO_SCRIPT_DEVANAGARI, /* Deva */
PANGO_SCRIPT_ETHIOPIC, /* Ethi */
PANGO_SCRIPT_GEORGIAN, /* Geor (Geon, Geoa) */
PANGO_SCRIPT_GOTHIC, /* Goth */
PANGO_SCRIPT_GREEK, /* Grek */
PANGO_SCRIPT_GUJARATI, /* Gujr */
PANGO_SCRIPT_GURMUKHI, /* Guru */
PANGO_SCRIPT_HAN, /* Hani */
PANGO_SCRIPT_HANGUL, /* Hang */
PANGO_SCRIPT_HEBREW, /* Hebr */
PANGO_SCRIPT_HIRAGANA, /* Hira */
PANGO_SCRIPT_KANNADA, /* Knda */
PANGO_SCRIPT_KATAKANA, /* Kana */
PANGO_SCRIPT_KHMER, /* Khmr */
PANGO_SCRIPT_LAO, /* Laoo */
PANGO_SCRIPT_LATIN, /* Latn (Latf, Latg) */
PANGO_SCRIPT_MALAYALAM, /* Mlym */
PANGO_SCRIPT_MONGOLIAN, /* Mong */
PANGO_SCRIPT_MYANMAR, /* Mymr */
PANGO_SCRIPT_OGHAM, /* Ogam */
PANGO_SCRIPT_OLD_ITALIC, /* Ital */
PANGO_SCRIPT_ORIYA, /* Orya */
PANGO_SCRIPT_RUNIC, /* Runr */
PANGO_SCRIPT_SINHALA, /* Sinh */
PANGO_SCRIPT_SYRIAC, /* Syrc (Syrj, Syrn, Syre) */
PANGO_SCRIPT_TAMIL, /* Taml */
PANGO_SCRIPT_TELUGU, /* Telu */
PANGO_SCRIPT_THAANA, /* Thaa */
PANGO_SCRIPT_THAI, /* Thai */
PANGO_SCRIPT_TIBETAN, /* Tibt */
PANGO_SCRIPT_CANADIAN_ABORIGINAL, /* Cans */
PANGO_SCRIPT_YI, /* Yiii */
PANGO_SCRIPT_TAGALOG, /* Tglg */
PANGO_SCRIPT_HANUNOO, /* Hano */
PANGO_SCRIPT_BUHID, /* Buhd */
PANGO_SCRIPT_TAGBANWA, /* Tagb */
/* Unicode-4.0 additions */
PANGO_SCRIPT_BRAILLE, /* Brai */
PANGO_SCRIPT_CYPRIOT, /* Cprt */
PANGO_SCRIPT_LIMBU, /* Limb */
PANGO_SCRIPT_OSMANYA, /* Osma */
PANGO_SCRIPT_SHAVIAN, /* Shaw */
PANGO_SCRIPT_LINEAR_B, /* Linb */
PANGO_SCRIPT_TAI_LE, /* Tale */
PANGO_SCRIPT_UGARITIC, /* Ugar */
/* Unicode-4.1 additions */
PANGO_SCRIPT_NEW_TAI_LUE, /* Talu */
PANGO_SCRIPT_BUGINESE, /* Bugi */
PANGO_SCRIPT_GLAGOLITIC, /* Glag */
PANGO_SCRIPT_TIFINAGH, /* Tfng */
PANGO_SCRIPT_SYLOTI_NAGRI, /* Sylo */
PANGO_SCRIPT_OLD_PERSIAN, /* Xpeo */
PANGO_SCRIPT_KHAROSHTHI, /* Khar */
/* Unicode-5.0 additions */
PANGO_SCRIPT_UNKNOWN, /* Zzzz */
PANGO_SCRIPT_BALINESE, /* Bali */
PANGO_SCRIPT_CUNEIFORM, /* Xsux */
PANGO_SCRIPT_PHOENICIAN, /* Phnx */
PANGO_SCRIPT_PHAGS_PA, /* Phag */
PANGO_SCRIPT_NKO, /* Nkoo */
/* Unicode-5.1 additions */
PANGO_SCRIPT_KAYAH_LI, /* Kali */
PANGO_SCRIPT_LEPCHA, /* Lepc */
PANGO_SCRIPT_REJANG, /* Rjng */
PANGO_SCRIPT_SUNDANESE, /* Sund */
PANGO_SCRIPT_SAURASHTRA, /* Saur */
PANGO_SCRIPT_CHAM, /* Cham */
PANGO_SCRIPT_OL_CHIKI, /* Olck */
PANGO_SCRIPT_VAI, /* Vaii */
PANGO_SCRIPT_CARIAN, /* Cari */
PANGO_SCRIPT_LYCIAN, /* Lyci */
PANGO_SCRIPT_LYDIAN, /* Lydi */
/* Unicode-6.0 additions */
PANGO_SCRIPT_BATAK, /* Batk */
PANGO_SCRIPT_BRAHMI, /* Brah */
PANGO_SCRIPT_MANDAIC, /* Mand */
/* Unicode-6.1 additions */
PANGO_SCRIPT_CHAKMA, /* Cakm */
PANGO_SCRIPT_MEROITIC_CURSIVE, /* Merc */
PANGO_SCRIPT_MEROITIC_HIEROGLYPHS,/* Mero */
PANGO_SCRIPT_MIAO, /* Plrd */
PANGO_SCRIPT_SHARADA, /* Shrd */
PANGO_SCRIPT_SORA_SOMPENG, /* Sora */
PANGO_SCRIPT_TAKRI, /* Takr */
/* Unicode 7.0 additions */
PANGO_SCRIPT_BASSA_VAH, /* Bass */
PANGO_SCRIPT_CAUCASIAN_ALBANIAN, /* Aghb */
PANGO_SCRIPT_DUPLOYAN, /* Dupl */
PANGO_SCRIPT_ELBASAN, /* Elba */
PANGO_SCRIPT_GRANTHA, /* Gran */
PANGO_SCRIPT_KHOJKI, /* Khoj */
PANGO_SCRIPT_KHUDAWADI, /* Sind */
PANGO_SCRIPT_LINEAR_A, /* Lina */
PANGO_SCRIPT_MAHAJANI, /* Mahj */
PANGO_SCRIPT_MANICHAEAN, /* Manu */
PANGO_SCRIPT_MENDE_KIKAKUI, /* Mend */
PANGO_SCRIPT_MODI, /* Modi */
PANGO_SCRIPT_MRO, /* Mroo */
PANGO_SCRIPT_NABATAEAN, /* Nbat */
PANGO_SCRIPT_OLD_NORTH_ARABIAN, /* Narb */
PANGO_SCRIPT_OLD_PERMIC, /* Perm */
PANGO_SCRIPT_PAHAWH_HMONG, /* Hmng */
PANGO_SCRIPT_PALMYRENE, /* Palm */
PANGO_SCRIPT_PAU_CIN_HAU, /* Pauc */
PANGO_SCRIPT_PSALTER_PAHLAVI, /* Phlp */
PANGO_SCRIPT_SIDDHAM, /* Sidd */
PANGO_SCRIPT_TIRHUTA, /* Tirh */
PANGO_SCRIPT_WARANG_CITI, /* Wara */
/* Unicode 8.0 additions */
PANGO_SCRIPT_AHOM, /* Ahom */
PANGO_SCRIPT_ANATOLIAN_HIEROGLYPHS, /* Hluw */
PANGO_SCRIPT_HATRAN, /* Hatr */
PANGO_SCRIPT_MULTANI, /* Mult */
PANGO_SCRIPT_OLD_HUNGARIAN, /* Hung */
PANGO_SCRIPT_SIGNWRITING /* Sgnw */
} PangoScript;
#include <pango/pango-version-macros.h>
PANGO_AVAILABLE_IN_1_4
PangoScript pango_script_for_unichar (gunichar ch) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_4
PangoScriptIter *pango_script_iter_new (const char *text,
int length);
PANGO_AVAILABLE_IN_1_4
void pango_script_iter_get_range (PangoScriptIter *iter,
const char **start,
const char **end,
PangoScript *script);
PANGO_AVAILABLE_IN_1_4
gboolean pango_script_iter_next (PangoScriptIter *iter);
PANGO_AVAILABLE_IN_1_4
void pango_script_iter_free (PangoScriptIter *iter);
#include <pango/pango-language.h>
PANGO_AVAILABLE_IN_1_4
PangoLanguage *pango_script_get_sample_language (PangoScript script) G_GNUC_PURE;
G_END_DECLS
#endif /* __PANGO_SCRIPT_H__ */

98
node_modules/sharp/vendor/include/pango/pango-tabs.h generated vendored Normal file
View File

@ -0,0 +1,98 @@
/* Pango
* pango-tabs.h: Tab-related stuff
*
* Copyright (C) 2000 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_TABS_H__
#define __PANGO_TABS_H__
#include <pango/pango-types.h>
G_BEGIN_DECLS
typedef struct _PangoTabArray PangoTabArray;
/**
* PangoTabAlign:
* @PANGO_TAB_LEFT: the tab stop appears to the left of the text.
*
* A #PangoTabAlign specifies where a tab stop appears relative to the text.
*/
typedef enum
{
PANGO_TAB_LEFT
/* These are not supported now, but may be in the
* future.
*
* PANGO_TAB_RIGHT,
* PANGO_TAB_CENTER,
* PANGO_TAB_NUMERIC
*/
} PangoTabAlign;
/**
* PANGO_TYPE_TAB_ARRAY:
*
* The #GObject type for #PangoTabArray.
*/
#define PANGO_TYPE_TAB_ARRAY (pango_tab_array_get_type ())
PANGO_AVAILABLE_IN_ALL
PangoTabArray *pango_tab_array_new (gint initial_size,
gboolean positions_in_pixels);
PANGO_AVAILABLE_IN_ALL
PangoTabArray *pango_tab_array_new_with_positions (gint size,
gboolean positions_in_pixels,
PangoTabAlign first_alignment,
gint first_position,
...);
PANGO_AVAILABLE_IN_ALL
GType pango_tab_array_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_ALL
PangoTabArray *pango_tab_array_copy (PangoTabArray *src);
PANGO_AVAILABLE_IN_ALL
void pango_tab_array_free (PangoTabArray *tab_array);
PANGO_AVAILABLE_IN_ALL
gint pango_tab_array_get_size (PangoTabArray *tab_array);
PANGO_AVAILABLE_IN_ALL
void pango_tab_array_resize (PangoTabArray *tab_array,
gint new_size);
PANGO_AVAILABLE_IN_ALL
void pango_tab_array_set_tab (PangoTabArray *tab_array,
gint tab_index,
PangoTabAlign alignment,
gint location);
PANGO_AVAILABLE_IN_ALL
void pango_tab_array_get_tab (PangoTabArray *tab_array,
gint tab_index,
PangoTabAlign *alignment,
gint *location);
PANGO_AVAILABLE_IN_ALL
void pango_tab_array_get_tabs (PangoTabArray *tab_array,
PangoTabAlign **alignments,
gint **locations);
PANGO_AVAILABLE_IN_ALL
gboolean pango_tab_array_get_positions_in_pixels (PangoTabArray *tab_array);
G_END_DECLS
#endif /* __PANGO_TABS_H__ */

205
node_modules/sharp/vendor/include/pango/pango-types.h generated vendored Normal file
View File

@ -0,0 +1,205 @@
/* Pango
* pango-types.h:
*
* Copyright (C) 1999 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_TYPES_H__
#define __PANGO_TYPES_H__
#include <glib.h>
#include <glib-object.h>
#include <pango/pango-version-macros.h>
G_BEGIN_DECLS
typedef struct _PangoLogAttr PangoLogAttr;
typedef struct _PangoEngineLang PangoEngineLang;
typedef struct _PangoEngineShape PangoEngineShape;
typedef struct _PangoFont PangoFont;
typedef struct _PangoFontMap PangoFontMap;
typedef struct _PangoRectangle PangoRectangle;
/* A index of a glyph into a font. Rendering system dependent */
/**
* PangoGlyph:
*
* A #PangoGlyph represents a single glyph in the output form of a string.
*/
typedef guint32 PangoGlyph;
/**
* PANGO_SCALE:
*
* The %PANGO_SCALE macro represents the scale between dimensions used
* for Pango distances and device units. (The definition of device
* units is dependent on the output device; it will typically be pixels
* for a screen, and points for a printer.) %PANGO_SCALE is currently
* 1024, but this may be changed in the future.
*
* When setting font sizes, device units are always considered to be
* points (as in "12 point font"), rather than pixels.
*/
/**
* PANGO_PIXELS:
* @d: a dimension in Pango units.
*
* Converts a dimension to device units by rounding.
*
* Return value: rounded dimension in device units.
*/
/**
* PANGO_PIXELS_FLOOR:
* @d: a dimension in Pango units.
*
* Converts a dimension to device units by flooring.
*
* Return value: floored dimension in device units.
* Since: 1.14
*/
/**
* PANGO_PIXELS_CEIL:
* @d: a dimension in Pango units.
*
* Converts a dimension to device units by ceiling.
*
* Return value: ceiled dimension in device units.
* Since: 1.14
*/
#define PANGO_SCALE 1024
#define PANGO_PIXELS(d) (((int)(d) + 512) >> 10)
#define PANGO_PIXELS_FLOOR(d) (((int)(d)) >> 10)
#define PANGO_PIXELS_CEIL(d) (((int)(d) + 1023) >> 10)
/* The above expressions are just slightly wrong for floating point d;
* For example we'd expect PANGO_PIXELS(-512.5) => -1 but instead we get 0.
* That's unlikely to matter for practical use and the expression is much
* more compact and faster than alternatives that work exactly for both
* integers and floating point.
*
* PANGO_PIXELS also behaves differently for +512 and -512.
*/
/**
* PANGO_UNITS_ROUND:
* @d: a dimension in Pango units.
*
* Rounds a dimension to whole device units, but does not
* convert it to device units.
*
* Return value: rounded dimension in Pango units.
* Since: 1.18
*/
#define PANGO_UNITS_ROUND(d) \
(((d) + (PANGO_SCALE >> 1)) & ~(PANGO_SCALE - 1))
PANGO_AVAILABLE_IN_1_16
int pango_units_from_double (double d) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_16
double pango_units_to_double (int i) G_GNUC_CONST;
/**
* PangoRectangle:
* @x: X coordinate of the left side of the rectangle.
* @y: Y coordinate of the the top side of the rectangle.
* @width: width of the rectangle.
* @height: height of the rectangle.
*
* The #PangoRectangle structure represents a rectangle. It is frequently
* used to represent the logical or ink extents of a single glyph or section
* of text. (See, for instance, pango_font_get_glyph_extents())
*
*/
struct _PangoRectangle
{
int x;
int y;
int width;
int height;
};
/* Macros to translate from extents rectangles to ascent/descent/lbearing/rbearing
*/
/**
* PANGO_ASCENT:
* @rect: a #PangoRectangle
*
* Extracts the <firstterm>ascent</firstterm> from a #PangoRectangle
* representing glyph extents. The ascent is the distance from the
* baseline to the highest point of the character. This is positive if the
* glyph ascends above the baseline.
*/
/**
* PANGO_DESCENT:
* @rect: a #PangoRectangle
*
* Extracts the <firstterm>descent</firstterm> from a #PangoRectangle
* representing glyph extents. The descent is the distance from the
* baseline to the lowest point of the character. This is positive if the
* glyph descends below the baseline.
*/
/**
* PANGO_LBEARING:
* @rect: a #PangoRectangle
*
* Extracts the <firstterm>left bearing</firstterm> from a #PangoRectangle
* representing glyph extents. The left bearing is the distance from the
* horizontal origin to the farthest left point of the character.
* This is positive for characters drawn completely to the right of the
* glyph origin.
*/
/**
* PANGO_RBEARING:
* @rect: a #PangoRectangle
*
* Extracts the <firstterm>right bearing</firstterm> from a #PangoRectangle
* representing glyph extents. The right bearing is the distance from the
* horizontal origin to the farthest right point of the character.
* This is positive except for characters drawn completely to the left of the
* horizontal origin.
*/
#define PANGO_ASCENT(rect) (-(rect).y)
#define PANGO_DESCENT(rect) ((rect).y + (rect).height)
#define PANGO_LBEARING(rect) ((rect).x)
#define PANGO_RBEARING(rect) ((rect).x + (rect).width)
PANGO_AVAILABLE_IN_1_16
void pango_extents_to_pixels (PangoRectangle *inclusive,
PangoRectangle *nearest);
#include <pango/pango-gravity.h>
#include <pango/pango-language.h>
#include <pango/pango-matrix.h>
#include <pango/pango-script.h>
#include <pango/pango-bidi-type.h>
G_END_DECLS
#endif /* __PANGO_TYPES_H__ */

211
node_modules/sharp/vendor/include/pango/pango-utils.h generated vendored Normal file
View File

@ -0,0 +1,211 @@
/* Pango
* pango-utils.c: Utilities for internal functions and modules
*
* Copyright (C) 2000 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_UTILS_H__
#define __PANGO_UTILS_H__
#include <stdio.h>
#include <glib.h>
#include <pango/pango-font.h>
G_BEGIN_DECLS
PANGO_DEPRECATED
char ** pango_split_file_list (const char *str);
PANGO_DEPRECATED
char *pango_trim_string (const char *str);
PANGO_DEPRECATED
gint pango_read_line (FILE *stream,
GString *str);
PANGO_DEPRECATED
gboolean pango_skip_space (const char **pos);
PANGO_DEPRECATED
gboolean pango_scan_word (const char **pos,
GString *out);
PANGO_DEPRECATED
gboolean pango_scan_string (const char **pos,
GString *out);
PANGO_DEPRECATED
gboolean pango_scan_int (const char **pos,
int *out);
#ifdef PANGO_ENABLE_BACKEND
PANGO_DEPRECATED_IN_1_38
char * pango_config_key_get_system (const char *key);
PANGO_DEPRECATED_IN_1_38
char * pango_config_key_get (const char *key);
PANGO_DEPRECATED_IN_1_32
void pango_lookup_aliases (const char *fontname,
char ***families,
int *n_families);
#endif /* PANGO_ENABLE_BACKEND */
PANGO_DEPRECATED
gboolean pango_parse_enum (GType type,
const char *str,
int *value,
gboolean warn,
char **possible_values);
/* Functions for parsing textual representations
* of PangoFontDescription fields. They return TRUE if the input string
* contains a valid value, which then has been assigned to the corresponding
* field in the PangoFontDescription. If the warn parameter is TRUE,
* a warning is printed (with g_warning) if the string does not
* contain a valid value.
*/
PANGO_AVAILABLE_IN_ALL
gboolean pango_parse_style (const char *str,
PangoStyle *style,
gboolean warn);
PANGO_AVAILABLE_IN_ALL
gboolean pango_parse_variant (const char *str,
PangoVariant *variant,
gboolean warn);
PANGO_AVAILABLE_IN_ALL
gboolean pango_parse_weight (const char *str,
PangoWeight *weight,
gboolean warn);
PANGO_AVAILABLE_IN_ALL
gboolean pango_parse_stretch (const char *str,
PangoStretch *stretch,
gboolean warn);
#ifdef PANGO_ENABLE_BACKEND
/* On Unix, return the name of the "pango" subdirectory of SYSCONFDIR
* (which is set at compile time). On Win32, return the Pango
* installation directory (which is set at installation time, and
* stored in the registry). The returned string should not be
* g_free'd.
*/
PANGO_DEPRECATED
const char * pango_get_sysconf_subdirectory (void) G_GNUC_PURE;
/* Ditto for LIBDIR/pango. On Win32, use the same Pango
* installation directory. This returned string should not be
* g_free'd either.
*/
PANGO_DEPRECATED
const char * pango_get_lib_subdirectory (void) G_GNUC_PURE;
#endif /* PANGO_ENABLE_BACKEND */
/* Hint line position and thickness.
*/
PANGO_AVAILABLE_IN_1_12
void pango_quantize_line_geometry (int *thickness,
int *position);
/* A routine from fribidi that we either wrap or provide ourselves.
*/
PANGO_AVAILABLE_IN_1_4
guint8 * pango_log2vis_get_embedding_levels (const gchar *text,
int length,
PangoDirection *pbase_dir);
/* Unicode characters that are zero-width and should not be rendered
* normally.
*/
PANGO_AVAILABLE_IN_1_10
gboolean pango_is_zero_width (gunichar ch) G_GNUC_CONST;
/* Pango version checking */
/* Encode a Pango version as an integer */
/**
* PANGO_VERSION_ENCODE:
* @major: the major component of the version number
* @minor: the minor component of the version number
* @micro: the micro component of the version number
*
* This macro encodes the given Pango version into an integer. The numbers
* returned by %PANGO_VERSION and pango_version() are encoded using this macro.
* Two encoded version numbers can be compared as integers.
*/
#define PANGO_VERSION_ENCODE(major, minor, micro) ( \
((major) * 10000) \
+ ((minor) * 100) \
+ ((micro) * 1))
/* Encoded version of Pango at compile-time */
/**
* PANGO_VERSION:
*
* The version of Pango available at compile-time, encoded using PANGO_VERSION_ENCODE().
*/
/**
* PANGO_VERSION_STRING:
*
* A string literal containing the version of Pango available at compile-time.
*/
/**
* PANGO_VERSION_MAJOR:
*
* The major component of the version of Pango available at compile-time.
*/
/**
* PANGO_VERSION_MINOR:
*
* The minor component of the version of Pango available at compile-time.
*/
/**
* PANGO_VERSION_MICRO:
*
* The micro component of the version of Pango available at compile-time.
*/
#define PANGO_VERSION PANGO_VERSION_ENCODE( \
PANGO_VERSION_MAJOR, \
PANGO_VERSION_MINOR, \
PANGO_VERSION_MICRO)
/* Check that compile-time Pango is as new as required */
/**
* PANGO_VERSION_CHECK:
* @major: the major component of the version number
* @minor: the minor component of the version number
* @micro: the micro component of the version number
*
* Checks that the version of Pango available at compile-time is not older than
* the provided version number.
*/
#define PANGO_VERSION_CHECK(major,minor,micro) \
(PANGO_VERSION >= PANGO_VERSION_ENCODE(major,minor,micro))
/* Return encoded version of Pango at run-time */
PANGO_AVAILABLE_IN_1_16
int pango_version (void) G_GNUC_CONST;
/* Return run-time Pango version as an string */
PANGO_AVAILABLE_IN_1_16
const char * pango_version_string (void) G_GNUC_CONST;
/* Check that run-time Pango is as new as required */
PANGO_AVAILABLE_IN_1_16
const char * pango_version_check (int required_major,
int required_minor,
int required_micro) G_GNUC_CONST;
G_END_DECLS
#endif /* __PANGO_UTILS_H__ */

636
node_modules/sharp/vendor/include/pango/pango-version-macros.h generated vendored Normal file
View File

@ -0,0 +1,636 @@
/* Pango - Internationalized text layout and rendering library
* Copyright (C) 1999 Red Hat Software
* Copyright (C) 2012 Ryan Lortie, Matthias Clasen and Emmanuele Bassi
* Copyright (C) 2016 Chun-wei Fan
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __PANGO_VERSION_H__
#define __PANGO_VERSION_H__
#include <pango/pango-features.h>
#include <glib.h>
#ifndef _PANGO_EXTERN
#define _PANGO_EXTERN extern
#endif
#define PANGO_AVAILABLE_IN_ALL _PANGO_EXTERN
/* XXX: Every new stable minor release bump should add a macro here */
/**
* PANGO_VERSION_1_2:
*
* A macro that evaluates to the 1.2 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_2 (G_ENCODE_VERSION (1, 2))
/**
* PANGO_VERSION_1_4:
*
* A macro that evaluates to the 1.4 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_4 (G_ENCODE_VERSION (1, 4))
/**
* PANGO_VERSION_1_6:
*
* A macro that evaluates to the 1.6 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_6 (G_ENCODE_VERSION (1, 6))
/**
* PANGO_VERSION_1_8:
*
* A macro that evaluates to the 1.8 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_8 (G_ENCODE_VERSION (1, 8))
/**
* PANGO_VERSION_1_10:
*
* A macro that evaluates to the 1.10 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_10 (G_ENCODE_VERSION (1, 10))
/**
* PANGO_VERSION_1_12:
*
* A macro that evaluates to the 1.12 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_12 (G_ENCODE_VERSION (1, 12))
/**
* PANGO_VERSION_1_14:
*
* A macro that evaluates to the 1.14 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_14 (G_ENCODE_VERSION (1, 14))
/**
* PANGO_VERSION_1_16:
*
* A macro that evaluates to the 1.16 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_16 (G_ENCODE_VERSION (1, 16))
/**
* PANGO_VERSION_1_18:
*
* A macro that evaluates to the 1.18 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_18 (G_ENCODE_VERSION (1, 18))
/**
* PANGO_VERSION_1_20:
*
* A macro that evaluates to the 1.20 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_20 (G_ENCODE_VERSION (1, 20))
/**
* PANGO_VERSION_1_22:
*
* A macro that evaluates to the 1.22 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_22 (G_ENCODE_VERSION (1, 22))
/**
* PANGO_VERSION_1_24:
*
* A macro that evaluates to the 1.24 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_24 (G_ENCODE_VERSION (1, 24))
/**
* PANGO_VERSION_1_26:
*
* A macro that evaluates to the 1.26 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_26 (G_ENCODE_VERSION (1, 26))
/**
* PANGO_VERSION_1_28:
*
* A macro that evaluates to the 1.28 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_28 (G_ENCODE_VERSION (1, 28))
/**
* PANGO_VERSION_1_30:
*
* A macro that evaluates to the 1.30 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_30 (G_ENCODE_VERSION (1, 30))
/**
* PANGO_VERSION_1_32:
*
* A macro that evaluates to the 1.32 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_32 (G_ENCODE_VERSION (1, 32))
/**
* PANGO_VERSION_1_34:
*
* A macro that evaluates to the 1.34 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_34 (G_ENCODE_VERSION (1, 34))
/**
* PANGO_VERSION_1_36:
*
* A macro that evaluates to the 1.36 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_36 (G_ENCODE_VERSION (1, 36))
/**
* PANGO_VERSION_1_38:
*
* A macro that evaluates to the 1.38 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_38 (G_ENCODE_VERSION (1, 38))
/**
* PANGO_VERSION_1_40:
*
* A macro that evaluates to the 1.40 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_40 (G_ENCODE_VERSION (1, 40))
/**
* PANGO_VERSION_1_42:
*
* A macro that evaluates to the 2.38 version of Pango, in a format
* that can be used by the C pre-processor.
*
* Since: 1.42
*/
#define PANGO_VERSION_1_42 (G_ENCODE_VERSION (1, 42))
/* evaluates to the current stable version; for development cycles,
* this means the next stable target
*/
#if (PANGO_VERSION_MINOR % 2)
#define PANGO_VERSION_CUR_STABLE (G_ENCODE_VERSION (PANGO_VERSION_MAJOR, PANGO_VERSION_MINOR + 1))
#else
#define PANGO_VERSION_CUR_STABLE (G_ENCODE_VERSION (PANGO_VERSION_MAJOR, PANGO_VERSION_MINOR))
#endif
/* evaluates to the previous stable version */
#if (PANGO_VERSION_MINOR % 2)
#define PANGO_VERSION_PREV_STABLE (G_ENCODE_VERSION (PANGO_VERSION_MAJOR, PANGO_VERSION_MINOR - 1))
#else
#define PANGO_VERSION_PREV_STABLE (G_ENCODE_VERSION (PANGO_VERSION_MAJOR, PANGO_VERSION_MINOR - 2))
#endif
/**
* PANGO_VERSION_MIN_REQUIRED:
*
* A macro that should be defined by the user prior to including
* the pango.h header.
* The definition should be one of the predefined Pango version
* macros: %PANGO_VERSION_1_2, %PANGO_VERSION_1_4,...
*
* This macro defines the earliest version of Pango that the package is
* required to be able to compile against.
*
* If the compiler is configured to warn about the use of deprecated
* functions, then using functions that were deprecated in version
* %PANGO_VERSION_MIN_REQUIRED or earlier will cause warnings (but
* using functions deprecated in later releases will not).
*
* Since: 1.42
*/
/* If the package sets PANGO_VERSION_MIN_REQUIRED to some future
* PANGO_VERSION_X_Y value that we don't know about, it will compare as
* 0 in preprocessor tests.
*/
#ifndef PANGO_VERSION_MIN_REQUIRED
# define PANGO_VERSION_MIN_REQUIRED (PANGO_VERSION_CUR_STABLE)
#elif PANGO_VERSION_MIN_REQUIRED == 0
# undef PANGO_VERSION_MIN_REQUIRED
# define PANGO_VERSION_MIN_REQUIRED (PANGO_VERSION_CUR_STABLE + 2)
#endif
/**
* PANGO_VERSION_MAX_ALLOWED:
*
* A macro that should be defined by the user prior to including
* the glib.h header.
* The definition should be one of the predefined Pango version
* macros: %PANGO_VERSION_1_2, %PANGO_VERSION_1_4,...
*
* This macro defines the latest version of the Pango API that the
* package is allowed to make use of.
*
* If the compiler is configured to warn about the use of deprecated
* functions, then using functions added after version
* %PANGO_VERSION_MAX_ALLOWED will cause warnings.
*
* Unless you are using PANGO_CHECK_VERSION() or the like to compile
* different code depending on the Pango version, then this should be
* set to the same value as %PANGO_VERSION_MIN_REQUIRED.
*
* Since: 1.42
*/
#if !defined (PANGO_VERSION_MAX_ALLOWED) || (PANGO_VERSION_MAX_ALLOWED == 0)
# undef PANGO_VERSION_MAX_ALLOWED
# define PANGO_VERSION_MAX_ALLOWED (PANGO_VERSION_CUR_STABLE)
#endif
/* sanity checks */
#if PANGO_VERSION_MIN_REQUIRED > PANGO_VERSION_CUR_STABLE
#error "PANGO_VERSION_MIN_REQUIRED must be <= PANGO_VERSION_CUR_STABLE"
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_MIN_REQUIRED
#error "PANGO_VERSION_MAX_ALLOWED must be >= PANGO_VERSION_MIN_REQUIRED"
#endif
#if PANGO_VERSION_MIN_REQUIRED < PANGO_VERSION_1_2
#error "PANGO_VERSION_MIN_REQUIRED must be >= PANGO_VERSION_1_2"
#endif
/* These macros are used to mark deprecated functions in Pango headers,
* and thus have to be exposed in installed headers.
*/
#ifdef PANGO_DISABLE_DEPRECATION_WARNINGS
# define PANGO_DEPRECATED _PANGO_EXTERN
# define PANGO_DEPRECATED_FOR(f) _PANGO_EXTERN
# define PANGO_UNAVAILABLE(maj,min) _PANGO_EXTERN
#else
# define PANGO_DEPRECATED G_DEPRECATED _PANGO_EXTERN
# define PANGO_DEPRECATED_FOR(f) G_DEPRECATED_FOR(f) _PANGO_EXTERN
# define PANGO_UNAVAILABLE(maj,min) G_UNAVAILABLE(maj,min) _PANGO_EXTERN
#endif
/* XXX: Every new stable minor release should add a set of macros here */
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_2
# define PANGO_DEPRECATED_IN_1_2 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_2_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_2 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_2_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_2
# define PANGO_AVAILABLE_IN_1_2 PANGO_UNAVAILABLE(1, 2)
#else
# define PANGO_AVAILABLE_IN_1_2 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_4
# define PANGO_DEPRECATED_IN_1_4 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_4_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_4 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_4_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_4
# define PANGO_AVAILABLE_IN_1_4 PANGO_UNAVAILABLE(1, 4)
#else
# define PANGO_AVAILABLE_IN_1_4 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_6
# define PANGO_DEPRECATED_IN_1_6 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_6_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_6 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_6_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_6
# define PANGO_AVAILABLE_IN_1_6 PANGO_UNAVAILABLE(1, 6)
#else
# define PANGO_AVAILABLE_IN_1_6 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_8
# define PANGO_DEPRECATED_IN_1_8 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_8_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_8 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_8_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_8
# define PANGO_AVAILABLE_IN_1_8 PANGO_UNAVAILABLE(1, 8)
#else
# define PANGO_AVAILABLE_IN_1_8 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_10
# define PANGO_DEPRECATED_IN_1_10 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_10_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_10 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_10_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_10
# define PANGO_AVAILABLE_IN_1_10 PANGO_UNAVAILABLE(1, 10)
#else
# define PANGO_AVAILABLE_IN_1_10 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_12
# define PANGO_AVAILABLE_IN_1_12 PANGO_UNAVAILABLE(1, 12)
#else
# define PANGO_AVAILABLE_IN_1_12 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_12
# define PANGO_DEPRECATED_IN_1_12 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_12_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_12 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_12_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_14
# define PANGO_AVAILABLE_IN_1_14 PANGO_UNAVAILABLE(1, 14)
#else
# define PANGO_AVAILABLE_IN_1_14 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_14
# define PANGO_DEPRECATED_IN_1_14 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_14_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_14 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_14_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_16
# define PANGO_AVAILABLE_IN_1_16 PANGO_UNAVAILABLE(1, 16)
#else
# define PANGO_AVAILABLE_IN_1_16 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_16
# define PANGO_DEPRECATED_IN_1_16 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_16_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_16 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_16_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_18
# define PANGO_DEPRECATED_IN_1_18 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_18_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_18 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_18_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_18
# define PANGO_AVAILABLE_IN_1_18 PANGO_UNAVAILABLE(1, 18)
#else
# define PANGO_AVAILABLE_IN_1_18 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_20
# define PANGO_DEPRECATED_IN_1_20 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_20_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_20 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_20_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_20
# define PANGO_AVAILABLE_IN_1_20 PANGO_UNAVAILABLE(1, 20)
#else
# define PANGO_AVAILABLE_IN_1_20 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_22
# define PANGO_DEPRECATED_IN_1_22 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_22_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_22 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_22_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_22
# define PANGO_AVAILABLE_IN_1_22 PANGO_UNAVAILABLE(1, 22)
#else
# define PANGO_AVAILABLE_IN_1_22 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_24
# define PANGO_DEPRECATED_IN_1_24 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_24_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_24 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_24_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_24
# define PANGO_AVAILABLE_IN_1_24 PANGO_UNAVAILABLE(1, 24)
#else
# define PANGO_AVAILABLE_IN_1_24 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_26
# define PANGO_DEPRECATED_IN_1_26 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_26_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_26 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_26_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_26
# define PANGO_AVAILABLE_IN_1_26 PANGO_UNAVAILABLE(1, 26)
#else
# define PANGO_AVAILABLE_IN_1_26 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_28
# define PANGO_DEPRECATED_IN_1_28 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_28_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_28 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_28_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_28
# define PANGO_AVAILABLE_IN_1_28 PANGO_UNAVAILABLE(1, 28)
#else
# define PANGO_AVAILABLE_IN_1_28 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_30
# define PANGO_DEPRECATED_IN_1_30 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_30_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_30 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_30_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_30
# define PANGO_AVAILABLE_IN_1_30 PANGO_UNAVAILABLE(1, 30)
#else
# define PANGO_AVAILABLE_IN_1_30 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_32
# define PANGO_DEPRECATED_IN_1_32 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_32_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_32 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_32_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_32
# define PANGO_AVAILABLE_IN_1_32 PANGO_UNAVAILABLE(1, 32)
#else
# define PANGO_AVAILABLE_IN_1_32 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_34
# define PANGO_DEPRECATED_IN_1_34 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_34_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_34 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_34_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_34
# define PANGO_AVAILABLE_IN_1_34 PANGO_UNAVAILABLE(1, 34)
#else
# define PANGO_AVAILABLE_IN_1_34 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_36
# define PANGO_DEPRECATED_IN_1_36 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_36_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_36 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_36_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_36
# define PANGO_AVAILABLE_IN_1_36 PANGO_UNAVAILABLE(1, 36)
#else
# define PANGO_AVAILABLE_IN_1_36 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_38
# define PANGO_DEPRECATED_IN_1_38 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_38_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_38 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_38_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_38
# define PANGO_AVAILABLE_IN_1_38 PANGO_UNAVAILABLE(1, 38)
#else
# define PANGO_AVAILABLE_IN_1_38 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_40
# define PANGO_DEPRECATED_IN_1_40 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_40_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_40 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_40_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_40
# define PANGO_AVAILABLE_IN_1_40 PANGO_UNAVAILABLE(1, 40)
#else
# define PANGO_AVAILABLE_IN_1_40 _PANGO_EXTERN
#endif
#if PANGO_VERSION_MIN_REQUIRED >= PANGO_VERSION_1_42
# define PANGO_DEPRECATED_IN_1_42 PANGO_DEPRECATED
# define PANGO_DEPRECATED_IN_1_42_FOR(f) PANGO_DEPRECATED_FOR(f)
#else
# define PANGO_DEPRECATED_IN_1_42 _PANGO_EXTERN
# define PANGO_DEPRECATED_IN_1_42_FOR(f) _PANGO_EXTERN
#endif
#if PANGO_VERSION_MAX_ALLOWED < PANGO_VERSION_1_42
# define PANGO_AVAILABLE_IN_1_42 PANGO_UNAVAILABLE(1, 42)
#else
# define PANGO_AVAILABLE_IN_1_42 _PANGO_EXTERN
#endif
#endif /* __PANGO_VERSION_H__ */

49
node_modules/sharp/vendor/include/pango/pango.h generated vendored Normal file
View File

@ -0,0 +1,49 @@
/* Pango
* pango.h:
*
* Copyright (C) 1999 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_H__
#define __PANGO_H__
#include <pango/pango-attributes.h>
#include <pango/pango-bidi-type.h>
#include <pango/pango-break.h>
#include <pango/pango-context.h>
#include <pango/pango-coverage.h>
#include <pango/pango-engine.h>
#include <pango/pango-enum-types.h>
#include <pango/pango-features.h>
#include <pango/pango-font.h>
#include <pango/pango-fontmap.h>
#include <pango/pango-fontset.h>
#include <pango/pango-glyph.h>
#include <pango/pango-glyph-item.h>
#include <pango/pango-gravity.h>
#include <pango/pango-item.h>
#include <pango/pango-layout.h>
#include <pango/pango-matrix.h>
#include <pango/pango-renderer.h>
#include <pango/pango-script.h>
#include <pango/pango-tabs.h>
#include <pango/pango-types.h>
#include <pango/pango-utils.h>
#include <pango/pango-version-macros.h>
#endif /* __PANGO_H__ */

198
node_modules/sharp/vendor/include/pango/pangocairo.h generated vendored Normal file
View File

@ -0,0 +1,198 @@
/* Pango
* pangocairo.h:
*
* Copyright (C) 1999, 2004 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGOCAIRO_H__
#define __PANGOCAIRO_H__
#include <pango/pango.h>
#include <cairo.h>
G_BEGIN_DECLS
/**
* PangoCairoFont:
*
* #PangoCairoFont is an interface exported by fonts for
* use with Cairo. The actual type of the font will depend
* on the particular font technology Cairo was compiled to use.
*
* Since: 1.18
**/
typedef struct _PangoCairoFont PangoCairoFont;
#define PANGO_TYPE_CAIRO_FONT (pango_cairo_font_get_type ())
#define PANGO_CAIRO_FONT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_CAIRO_FONT, PangoCairoFont))
#define PANGO_IS_CAIRO_FONT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_CAIRO_FONT))
/**
* PangoCairoFontMap:
*
* #PangoCairoFontMap is an interface exported by font maps for
* use with Cairo. The actual type of the font map will depend
* on the particular font technology Cairo was compiled to use.
*
* Since: 1.10
**/
typedef struct _PangoCairoFontMap PangoCairoFontMap;
#define PANGO_TYPE_CAIRO_FONT_MAP (pango_cairo_font_map_get_type ())
#define PANGO_CAIRO_FONT_MAP(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_CAIRO_FONT_MAP, PangoCairoFontMap))
#define PANGO_IS_CAIRO_FONT_MAP(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_CAIRO_FONT_MAP))
/**
* PangoCairoShapeRendererFunc:
* @cr: a Cairo context with current point set to where the shape should
* be rendered
* @attr: the %PANGO_ATTR_SHAPE to render
* @do_path: whether only the shape path should be appended to current
* path of @cr and no filling/stroking done. This will be set
* to %TRUE when called from pango_cairo_layout_path() and
* pango_cairo_layout_line_path() rendering functions.
* @data: user data passed to pango_cairo_context_set_shape_renderer()
*
* Function type for rendering attributes of type %PANGO_ATTR_SHAPE
* with Pango's Cairo renderer.
*/
typedef void (* PangoCairoShapeRendererFunc) (cairo_t *cr,
PangoAttrShape *attr,
gboolean do_path,
gpointer data);
/*
* PangoCairoFontMap
*/
PANGO_AVAILABLE_IN_1_10
GType pango_cairo_font_map_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_10
PangoFontMap *pango_cairo_font_map_new (void);
PANGO_AVAILABLE_IN_1_18
PangoFontMap *pango_cairo_font_map_new_for_font_type (cairo_font_type_t fonttype);
PANGO_AVAILABLE_IN_1_10
PangoFontMap *pango_cairo_font_map_get_default (void);
PANGO_AVAILABLE_IN_1_22
void pango_cairo_font_map_set_default (PangoCairoFontMap *fontmap);
PANGO_AVAILABLE_IN_1_18
cairo_font_type_t pango_cairo_font_map_get_font_type (PangoCairoFontMap *fontmap);
PANGO_AVAILABLE_IN_1_10
void pango_cairo_font_map_set_resolution (PangoCairoFontMap *fontmap,
double dpi);
PANGO_AVAILABLE_IN_1_10
double pango_cairo_font_map_get_resolution (PangoCairoFontMap *fontmap);
#ifndef PANGO_DISABLE_DEPRECATED
PANGO_DEPRECATED_IN_1_22_FOR(pango_font_map_create_context)
PangoContext *pango_cairo_font_map_create_context (PangoCairoFontMap *fontmap);
#endif
/*
* PangoCairoFont
*/
PANGO_AVAILABLE_IN_1_18
GType pango_cairo_font_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_18
cairo_scaled_font_t *pango_cairo_font_get_scaled_font (PangoCairoFont *font);
/* Update a Pango context for the current state of a cairo context
*/
PANGO_AVAILABLE_IN_1_10
void pango_cairo_update_context (cairo_t *cr,
PangoContext *context);
PANGO_AVAILABLE_IN_1_10
void pango_cairo_context_set_font_options (PangoContext *context,
const cairo_font_options_t *options);
PANGO_AVAILABLE_IN_1_10
const cairo_font_options_t *pango_cairo_context_get_font_options (PangoContext *context);
PANGO_AVAILABLE_IN_1_10
void pango_cairo_context_set_resolution (PangoContext *context,
double dpi);
PANGO_AVAILABLE_IN_1_10
double pango_cairo_context_get_resolution (PangoContext *context);
PANGO_AVAILABLE_IN_1_18
void pango_cairo_context_set_shape_renderer (PangoContext *context,
PangoCairoShapeRendererFunc func,
gpointer data,
GDestroyNotify dnotify);
PANGO_AVAILABLE_IN_1_18
PangoCairoShapeRendererFunc pango_cairo_context_get_shape_renderer (PangoContext *context,
gpointer *data);
/* Convenience
*/
PANGO_AVAILABLE_IN_1_22
PangoContext *pango_cairo_create_context (cairo_t *cr);
PANGO_AVAILABLE_IN_ALL
PangoLayout *pango_cairo_create_layout (cairo_t *cr);
PANGO_AVAILABLE_IN_1_10
void pango_cairo_update_layout (cairo_t *cr,
PangoLayout *layout);
/*
* Rendering
*/
PANGO_AVAILABLE_IN_1_10
void pango_cairo_show_glyph_string (cairo_t *cr,
PangoFont *font,
PangoGlyphString *glyphs);
PANGO_AVAILABLE_IN_1_22
void pango_cairo_show_glyph_item (cairo_t *cr,
const char *text,
PangoGlyphItem *glyph_item);
PANGO_AVAILABLE_IN_1_10
void pango_cairo_show_layout_line (cairo_t *cr,
PangoLayoutLine *line);
PANGO_AVAILABLE_IN_1_10
void pango_cairo_show_layout (cairo_t *cr,
PangoLayout *layout);
PANGO_AVAILABLE_IN_1_14
void pango_cairo_show_error_underline (cairo_t *cr,
double x,
double y,
double width,
double height);
/*
* Rendering to a path
*/
PANGO_AVAILABLE_IN_1_10
void pango_cairo_glyph_string_path (cairo_t *cr,
PangoFont *font,
PangoGlyphString *glyphs);
PANGO_AVAILABLE_IN_1_10
void pango_cairo_layout_line_path (cairo_t *cr,
PangoLayoutLine *line);
PANGO_AVAILABLE_IN_1_10
void pango_cairo_layout_path (cairo_t *cr,
PangoLayout *layout);
PANGO_AVAILABLE_IN_1_14
void pango_cairo_error_underline_path (cairo_t *cr,
double x,
double y,
double width,
double height);
G_END_DECLS
#endif /* __PANGOCAIRO_H__ */

87
node_modules/sharp/vendor/include/pango/pangocoretext.h generated vendored Normal file
View File

@ -0,0 +1,87 @@
/* Pango
* pangocoretext.h:
*
* Copyright (C) 2005 Imendio AB
* Copyright (C) 2010 Kristian Rietveld <kris@gtk.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGOCORETEXT_H__
#define __PANGOCORETEXT_H__
#include <pango/pango.h>
#include <Carbon/Carbon.h>
G_BEGIN_DECLS
#define PANGO_TYPE_CORE_TEXT_FONT (pango_core_text_font_get_type ())
#define PANGO_CORE_TEXT_FONT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_CORE_TEXT_FONT, PangoCoreTextFont))
#define PANGO_IS_CORE_TEXT_FONT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_CORE_TEXT_FONT))
typedef struct _PangoCoreTextFont PangoCoreTextFont;
typedef struct _PangoCoreTextFontClass PangoCoreTextFontClass;
#if defined(PANGO_ENABLE_ENGINE) || defined(PANGO_ENABLE_BACKEND)
/**
* PANGO_RENDER_TYPE_CORE_TEXT:
*
* A string constant identifying the CoreText renderer. The associated quark (see
* g_quark_from_string()) is used to identify the renderer in pango_find_map().
*/
#define PANGO_RENDER_TYPE_CORE_TEXT "PangoRenderCoreText"
#ifdef PANGO_ENABLE_BACKEND
#define PANGO_CORE_TEXT_FONT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_CORE_TEXT_FONT, PangoCoreTextFontClass))
#define PANGO_IS_CORE_TEXT_FONT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_CORE_TEXT_FONT))
#define PANGO_CORE_TEXT_FONT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_CORE_TEXT_FONT, PangoCoreTextFontClass))
typedef struct _PangoCoreTextFontPrivate PangoCoreTextFontPrivate;
struct _PangoCoreTextFont
{
PangoFont parent_instance;
PangoCoreTextFontPrivate *priv;
};
struct _PangoCoreTextFontClass
{
PangoFontClass parent_class;
/*< private >*/
/* Padding for future expansion */
void (*_pango_reserved1) (void);
void (*_pango_reserved2) (void);
void (*_pango_reserved3) (void);
void (*_pango_reserved4) (void);
};
#endif /* PANGO_ENABLE_BACKEND */
PANGO_AVAILABLE_IN_1_24
CTFontRef pango_core_text_font_get_ctfont (PangoCoreTextFont *font);
#endif /* PANGO_ENABLE_ENGINE || PANGO_ENABLE_BACKEND */
PANGO_AVAILABLE_IN_ALL
GType pango_core_text_font_get_type (void) G_GNUC_CONST;
G_END_DECLS
#endif /* __PANGOCORETEXT_H__ */

113
node_modules/sharp/vendor/include/pango/pangofc-decoder.h generated vendored Normal file
View File

@ -0,0 +1,113 @@
/* Pango
* pangofc-decoder.h: Custom encoders/decoders on a per-font basis.
*
* Copyright (C) 2004 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_DECODER_H_
#define __PANGO_DECODER_H_
#include <pango/pangofc-font.h>
G_BEGIN_DECLS
#define PANGO_TYPE_FC_DECODER (pango_fc_decoder_get_type())
#define PANGO_FC_DECODER(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FC_DECODER, PangoFcDecoder))
#define PANGO_IS_FC_DECODER(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FC_DECODER))
typedef struct _PangoFcDecoder PangoFcDecoder;
typedef struct _PangoFcDecoderClass PangoFcDecoderClass;
#define PANGO_FC_DECODER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FC_DECODER, PangoFcDecoderClass))
#define PANGO_IS_FC_DECODER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FC_DECODER))
#define PANGO_FC_DECODER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FC_DECODER, PangoFcDecoderClass))
/**
* PangoFcDecoder:
*
* #PangoFcDecoder is a virtual base class that implementations will
* inherit from. It's the interface that is used to define a custom
* encoding for a font. These objects are created in your code from a
* function callback that was originally registered with
* pango_fc_font_map_add_decoder_find_func(). Pango requires
* information about the supported charset for a font as well as the
* individual character to glyph conversions. Pango gets that
* information via the #get_charset and #get_glyph callbacks into your
* object implementation.
*
* Since: 1.6
**/
struct _PangoFcDecoder
{
/*< private >*/
GObject parent_instance;
};
/**
* PangoFcDecoderClass:
* @get_charset: This returns an #FcCharset given a #PangoFcFont that
* includes a list of supported characters in the font. The
* #FcCharSet that is returned should be an internal reference to your
* code. Pango will not free this structure. It is important that
* you make this callback fast because this callback is called
* separately for each character to determine Unicode coverage.
* @get_glyph: This returns a single #PangoGlyph for a given Unicode
* code point.
*
* Class structure for #PangoFcDecoder.
*
* Since: 1.6
**/
struct _PangoFcDecoderClass
{
/*< private >*/
GObjectClass parent_class;
/* vtable - not signals */
/*< public >*/
FcCharSet *(*get_charset) (PangoFcDecoder *decoder,
PangoFcFont *fcfont);
PangoGlyph (*get_glyph) (PangoFcDecoder *decoder,
PangoFcFont *fcfont,
guint32 wc);
/*< private >*/
/* Padding for future expansion */
void (*_pango_reserved1) (void);
void (*_pango_reserved2) (void);
void (*_pango_reserved3) (void);
void (*_pango_reserved4) (void);
};
PANGO_AVAILABLE_IN_1_6
GType pango_fc_decoder_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_6
FcCharSet *pango_fc_decoder_get_charset (PangoFcDecoder *decoder,
PangoFcFont *fcfont);
PANGO_AVAILABLE_IN_1_6
PangoGlyph pango_fc_decoder_get_glyph (PangoFcDecoder *decoder,
PangoFcFont *fcfont,
guint32 wc);
G_END_DECLS
#endif /* __PANGO_DECODER_H_ */

166
node_modules/sharp/vendor/include/pango/pangofc-font.h generated vendored Normal file
View File

@ -0,0 +1,166 @@
/* Pango
* pangofc-font.h: Base fontmap type for fontconfig-based backends
*
* Copyright (C) 2003 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_FC_FONT_H__
#define __PANGO_FC_FONT_H__
#include <pango/pango.h>
/* Freetype has undefined macros in its header */
#ifdef PANGO_COMPILATION
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wundef"
#endif
#include <ft2build.h>
#include FT_FREETYPE_H
#include <fontconfig/fontconfig.h>
#ifdef PANGO_COMPILATION
#pragma GCC diagnostic pop
#endif
G_BEGIN_DECLS
#define PANGO_TYPE_FC_FONT (pango_fc_font_get_type ())
#define PANGO_FC_FONT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FC_FONT, PangoFcFont))
#define PANGO_IS_FC_FONT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FC_FONT))
typedef struct _PangoFcFont PangoFcFont;
typedef struct _PangoFcFontClass PangoFcFontClass;
#if defined(PANGO_ENABLE_ENGINE) || defined(PANGO_ENABLE_BACKEND)
/**
* PANGO_RENDER_TYPE_FC:
*
* A string constant used to identify shape engines that work
* with the fontconfig based backends. See the @engine_type field
* of #PangoEngineInfo.
**/
#define PANGO_RENDER_TYPE_FC "PangoRenderFc"
#ifdef PANGO_ENABLE_BACKEND
#define PANGO_FC_FONT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FC_FONT, PangoFcFontClass))
#define PANGO_IS_FC_FONT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FC_FONT))
#define PANGO_FC_FONT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FC_FONT, PangoFcFontClass))
/**
* PangoFcFont:
*
* #PangoFcFont is a base class for font implementations
* using the Fontconfig and FreeType libraries and is used in
* conjunction with #PangoFcFontMap. When deriving from this
* class, you need to implement all of its virtual functions
* other than shutdown() along with the get_glyph_extents()
* virtual function from #PangoFont.
**/
struct _PangoFcFont
{
PangoFont parent_instance;
FcPattern *font_pattern; /* fully resolved pattern */
PangoFontMap *fontmap; /* associated map */
gpointer priv; /* used internally */
PangoMatrix matrix; /* used internally */
PangoFontDescription *description;
GSList *metrics_by_lang;
guint is_hinted : 1;
guint is_transformed : 1;
};
/**
* PangoFcFontClass:
* @lock_face: Returns the FT_Face of the font and increases
* the reference count for the face by one.
* @unlock_face: Decreases the reference count for the
* FT_Face of the font by one. When the count is zero,
* the #PangoFcFont subclass is allowed to free the
* FT_Face.
* @has_char: Return %TRUE if the the font contains a glyph
* corresponding to the specified character.
* @get_glyph: Gets the glyph that corresponds to the given
* Unicode character.
* @get_unknown_glyph: (nullable): Gets the glyph that
* should be used to display an unknown-glyph indication
* for the specified Unicode character. May be %NULL.
* @shutdown: (nullable): Performs any font-specific
* shutdown code that needs to be done when
* pango_fc_font_map_shutdown is called. May be %NULL.
*
* Class structure for #PangoFcFont.
**/
struct _PangoFcFontClass
{
/*< private >*/
PangoFontClass parent_class;
/*< public >*/
FT_Face (*lock_face) (PangoFcFont *font);
void (*unlock_face) (PangoFcFont *font);
gboolean (*has_char) (PangoFcFont *font,
gunichar wc);
guint (*get_glyph) (PangoFcFont *font,
gunichar wc);
PangoGlyph (*get_unknown_glyph) (PangoFcFont *font,
gunichar wc);
void (*shutdown) (PangoFcFont *font);
/*< private >*/
/* Padding for future expansion */
void (*_pango_reserved1) (void);
void (*_pango_reserved2) (void);
void (*_pango_reserved3) (void);
void (*_pango_reserved4) (void);
};
#endif /* PANGO_ENABLE_BACKEND */
PANGO_AVAILABLE_IN_1_4
gboolean pango_fc_font_has_char (PangoFcFont *font,
gunichar wc);
PANGO_AVAILABLE_IN_1_4
guint pango_fc_font_get_glyph (PangoFcFont *font,
gunichar wc);
#ifndef PANGO_DISABLE_DEPRECATED
PANGO_DEPRECATED_FOR(PANGO_GET_UNKNOWN_GLYPH)
PangoGlyph pango_fc_font_get_unknown_glyph (PangoFcFont *font,
gunichar wc);
PANGO_DEPRECATED_IN_1_32
void pango_fc_font_kern_glyphs (PangoFcFont *font,
PangoGlyphString *glyphs);
#endif /* PANGO_DISABLE_DEPRECATED */
#endif /* PANGO_ENABLE_ENGINE || PANGO_ENABLE_BACKEND */
PANGO_AVAILABLE_IN_ALL
GType pango_fc_font_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_4
FT_Face pango_fc_font_lock_face (PangoFcFont *font);
PANGO_AVAILABLE_IN_1_4
void pango_fc_font_unlock_face (PangoFcFont *font);
G_END_DECLS
#endif /* __PANGO_FC_FONT_H__ */

329
node_modules/sharp/vendor/include/pango/pangofc-fontmap.h generated vendored Normal file
View File

@ -0,0 +1,329 @@
/* Pango
* pangofc-fontmap.h: Base fontmap type for fontconfig-based backends
*
* Copyright (C) 2003 Red Hat Software
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGO_FC_FONT_MAP_H__
#define __PANGO_FC_FONT_MAP_H__
#include <pango/pango.h>
#include <fontconfig/fontconfig.h>
#include <pango/pangofc-decoder.h>
#include <pango/pangofc-font.h>
G_BEGIN_DECLS
#ifdef PANGO_ENABLE_BACKEND
/**
* PangoFcFontsetKey:
*
* An opaque structure containing all the information needed for
* loading a fontset with the PangoFc fontmap.
*
* Since: 1.24
**/
typedef struct _PangoFcFontsetKey PangoFcFontsetKey;
PANGO_AVAILABLE_IN_1_24
PangoLanguage *pango_fc_fontset_key_get_language (const PangoFcFontsetKey *key);
PANGO_AVAILABLE_IN_1_24
const PangoFontDescription *pango_fc_fontset_key_get_description (const PangoFcFontsetKey *key);
PANGO_AVAILABLE_IN_1_24
const PangoMatrix *pango_fc_fontset_key_get_matrix (const PangoFcFontsetKey *key);
PANGO_AVAILABLE_IN_1_24
double pango_fc_fontset_key_get_absolute_size (const PangoFcFontsetKey *key);
PANGO_AVAILABLE_IN_1_24
double pango_fc_fontset_key_get_resolution (const PangoFcFontsetKey *key);
PANGO_AVAILABLE_IN_1_24
gpointer pango_fc_fontset_key_get_context_key (const PangoFcFontsetKey *key);
/**
* PangoFcFontKey:
*
* An opaque structure containing all the information needed for
* loading a font with the PangoFc fontmap.
*
* Since: 1.24
**/
typedef struct _PangoFcFontKey PangoFcFontKey;
PANGO_AVAILABLE_IN_1_24
const FcPattern *pango_fc_font_key_get_pattern (const PangoFcFontKey *key);
PANGO_AVAILABLE_IN_1_24
const PangoMatrix *pango_fc_font_key_get_matrix (const PangoFcFontKey *key);
PANGO_AVAILABLE_IN_1_24
gpointer pango_fc_font_key_get_context_key (const PangoFcFontKey *key);
PANGO_AVAILABLE_IN_1_40
const char *pango_fc_font_key_get_variations (const PangoFcFontKey *key);
#endif
/*
* PangoFcFontMap
*/
#define PANGO_TYPE_FC_FONT_MAP (pango_fc_font_map_get_type ())
#define PANGO_FC_FONT_MAP(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FC_FONT_MAP, PangoFcFontMap))
#define PANGO_IS_FC_FONT_MAP(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FC_FONT_MAP))
typedef struct _PangoFcFontMap PangoFcFontMap;
typedef struct _PangoFcFontMapClass PangoFcFontMapClass;
typedef struct _PangoFcFontMapPrivate PangoFcFontMapPrivate;
#ifdef PANGO_ENABLE_BACKEND
#define PANGO_FC_FONT_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), PANGO_TYPE_FC_FONT_MAP, PangoFcFontMapClass))
#define PANGO_IS_FC_FONT_MAP_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), PANGO_TYPE_FC_FONT_MAP))
#define PANGO_FC_FONT_MAP_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), PANGO_TYPE_FC_FONT_MAP, PangoFcFontMapClass))
/**
* PangoFcFontMap:
*
* #PangoFcFontMap is a base class for font map implementations
* using the Fontconfig and FreeType libraries. To create a new
* backend using Fontconfig and FreeType, you derive from this class
* and implement a new_font() virtual function that creates an
* instance deriving from #PangoFcFont.
**/
struct _PangoFcFontMap
{
PangoFontMap parent_instance;
PangoFcFontMapPrivate *priv;
};
/**
* PangoFcFontMapClass:
* @default_substitute: (nullable): Substitutes in default
* values for unspecified fields in a #FcPattern. This will
* be called prior to creating a font for the pattern. May be
* %NULL. Deprecated in favor of @font_key_substitute().
* @new_font: Creates a new #PangoFcFont for the specified
* pattern of the appropriate type for this font map. The
* @pattern argument must be passed to the "pattern" property
* of #PangoFcFont when you call g_object_new(). Deprecated
* in favor of @create_font().
* @get_resolution: Gets the resolution (the scale factor
* between logical and absolute font sizes) that the backend
* will use for a particular fontmap and context. @context
* may be null.
* @context_key_get: Gets an opaque key holding backend
* specific options for the context that will affect
* fonts created by @create_font(). The result must point to
* persistant storage owned by the fontmap. This key
* is used to index hash tables used to look up fontsets
* and fonts.
* @context_key_copy: Copies a context key. Pango uses this
* to make a persistant copy of the value returned from
* @context_key_get.
* @context_key_free: Frees a context key copied with
* @context_key_copy.
* @context_key_hash: Gets a hash value for a context key
* @context_key_equal: Compares two context keys for equality.
* @fontset_key_substitute: (nullable): Substitutes in
* default values for unspecified fields in a
* #FcPattern. This will be called prior to creating a font
* for the pattern. May be %NULL. (Since: 1.24)
* @create_font: (nullable): Creates a new #PangoFcFont for
* the specified pattern of the appropriate type for this
* font map using information from the font key that is
* passed in. The @pattern member of @font_key can be
* retrieved using pango_fc_font_key_get_pattern() and must
* be passed to the "pattern" property of #PangoFcFont when
* you call g_object_new(). If %NULL, new_font() is used.
* (Since: 1.24)
*
* Class structure for #PangoFcFontMap.
**/
struct _PangoFcFontMapClass
{
/*< private >*/
PangoFontMapClass parent_class;
/*< public >*/
/* Deprecated in favor of fontset_key_substitute */
void (*default_substitute) (PangoFcFontMap *fontmap,
FcPattern *pattern);
/* Deprecated in favor of create_font */
PangoFcFont *(*new_font) (PangoFcFontMap *fontmap,
FcPattern *pattern);
double (*get_resolution) (PangoFcFontMap *fcfontmap,
PangoContext *context);
gconstpointer (*context_key_get) (PangoFcFontMap *fcfontmap,
PangoContext *context);
gpointer (*context_key_copy) (PangoFcFontMap *fcfontmap,
gconstpointer key);
void (*context_key_free) (PangoFcFontMap *fcfontmap,
gpointer key);
guint32 (*context_key_hash) (PangoFcFontMap *fcfontmap,
gconstpointer key);
gboolean (*context_key_equal) (PangoFcFontMap *fcfontmap,
gconstpointer key_a,
gconstpointer key_b);
void (*fontset_key_substitute)(PangoFcFontMap *fontmap,
PangoFcFontsetKey *fontsetkey,
FcPattern *pattern);
PangoFcFont *(*create_font) (PangoFcFontMap *fontmap,
PangoFcFontKey *fontkey);
/*< private >*/
/* Padding for future expansion */
void (*_pango_reserved1) (void);
void (*_pango_reserved2) (void);
void (*_pango_reserved3) (void);
void (*_pango_reserved4) (void);
};
#ifndef PANGO_DISABLE_DEPRECATED
PANGO_DEPRECATED_IN_1_22_FOR(pango_font_map_create_context)
PangoContext * pango_fc_font_map_create_context (PangoFcFontMap *fcfontmap);
#endif
PANGO_AVAILABLE_IN_1_4
void pango_fc_font_map_shutdown (PangoFcFontMap *fcfontmap);
#endif
PANGO_AVAILABLE_IN_ALL
GType pango_fc_font_map_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_4
void pango_fc_font_map_cache_clear (PangoFcFontMap *fcfontmap);
PANGO_AVAILABLE_IN_1_38
void
pango_fc_font_map_config_changed (PangoFcFontMap *fcfontmap);
PANGO_AVAILABLE_IN_1_38
void
pango_fc_font_map_set_config (PangoFcFontMap *fcfontmap,
FcConfig *fcconfig);
PANGO_AVAILABLE_IN_1_38
FcConfig *
pango_fc_font_map_get_config (PangoFcFontMap *fcfontmap);
/**
* PangoFcDecoderFindFunc:
* @pattern: a fully resolved #FcPattern specifying the font on the system
* @user_data: user data passed to pango_fc_font_map_add_decoder_find_func()
*
* Callback function passed to pango_fc_font_map_add_decoder_find_func().
*
* Return value: a new reference to a custom decoder for this pattern,
* or %NULL if the default decoder handling should be used.
**/
typedef PangoFcDecoder * (*PangoFcDecoderFindFunc) (FcPattern *pattern,
gpointer user_data);
PANGO_AVAILABLE_IN_1_6
void pango_fc_font_map_add_decoder_find_func (PangoFcFontMap *fcfontmap,
PangoFcDecoderFindFunc findfunc,
gpointer user_data,
GDestroyNotify dnotify);
PANGO_AVAILABLE_IN_1_26
PangoFcDecoder *pango_fc_font_map_find_decoder (PangoFcFontMap *fcfontmap,
FcPattern *pattern);
PANGO_AVAILABLE_IN_1_4
PangoFontDescription *pango_fc_font_description_from_pattern (FcPattern *pattern,
gboolean include_size);
/**
* PANGO_FC_GRAVITY:
*
* String representing a fontconfig property name that Pango sets on any
* fontconfig pattern it passes to fontconfig if a #PangoGravity other
* than %PANGO_GRAVITY_SOUTH is desired.
*
* The property will have a #PangoGravity value as a string, like "east".
* This can be used to write fontconfig configuration rules to choose
* different fonts for horizontal and vertical writing directions.
*
* Since: 1.20
*/
#define PANGO_FC_GRAVITY "pangogravity"
/**
* PANGO_FC_VERSION:
*
* String representing a fontconfig property name that Pango sets on any
* fontconfig pattern it passes to fontconfig.
*
* The property will have an integer value equal to what
* pango_version() returns.
* This can be used to write fontconfig configuration rules that only affect
* certain pango versions (or only pango-using applications, or only
* non-pango-using applications).
*
* Since: 1.20
*/
#define PANGO_FC_VERSION "pangoversion"
/**
* PANGO_FC_PRGNAME:
*
* String representing a fontconfig property name that Pango sets on any
* fontconfig pattern it passes to fontconfig.
*
* The property will have a string equal to what
* g_get_prgname() returns.
* This can be used to write fontconfig configuration rules that only affect
* certain applications.
*
* This is equivalent to FC_PRGNAME in versions of fontconfig that have that.
*
* Since: 1.24
*/
#define PANGO_FC_PRGNAME "prgname"
/**
* PANGO_FC_FONT_FEATURES:
*
* String representing a fontconfig property name that Pango reads from font
* patterns to populate list of OpenType features to be enabled for the font
* by default.
*
* The property will have a number of string elements, each of which is the
* OpenType feature tag of one feature to enable.
*
* This is equivalent to FC_FONT_FEATURES in versions of fontconfig that have that.
*
* Since: 1.34
*/
#define PANGO_FC_FONT_FEATURES "fontfeatures"
/**
* PANGO_FC_FONT_VARIATIONS:
*
* String representing a fontconfig property name that Pango reads from font
* patterns to populate list of OpenType font variations to be used for a font.
*
* The property will have a string elements, each of which a comma-separated
* list of OpenType axis setting of the form AXIS=VALUE.
*/
#define PANGO_FC_FONT_VARIATIONS "fontvariations"
G_END_DECLS
#endif /* __PANGO_FC_FONT_MAP_H__ */

144
node_modules/sharp/vendor/include/pango/pangoft2.h generated vendored Normal file
View File

@ -0,0 +1,144 @@
/* Pango
* pangoft2.h:
*
* Copyright (C) 1999 Red Hat Software
* Copyright (C) 2000 Tor Lillqvist
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#ifndef __PANGOFT2_H__
#define __PANGOFT2_H__
#include <fontconfig/fontconfig.h>
#include <pango/pango-layout.h>
#include <pango/pangofc-font.h>
G_BEGIN_DECLS
#ifndef PANGO_DISABLE_DEPRECATED
/**
* PANGO_RENDER_TYPE_FT2:
*
* A string constant that was used to identify shape engines that work
* with the FreeType backend. See %PANGO_RENDER_TYPE_FC for the replacement.
*/
#define PANGO_RENDER_TYPE_FT2 "PangoRenderFT2"
#endif
#define PANGO_TYPE_FT2_FONT_MAP (pango_ft2_font_map_get_type ())
#define PANGO_FT2_FONT_MAP(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), PANGO_TYPE_FT2_FONT_MAP, PangoFT2FontMap))
#define PANGO_FT2_IS_FONT_MAP(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), PANGO_TYPE_FT2_FONT_MAP))
typedef struct _PangoFT2FontMap PangoFT2FontMap;
/**
* PangoFT2SubstituteFunc:
* @pattern: the <type>FcPattern</type> to tweak.
* @data: user data.
*
* Function type for doing final config tweaking on prepared FcPatterns.
*/
typedef void (*PangoFT2SubstituteFunc) (FcPattern *pattern,
gpointer data);
/* Calls for applications */
PANGO_AVAILABLE_IN_ALL
void pango_ft2_render (FT_Bitmap *bitmap,
PangoFont *font,
PangoGlyphString *glyphs,
gint x,
gint y);
PANGO_AVAILABLE_IN_1_6
void pango_ft2_render_transformed (FT_Bitmap *bitmap,
const PangoMatrix *matrix,
PangoFont *font,
PangoGlyphString *glyphs,
int x,
int y);
PANGO_AVAILABLE_IN_ALL
void pango_ft2_render_layout_line (FT_Bitmap *bitmap,
PangoLayoutLine *line,
int x,
int y);
PANGO_AVAILABLE_IN_1_6
void pango_ft2_render_layout_line_subpixel (FT_Bitmap *bitmap,
PangoLayoutLine *line,
int x,
int y);
PANGO_AVAILABLE_IN_ALL
void pango_ft2_render_layout (FT_Bitmap *bitmap,
PangoLayout *layout,
int x,
int y);
PANGO_AVAILABLE_IN_1_6
void pango_ft2_render_layout_subpixel (FT_Bitmap *bitmap,
PangoLayout *layout,
int x,
int y);
PANGO_AVAILABLE_IN_ALL
GType pango_ft2_font_map_get_type (void) G_GNUC_CONST;
PANGO_AVAILABLE_IN_1_2
PangoFontMap *pango_ft2_font_map_new (void);
PANGO_AVAILABLE_IN_1_2
void pango_ft2_font_map_set_resolution (PangoFT2FontMap *fontmap,
double dpi_x,
double dpi_y);
PANGO_AVAILABLE_IN_1_2
void pango_ft2_font_map_set_default_substitute (PangoFT2FontMap *fontmap,
PangoFT2SubstituteFunc func,
gpointer data,
GDestroyNotify notify);
PANGO_AVAILABLE_IN_1_2
void pango_ft2_font_map_substitute_changed (PangoFT2FontMap *fontmap);
#ifndef PANGO_DISABLE_DEPRECATED
PANGO_DEPRECATED_IN_1_22_FOR(pango_font_map_create_context)
PangoContext *pango_ft2_font_map_create_context (PangoFT2FontMap *fontmap);
#endif
/* API for rendering modules
*/
#ifndef PANGO_DISABLE_DEPRECATED
PANGO_DEPRECATED_FOR(pango_font_map_create_context)
PangoContext *pango_ft2_get_context (double dpi_x,
double dpi_y);
PANGO_DEPRECATED_FOR(pango_ft2_font_map_new)
PangoFontMap *pango_ft2_font_map_for_display (void);
PANGO_DEPRECATED
void pango_ft2_shutdown_display (void);
PANGO_DEPRECATED_FOR(PANGO_GET_UNKNOWN_GLYPH)
PangoGlyph pango_ft2_get_unknown_glyph (PangoFont *font);
PANGO_DEPRECATED_FOR(pango_fc_font_kern_glyphs)
int pango_ft2_font_get_kerning (PangoFont *font,
PangoGlyph left,
PangoGlyph right);
PANGO_DEPRECATED_FOR(pango_fc_font_lock_face)
FT_Face pango_ft2_font_get_face (PangoFont *font);
PANGO_DEPRECATED_FOR(pango_font_get_coverage)
PangoCoverage *pango_ft2_font_get_coverage (PangoFont *font,
PangoLanguage *language);
#endif /* PANGO_DISABLE_DEPRECATED */
G_END_DECLS
#endif /* __PANGOFT2_H__ */