From c9b4dc3d736299b64bf79c87cef9b745d041c6ec Mon Sep 17 00:00:00 2001

From: Vladimir 'phcoder' Serbinenko <phcoder@gmail.com>

Date: Wed, 16 Jan 2013 13:41:16 +0100

Subject: [PATCH 109/364] 	Improve bidi handling in entry editor.

---

 ChangeLog                     |   4 +

 grub-core/gfxmenu/font.c      |   2 +-

 grub-core/normal/charset.c    |  98 ++++++++++-

 grub-core/normal/menu_entry.c | 394 ++++++++++++++++++------------------------

 grub-core/normal/term.c       | 186 +++++++++++++++++---

 include/grub/normal.h         |   8 +

 include/grub/term.h           |   6 +-

 include/grub/unicode.h        |  22 ++-

 8 files changed, 453 insertions(+), 267 deletions(-)

diff --git a/ChangeLog b/ChangeLog

index 76a9f68..96aca66 100644

--- a/ChangeLog

+++ b/ChangeLog

@@ -1,5 +1,9 @@

 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

 	argument to prevent name collision.

diff --git a/grub-core/gfxmenu/font.c b/grub-core/gfxmenu/font.c

index 3c15e19..81a689d 100644

--- a/grub-core/gfxmenu/font.c

+++ b/grub-core/gfxmenu/font.c

@@ -52,7 +52,7 @@ grub_font_draw_string (const char *str, grub_font_t font,

     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;

diff --git a/grub-core/normal/charset.c b/grub-core/normal/charset.c

index 25593ce..bd9fbf4 100644

--- a/grub-core/normal/charset.c

+++ b/grub-core/normal/charset.c

@@ -513,7 +513,10 @@ bidi_line_wrap (struct grub_unicode_glyph *visual_out,

 		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;

@@ -521,17 +524,30 @@ bidi_line_wrap (struct grub_unicode_glyph *visual_out,

   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;

@@ -545,11 +561,27 @@ bidi_line_wrap (struct grub_unicode_glyph *visual_out,

     {

       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;

@@ -561,9 +593,12 @@ bidi_line_wrap (struct grub_unicode_glyph *visual_out,

 	  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;

@@ -685,6 +720,12 @@ bidi_line_wrap (struct grub_unicode_glyph *visual_out,

 	  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++;

@@ -695,6 +736,11 @@ bidi_line_wrap (struct grub_unicode_glyph *visual_out,

 	  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;

+	    }

 	}

     }

@@ -707,7 +753,11 @@ grub_bidi_line_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 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};

@@ -832,7 +882,7 @@ grub_bidi_line_logical_to_visual (const grub_uint32_t *logical,

 	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)

 	  {

@@ -1066,7 +1116,8 @@ grub_bidi_line_logical_to_visual (const grub_uint32_t *logical,

   {

     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;

@@ -1078,11 +1129,12 @@ 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_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;

@@ -1096,7 +1148,11 @@ grub_bidi_logical_to_visual (const grub_uint32_t *logical,

 						  visual_ptr,

 						  getcharwidth,

 						  max_length,

-						  startwidth);

+						  startwidth,

+						  contchar,

+						  pos,

+						  primitive_wrap,

+						  logical_len);

 	  startwidth = 0;

 	  if (ret < 0)

@@ -1188,3 +1244,27 @@ grub_unicode_get_comb_start (const grub_uint32_t *str,

   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;

+}

+

diff --git a/grub-core/normal/menu_entry.c b/grub-core/normal/menu_entry.c

index 33b644b..7cd67f3 100644

--- a/grub-core/normal/menu_entry.c

+++ b/grub-core/normal/menu_entry.c

@@ -43,15 +43,12 @@ struct line

   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;

@@ -90,13 +87,18 @@ static int completion_type;

 /* 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;

 }

@@ -126,93 +128,16 @@ get_logical_num_lines (struct line *linep, struct per_term_screen *term_screen)

 }

 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.  */

@@ -225,7 +150,7 @@ print_empty_line (int y, struct per_term_screen *term_screen)

 		    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);

 }

@@ -261,7 +186,7 @@ print_down (int flag, struct per_term_screen *term_screen)

 /* 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;

@@ -270,19 +195,26 @@ update_screen (struct screen *screen, struct per_term_screen *term_screen,

   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;

@@ -293,58 +225,81 @@ update_screen (struct screen *screen, struct per_term_screen *term_screen,

       /* 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;

@@ -367,10 +322,30 @@ update_screen (struct screen *screen, struct per_term_screen *term_screen,

     }

   /* 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);

 }

@@ -424,7 +399,7 @@ insert_string (struct screen *screen, const char *s, int update)

 			((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.  */

@@ -439,6 +414,11 @@ insert_string (struct screen *screen, const char *s, int update)

 			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.  */

@@ -457,12 +437,6 @@ insert_string (struct screen *screen, const char *s, int update)

 	  /* 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

@@ -502,6 +476,12 @@ insert_string (struct screen *screen, const char *s, int update)

 	  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]);

 	  current_linep->len += size;

@@ -582,7 +562,7 @@ make_screen (grub_menu_entry_t entry)

     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);

@@ -593,9 +573,7 @@ make_screen (grub_menu_entry_t entry)

   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;

@@ -609,21 +587,20 @@ static int

 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;

@@ -636,8 +613,6 @@ forward_char (struct screen *screen, int update)

 static int

 backward_char (struct screen *screen, int update)

 {

-  unsigned i;

-

   if (screen->column > 0)

     {

       struct grub_unicode_glyph glyph;

@@ -653,36 +628,16 @@ backward_char (struct screen *screen, int update)

       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;