diff --git a/include/gdi.h b/include/gdi.h index 5de4e63d..1afd4733 100644 --- a/include/gdi.h +++ b/include/gdi.h @@ -12730,7 +12730,8 @@ typedef struct _LAYOUTLINE LAYOUTLINE; MG_EXPORT LAYOUTINFO* GUIAPI CreateLayoutInfo( const TEXTRUNSINFO* run_info, Uint32 render_flags, const BreakOppo* break_oppos, BOOL persist_lines, - int letter_spacing, int word_spacing, int tab_size); + int letter_spacing, int word_spacing, int tab_size, + int* tabs, int nr_tabs); /** * Destroy the specified layout information structure. diff --git a/src/include/unicode-ops.h b/src/include/unicode-ops.h index 0238d29d..0486f9bd 100644 --- a/src/include/unicode-ops.h +++ b/src/include/unicode-ops.h @@ -43,10 +43,11 @@ #ifndef GUI_UNICODE_OPS_H #define GUI_UNICODE_OPS_H -#define UCHAR_SPACE 0x0020 -#define UCHAR_SHY 0x00AD -#define UCHAR_IDSPACE 0x3000 -#define UCHAR_TAB 0x0009 +#define UCHAR_TAB 0x0009 +#define UCHAR_SPACE 0x0020 +#define UCHAR_SHY 0x00AD +#define UCHAR_IDSPACE 0x3000 +#define UCHAR_LINE_SEPARATOR 0x2028 #define PAREN_STACK_DEPTH 128 diff --git a/src/newgdi/layout-ellipsize.c b/src/newgdi/layout-ellipsize.c index 42ddddf5..524af21e 100644 --- a/src/newgdi/layout-ellipsize.c +++ b/src/newgdi/layout-ellipsize.c @@ -353,24 +353,6 @@ static void shape_ellipsis (EllipsizeState *state) state->ellipsis_width += glyphs->glyphs[i].width; } -#if 0 -/* Helper function to advance a PangoAttrIterator to a particular - * byte index. - */ -static void advance_iterator_to (PangoAttrIterator *iter, int new_index) -{ - int start, end; - - do - { - pango_attr_iterator_range (iter, &start, &end); - if (end > new_index) - break; - } - while (pango_attr_iterator_next (iter)); -} -#endif - /* Updates the shaping of the ellipsis if necessary when we move the * position of the start of the gap. * @@ -609,7 +591,6 @@ static void get_run_list (EllipsizeState *state, LAYOUTLINE* line) if (run_iter->end_char != run_info->run->lrun->len) { partial_end_run = run_info->run; run_info->run = __mg_glyph_run_split (run_info->run, - state->layout->truninfo->ucs, run_iter->end_index - run_info->run->lrun->si); } @@ -617,7 +598,6 @@ static void get_run_list (EllipsizeState *state, LAYOUTLINE* line) run_iter = &state->gap_start_iter.run_iter; if (run_iter->start_char != 0) { partial_start_run = __mg_glyph_run_split (run_info->run, - state->layout->truninfo->ucs, run_iter->start_index - run_info->run->lrun->si); } diff --git a/src/newgdi/layout-utils.c b/src/newgdi/layout-utils.c index 55c8cc09..fd3efb64 100644 --- a/src/newgdi/layout-utils.c +++ b/src/newgdi/layout-utils.c @@ -124,6 +124,15 @@ void __mg_release_logfont_for_layout(const LAYOUTINFO* layout, ReleaseRes(Str2Key(my_fontname)); } +/* + * Not like Pango, we simply use the properties of the referenced TextRun + * for the new orphan LayoutRun, including the direction, the orientation, + * the embedding level, and the language, except the script type. + * + * Therefore, we assume that the text of the new LayoutRun are all + * in the same script, same direction, and same orientation. This is + * enough for the ellipsis. + */ LayoutRun* __mg_layout_run_new_orphan(const LAYOUTINFO* layout, const TextRun* trun, const Uchar32* ucs, int nr_ucs) { @@ -142,7 +151,7 @@ LayoutRun* __mg_layout_run_new_orphan(const LAYOUTINFO* layout, lrun->si = trun->si; lrun->len = trun->len; lrun->lc = trun->lc; - lrun->st = trun->st; + lrun->st = UCharGetScriptType(ucs[0]); lrun->el = trun->el; lrun->dir = trun->dir; lrun->ort = trun->ort; @@ -339,7 +348,6 @@ void __mg_glyph_run_free(GlyphRun* run) /** * __mg_glyph_run_split: * @orig: a #GlyphRun - * @text: text to which positions in @orig apply * @split_index: byte index of position to split item, relative to the start of the item * * Modifies @orig to cover only the text after @split_index, and @@ -357,8 +365,7 @@ void __mg_glyph_run_free(GlyphRun* run) * @split_index, which should be freed * with pango_glyph_run_free(). **/ -GlyphRun *__mg_glyph_run_split (GlyphRun *orig, - const Uchar32 *text, int split_index) +GlyphRun *__mg_glyph_run_split (GlyphRun *orig, int split_index) { GlyphRun *new_grun; int i; diff --git a/src/newgdi/layoutinfo.c b/src/newgdi/layoutinfo.c index fbfeb42c..8e4b074e 100644 --- a/src/newgdi/layoutinfo.c +++ b/src/newgdi/layoutinfo.c @@ -56,7 +56,8 @@ LAYOUTINFO* GUIAPI CreateLayoutInfo( const TEXTRUNSINFO* truninfo, Uint32 render_flags, const BreakOppo* break_oppos, BOOL persist_lines, - int letter_spacing, int word_spacing, int tab_size) + int letter_spacing, int word_spacing, int tab_size, + int* tabs, int nr_tabs) { LAYOUTINFO* layout; @@ -75,6 +76,8 @@ LAYOUTINFO* GUIAPI CreateLayoutInfo( layout->ls = letter_spacing; layout->ws = word_spacing; layout->ts = tab_size; + layout->tabs = tabs; + layout->nr_tabs = nr_tabs; INIT_LIST_HEAD(&layout->lines); layout->nr_left_ucs = truninfo->nr_ucs; @@ -152,10 +155,8 @@ struct _LayoutState { const TextRun* trun; // Current layout run LayoutRun* lrun; - // Start index of line in current lrun */ - int start_index_in_lrun; - // the number of not fit uchars in current text run - int left_ucs_in_lrun; + // Start index of layout run in current text run */ + int start_index_in_trun; // Goal width of line currently processing; < 0 is infinite int line_width; @@ -180,11 +181,134 @@ static BOOL should_ellipsize_current_line(LAYOUTINFO *layout, int __mg_shape_layout_run(const TEXTRUNSINFO* info, const LayoutRun* run, GlyphString* glyphs) { - return 0; + if (!info->sei.shape(info->sei.inst, info, run, glyphs)) + return 0; + + return glyphs->nr_glyphs; +} + +static void ensure_tab_width(LAYOUTINFO *layout) +{ + if (layout->ts == -1) { + /* Find out how wide 8 spaces are in the context's default + * font. + */ + + // TODO + + /* We need to make sure the ts is > 0 so finding tab positions + * terminates. This check should be necessary only under extreme + * problems with the font. + */ + if (layout->ts <= 0) + layout->ts = 50; /* pretty much arbitrary */ + } +} + +/* For now we only need the tab position, we assume + * all tabs are left-aligned. + */ +static int get_tab_pos(LAYOUTINFO *layout, int index, BOOL *is_default) +{ + int n_tabs; + + if (layout->tabs) { + n_tabs = layout->nr_tabs; + if (is_default) + *is_default = FALSE; + } + else { + n_tabs = 0; + if (is_default) + *is_default = TRUE; + } + + if (index < n_tabs) { + return layout->tabs[index]; + } + + if (n_tabs > 0) { + /* Extrapolate tab position, repeating the last tab gap to + * infinity. + */ + int last_pos = 0; + int next_to_last_pos = 0; + int ts; + + last_pos = layout->tabs[n_tabs - 1]; + + if (n_tabs > 1) + next_to_last_pos = layout->tabs[n_tabs - 2]; + else + next_to_last_pos = 0; + + if (last_pos > next_to_last_pos) { + ts = last_pos - next_to_last_pos; + } + else { + ts = layout->ts; + } + + return last_pos + ts * (index - n_tabs + 1); + } + else { + /* No tab array set, so use default tab width + */ + return layout->ts * index; + } +} + +static int get_line_width(LAYOUTLINE *line) +{ + struct list_head *l; + int i; + int width = 0; + + /* Compute the width of the line currently - inefficient, but easier + * than keeping the current width of the line up to date everywhere + */ + list_for_each(l, &line->gruns) { + GlyphRun *run = (GlyphRun*)l; + + for (i = 0; i < run->gs->nr_glyphs; i++) + width += run->gs->glyphs[i].width; + } + + return width; } static void shape_tab(LAYOUTLINE *line, GlyphString *glyphs) { + int i, space_width; + + int current_width = get_line_width(line); + + __mg_glyph_string_set_size (glyphs, 1); + + glyphs->glyphs[0].gv = INV_GLYPH_VALUE; + glyphs->glyphs[0].x_off = 0; + glyphs->glyphs[0].y_off = 0; + glyphs->glyphs[0].is_cluster_start = 1; + + glyphs->log_clusters[0] = 0; + + ensure_tab_width (line->layout); + space_width = line->layout->ts / 8; + + for (i=0; ; i++) { + BOOL is_default; + int tab_pos = get_tab_pos (line->layout, i, &is_default); + /* Make sure there is at least a space-width of space between + * tab-aligned text and the text before it. However, only do + * this if no tab array is set on the layout, ie. using default + * tab positions. If use has set tab positions, respect it to + * the pixel. + */ + if (tab_pos >= current_width + (is_default ? space_width : 1)) { + glyphs->glyphs[0].width = tab_pos - current_width; + break; + } + } } static void shape_shape(const Uchar32* ucs, int nr_ucs, @@ -207,9 +331,11 @@ static void shape_shape(const Uchar32* ucs, int nr_ucs, static void shape_full(const Uchar32* lrun_ucs, int nr_lrun_ucs, const Uchar32* para_ucs, int nr_para_ucs, - const TEXTRUNSINFO* truninfo, LayoutRun* textrun, + const TEXTRUNSINFO* info, LayoutRun* lrun, GlyphString* glyphs) { + // TODO + info->sei.shape(info->sei.inst, info, lrun, glyphs); } static void distribute_letter_spacing (int letter_spacing, @@ -230,7 +356,7 @@ static GlyphString* shape_run(LAYOUTLINE *line, LayoutState *state, LAYOUTINFO *layout = line->layout; GlyphString *glyphs = __mg_glyph_string_new (); - if (layout->truninfo->ucs[lrun->si] == '\t') + if (layout->truninfo->ucs[lrun->si] == UCHAR_TAB) shape_tab(line, glyphs); else { if (state->shape_set) @@ -377,10 +503,6 @@ BreakResult process_text_run(LAYOUTINFO *layout, int i; BOOL processing_new_lrun = FALSE; - /* Only one character has type UCHAR_CATEGORY_LINE_SEPARATOR in - * Unicode 12.0; update this if that changes. */ -#define LINE_SEPARATOR 0x2028 - if (!state->glyphs) { state->glyphs = shape_run (line, state, lrun); @@ -391,17 +513,16 @@ BreakResult process_text_run(LAYOUTINFO *layout, } if (!layout->single_paragraph && - layout->truninfo->ucs[lrun->si] == LINE_SEPARATOR && + layout->truninfo->ucs[lrun->si] == UCHAR_LINE_SEPARATOR && !should_ellipsize_current_line (layout, state)) { - insert_run (line, state, lrun, TRUE); + insert_run(line, state, lrun, TRUE); state->log_widths_offset += lrun->len; return BREAK_LINE_SEPARATOR; } - if (state->remaining_width < 0 && !no_break_at_end) /* Wrapping off */ - { + if (state->remaining_width < 0 && !no_break_at_end) { + /* Wrapping off */ insert_run (line, state, lrun, TRUE); - return BREAK_ALL_FIT; } @@ -449,7 +570,8 @@ retry_break: if (width > state->remaining_width && break_num_chars < lrun->len) break; - /* If there are no previous runs we have to take care to grab at least one char. */ + /* If there are no previous runs we have to take care to + * grab at least one char. */ if (can_break_at (layout, state->start_offset + num_chars, retrying_with_char_breaks) && (num_chars > 0 || !list_empty(&line->gruns))) @@ -466,9 +588,11 @@ retry_break: * XXX Currently it doesn't quite match the logic there. We don't check * the cluster here. But should be fine in practice. */ if (break_num_chars > 0 && break_num_chars < lrun->len && - layout->bos[state->start_offset + break_num_chars - 1] & BOV_WHITESPACE) + layout->bos[state->start_offset + break_num_chars - 1] & + BOV_WHITESPACE) { - break_width -= state->log_widths[state->log_widths_offset + break_num_chars - 1]; + break_width -= state->log_widths[state->log_widths_offset + + break_num_chars - 1]; } if ((layout->rf & GRF_OVERFLOW_WRAP_MASK) == GRF_OVERFLOW_WRAP_NORMAL @@ -483,8 +607,8 @@ retry_break: goto retry_break; } - if (force_fit || break_width <= state->remaining_width) /* Successfully broke the lrun */ - { + if (force_fit || break_width <= state->remaining_width) { + /* Successfully broke the lrun */ if (state->remaining_width >= 0) { state->remaining_width -= break_width; state->remaining_width = MAX (state->remaining_width, 0); @@ -498,13 +622,16 @@ retry_break: return BREAK_EMPTY_FIT; } else { + LayoutRun* new_lrun; GlyphRun *grun; + new_lrun = __mg_layout_run_split(lrun, break_num_chars); + /* Add the width back, to the line, reshape, subtract the new width */ state->remaining_width += break_width; - grun = insert_run (line, state, lrun, FALSE); - break_width = __mg_glyph_string_get_width (grun->gs); + grun = insert_run (line, state, new_lrun, FALSE); + break_width = __mg_glyph_string_get_width(grun->gs); state->remaining_width -= break_width; state->log_widths_offset += break_num_chars; @@ -1076,7 +1203,8 @@ static void layout_line_postprocess (LAYOUTLINE *line, (wrapped || ellipsized)) { /* if we ellipsized, we don't have remaining_width set */ if (state->remaining_width < 0) - state->remaining_width = state->line_width - layout_line_get_width (line); + state->remaining_width = state->line_width - + layout_line_get_width (line); justify_words (line, state); } @@ -1085,32 +1213,13 @@ static void layout_line_postprocess (LAYOUTLINE *line, line->layout->is_ellipsized |= ellipsized; } -static void add_line (LAYOUTLINE *line, LayoutState *state) -{ -#if 0 - LAYOUTINFO *layout = line->layout; - - list_add_tail(&line->list, &layout->lines); - layout->nr_lines++; - - if (layout->height >= 0) { - PangoRectangle logical_rect; - pango_layout_line_get_extents (line, NULL, &logical_rect); - state->remaining_height -= logical_rect.height; - state->remaining_height -= layout->spacing; - state->line_height = logical_rect.height; - } -#else - // do nothing -#endif -} - static LAYOUTLINE* check_next_line(LAYOUTINFO* layout, LayoutState* state) { LAYOUTLINE *line; + struct list_head* t; BOOL have_break = FALSE; // If we've seen a possible break yet - int break_remaining_width = 0;// Remaining width before adding run with break + int break_remaining_width = 0;// Left width before adding run with break int break_start_offset = 0; // Start offset before adding run with break struct list_head *break_link = NULL; // Link holding run before break BOOL wrapped = FALSE; // If we had to wrap the line @@ -1125,21 +1234,32 @@ static LAYOUTLINE* check_next_line(LAYOUTINFO* layout, LayoutState* state) else state->remaining_width = state->line_width; - while (state->lrun) { - LayoutRun *lrun = state->lrun; + list_for_each_ex(t, &layout->truninfo->truns, &state->trun->list) { + state->trun = (const TextRun*)t; + LayoutRun *lrun; BreakResult result; int old_num_chars; int old_remaining_width; BOOL first_lrun_in_line; + if (state->start_index_in_trun > 0) { + lrun = __mg_layout_run_new_from_offset(layout, + state->trun, state->start_index_in_trun); + } + else { + lrun = __mg_layout_run_new_from(layout, state->trun); + } + state->lrun = lrun; + old_num_chars = lrun->len; old_remaining_width = state->remaining_width; - first_lrun_in_line = !list_empty(&line->gruns); + first_lrun_in_line = list_empty(&line->gruns); result = process_text_run(layout, line, state, !have_break, FALSE); switch (result) { case BREAK_ALL_FIT: - if (can_break_in (layout, state->start_offset, old_num_chars, first_lrun_in_line)) + if (can_break_in (layout, state->start_offset, + old_num_chars, first_lrun_in_line)) { have_break = TRUE; break_remaining_width = old_remaining_width; @@ -1198,7 +1318,6 @@ static LAYOUTLINE* check_next_line(LAYOUTINFO* layout, LayoutState* state) done: layout_line_postprocess (line, state, wrapped); - add_line (line, state); state->line_of_par++; state->line_start_index += line->len; return line; @@ -1221,7 +1340,14 @@ LAYOUTLINE* GUIAPI LayoutNextLine( if (layout->persist && layout->nr_left_ucs == 0) { // already laid out - if (prev_line && &prev_line->list != &layout->lines) { + if (list_empty(&layout->lines)) + return NULL; + + if (prev_line == NULL) { + next_line = (LAYOUTLINE*)layout->lines.next; + goto out; + } + else if ((struct list_head*)prev_line != &layout->lines) { next_line = (LAYOUTLINE*)prev_line->list.next; goto out; } @@ -1243,30 +1369,24 @@ LAYOUTLINE* GUIAPI LayoutNextLine( state.log_widths_offset = 0; if (prev_line == NULL) { - state.line_start_index = 0; if (list_empty(&layout->truninfo->truns)) { - next_line = layout_line_new(layout); - next_line->si = state.line_start_index; - next_line->is_paragraph_start = TRUE; - line_set_resolved_dir(next_line, layout->truninfo->run_dir); - goto next_line; + // empty line + next_line = NULL; + goto out; } + state.line_start_index = 0; + state.start_index_in_trun = 0; state.trun = (TextRun*)&layout->truninfo->truns.next; - state.lrun = __mg_layout_run_new_from(layout, state.trun); - state.start_index_in_lrun = 0; - state.left_ucs_in_lrun = state.lrun->len; } else { - state.start_offset = layout->truninfo->nr_ucs - layout->nr_left_ucs; + state.line_start_index = layout->truninfo->nr_ucs - layout->nr_left_ucs; state.trun = __mg_textruns_get_by_offset(layout->truninfo, - state.start_offset, &state.start_index_in_lrun); + state.start_offset, &state.start_index_in_trun); if (state.trun == NULL) { - return NULL; + next_line = NULL; + goto out; } - state.lrun = __mg_layout_run_new_from_offset(layout, - state.trun, state.start_index_in_lrun); - state.left_ucs_in_lrun = state.lrun->len - state.start_index_in_lrun; } state.line_width = max_extent; @@ -1274,7 +1394,6 @@ LAYOUTLINE* GUIAPI LayoutNextLine( next_line = check_next_line(layout, &state); -next_line: if (next_line) { if (layout->persist) { list_add_tail(&next_line->list, &layout->lines); @@ -1283,7 +1402,7 @@ next_line: release_line(prev_line); } - layout->nr_lines ++; + layout->nr_lines++; layout->nr_left_ucs -= next_line->len; } diff --git a/src/newgdi/layoutinfo.h b/src/newgdi/layoutinfo.h index 7edc85fa..4aa86f0d 100644 --- a/src/newgdi/layoutinfo.h +++ b/src/newgdi/layoutinfo.h @@ -105,6 +105,7 @@ struct _LAYOUTLINE { struct _LAYOUTINFO { const TEXTRUNSINFO* truninfo; const BreakOppo* bos; + const int* tabs; // tabstop array Uint32 rf; // rendering flags int ls; // letter spacing @@ -113,6 +114,7 @@ struct _LAYOUTINFO { struct list_head lines; // the list head of lines + int nr_tabs; // number of tabstops int nr_left_ucs;// the number of chars not laied out int nr_lines; // the number of lines @@ -146,8 +148,7 @@ LOGFONT* __mg_create_logfont_for_layout(const LAYOUTINFO* layout, void __mg_release_logfont_for_layout(const LAYOUTINFO* layout, const char* fontname, GlyphOrient ort); -GlyphRun *__mg_glyph_run_split (GlyphRun *orig, - const Uchar32 *text, int split_index); +GlyphRun *__mg_glyph_run_split (GlyphRun *orig, int split_index); void __mg_glyph_run_free(GlyphRun* run); LayoutRun* __mg_layout_run_new_orphan(const LAYOUTINFO* layout, diff --git a/src/newgdi/shape-glyphs-basic.c b/src/newgdi/shape-glyphs-basic.c index efee49bc..b09153a2 100644 --- a/src/newgdi/shape-glyphs-basic.c +++ b/src/newgdi/shape-glyphs-basic.c @@ -77,7 +77,7 @@ static void reverse_shaped_glyphs(ShapedGlyph* glyphs, int len) } } -static BOOL shape_text_run(SEInstance* inst, +static BOOL shape_layout_run(SEInstance* inst, const TEXTRUNSINFO* info, const LayoutRun* run, GlyphString* gs) { @@ -254,11 +254,44 @@ out: return ok; } -BOOL GUIAPI InitBasicShapingEngine(TEXTRUNSINFO* info) +struct _SEInstance { + const char* name; + int ref_count; +}; + +static struct _SEInstance shaping_engine_basic = { + "Basic Shapping Engine", 0 +}; + +static BOOL destroy_instance(SEInstance* instance) { - info->sei.shape = shape_text_run; + if (instance == &shaping_engine_basic) { + shaping_engine_basic.ref_count--; + return TRUE; + } + + _ERR_PRINTF("%s: you are destroying a non-basic shaping engine instance.\n", + __FUNCTION__); + return FALSE; } +BOOL GUIAPI InitBasicShapingEngine(TEXTRUNSINFO* info) +{ + shaping_engine_basic.ref_count++; + + info->sei.inst = &shaping_engine_basic; + info->sei.shape = shape_layout_run; + info->sei.free = destroy_instance; + return TRUE; +} + +#ifdef _MGDEVEL_MODE +int GetBasicShapingEngineRefCount(void) +{ + return shaping_engine_basic.ref_count; +} +#endif /* _MGDEVEL_MODE */ + #endif /* _MGCHARSET_UNICODE */ diff --git a/src/newgdi/textrunsinfo.c b/src/newgdi/textrunsinfo.c index 66b43bbd..8adf7d33 100644 --- a/src/newgdi/textrunsinfo.c +++ b/src/newgdi/textrunsinfo.c @@ -236,11 +236,7 @@ static BOOL state_process_run (TextRunState *state) for (p = state->run_start; p < state->run_end; p++) { Uchar32 uc = *p; -/* Only one character has the category LINE_SEPARATOR in Unicode 12.0; - * update this if that changes. */ -#define LINE_SEPARATOR 0x2028 - - BOOL is_forced_break = (uc == '\t' || uc == LINE_SEPARATOR); + BOOL is_forced_break = (uc == UCHAR_TAB || uc == UCHAR_LINE_SEPARATOR); BOOL no_shaping; no_shaping = is_uchar_no_shaping(uc); @@ -516,32 +512,6 @@ TEXTRUNSINFO* GUIAPI CreateTextRunsInfo(Uchar32* ucs, int nr_ucs, INIT_LIST_HEAD(&runinfo->truns); runinfo->nr_runs = 0; -#if 0 - int i, j; - BidiLevel max_level = 0; - BidiLevel level_or, level_and; - - // make the embedding levels of the bidi marks to be -1. - level_or = 0, level_and = 1; - j = 0; - for (i = 0; i < nr_ucs; i++) { - if (BIDI_IS_EXPLICIT_OR_BN (bidi_ts[i])) { - els[i] = -1; - } - else { - level_or |= els[j]; - level_and &= els[j]; - j++; - } - } - - // check for all even or odd - /* If none of the levels had the LSB set, all chars were even. */ - runinfo->all_even = (level_or & 0x1) == 0; - /* If all of the levels had the LSB set, all chars were odd. */ - runinfo->all_odd = (level_and & 0x1) == 1; -#endif - if (!create_text_runs(runinfo, els)) { _ERR_PRINTF("%s: failed to call create_text_runs.\n", __FUNCTION__); @@ -572,6 +542,7 @@ BOOL GUIAPI SetFontInTextRuns(TEXTRUNSINFO* runinfo, if (list_empty(&runinfo->truns)) return FALSE; + // TODO return FALSE; } diff --git a/src/newgdi/textrunsinfo.h b/src/newgdi/textrunsinfo.h index 0b7b6c90..3dae2250 100644 --- a/src/newgdi/textrunsinfo.h +++ b/src/newgdi/textrunsinfo.h @@ -49,7 +49,7 @@ typedef struct _GlyphString GlyphString; typedef struct _SEInstance SEInstance; typedef struct _TextAttrMap TextAttrMap; -typedef BOOL (*CB_SHAPE_TEXT_RUN)(SEInstance* instance, +typedef BOOL (*CB_SHAPE_LAYOUT_RUN)(SEInstance* instance, const TEXTRUNSINFO* info, const LayoutRun* run, GlyphString* gs); @@ -62,7 +62,7 @@ struct _ShapingEngineInfo { SEInstance* inst; /* callback to shap a text run */ - CB_SHAPE_TEXT_RUN shape; + CB_SHAPE_LAYOUT_RUN shape; /* callback to destroy the shaping engine instance */ CB_DESTROY_INSTANCE free;