+2013-01-16 Vladimir Serbinenko <phcoder@gmail.com>
+
+ Improve bidi handling in entry editor.
+
2013-01-16 Vladimir Serbinenko <phcoder@gmail.com>
* grub-core/script/lexer.c (grub_script_lexer_init): Rename getline
return grub_errno;
visual_len = grub_bidi_logical_to_visual (logical, logical_len, &visual,
- 0, 0, 0);
+ 0, 0, 0, 0, 0, 0);
grub_free (logical);
if (visual_len < 0)
return grub_errno;
struct grub_unicode_glyph *visual,
grub_size_t visual_len, unsigned *levels,
grub_ssize_t (*getcharwidth) (const struct grub_unicode_glyph *visual),
- grub_size_t maxwidth, grub_size_t startwidth)
+ grub_size_t maxwidth, grub_size_t startwidth,
+ grub_uint32_t contchar,
+ struct grub_term_pos *pos, int primitive_wrap,
+ grub_size_t log_end)
{
struct grub_unicode_glyph *outptr = visual_out;
unsigned line_start = 0;
unsigned k;
grub_ssize_t last_space = -1;
grub_ssize_t last_space_width = 0;
+ int lines = 0;
auto void revert (unsigned start, unsigned end);
void revert (unsigned start, unsigned end)
{
struct grub_unicode_glyph t;
unsigned i, tl;
+ int a, b;
+ if (pos)
+ {
+ a = pos[visual[start].orig_pos].x;
+ b = pos[visual[end].orig_pos].x;
+ }
for (i = 0; i < (end - start) / 2 + 1; i++)
{
t = visual[start + i];
visual[start + i] = visual[end - i];
visual[end - i] = t;
+
+ if (pos)
+ {
+ pos[visual[start + i].orig_pos].x = a + b - pos[visual[start + i].orig_pos].x;
+ pos[visual[end - i].orig_pos].x = a + b - pos[visual[end - i].orig_pos].x;
+ }
tl = levels[start + i];
levels[start + i] = levels[end - i];
levels[end - i] = tl;
{
grub_ssize_t last_width = 0;
+
+ if (pos && k != visual_len)
+ {
+ pos[visual[k].orig_pos].x = line_width;
+ pos[visual[k].orig_pos].y = lines;
+ pos[visual[k].orig_pos].valid = 1;
+ }
+
+ if (k == visual_len && pos)
+ {
+ pos[log_end].x = line_width;
+ pos[log_end].y = lines;
+ pos[log_end].valid = 1;
+ }
+
if (getcharwidth && k != visual_len)
line_width += last_width = getcharwidth (&visual[k]);
if (k != visual_len && (visual[k].base == ' '
- || visual[k].base == '\t'))
+ || visual[k].base == '\t')
+ && !primitive_wrap)
{
last_space = k;
last_space_width = line_width;
unsigned min_odd_level = 0xffffffff;
unsigned max_level = 0;
+ lines++;
+
if (k != visual_len && last_space > (signed) line_start)
k = last_space;
- else if (k != visual_len && line_start == 0 && startwidth != 0)
+ else if (k != visual_len && line_start == 0 && startwidth != 0
+ && !primitive_wrap)
{
k = 0;
last_space_width = startwidth;
outptr += k - line_start;
if (k != visual_len)
{
+ if (contchar)
+ {
+ grub_memset (outptr, 0, sizeof (visual[0]));
+ outptr->base = contchar;
+ outptr++;
+ }
grub_memset (outptr, 0, sizeof (visual[0]));
outptr->base = '\n';
outptr++;
line_start = k;
line_width -= last_space_width;
+ if (pos && k != visual_len)
+ {
+ pos[visual[k].orig_pos].x = 0;
+ pos[visual[k].orig_pos].y = lines;
+ }
}
}
grub_size_t logical_len,
struct grub_unicode_glyph *visual_out,
grub_ssize_t (*getcharwidth) (const struct grub_unicode_glyph *visual),
- grub_size_t maxwidth, grub_size_t startwidth)
+ grub_size_t maxwidth, grub_size_t startwidth,
+ grub_uint32_t contchar,
+ struct grub_term_pos *pos,
+ int primitive_wrap,
+ grub_size_t log_end)
{
enum grub_bidi_type type = GRUB_BIDI_TYPE_L;
enum override_status {OVERRIDE_NEUTRAL = 0, OVERRIDE_R, OVERRIDE_L};
p = grub_unicode_aglomerate_comb (lptr, logical + logical_len - lptr,
&visual[visual_len]);
-
+ visual[visual_len].orig_pos = lptr - logical;
type = get_bidi_type (visual[visual_len].base);
switch (type)
{
{
grub_ssize_t ret;
ret = bidi_line_wrap (visual_out, visual, visual_len, levels,
- getcharwidth, maxwidth, startwidth);
+ getcharwidth, maxwidth, startwidth, contchar,
+ pos, primitive_wrap, log_end);
grub_free (levels);
grub_free (visual);
return ret;
grub_size_t logical_len,
struct grub_unicode_glyph **visual_out,
grub_ssize_t (*getcharwidth) (const struct grub_unicode_glyph *visual),
- grub_size_t max_length, grub_size_t startwidth)
+ grub_size_t max_length, grub_size_t startwidth,
+ grub_uint32_t contchar, struct grub_term_pos *pos, int primitive_wrap)
{
const grub_uint32_t *line_start = logical, *ptr;
struct grub_unicode_glyph *visual_ptr;
- *visual_out = visual_ptr = grub_malloc (2 * sizeof (visual_ptr[0])
+ *visual_out = visual_ptr = grub_malloc (3 * sizeof (visual_ptr[0])
* logical_len);
if (!visual_ptr)
return -1;
visual_ptr,
getcharwidth,
max_length,
- startwidth);
+ startwidth,
+ contchar,
+ pos,
+ primitive_wrap,
+ logical_len);
startwidth = 0;
if (ret < 0)
return str;
}
+const grub_uint32_t *
+grub_unicode_get_comb_end (const grub_uint32_t *end,
+ const grub_uint32_t *cur)
+{
+ const grub_uint32_t *ptr;
+ for (ptr = cur; ptr < end; ptr++)
+ {
+ if (*ptr >= GRUB_UNICODE_VARIATION_SELECTOR_1
+ && *ptr <= GRUB_UNICODE_VARIATION_SELECTOR_16)
+ continue;
+
+ if (*ptr >= GRUB_UNICODE_VARIATION_SELECTOR_17
+ && *ptr <= GRUB_UNICODE_VARIATION_SELECTOR_256)
+ continue;
+
+ enum grub_comb_type comb_type;
+ comb_type = grub_unicode_get_comb_type (*ptr);
+ if (comb_type)
+ continue;
+ return ptr;
+ }
+ return end;
+}
+
int len;
/* The maximum length of the line. */
int max_len;
+ struct grub_term_pos **pos;
};
struct per_term_screen
{
struct grub_term_output *term;
- /* The X coordinate. */
- int x;
- /* The Y coordinate. */
- int y;
int y_line_start;
/* Number of entries. */
int num_entries;
/* Initialize a line. */
static int
-init_line (struct line *linep)
+init_line (struct screen *screen, struct line *linep)
{
linep->len = 0;
linep->max_len = 80;
linep->buf = grub_malloc ((linep->max_len + 1) * sizeof (linep->buf[0]));
- if (! linep->buf)
- return 0;
+ linep->pos = grub_zalloc (screen->nterms * sizeof (linep->pos[0]));
+ if (! linep->buf || !linep->pos)
+ {
+ grub_free (linep->buf);
+ grub_free (linep->pos);
+ return 0;
+ }
return 1;
}
/ grub_term_entry_width (term_screen->term)) + 1;
}
-static void
-advance (struct screen *screen)
-{
- unsigned i;
- struct grub_unicode_glyph glyph;
-
- screen->column += grub_unicode_aglomerate_comb (screen->lines[screen->line].buf + screen->column,
- screen->lines[screen->line].len - screen->column,
- &glyph);
-
- for (i = 0; i < screen->nterms; i++)
- {
- grub_ssize_t width;
- width = grub_term_getcharwidth (screen->terms[i].term, &glyph);
- screen->terms[i].x += width;
- if (screen->terms[i].x
- == grub_term_entry_width (screen->terms[i].term))
- {
- screen->terms[i].x = 0;
- screen->terms[i].y++;
- }
- if (screen->terms[i].x
- > grub_term_entry_width (screen->terms[i].term))
- {
- screen->terms[i].x = width;
- screen->terms[i].y++;
- }
- }
- grub_free (glyph.combining);
-}
-
static void
advance_to (struct screen *screen, int c)
{
if (c > screen->lines[screen->line].len)
c = screen->lines[screen->line].len;
- while (screen->column < c)
- advance (screen);
-}
-
-/* Print a line. */
-static int
-print_line (struct line *linep, int offset, int y,
- struct per_term_screen *term_screen, int dry_run)
-{
- int x;
- int i;
-
- grub_term_gotoxy (term_screen->term,
- GRUB_TERM_LEFT_BORDER_X + GRUB_TERM_MARGIN + 1,
- y + GRUB_TERM_FIRST_ENTRY_Y);
-
- x = 0;
- for (i = 0; i + offset < (int) linep->len;)
- {
- grub_ssize_t width;
- grub_size_t delta = 0;
- struct grub_unicode_glyph glyph;
-
- delta = grub_unicode_aglomerate_comb (linep->buf + offset + i,
- linep->len - offset - i,
- &glyph);
- width = grub_term_getcharwidth (term_screen->term, &glyph);
- grub_free (glyph.combining);
-
- if (x + width > grub_term_entry_width (term_screen->term) && x != 0)
- break;
- x += width;
- i += delta;
- }
-
- if (dry_run)
- return i;
-
- grub_print_ucs4 (linep->buf + offset,
- linep->buf + offset + i, 0, 0, term_screen->term);
-
- if (i + offset != linep->len)
- grub_putcode ('\\', term_screen->term);
- else
- {
- for (;
- x <= (int) grub_term_entry_width (term_screen->term);
- x++)
- grub_putcode (' ', term_screen->term);
- }
- return i;
+ screen->column = grub_unicode_get_comb_end (screen->lines[screen->line].buf
+ + screen->lines[screen->line].len,
+ screen->lines[screen->line].buf
+ + c)
+ - screen->lines[screen->line].buf;
}
/* Print an empty line. */
GRUB_TERM_LEFT_BORDER_X + GRUB_TERM_MARGIN + 1,
y + GRUB_TERM_FIRST_ENTRY_Y);
- for (i = 0; i < grub_term_entry_width (term_screen->term) + 1; i++)
+ for (i = 0; i < grub_term_entry_width (term_screen->term); i++)
grub_putcode (' ', term_screen->term);
}
/* Draw the lines of the screen SCREEN. */
static void
update_screen (struct screen *screen, struct per_term_screen *term_screen,
- int region_start, int region_column,
+ int region_start, int region_column __attribute__ ((unused)),
int up, int down, enum update_mode mode)
{
int up_flag = 0;
int i;
struct line *linep;
+ y = term_screen->y_line_start;
+ linep = screen->lines;
+
+ for (i = 0; i < screen->line; i++, linep++)
+ y += get_logical_num_lines (linep, term_screen);
+ linep = screen->lines + screen->line;
+ y += grub_getstringwidth (linep->buf, linep->buf + screen->column,
+ term_screen->term) / grub_term_entry_width (term_screen->term);
+
/* Check if scrolling is necessary. */
- if (term_screen->y < 0 || term_screen->y >= term_screen->num_entries)
+ if (y < 0 || y >= term_screen->num_entries)
{
int delta;
- if (term_screen->y < 0)
- delta = -term_screen->y;
+ if (y < 0)
+ delta = -y;
else
- delta = term_screen->num_entries - 1 - term_screen->y;
- term_screen->y += delta;
+ delta = term_screen->num_entries - 1 - y;
term_screen->y_line_start += delta;
region_start = 0;
- region_column = 0;
up = 1;
down = 1;
mode = ALL_LINES;
/* Draw lines. This code is tricky, because this must calculate logical
positions. */
y = term_screen->y_line_start;
- i = screen->line;
- linep = screen->lines + i;
- while (y > 0)
- {
- i--;
- linep--;
- y -= get_logical_num_lines (linep, term_screen);
- }
+ i = 0;
+ linep = screen->lines;
+ while (1)
+ {
+ int add;
+ add = get_logical_num_lines (linep, term_screen);
+ if (y + add > 0)
+ break;
+ i++;
+ linep++;
+ y += add;
+ }
if (y < 0 || i > 0)
up_flag = 1;
do
{
- int column;
int off = 0;
- int full_len;
+ struct grub_term_pos **pos;
if (linep >= screen->lines + screen->num_lines)
break;
- full_len = grub_getstringwidth (linep->buf, linep->buf + linep->len,
- term_screen->term);
+ pos = linep->pos + (term_screen - screen->terms);
- for (column = 0;
- column <= full_len
- && y < term_screen->num_entries;
- column += grub_term_entry_width (term_screen->term), y++)
+ if (!*pos)
+ *pos = grub_zalloc ((linep->len + 1) * sizeof (**pos));
+
+ if (i == region_start || linep == screen->lines + screen->line)
+ {
+ int sp;
+ grub_term_gotoxy (term_screen->term, GRUB_TERM_LEFT_BORDER_X
+ + GRUB_TERM_MARGIN + 1, (y < 0 ? 0 : y)
+ + GRUB_TERM_FIRST_ENTRY_Y);
+ grub_print_ucs4_menu (linep->buf,
+ linep->buf + linep->len,
+ GRUB_TERM_LEFT_BORDER_X + GRUB_TERM_MARGIN
+ + 1,
+ GRUB_TERM_MARGIN
+ + GRUB_TERM_SCROLL_WIDTH + 2,
+ term_screen->term,
+ (y < 0) ? -y : 0,
+ term_screen->num_entries
+ - ((y > 0) ? y : 0), '\\',
+ *pos);
+ sp = grub_term_entry_width (term_screen->term)
+ - (*pos)[linep->len].x;
+ if (sp > 0)
+ grub_print_spaces (term_screen->term, sp);
+ }
+ else if (i > region_start && mode == ALL_LINES)
{
- if (y < 0)
- {
- off += print_line (linep, off, y, term_screen, 1);
- continue;
- }
-
- if (i == region_start)
- {
- if (region_column >= column
- && region_column
- < (column
- + grub_term_entry_width (term_screen->term)))
- off += print_line (linep, off, y, term_screen, 0);
- else if (region_column < column)
- off += print_line (linep, off, y, term_screen, 0);
- else
- off += print_line (linep, off, y, term_screen, 1);
- }
- else if (i > region_start && mode == ALL_LINES)
- off += print_line (linep, off, y, term_screen, 0);
+ int sp;
+ grub_term_gotoxy (term_screen->term, GRUB_TERM_LEFT_BORDER_X
+ + GRUB_TERM_MARGIN + 1, (y < 0 ? 0 : y)
+ + GRUB_TERM_FIRST_ENTRY_Y);
+ grub_print_ucs4_menu (linep->buf,
+ linep->buf + linep->len,
+ GRUB_TERM_LEFT_BORDER_X
+ + GRUB_TERM_MARGIN + 1,
+ GRUB_TERM_MARGIN
+ + GRUB_TERM_SCROLL_WIDTH + 2,
+ term_screen->term,
+ (y < 0) ? -y : 0,
+ term_screen->num_entries
+ - ((y > 0) ? y : 0), '\\',
+ *pos);
+ sp = grub_term_entry_width (term_screen->term)
+ - (*pos)[linep->len].x;
+ if (sp > 0)
+ grub_print_spaces (term_screen->term, sp);
}
-
- if (y == term_screen->num_entries)
+ y += get_logical_num_lines (linep, term_screen);
+ if (y >= term_screen->num_entries)
{
if (off <= linep->len || i + 1 < screen->num_lines)
down_flag = 1;
}
/* Place the cursor. */
- grub_term_gotoxy (term_screen->term,
- GRUB_TERM_LEFT_BORDER_X + GRUB_TERM_MARGIN + 1
- + term_screen->x,
- GRUB_TERM_FIRST_ENTRY_Y + term_screen->y);
+ if (screen->lines[screen->line].pos[term_screen - screen->terms])
+ {
+ const struct grub_term_pos *cpos;
+ for (cpos = &(screen->lines[screen->line].pos[term_screen - screen->terms])[screen->column];
+ cpos >= &(screen->lines[screen->line].pos[term_screen - screen->terms])[0];
+ cpos--)
+ if (cpos->valid)
+ break;
+ y = term_screen->y_line_start;
+ for (i = 0; i < screen->line; i++)
+ y += get_logical_num_lines (screen->lines + i, term_screen);
+ if (cpos >= &(screen->lines[screen->line].pos[term_screen - screen->terms])[0])
+ grub_term_gotoxy (term_screen->term,
+ cpos->x + GRUB_TERM_LEFT_BORDER_X
+ + GRUB_TERM_MARGIN + 1,
+ cpos->y + y
+ + GRUB_TERM_FIRST_ENTRY_Y);
+ else
+ grub_term_gotoxy (term_screen->term,
+ GRUB_TERM_LEFT_BORDER_X
+ + GRUB_TERM_MARGIN + 1,
+ y + GRUB_TERM_FIRST_ENTRY_Y);
+
+ }
grub_term_refresh (term_screen->term);
}
((screen->num_lines - screen->line - 2)
* sizeof (struct line)));
- if (! init_line (screen->lines + screen->line + 1))
+ if (! init_line (screen, screen->lines + screen->line + 1))
return 0;
/* Fold the line. */
current_linep->buf + screen->column,
size * sizeof (next_linep->buf[0]));
current_linep->len = screen->column;
+ for (i = 0; i < screen->nterms; i++)
+ {
+ grub_free (current_linep->pos[i]);
+ current_linep->pos[i] = 0;
+ }
next_linep->len = size;
/* Update a dirty region. */
/* Move the cursor. */
screen->column = screen->real_column = 0;
screen->line++;
- for (i = 0; i < screen->nterms; i++)
- {
- screen->terms[i].x = 0;
- screen->terms[i].y++;
- screen->terms[i].y_line_start = screen->terms[i].y;
- }
s++;
}
else
size * sizeof (current_linep->buf[0]));
grub_free (unicode_msg);
+ for (i = 0; i < screen->nterms; i++)
+ {
+ grub_free (current_linep->pos[i]);
+ current_linep->pos[i] = 0;
+ }
+
for (i = 0; i < screen->nterms; i++)
orig_num[i] = get_logical_num_lines (current_linep,
&screen->terms[i]);
goto fail;
/* Initialize the first line which must be always present. */
- if (! init_line (screen->lines))
+ if (! init_line (screen, screen->lines))
goto fail;
insert_string (screen, (char *) entry->sourcecode, 0);
screen->line = 0;
for (i = 0; i < screen->nterms; i++)
{
- screen->terms[i].x = 0;
- screen->terms[i].y = 0;
- screen->terms[i].y_line_start = screen->terms[i].y;
+ screen->terms[i].y_line_start = 0;
}
return screen;
forward_char (struct screen *screen, int update)
{
struct line *linep;
- unsigned i;
linep = screen->lines + screen->line;
if (screen->column < linep->len)
- advance (screen);
+ {
+ screen->column = grub_unicode_get_comb_end (screen->lines[screen->line].buf
+ + screen->lines[screen->line].len,
+ screen->lines[screen->line].buf
+ + screen->column + 1)
+ - screen->lines[screen->line].buf;
+ }
else if (screen->num_lines > screen->line + 1)
{
screen->column = 0;
screen->line++;
- for (i = 0; i < screen->nterms; i++)
- {
- screen->terms[i].x = 0;
- screen->terms[i].y++;
- screen->terms[i].y_line_start = screen->terms[i].y;
- }
}
screen->real_column = screen->column;
static int
backward_char (struct screen *screen, int update)
{
- unsigned i;
-
if (screen->column > 0)
{
struct grub_unicode_glyph glyph;
grub_unicode_aglomerate_comb (screen->lines[screen->line].buf + screen->column,
screen->lines[screen->line].len - screen->column,
&glyph);
+ screen->column = grub_unicode_get_comb_start (linep->buf,
+ linep->buf + screen->column)
+ - linep->buf;
- for (i = 0; i < screen->nterms; i++)
- {
- grub_ssize_t width;
- width = grub_term_getcharwidth (screen->terms[i].term, &glyph);
- screen->terms[i].x -= width;
- if (screen->terms[i].x < 0)
- {
- screen->terms[i].x
- = grub_term_entry_width (screen->terms[i].term) - 1;
- screen->terms[i].y--;
- }
- }
grub_free (glyph.combining);
}
else if (screen->line > 0)
{
- struct line *linep;
-
- screen->column = 0;
screen->line--;
- linep = screen->lines + screen->line;
-
- for (i = 0; i < screen->nterms; i++)
- {
- screen->terms[i].y_line_start -= get_logical_num_lines (linep, &screen->terms[i]);
- screen->terms[i].y = screen->terms[i].y_line_start;
- screen->terms[i].x = 0;
- }
- advance_to (screen, screen->lines[screen->line].len);
+ screen->column = screen->lines[screen->line].len;
}
screen->real_column = screen->column;
static int
previous_line (struct screen *screen, int update)
{
- unsigned i;
-
if (screen->line > 0)
{
struct line *linep;
col = screen->real_column;
screen->column = 0;
-
- for (i = 0; i < screen->nterms; i++)
- {
- screen->terms[i].y_line_start -= get_logical_num_lines (linep, &screen->terms[i]);
- screen->terms[i].y = screen->terms[i].y_line_start;
- screen->terms[i].x = 0;
- }
advance_to (screen, col);
}
else
{
- for (i = 0; i < screen->nterms; i++)
- {
- screen->terms[i].y = screen->terms[i].y_line_start;
- screen->terms[i].x = 0;
- }
screen->column = 0;
}
static int
next_line (struct screen *screen, int update)
{
- unsigned i;
-
if (screen->line < screen->num_lines - 1)
{
struct line *linep;
c = screen->real_column;
screen->column = 0;
- for (i = 0; i < screen->nterms; i++)
- {
- screen->terms[i].y_line_start += get_logical_num_lines (linep, &screen->terms[i]);
- screen->terms[i].x = 0;
- screen->terms[i].y = screen->terms[i].y_line_start;
- }
advance_to (screen, c);
}
else
static int
beginning_of_line (struct screen *screen, int update)
{
- unsigned i;
-
screen->column = screen->real_column = 0;
- for (i = 0; i < screen->nterms; i++)
- {
- screen->terms[i].x = 0;
- screen->terms[i].y = screen->terms[i].y_line_start;
- }
if (update)
update_screen_all (screen, screen->num_lines, 0, 0, 0, NO_LINE);
* sizeof (linep->buf[0]));
linep->len--;
+ for (i = 0; i < screen->nterms; i++)
+ {
+ grub_free (linep->pos[i]);
+ linep->pos[i] = 0;
+ }
start = screen->line;
column = screen->column;
else if (screen->num_lines > screen->line + 1)
{
struct line *next_linep;
+ unsigned i;
next_linep = linep + 1;
if (! ensure_space (linep, next_linep->len))
grub_memmove (linep->buf + linep->len, next_linep->buf,
next_linep->len * sizeof (linep->buf[0]));
linep->len += next_linep->len;
+ for (i = 0; i < screen->nterms; i++)
+ {
+ grub_free (linep->pos[i]);
+ linep->pos[i] = 0;
+ }
grub_free (next_linep->buf);
grub_memmove (next_linep,
static int
open_line (struct screen *screen, int update)
{
- int saved_y[screen->nterms];
- unsigned i;
-
- for (i = 0; i < screen->nterms; i++)
- saved_y[i] = screen->terms[i].y;
-
if (! insert_string (screen, "\n", 0))
return 0;
if (! backward_char (screen, 0))
return 0;
- for (i = 0; i < screen->nterms; i++)
- {
- screen->terms[i].y = saved_y[i];
- screen->terms[i].y_line_start = screen->terms[i].y;
- }
-
if (update)
update_screen_all (screen, screen->line, screen->column, 0, 1, ALL_LINES);
screen->nterms = 0;
FOR_ACTIVE_TERM_OUTPUTS(term)
screen->nterms++;
- screen->terms = grub_malloc (screen->nterms * sizeof (screen->terms[0]));
+
+ for (i = 0; i < (unsigned) screen->num_lines; i++)
+ {
+ grub_free (screen->lines[i].pos);
+ screen->lines[i].pos = grub_zalloc (screen->nterms * sizeof (screen->lines[i].pos[0]));
+ if (! screen->lines[i].pos)
+ {
+ grub_print_error ();
+ grub_errno = GRUB_ERR_NONE;
+ return;
+ }
+ }
+
+ screen->terms = grub_zalloc (screen->nterms * sizeof (screen->terms[0]));
if (!screen->terms)
{
grub_print_error ();
FOR_ACTIVE_TERM_OUTPUTS(term)
{
screen->terms[i].term = term;
- screen->terms[i].x = 0;
- screen->terms[i].y = 0;
- screen->terms[i].y_line_start = screen->terms[i].y;
+ screen->terms[i].y_line_start = 0;
i++;
}
/* Draw the screen. */
int backlog_fixed_tab;
grub_size_t backlog_len;
+ int bidi_stack_depth;
+ grub_uint8_t bidi_stack[GRUB_BIDI_MAX_EXPLICIT_LEVEL];
+ int invalid_pushes;
+
void *free;
int num_lines;
char *term_name;
const grub_uint32_t * last_position,
int margin_left, int margin_right,
struct grub_term_output *term, int backlog,
- int dry_run, int fixed_tab);
+ int dry_run, int fixed_tab, unsigned skip_lines,
+ unsigned max_lines,
+ grub_uint32_t contchar, struct grub_term_pos *pos);
static struct term_state *term_states = NULL;
return;
}
- print_ucs4_real (unicode_str, unicode_last_position, 0, 0, term, 0, 0, 0);
+ print_ucs4_real (unicode_str, unicode_last_position, 0, 0, term,
+ 0, 0, 0, 0, -1, 0, 0);
grub_free (unicode_str);
}
return ((term->getxy (term) >> 8) & 0xff) - margin_left;
}
+static void
+fill_margin (struct grub_term_output *term, int r)
+{
+ int sp = (term->getwh (term) >> 8)
+ - (term->getxy (term) >> 8) - r;
+ if (sp > 0)
+ grub_print_spaces (term, sp);
+}
+
static int
print_ucs4_terminal (const grub_uint32_t * str,
const grub_uint32_t * last_position,
int margin_left, int margin_right,
struct grub_term_output *term,
struct term_state *state,
- int dry_run, int fixed_tab)
+ int dry_run, int fixed_tab, unsigned skip_lines,
+ unsigned max_lines,
+ grub_uint32_t contchar,
+ int primitive_wrap, struct grub_term_pos *pos)
{
const grub_uint32_t *ptr;
grub_ssize_t startwidth = dry_run ? 0 : get_startwidth (term, margin_left);
grub_ssize_t max_width = get_maxwidth (term, margin_left, margin_right);
const grub_uint32_t *line_start = str, *last_space = str - 1;
int lines = 0;
+ int i;
+ struct term_state local_state;
+
+ if (!state)
+ {
+ grub_memset (&local_state, 0, sizeof (local_state));
+ state = &local_state;
+ }
+
+ for (i = 0; i < state->bidi_stack_depth; i++)
+ putcode_real (state->bidi_stack[i] | (GRUB_UNICODE_LRE & ~0xff),
+ term, fixed_tab);
for (ptr = str; ptr < last_position; ptr++)
{
grub_ssize_t last_width = 0;
+ switch (*ptr)
+ {
+ case GRUB_UNICODE_LRE:
+ case GRUB_UNICODE_RLE:
+ case GRUB_UNICODE_LRO:
+ case GRUB_UNICODE_RLO:
+ if (state->bidi_stack_depth >= (int) ARRAY_SIZE (state->bidi_stack))
+ state->invalid_pushes++;
+ else
+ state->bidi_stack[state->bidi_stack_depth++] = *ptr;
+ break;
+ case GRUB_UNICODE_PDF:
+ if (state->invalid_pushes)
+ state->invalid_pushes--;
+ else if (state->bidi_stack_depth)
+ state->bidi_stack_depth--;
+ break;
+ }
if (grub_unicode_get_comb_type (*ptr) == GRUB_UNICODE_COMB_NONE)
{
struct grub_unicode_glyph c = {
.combining = 0
};
c.base = *ptr;
+ if (pos)
+ {
+ pos[ptr - str].x = line_width;
+ pos[ptr - str].y = lines;
+ pos[ptr - str].valid = 1;
+ }
line_width += last_width = grub_term_getcharwidth (term, &c);
}
- if (*ptr == ' ')
+ if (*ptr == ' ' && !primitive_wrap)
{
lastspacewidth = line_width;
last_space = ptr;
if (line_width > max_width || *ptr == '\n')
{
const grub_uint32_t *ptr2;
+ int wasn = (*ptr == '\n');
+
+ if (wasn)
+ {
+ state->bidi_stack_depth = 0;
+ state->invalid_pushes = 0;
+ }
if (line_width > max_width && last_space > line_start)
ptr = last_space;
lines++;
- if (!dry_run)
+ if (!skip_lines && !dry_run)
{
for (ptr2 = line_start; ptr2 < ptr; ptr2++)
{
putcode_real (*ptr2, term, fixed_tab);
}
- grub_print_spaces (term, margin_right);
+ if (!wasn && contchar)
+ putcode_real (contchar, term, fixed_tab);
+ fill_margin (term, contchar ? margin_right : 1);
+
grub_putcode ('\n', term);
- if (state && ++state->num_lines
+ if (state != &local_state && ++state->num_lines
>= (grub_ssize_t) grub_term_height (term) - 2)
{
state->backlog_ucs4 = (ptr == last_space || *ptr == '\n')
}
line_width -= lastspacewidth;
- if (!dry_run)
- grub_print_spaces (term, margin_left);
if (ptr == last_space || *ptr == '\n')
ptr++;
line_start = ptr;
+
+ if (skip_lines)
+ skip_lines--;
+ else if (max_lines != (unsigned) -1)
+ {
+ max_lines--;
+ if (!max_lines)
+ break;
+ }
+ if (!skip_lines && !dry_run)
+ {
+ if (!contchar)
+ grub_print_spaces (term, margin_left);
+ else
+ grub_term_gotoxy (term, margin_left,
+ grub_term_getxy (term) & 0xff);
+ for (i = 0; i < state->bidi_stack_depth; i++)
+ putcode_real (state->bidi_stack[i] | (GRUB_UNICODE_LRE & ~0xff),
+ term, fixed_tab);
+ }
}
}
+ if (pos)
+ {
+ pos[ptr - str].x = line_width;
+ pos[ptr - str].y = lines;
+ pos[ptr - str].valid = 1;
+ }
+
if (line_start < last_position)
lines++;
- if (!dry_run)
+ if (!dry_run && !skip_lines && max_lines)
{
const grub_uint32_t *ptr2;
for (ptr2 = line_start; ptr2 < last_position; ptr2++)
ret = print_ucs4_terminal (state->backlog_ucs4,
state->backlog_ucs4 + state->backlog_len,
margin_left, margin_right, term, state, 0,
- state->backlog_fixed_tab);
+ state->backlog_fixed_tab, 0, -1, 0, 0,
+ 0);
if (!ret)
{
grub_free (state->free);
const grub_uint32_t * last_position,
int margin_left, int margin_right,
struct grub_term_output *term, int backlog,
- int dry_run, int fixed_tab)
+ int dry_run, int fixed_tab, unsigned skip_lines,
+ unsigned max_lines,
+ grub_uint32_t contchar, struct grub_term_pos *pos)
{
struct term_state *state = NULL;
if (!dry_run)
{
+ int xy;
if (backlog)
state = find_term_state (term);
- if (((term->getxy (term) >> 8) & 0xff) < margin_left)
- grub_print_spaces (term, margin_left - ((term->getxy (term) >> 8) & 0xff));
+ xy = term->getxy (term);
+
+ if (((xy >> 8) & 0xff) < margin_left)
+ {
+ if (!contchar)
+ grub_print_spaces (term, margin_left - ((xy >> 8) & 0xff));
+ else
+ grub_term_gotoxy (term, margin_left,
+ xy & 0xff);
+ }
}
if ((term->flags & GRUB_TERM_CODE_TYPE_MASK)
{
grub_ssize_t visual_len;
struct grub_unicode_glyph *visual;
+ grub_ssize_t visual_len_show;
+ struct grub_unicode_glyph *visual_show;
int ret;
+ struct grub_unicode_glyph *vptr;
auto grub_ssize_t getcharwidth (const struct grub_unicode_glyph *c);
grub_ssize_t getcharwidth (const struct grub_unicode_glyph *c)
margin_left,
margin_right),
get_startwidth (term,
- margin_left));
+ margin_left),
+ contchar, pos, !!contchar);
if (visual_len < 0)
{
grub_print_error ();
return 0;
}
+ visual_show = visual;
+ for (; skip_lines && visual_show < visual + visual_len; visual_show++)
+ if (visual_show->base == '\n')
+ skip_lines--;
+ if (max_lines != (unsigned) -1)
+ {
+ for (vptr = visual_show;
+ max_lines && vptr < visual + visual_len; vptr++)
+ if (visual_show->base == '\n')
+ max_lines--;
+
+ visual_len_show = vptr - visual_show;
+ }
+ else
+ visual_len_show = visual + visual_len - visual_show;
+
if (dry_run)
{
- struct grub_unicode_glyph *vptr;
ret = 0;
- for (vptr = visual; vptr < visual + visual_len; vptr++)
+ for (vptr = visual_show; vptr < visual_show + visual_len_show; vptr++)
if (vptr->base == '\n')
ret++;
- if (visual_len && visual[visual_len - 1].base != '\n')
+ if (visual_len_show && visual[visual_len_show - 1].base != '\n')
ret++;
grub_free (visual);
}
else
{
- ret = put_glyphs_terminal (visual, visual_len, margin_left,
- margin_right, term, state, fixed_tab);
+ ret = put_glyphs_terminal (visual_show, visual_len_show, margin_left,
+ contchar ? margin_right : 1,
+ term, state, fixed_tab);
+
if (!ret)
grub_free (visual);
else
return ret;
}
return print_ucs4_terminal (str, last_position, margin_left, margin_right,
- term, state, dry_run, fixed_tab);
+ term, state, dry_run, fixed_tab, skip_lines,
+ max_lines, contchar, !!contchar, pos);
+}
+
+void
+grub_print_ucs4_menu (const grub_uint32_t * str,
+ const grub_uint32_t * last_position,
+ int margin_left, int margin_right,
+ struct grub_term_output *term,
+ int skip_lines, int max_lines,
+ grub_uint32_t contchar,
+ struct grub_term_pos *pos)
+{
+ print_ucs4_real (str, last_position, margin_left, margin_right,
+ term, 0, 0, 1, skip_lines, max_lines,
+ contchar, pos);
}
void
struct grub_term_output *term)
{
print_ucs4_real (str, last_position, margin_left, margin_right,
- term, 0, 0, 1);
+ term, 0, 0, 1, 0, -1, 0, 0);
}
int
struct grub_term_output *term)
{
return print_ucs4_real (str, last_position, margin_left, margin_right,
- term, 0, 1, 1);
+ term, 0, 1, 1, 0, -1, 0, 0);
}
void
{
int cur;
cur = print_ucs4_real (unicode_str, unicode_last_position, 0, 0,
- term, grub_more, 0, 0);
+ term, grub_more, 0, 0, 0, -1, 0, 0);
if (cur)
backlog = 1;
}
const grub_uint32_t * last_position,
int margin_left, int margin_right,
struct grub_term_output *term);
+
+void
+grub_print_ucs4_menu (const grub_uint32_t * str,
+ const grub_uint32_t * last_position,
+ int margin_left, int margin_right,
+ struct grub_term_output *term,
+ int skip_lines, int max_lines, grub_uint32_t contchar,
+ struct grub_term_pos *pos);
int
grub_ucs4_count_lines (const grub_uint32_t * str,
const grub_uint32_t * last_position,
#define GRUB_TERM_CODE_TYPE_CP437 (1 << GRUB_TERM_CODE_TYPE_SHIFT)
/* UTF-8 stream in logical order. Usually used for terminals
which just forward the stream to another computer. */
-#define GRUB_TERM_CODE_TYPE_UTF8_LOGICAL (2 << GRUB_TERM_CODE_TYPE_SHIFT)
+#define GRUB_TERM_CODE_TYPE_UTF8_LOGICAL (2 << GRUB_TERM_CODE_TYPE_SHIFT)
/* UTF-8 in visual order. Like UTF-8 logical but for buggy endpoints. */
#define GRUB_TERM_CODE_TYPE_UTF8_VISUAL (3 << GRUB_TERM_CODE_TYPE_SHIFT)
/* Glyph description in visual order. */
static inline unsigned
grub_term_border_width (struct grub_term_output *term)
{
- return grub_term_width (term) - GRUB_TERM_MARGIN * 3 - GRUB_TERM_SCROLL_WIDTH;
+ return grub_term_width (term) - GRUB_TERM_MARGIN * 2;
}
/* The max column number of an entry. The last "-1" is for a
static inline int
grub_term_entry_width (struct grub_term_output *term)
{
- return grub_term_border_width (term) - 2 - GRUB_TERM_MARGIN * 2 - 1;
+ return grub_term_border_width (term) - GRUB_TERM_MARGIN * 2 - 1;
}
static inline grub_uint16_t
grub_uint16_t variant:9;
grub_uint8_t attributes:5;
grub_size_t ncomb;
+ grub_size_t orig_pos;
struct grub_unicode_combining {
grub_uint32_t code;
enum grub_comb_type type;
GRUB_UNICODE_THAANA_SUKUN = 0x07b0,
GRUB_UNICODE_ZWNJ = 0x200c,
GRUB_UNICODE_ZWJ = 0x200d,
+ GRUB_UNICODE_LRM = 0x200e,
+ GRUB_UNICODE_RLM = 0x200f,
+ GRUB_UNICODE_LRE = 0x202a,
+ GRUB_UNICODE_RLE = 0x202b,
+ GRUB_UNICODE_PDF = 0x202c,
+ GRUB_UNICODE_LRO = 0x202d,
+ GRUB_UNICODE_RLO = 0x202e,
GRUB_UNICODE_LEFTARROW = 0x2190,
GRUB_UNICODE_UPARROW = 0x2191,
GRUB_UNICODE_RIGHTARROW = 0x2192,
/* Unicode mandates an arbitrary limit. */
#define GRUB_BIDI_MAX_EXPLICIT_LEVEL 61
+struct grub_term_pos
+{
+ unsigned valid:1;
+ unsigned x:15, y:16;
+};
+
grub_ssize_t
grub_bidi_logical_to_visual (const grub_uint32_t *logical,
grub_size_t logical_len,
struct grub_unicode_glyph **visual_out,
grub_ssize_t (*getcharwidth) (const struct grub_unicode_glyph *visual),
grub_size_t max_width,
- grub_size_t start_width);
+ grub_size_t start_width, grub_uint32_t codechar,
+ struct grub_term_pos *pos,
+ int primitive_wrap);
enum grub_comb_type
grub_unicode_get_comb_type (grub_uint32_t c);
grub_uint32_t
grub_unicode_shape_code (grub_uint32_t in, grub_uint8_t attr);
+const grub_uint32_t *
+grub_unicode_get_comb_end (const grub_uint32_t *end,
+ const grub_uint32_t *cur);
+
#endif
projects / grub2.git / commitdiff