pango_split_file_list ()

char**      pango_split_file_list           (const char *str);

Splits a G_SEARCHPATH_SEPARATOR-separated list of files, stripping white space and substituting ~/ with $HOME/.

pango_trim_string ()

char*       pango_trim_string               (const char *str);

Trims leading and trailing whitespace from a string.

pango_read_line ()

gint        pango_read_line                 (FILE *stream,
                                             GString *str);

Reads an entire line from a file into a buffer. Lines may be delimited with '\n', '\r', '\n\r', or '\r\n'. The delimiter is not written into the buffer. Text after a '#' character is treated as a comment and skipped. '\' can be used to escape a # character. '\' proceeding a line delimiter combines adjacent lines. A '\' proceeding any other character is ignored and written into the output buffer unmodified.

pango_skip_space ()

gboolean    pango_skip_space                (const char **pos);

Skips 0 or more characters of white space.

pango_scan_word ()

gboolean    pango_scan_word                 (const char **pos,
                                             GString *out);

Scans a word into a GString buffer. A word consists of [A-Za-z_] followed by zero or more [A-Za-z_0-9] Leading white space is skipped.

pango_scan_string ()

gboolean    pango_scan_string               (const char **pos,
                                             GString *out);

Scans a string into a GString buffer. The string may either be a sequence of non-white-space characters, or a quoted string with '"'. Instead a quoted string, '\"' represents a literal quote. Leading white space outside of quotes is skipped.

pango_scan_int ()

gboolean    pango_scan_int                  (const char **pos,
                                             int *out);

Scans an integer. Leading white space is skipped.

pango_config_key_get ()

char*       pango_config_key_get            (const char *key);

Looks up a key in the Pango config database (pseudo-win.ini style, read from $sysconfdir/pango/pangorc, ~/.pangorc, and getenv (PANGO_RC_FILE).)

pango_lookup_aliases ()

void        pango_lookup_aliases            (const char *fontname,
                                             char ***families,
                                             int *n_families);

Look up all user defined aliases for the alias fontname. The resulting font family names will be stored in families, and the number of families in n_families.

pango_parse_enum ()

gboolean    pango_parse_enum                (GType type,
                                             const char *str,
                                             int *value,
                                             gboolean warn,
                                             char **possible_values);

Parses an enum type and stored the result in value.

If str does not match the nick name of any of the possible values for the enum, FALSE is returned, a warning is issued if warn is TRUE, and a string representing the list of possible values is stored in possible_values. The list is slash-separated, eg. "none/start/middle/end". If failed and possible_values is not NULL, returned string should be freed using g_free().

Since 1.16

pango_parse_style ()

gboolean    pango_parse_style               (const char *str,
                                             PangoStyle *style,
                                             gboolean warn);

Parses a font style. The allowed values are "normal", "italic" and "oblique", case variations being ignored.

pango_parse_variant ()

gboolean    pango_parse_variant             (const char *str,
                                             PangoVariant *variant,
                                             gboolean warn);

Parses a font variant. The allowed values are "normal" and "smallcaps" or "small_caps", case variations being ignored.

pango_parse_weight ()

gboolean    pango_parse_weight              (const char *str,
                                             PangoWeight *weight,
                                             gboolean warn);

Parses a font weight. The allowed values are "heavy", "ultrabold", "bold", "normal", "light", "ultraleight" and integers. Case variations are ignored.

pango_parse_stretch ()

gboolean    pango_parse_stretch             (const char *str,
                                             PangoStretch *stretch,
                                             gboolean warn);

Parses a font stretch. The allowed values are "ultra_condensed", "extra_condensed", "condensed", "semi_condensed", "normal", "semi_expanded", "expanded", "extra_expanded" and "ultra_expanded". Case variations are ignored and the '_' characters may be omitted.

pango_get_sysconf_subdirectory ()

const char* pango_get_sysconf_subdirectory  (void);

On Unix, returns the name of the "pango" subdirectory of SYSCONFDIR (which is set at compile time). On Win32, returns a subdirectory of the Pango installation directory (which is deduced at run time from the DLL's location, or stored in the Registry).

pango_get_lib_subdirectory ()

const char* pango_get_lib_subdirectory      (void);

On Unix, returns the name of the "pango" subdirectory of LIBDIR (which is set at compile time). On Win32, returns the Pango installation directory (which is deduced at run time from the DLL's location, or stored in the Registry). The returned string should not be freed.

pango_log2vis_get_embedding_levels ()

guint8*     pango_log2vis_get_embedding_levels
                                            (const gchar *text,
                                             int length,
                                             PangoDirection *pbase_dir);

This will return the bidirectional embedding levels of the input paragraph as defined by the Unicode Bidirectional Algorithm available at:

http://www.unicode.org/reports/tr9/

If the input base direction is a weak direction, the direction of the characters in the text will determine the final resolved direction.

Since 1.4

pango_language_get_default ()

PangoLanguage* pango_language_get_default   (void);

Returns the PangoLanguage for the current locale of the process. Note that this can change over the life of an application.

On Unix systems, this is the return value is derived from setlocale(LC_CTYPE, NULL), and the user can affect this through the environment variables LC_ALL, LC_CTYPE or LANG (checked in that order). The locale string typically is in the form lang_COUNTRY, where lang is an ISO-639 language code, and COUNTRY is an ISO-3166 country code. For instance, sv_FI for Swedish as written in Finland or pt_BR for Portuguese as written in Brazil.

On Windows, the C library does not use any such environment variables, and setting them won't affect the behavior of functions like ctime(). The user sets the locale through the Regional Options in the Control Panel. The C library (in the setlocale() function) does not use country and language codes, but country and language names spelled out in English. However, this function does check the above environment variables, and does return a Unix-style locale string based on either said environment variables or the thread's current locale.

Your application should call setlocale(LC_ALL, ""); for the user settings to take effect. Gtk+ does this in its initialization functions automatically (by calling gtk_set_locale()). See man setlocale for more details.

Since 1.16

pango_language_get_sample_string ()

const char* pango_language_get_sample_string
                                            (PangoLanguage *language);

Get a string that is representative of the characters needed to render a particular language. This function is a bad hack for internal use by renderers and Pango.

pango_is_zero_width ()

gboolean    pango_is_zero_width             (gunichar ch);

Checks ch to see if it is a character that should not be normally rendered on the screen. This includes all Unicode characters with "ZERO WIDTH" in their name, as well as bidi formatting characters, and a few other ones. This is totally different from g_unichar_iszerowidth() and is at best misnamed.

Since 1.10

pango_quantize_line_geometry ()

void        pango_quantize_line_geometry    (int *thickness,
                                             int *position);

Quantizes the thickness and position of a line, typically an underline or strikethrough, to whole device pixels, that is integer multiples of PANGO_SCALE. The purpose of this function is to avoid such lines looking blurry.

Since 1.12