From 1df726dd10e34c7ea3884e27626e2a893c5bfd8e Mon Sep 17 00:00:00 2001 From: Vincent Wei Date: Tue, 2 Apr 2019 09:27:06 +0800 Subject: [PATCH] tune gravity and orientation --- include/gdi.h | 60 +++++++++++----------- src/font/unicode-script.c | 48 ++++++++++-------- src/newgdi/layout-utils.c | 49 ++++++++---------- src/newgdi/layoutinfo.c | 104 ++++++++++++++++---------------------- src/newgdi/layoutinfo.h | 10 +++- src/newgdi/textrunsinfo.c | 30 +++++------ 6 files changed, 141 insertions(+), 160 deletions(-) diff --git a/include/gdi.h b/include/gdi.h index 5f012b5d..fd2deaf6 100644 --- a/include/gdi.h +++ b/include/gdi.h @@ -9080,37 +9080,34 @@ typedef enum { } GlyphRunDir; typedef enum { - LAYOUT_GRAVITY_SOUTH = 0, - LAYOUT_GRAVITY_EAST, - LAYOUT_GRAVITY_NORTH, - LAYOUT_GRAVITY_WEST, - LAYOUT_GRAVITY_AUTO, -} LayoutGravity; + GLYPH_GRAVITY_SOUTH = 0, + GLYPH_GRAVITY_EAST, + GLYPH_GRAVITY_NORTH, + GLYPH_GRAVITY_WEST, + GLYPH_GRAVITY_AUTO, +} GlyphGravity; typedef enum { - LAYOUT_GRAVITY_POLICY_NATURAL, - LAYOUT_GRAVITY_POLICY_STRONG, - LAYOUT_GRAVITY_POLICY_LINE, -} LayoutGravityPolicy; - -#define LAYOUT_GRAVITY_IS_VERTICAL(gravity) \ - ((gravity) == LAYOUT_GRAVITY_EAST || (gravity) == LAYOUT_GRAVITY_WEST) + GLYPH_GRAVITY_POLICY_NATURAL, + GLYPH_GRAVITY_POLICY_STRONG, + GLYPH_GRAVITY_POLICY_LINE, +} GlyphGravityPolicy; /** Get the vertical orientation property of a Unicode character */ MG_EXPORT UVerticalOrient GUIAPI UCharGetVerticalOrientation(Uchar32 uc); /** - * \fn LayoutGravity GUIAPI ScriptGetLayoutGravity(ScriptType script, - * LayoutGravity base_gravity, LayoutGravityPolicy policy) + * \fn GlyphGravity GUIAPI ScriptGetGlyphGravity(ScriptType script, + * GlyphGravity base_gravity, GlyphGravityPolicy policy) * \brief Based on the script, base gravity, and policy, returns actual gravity * to use in laying out a single glyph run. * - * If @base_orient is %LAYOUT_GRAVITY_AUTO, it is first replaced with the + * If @base_orient is %GLYPH_GRAVITY_AUTO, it is first replaced with the * preferred orientation of @script. To get the preferred orientation of a script, - * pass %LAYOUT_GRAVITY_AUTO and %LAYOUT_GRAVITY_POLICY_STRONG in. + * pass %GLYPH_GRAVITY_AUTO and %GLYPH_GRAVITY_POLICY_STRONG in. * * \param script The script type to query - * \param base_gravity The base gravity of the paragraph/layout + * \param base_gravity The base gravity of the layout * \param policy The gravity policy * * \param The resolved gravity suitable to use for a layout run of text @@ -9118,24 +9115,24 @@ MG_EXPORT UVerticalOrient GUIAPI UCharGetVerticalOrientation(Uchar32 uc); * * Since: 3.4.0 */ -MG_EXPORT LayoutGravity GUIAPI ScriptGetLayoutGravity(ScriptType script, - LayoutGravity base_gravity, LayoutGravityPolicy policy); +MG_EXPORT GlyphGravity GUIAPI ScriptGetGlyphGravity(ScriptType script, + GlyphGravity base_gravity, GlyphGravityPolicy policy); /** - * \fn LayoutGravity GUIAPI ScriptGetLayoutGravityForWide (ScriptType script, - * BOOL wide, LayoutGravity base_gravity, LayoutGravityPolicy policy) + * \fn GlyphGravity GUIAPI ScriptGetGlyphGravityForWide (ScriptType script, + * BOOL wide, GlyphGravity base_gravity, GlyphGravityPolicy policy) * \brief Based on the script, East Asian width, base gravity, and policy, * returns the actual gravity to use in laying out a single character * or a run of text. * - * This function is similar to ScriptGetLayoutGravity() except + * This function is similar to ScriptGetGlyphGravity() except * that this function makes a distinction between narrow/half-width and * wide/full-width characters also. Wide/full-width characters always * stand upright, that is, they always take the * base gravity, whereas narrow/half-width characters are always * rotated in vertical context. * - * If @base_orient is %LAYOUT_GRAVITY_AUTO, it is first replaced with the + * If @base_orient is %GLYPH_GRAVITY_AUTO, it is first replaced with the * preferred gravity of @script. * * \param script The script type to query @@ -9148,8 +9145,8 @@ MG_EXPORT LayoutGravity GUIAPI ScriptGetLayoutGravity(ScriptType script, * * Since: 3.4.0 */ -LayoutGravity ScriptGetLayoutGravityForWide (ScriptType script, - BOOL wide, LayoutGravity base_gravity, LayoutGravityPolicy policy); +GlyphGravity ScriptGetGlyphGravityForWide (ScriptType script, + BOOL wide, GlyphGravity base_gravity, GlyphGravityPolicy policy); /** @} end of unicode_ops */ @@ -12197,6 +12194,7 @@ MG_EXPORT int GUIAPI UChars2AChars(LOGFONT* logfont, const Uchar32* ucs, */ #define GRF_WRITING_MODE_MASK 0xF0000000 +#define GRF_WRITING_MODE_VERTICAL_FLAG 0x20000000 /** * Top-to-bottom horizontal direction. * Both the writing mode and the typographic mode are horizontal. @@ -12408,10 +12406,10 @@ MG_EXPORT int GUIAPI UChars2AChars(LOGFONT* logfont, const Uchar32* ucs, /** @} end of glyph_render_flags */ typedef enum { - GLYPH_ORIENT_UPRIGHT = 0, - GLYPH_ORIENT_SIDEWAYS, - GLYPH_ORIENT_UPSIDE_DOWN, - GLYPH_ORIENT_SIDEWAYS_LEFT, + GLYPH_ORIENT_UPRIGHT = GLYPH_GRAVITY_SOUTH, + GLYPH_ORIENT_SIDEWAYS = GLYPH_GRAVITY_EAST, + GLYPH_ORIENT_UPSIDE_DOWN = GLYPH_GRAVITY_NORTH, + GLYPH_ORIENT_SIDEWAYS_LEFT = GLYPH_GRAVITY_WEST, } GlyphOrient; typedef enum { @@ -13121,7 +13119,7 @@ MG_EXPORT TEXTRUN* GetNextTextRunInfo(TEXTRUNSINFO* runinfo, /* Get layout line information */ MG_EXPORT BOOL GUIAPI GetLayoutLineInfo(LAYOUTLINE* line, - int* line_no, int* max_extent, int* nr_chars, int* nr_glyphs, + int* max_extent, int* nr_chars, int* nr_glyphs, int** log_widths, int* width, int* height, BOOL* is_ellipsized, BOOL* is_wrapped); #endif diff --git a/src/font/unicode-script.c b/src/font/unicode-script.c index 1b37ba1b..92a89d94 100644 --- a/src/font/unicode-script.c +++ b/src/font/unicode-script.c @@ -405,7 +405,7 @@ typedef struct { /* VerticalDirection */ Uint8 vert_dir; /* Orientation in vertical context */ - /* LayoutGravity */ + /* GlyphGravity */ Uint8 preferred_gravity; /* Preferred context gravity */ /* BOOL */ @@ -422,9 +422,9 @@ typedef struct { #define RTL HORIZONTAL_DIRECTION_RTL #define WEAK HORIZONTAL_DIRECTION_WEAK -#define S LAYOUT_GRAVITY_SOUTH -#define E LAYOUT_GRAVITY_EAST -#define W LAYOUT_GRAVITY_WEST +#define S GLYPH_GRAVITY_SOUTH +#define E GLYPH_GRAVITY_EAST +#define W GLYPH_GRAVITY_WEST #define UNKNOWN_SCRIPT_PROPERTY \ {LTR, NONE, S, FALSE} @@ -633,28 +633,32 @@ static inline ScriptTypeProperties get_script_properties (ScriptType script) return script_properties[script]; } -LayoutGravity ScriptGetLayoutGravity (ScriptType script, - LayoutGravity base_gravity, LayoutGravityPolicy hint) +GlyphGravity ScriptGetGlyphGravity (ScriptType script, + GlyphGravity base_gravity, GlyphGravityPolicy hint) { ScriptTypeProperties props = get_script_properties (script); - if (base_gravity == LAYOUT_GRAVITY_AUTO) + if (base_gravity == GLYPH_GRAVITY_AUTO) base_gravity = props.preferred_gravity; - return ScriptGetLayoutGravityForWide (script, props.wide, + return ScriptGetGlyphGravityForWide (script, props.wide, base_gravity, hint); } -LayoutGravity ScriptGetLayoutGravityForWide (ScriptType script, - BOOL wide, LayoutGravity base_gravity, LayoutGravityPolicy hint) + +#define GLYPH_GRAVITY_IS_VERTICAL(gravity) \ + ((gravity) == GLYPH_GRAVITY_EAST || (gravity) == GLYPH_GRAVITY_WEST) + +GlyphGravity ScriptGetGlyphGravityForWide (ScriptType script, + BOOL wide, GlyphGravity base_gravity, GlyphGravityPolicy hint) { ScriptTypeProperties props = get_script_properties (script); BOOL vertical; - if (base_gravity == LAYOUT_GRAVITY_AUTO) + if (base_gravity == GLYPH_GRAVITY_AUTO) base_gravity = props.preferred_gravity; - vertical = LAYOUT_GRAVITY_IS_VERTICAL(base_gravity); + vertical = GLYPH_GRAVITY_IS_VERTICAL(base_gravity); /* Everything is designed such that a system with no vertical support * renders everything correctly horizontally. So, if not in a vertical @@ -670,24 +674,24 @@ LayoutGravity ScriptGetLayoutGravityForWide (ScriptType script, */ switch (hint) { default: - case LAYOUT_GRAVITY_POLICY_NATURAL: + case GLYPH_GRAVITY_POLICY_NATURAL: if (props.vert_dir == VERTICAL_DIRECTION_NONE) - return LAYOUT_GRAVITY_SOUTH; - if ((base_gravity == LAYOUT_GRAVITY_EAST) ^ + return GLYPH_GRAVITY_SOUTH; + if ((base_gravity == GLYPH_GRAVITY_EAST) ^ (props.vert_dir == VERTICAL_DIRECTION_BTT)) - return LAYOUT_GRAVITY_SOUTH; + return GLYPH_GRAVITY_SOUTH; else - return LAYOUT_GRAVITY_NORTH; + return GLYPH_GRAVITY_NORTH; - case LAYOUT_GRAVITY_POLICY_STRONG: + case GLYPH_GRAVITY_POLICY_STRONG: return base_gravity; - case LAYOUT_GRAVITY_POLICY_LINE: - if ((base_gravity == LAYOUT_GRAVITY_EAST) ^ + case GLYPH_GRAVITY_POLICY_LINE: + if ((base_gravity == GLYPH_GRAVITY_EAST) ^ (props.horiz_dir == GLYPH_RUN_DIR_RTL)) - return LAYOUT_GRAVITY_SOUTH; + return GLYPH_GRAVITY_SOUTH; else - return LAYOUT_GRAVITY_NORTH; + return GLYPH_GRAVITY_NORTH; } } #endif /* _MGCHARSET_UNICODE */ diff --git a/src/newgdi/layout-utils.c b/src/newgdi/layout-utils.c index c8f3dc6e..7d696b46 100644 --- a/src/newgdi/layout-utils.c +++ b/src/newgdi/layout-utils.c @@ -127,29 +127,18 @@ void __mg_release_logfont_for_layout(const LAYOUTINFO* layout, static GlyphOrient resolve_glyph_orient(const LAYOUTINFO* layout, const TextRun* trun) { - LayoutGravity gravity; + GlyphGravity gravity; - if (layout->grv_plc == LAYOUT_GRAVITY_POLICY_STRONG) { - return layout->orient; + if (layout->grv_plc == GLYPH_GRAVITY_POLICY_STRONG) { + assert(layout->grv_base != GLYPH_GRAVITY_AUTO); + return layout->grv_base; } - gravity = ScriptGetLayoutGravityForWide(trun->st, + gravity = ScriptGetGlyphGravityForWide(trun->st, trun->flags & TEXTRUN_FLAG_UPRIGHT, layout->grv_base, layout->grv_plc); - switch (gravity) { - case LAYOUT_GRAVITY_SOUTH: - return GLYPH_ORIENT_UPRIGHT; - case LAYOUT_GRAVITY_EAST: - return GLYPH_ORIENT_SIDEWAYS; - case LAYOUT_GRAVITY_NORTH: - return GLYPH_ORIENT_SIDEWAYS_LEFT; - case LAYOUT_GRAVITY_WEST: - return GLYPH_ORIENT_UPSIDE_DOWN; - default: - break; - } - return GLYPH_ORIENT_UPRIGHT; + return (GlyphOrient)gravity; } static void resolve_layout_run_dir(const LAYOUTINFO* layout, @@ -166,29 +155,31 @@ static void resolve_layout_run_dir(const LAYOUTINFO* layout, * it's a counter-clockwise-rotated layout, so the rotated * top is unrotated right. */ - switch (layout->grv_base) { - case LAYOUT_GRAVITY_SOUTH: + switch (lrun->ort) { + case GLYPH_GRAVITY_SOUTH: default: - lrun->dir = (lrun->el & 1) ? GLYPH_RUN_DIR_RTL : GLYPH_RUN_DIR_LTR; break; - case LAYOUT_GRAVITY_NORTH: + case GLYPH_GRAVITY_NORTH: lrun->el++; - lrun->dir = (lrun->el & 1) ? GLYPH_RUN_DIR_RTL : GLYPH_RUN_DIR_LTR; break; - case LAYOUT_GRAVITY_EAST: + case GLYPH_GRAVITY_EAST: lrun->el += 1; lrun->el &= ~1; - lrun->dir = (lrun->el & 1) ? GLYPH_RUN_DIR_TTB : GLYPH_RUN_DIR_BTT; break; - case LAYOUT_GRAVITY_WEST: + case GLYPH_GRAVITY_WEST: lrun->el |= 1; - lrun->dir = (lrun->el & 1) ? GLYPH_RUN_DIR_TTB : GLYPH_RUN_DIR_BTT; break; } - if (LAYOUT_GRAVITY_IS_VERTICAL(layout->grv_base) && - lrun->ort == GLYPH_ORIENT_UPRIGHT) - lrun->flags |= LAYOUTRUN_FLAG_CENTERED_BASELINE; + if (layout->rf & GRF_WRITING_MODE_VERTICAL_FLAG) { + lrun->dir = (lrun->el & 1) ? GLYPH_RUN_DIR_TTB : GLYPH_RUN_DIR_BTT; + + if (lrun->ort == GLYPH_ORIENT_UPRIGHT) + lrun->flags |= LAYOUTRUN_FLAG_CENTERED_BASELINE; + } + else { + lrun->dir = (lrun->el & 1) ? GLYPH_RUN_DIR_RTL : GLYPH_RUN_DIR_LTR; + } } /* diff --git a/src/newgdi/layoutinfo.c b/src/newgdi/layoutinfo.c index dd9f7a23..5f5c6b90 100644 --- a/src/newgdi/layoutinfo.c +++ b/src/newgdi/layoutinfo.c @@ -116,47 +116,37 @@ LAYOUTINFO* GUIAPI CreateLayoutInfo( INIT_LIST_HEAD(&layout->lines); layout->nr_left_ucs = truninfo->nr_ucs; - switch (render_flags & GRF_WRITING_MODE_MASK) { - default: - case GRF_WRITING_MODE_HORIZONTAL_TB: - layout->grv_base = LAYOUT_GRAVITY_SOUTH; - break; - case GRF_WRITING_MODE_HORIZONTAL_BT: - layout->grv_base = LAYOUT_GRAVITY_NORTH; - break; - case GRF_WRITING_MODE_VERTICAL_RL: - layout->grv_base = LAYOUT_GRAVITY_WEST; - break; - case GRF_WRITING_MODE_VERTICAL_LR: - layout->grv_base = LAYOUT_GRAVITY_EAST; - break; + if (render_flags & GRF_WRITING_MODE_VERTICAL_FLAG) { + switch (render_flags & GRF_TEXT_ORIENTATION_MASK) { + case GRF_TEXT_ORIENTATION_AUTO: + layout->grv_base = GLYPH_GRAVITY_SOUTH; + layout->grv_plc = GLYPH_GRAVITY_POLICY_NATURAL; + break; + case GRF_TEXT_ORIENTATION_MIXED: + layout->grv_base = GLYPH_GRAVITY_SOUTH; + layout->grv_plc = GLYPH_GRAVITY_POLICY_LINE; + break; + case GRF_TEXT_ORIENTATION_UPRIGHT: + layout->grv_base = GLYPH_GRAVITY_SOUTH; + layout->grv_plc = GLYPH_GRAVITY_POLICY_STRONG; + break; + case GRF_TEXT_ORIENTATION_SIDEWAYS: + layout->grv_base = GLYPH_GRAVITY_EAST; + layout->grv_plc = GLYPH_GRAVITY_POLICY_STRONG; + break; + case GRF_TEXT_ORIENTATION_UPSIDE_DOWN: + layout->grv_base = GLYPH_GRAVITY_NORTH; + layout->grv_plc = GLYPH_GRAVITY_POLICY_STRONG; + break; + case GRF_TEXT_ORIENTATION_SIDEWAYS_LEFT: + layout->grv_base = GLYPH_GRAVITY_WEST; + layout->grv_plc = GLYPH_GRAVITY_POLICY_STRONG; + break; + } } - - switch (render_flags & GRF_TEXT_ORIENTATION_MASK) { - case GRF_TEXT_ORIENTATION_AUTO: - layout->grv_plc = LAYOUT_GRAVITY_POLICY_NATURAL; - layout->orient = GLYPH_ORIENT_UPRIGHT; - break; - case GRF_TEXT_ORIENTATION_MIXED: - layout->grv_plc = LAYOUT_GRAVITY_POLICY_LINE; - layout->orient = GLYPH_ORIENT_UPRIGHT; - break; - case GRF_TEXT_ORIENTATION_UPRIGHT: - layout->grv_plc = LAYOUT_GRAVITY_POLICY_STRONG; - layout->orient = GLYPH_ORIENT_UPRIGHT; - break; - case GRF_TEXT_ORIENTATION_SIDEWAYS: - layout->grv_plc = LAYOUT_GRAVITY_POLICY_STRONG; - layout->orient = GLYPH_ORIENT_SIDEWAYS; - break; - case GRF_TEXT_ORIENTATION_UPSIDE_DOWN: - layout->grv_plc = LAYOUT_GRAVITY_POLICY_STRONG; - layout->orient = GLYPH_ORIENT_UPSIDE_DOWN; - break; - case GRF_TEXT_ORIENTATION_SIDEWAYS_LEFT: - layout->grv_plc = LAYOUT_GRAVITY_POLICY_STRONG; - layout->orient = GLYPH_ORIENT_SIDEWAYS_LEFT; - break; + else { + layout->grv_base = GLYPH_GRAVITY_SOUTH; + layout->grv_plc = GLYPH_GRAVITY_POLICY_STRONG; } layout->persist = persist_lines ? 1 : 0; @@ -944,11 +934,11 @@ static void line_set_resolved_dir(LAYOUTLINE *line, ParagraphDir direction) case BIDI_PGDIR_LTR: case BIDI_PGDIR_WLTR: case BIDI_PGDIR_ON: - line->resolved_dir = GLYPH_RUN_DIR_LTR; + line->resolved_dir = LINE_DIRECTION_LTR; break; case BIDI_PGDIR_RTL: case BIDI_PGDIR_WRTL: - line->resolved_dir = GLYPH_RUN_DIR_RTL; + line->resolved_dir = LINE_DIRECTION_RTL; break; } @@ -961,25 +951,22 @@ static void line_set_resolved_dir(LAYOUTLINE *line, ParagraphDir direction) * If gravity is WEST, set to RTL, as * it's a counter-clockwise-rotated layout, so the rotated * top is unrotated right. - * - * A similar dance is performed in textrunsinfo.c: - * state_add_character(). Keep in sync. */ switch (line->layout->grv_base) { default: - case LAYOUT_GRAVITY_AUTO: - case LAYOUT_GRAVITY_SOUTH: + case GLYPH_GRAVITY_AUTO: + case GLYPH_GRAVITY_SOUTH: break; - case LAYOUT_GRAVITY_NORTH: - line->resolved_dir = GLYPH_RUN_DIR_LTR - + GLYPH_RUN_DIR_RTL + case GLYPH_GRAVITY_NORTH: + line->resolved_dir = LINE_DIRECTION_LTR + + LINE_DIRECTION_RTL - line->resolved_dir; break; - case LAYOUT_GRAVITY_EAST: - line->resolved_dir = GLYPH_RUN_DIR_LTR; + case GLYPH_GRAVITY_EAST: + line->resolved_dir = LINE_DIRECTION_LTR; break; - case LAYOUT_GRAVITY_WEST: - line->resolved_dir = GLYPH_RUN_DIR_RTL; + case GLYPH_GRAVITY_WEST: + line->resolved_dir = LINE_DIRECTION_RTL; break; } } @@ -1904,10 +1891,6 @@ LAYOUTLINE* GUIAPI LayoutNextLine( if (next_line) { next_line->max_extent = max_extent; next_line->is_last_line = last_line; - if (prev_line == 0) - next_line->line_no = 0; - else - next_line->line_no = prev_line->line_no + 1; if (layout->persist) { list_add_tail(&next_line->list, &layout->lines); @@ -2011,7 +1994,7 @@ int GUIAPI CalcLayoutBoundingRect(LAYOUTINFO* layout, } while (1); - // TODO: transform the bouding rectangle according to the wrting mode + // TODO: transform the bouding rectangle according to the writing mode OffsetRect(bounding, x, y); return nr_lines; @@ -2019,14 +2002,13 @@ int GUIAPI CalcLayoutBoundingRect(LAYOUTINFO* layout, #ifdef _MGDEVEL_MODE BOOL GUIAPI GetLayoutLineInfo(LAYOUTLINE* line, - int* line_no, int* max_extent, int* nr_chars, int* nr_glyphs, + int* max_extent, int* nr_chars, int* nr_glyphs, int** log_widths, int* width, int* height, BOOL* is_ellipsized, BOOL* is_wrapped) { if (line == NULL) return FALSE; - if (line_no) *line_no = line->line_no; if (max_extent) *max_extent = line->max_extent; if (nr_chars) *nr_chars = line->len; if (log_widths) *log_widths = line->log_widths; diff --git a/src/newgdi/layoutinfo.h b/src/newgdi/layoutinfo.h index 36f49cde..efbe8111 100644 --- a/src/newgdi/layoutinfo.h +++ b/src/newgdi/layoutinfo.h @@ -91,6 +91,14 @@ struct _GlyphRun { GlyphString* gstr; // the glyph string }; +typedef enum { + LINE_DIRECTION_LTR, + LINE_DIRECTION_RTL, + LINE_DIRECTION_WEAK_LTR, + LINE_DIRECTION_WEAK_RTL, + LINE_DIRECTION_NEUTRAL +} LineDirection; + struct _LAYOUTLINE { struct list_head list; LAYOUTINFO* layout; @@ -105,7 +113,6 @@ struct _LAYOUTLINE { int width; // actual width int height; // actual height - Uint32 line_no:24; // line number (0 for the first line). Uint32 resolved_dir:4; // resolved direction of the line Uint32 is_paragraph_start:1;// is first line of the paragraph? Uint32 is_last_line:1; // is the last line. @@ -134,7 +141,6 @@ struct _LAYOUTINFO { Uint32 grv_base:4; // the base gravity Uint32 grv_plc:2; // the gravity policy specified - Uint32 orient:2; // the glyph orientation specified Uint32 persist:1; // persist lines? Uint32 single_paragraph:1; }; diff --git a/src/newgdi/textrunsinfo.c b/src/newgdi/textrunsinfo.c index 7a40d83b..62108c94 100644 --- a/src/newgdi/textrunsinfo.c +++ b/src/newgdi/textrunsinfo.c @@ -86,7 +86,7 @@ typedef struct _TextRunState { BidiLevel emb_level; Uint8 upright; #if 0 - LayoutGravity grv_rsv; + GlyphGravity grv_rsv; BOOL centered_baseline; #endif @@ -148,13 +148,13 @@ static void state_update_for_new_run (TextRunState *state) if (state->changed & (SCRIPT_CHANGED | WIDTH_CHANGED)) { state->upright = state->width_iter.upright; #if 0 - LayoutGravity gravity = state->runinfo->grv_base; - LayoutGravityPolicy gravity_policy = state->runinfo->grv_plc; + GlyphGravity gravity = state->runinfo->grv_base; + GlyphGravityPolicy gravity_policy = state->runinfo->grv_plc; - if (gravity == LAYOUT_GRAVITY_AUTO) + if (gravity == GLYPH_GRAVITY_AUTO) gravity = state->runinfo->grv_rsv; - state->grv_rsv = ScriptGetLayoutGravityForWide( + state->grv_rsv = ScriptGetGlyphGravityForWide( state->script_iter.script, state->width_iter.upright, gravity, gravity_policy); #endif @@ -213,17 +213,17 @@ static void state_add_character(TextRunState *state, * top is unrotated right. */ switch (state->run->ort) { - case LAYOUT_GRAVITY_SOUTH: + case GLYPH_GRAVITY_SOUTH: default: break; - case LAYOUT_GRAVITY_NORTH: + case GLYPH_GRAVITY_NORTH: state->run->el++; break; - case LAYOUT_GRAVITY_EAST: + case GLYPH_GRAVITY_EAST: state->run->el += 1; state->run->el &= ~1; break; - case LAYOUT_GRAVITY_WEST: + case GLYPH_GRAVITY_WEST: state->run->el |= 1; break; } @@ -320,7 +320,7 @@ static BOOL create_text_runs(TEXTRUNSINFO* runinfo, BidiLevel* els) state.upright = 0; #if 0 state.grv_rsv = runinfo->ort_rsv; - state.centered_baseline = LAYOUT_GRAVITY_IS_VERTICAL(runinfo->grv_rsv); + state.centered_baseline = GLYPH_GRAVITY_IS_VERTICAL(runinfo->grv_rsv); #endif state.run_start = state.text; @@ -364,17 +364,17 @@ static inline Uint8 get_gravity_from_fontname (const char* fontname) { switch (fontGetOrientFromName (fontname)) { case FONT_ORIENT_SIDEWAYS: - return LAYOUT_GRAVITY_EAST; + return GLYPH_GRAVITY_EAST; case FONT_ORIENT_UPSIDE_DOWN: - return LAYOUT_GRAVITY_NORTH; + return GLYPH_GRAVITY_NORTH; case FONT_ORIENT_SIDEWAYS_LEFT: - return LAYOUT_GRAVITY_WEST; + return GLYPH_GRAVITY_WEST; case FONT_ORIENT_UPRIGHT: default: - return LAYOUT_GRAVITY_SOUTH; + return GLYPH_GRAVITY_SOUTH; } } @@ -490,7 +490,7 @@ TEXTRUNSINFO* GUIAPI CreateTextRunsInfo(const Uchar32* ucs, int nr_ucs, runinfo->base_level = (base_dir == BIDI_PGDIR_LTR) ? 0 : 1; runinfo->grv_base = glyph_orient; runinfo->grv_plc = gravity_policy; - if (runinfo->grv_base == LAYOUT_GRAVITY_AUTO) + if (runinfo->grv_base == GLYPH_GRAVITY_AUTO) runinfo->grv_rsv = get_gravity_from_fontname (runinfo->fontname); else runinfo->grv_rsv = runinfo->ort_base;