Index: Makefile.am
===================================================================
RCS file: /cvs/gnome/pango/modules/hangul/Makefile.am,v
retrieving revision 1.18
diff -u -r1.18 Makefile.am
--- Makefile.am	8 Aug 2002 18:22:05 -0000	1.18
+++ Makefile.am	22 Oct 2002 14:18:50 -0000
@@ -6,7 +6,7 @@
 pangoft2libs = $(top_builddir)/pango/libpangoft2-$(PANGO_API_VERSION).la $(FREETYPE_LIBS) $(pangolibs)
 
 x_sources = hangul-x.c hangul-defs.h
-xft_sources = hangul-xft.c hangul-defs.h
+xft_sources = hangul-utils.c hangul-utils.h hangul-xft.c hangul-defs.h
 
 if HAVE_XFT
 if INCLUDE_HANGUL_XFT
@@ -64,7 +64,9 @@
 EXTRA_DIST =			\
 	tables-ksc5601.i	\
 	tables-johabfont.i	\
-	tables-jamos.i
+	tables-jamos.i 		\
+	tables-jamos2.i 	\
+	tables-ext-jamos.i
 
 included-modules: $(noinst_LTLIBRARIES)
 
Index: hangul-defs.h
===================================================================
RCS file: /cvs/gnome/pango/modules/hangul/hangul-defs.h,v
retrieving revision 1.1
diff -u -r1.1 hangul-defs.h
--- hangul-defs.h	31 Jul 2002 19:08:14 -0000	1.1
+++ hangul-defs.h	22 Oct 2002 14:18:50 -0000
@@ -20,13 +20,17 @@
  * Boston, MA 02111-1307, USA.
  */
 
+#ifndef __PANGO_HANGUL_DEFS_H
+#define __PANGO_HANGUL_DEFS_H
+
 /*
- * From 3.10 of the Unicode 2.0 Book; used for combining Jamos.
+ * From 3.10 of the Unicode 2.0 Book; used for conjoining Jamos.
  */
 #define SBASE 0xAC00
 #define LBASE 0x1100
 #define VBASE 0x1161
-#define TBASE 0x11A7
+#define TBASE 0x11A7  
+#define TSTART 0x11A8  
 
 #define LEND 0x115F
 #define VEND 0x11A6
@@ -48,15 +52,17 @@
 
 #define IS_L(wc) (wc >= LBASE && wc <= LEND)
 #define IS_V(wc) (wc >= VFILL && wc <= VEND)
-#define IS_T(wc) (wc >= TBASE && wc <= TEND)
+#define IS_T(wc) (wc > TBASE && wc <= TEND)
 
 /* jamo which can be composited as a Hangul syllable */
 #define IS_L_S(wc) (wc >= LBASE && wc < LBASE + LCOUNT)
 #define IS_V_S(wc) (wc >= VBASE && wc < VBASE + VCOUNT)
-#define IS_T_S(wc) (wc >= TBASE && wc < TBASE + TCOUNT)
+#define IS_T_S(wc) (wc >  TBASE && wc < TBASE + TCOUNT)
 
 #define S_FROM_LVT(l,v,t)	(SBASE + (((l) - LBASE) * VCOUNT + ((v) - VBASE)) * TCOUNT + ((t) - TBASE))
 #define S_FROM_LV(l,v)		(SBASE + (((l) - LBASE) * VCOUNT + ((v) - VBASE)) * TCOUNT)
 #define L_FROM_S(s)		(LBASE + (((s) - SBASE) / NCOUNT))
 #define V_FROM_S(s)		(VBASE + (((s) - SBASE) % NCOUNT) / TCOUNT)
 #define T_FROM_S(s)		(TBASE + (((s) - SBASE) % TCOUNT))
+
+#endif
Index: hangul-xft.c
===================================================================
RCS file: /cvs/gnome/pango/modules/hangul/hangul-xft.c,v
retrieving revision 1.4
diff -u -r1.4 hangul-xft.c
--- hangul-xft.c	15 Oct 2002 09:50:26 -0000	1.4
+++ hangul-xft.c	22 Oct 2002 14:18:52 -0000
@@ -27,7 +27,9 @@
 #include "pango-utils.h"
 
 #include "hangul-defs.h"
+#include "hangul-utils.h"
 #include "tables-jamos.i"
+#include "tables-ext-jamos.i"
 
 #define SCRIPT_ENGINE_NAME "HangulScriptEngineXft"
 
@@ -59,25 +61,40 @@
   glyphs->glyphs[i].geometry.width = logical_rect.width;
 }
 
+
+
+typedef void (* RenderSyllableFunc) (PangoFont *font, gunichar *text, 
+                                     int length, PangoGlyphString *glyphs,
+                                     int *n_glyphs, int cluster_offset);
+
+
 #define find_char pango_xft_font_get_glyph
 
-static void
-render_syllable (PangoFont *font, gunichar *text, int length,
-		 PangoGlyphString *glyphs, int *n_glyphs, int cluster_offset)
+static int
+render_as_precomp_syllable (PangoFont	     *font, 
+			    gunichar 	     *text, 
+			    int 	     *length,
+			    PangoGlyphString *glyphs, 
+			    int 	     *n_glyphs, 
+			    int		     cluster_offset,
+			    gboolean	     spacing_jamo)
 {
-  int index;
-  gunichar wc;
-  int i, j, composed;
 
-  if (length >= 3 && IS_L_S(text[0]) && IS_V_S(text[1]) && IS_T_S(text[2]))
+  int composed;
+
+  if ((*length == 3 || (spacing_jamo && *length > 3)) && 
+      IS_L_S(text[0]) && IS_V_S(text[1]) && IS_T_S(text[2]))
     composed = 3;
-  else if (length >= 2 && IS_L_S(text[0]) && IS_V_S(text[1]))
+  else if ((*length == 2 || (spacing_jamo && *length > 2)) && 
+           IS_L_S(text[0]) && IS_V_S(text[1]))
     composed = 2;
   else
     composed = 0;
 
   if (composed)
     {
+      gunichar wc;
+      int index;
       if (composed == 3)
 	wc = S_FROM_LVT(text[0], text[1], text[2]);
       else
@@ -90,15 +107,45 @@
       else
 	set_glyph (font, glyphs, *n_glyphs, cluster_offset, index);
       (*n_glyphs)++;
-      text += composed;
-      length -= composed;
+      *length -= composed;
     }
+  return composed;
+
+}
+
+static void
+render_syllable_base (PangoFont	       *font, 
+		      gunichar	       *text, 
+		      int	       length,
+		      PangoGlyphString *glyphs, 
+		      int	       *n_glyphs, 
+		      int	       cluster_offset,
+		      gboolean         spacing_jamo)
+{
+  int index;
+  gunichar wc,*text0;
+  int i, j;
+
+  text = _normalize_jamo (text, &length);
+  text0 = text;  /* preserve the addrs. for g_free */
+
+  text += render_as_precomp_syllable (font, text, &length, glyphs, n_glyphs,
+          cluster_offset, spacing_jamo);
+
 
   /* Render the remaining text as uncomposed forms as a fallback.  */
   for (i = 0; i < length; i++)
     {
       int jindex;
 
+      /* skip VFILL if  VFILL is not the only char. in a given syllable.
+       * There's a strange problem with pango-break(). For an unknown reason,
+       * (the code in break.c has no problem handling Jamo breaks.)
+       * sometimes L+Vf is broken into L and Vf and shaping engine gets them
+       * one by one.*/
+      if ( text[i] == VFILL && length > 1)
+	continue;
+
       index = find_char (font, text[i]);
       if (index)
 	{
@@ -124,6 +171,413 @@
 	  (*n_glyphs)++;
 	}
     }
+
+
+  g_free (text0);
+}  
+
+static void
+render_syllable_with_spacing_jamo (PangoFont	      *font, 
+			     	   gunichar	      *text, 
+			     	   int	      	      length,
+			     	   PangoGlyphString   *glyphs, 
+			     	   int	              *n_glyphs, 
+				   int	              cluster_offset)
+{
+  render_syllable_base (font, text, length, glyphs, n_glyphs, cluster_offset, TRUE);
+}
+
+static void
+render_syllable_with_combining_jamo (PangoFont	      *font, 
+			     	     gunichar	      *text, 
+			     	     int	      length,
+			     	     PangoGlyphString *glyphs, 
+			     	     int	      *n_glyphs, 
+				     int	      cluster_offset)
+{
+  render_syllable_base (font, text, length, glyphs, n_glyphs, cluster_offset, FALSE);
+}
+
+
+static void 
+og_transform (gunichar *text, int *length)
+{
+	int i;
+  /* translate jamo code points to temporary code points in PUA */
+  for (i = 0; i < *length; i++)
+    {
+      if (IS_L(text[i]))
+	text[i] += LC_OFFSET;
+      else if (IS_V(text[i]))
+	text[i] += VO_OFFSET;
+      else if (IS_T(text[i]))
+	text[i] += TC_OFFSET;
+    }
+
+  /* LV or LVT : no need to search for and replace jamo sequences */
+  if ((*length == 2 && OG_IS_L(text[0]) && OG_IS_V(text[1])) || 
+      (*length == 3 && OG_IS_L(text[0]) && OG_IS_V(text[1]) && OG_IS_T(text[2])))
+    return;
+
+  /* replace a sequence of Jamos with the corresponding precomposed 
+   * Jamo cluster in PUA */
+  for (i=0; __ext_lc_clusters[i].seq[0]; i++)
+    _jamo_srch_repl (&__ext_lc_clusters[i], text, length); 
+  for (i=0; __ext_vo_clusters[i].seq[0]; i++)
+    _jamo_srch_repl (&__ext_vo_clusters[i], text, length); 
+  for (i=0; __ext_tc_clusters[i].seq[0]; i++)
+    _jamo_srch_repl (&__ext_tc_clusters[i], text, length);
+
+}
+
+
+static void
+render_syllable_with_ogulim (PangoFont	      *font, 
+			     gunichar	      *text, 
+			     int	      length,
+			     PangoGlyphString *glyphs, 
+			     int	      *n_glyphs, 
+			     int	      cluster_offset)
+{
+  int index;
+  gunichar wc;
+  int i;
+
+  text = _normalize_jamo (text, &length);
+
+  og_transform (text, &length);
+
+  if (length != 2 && length != 3)
+    goto fallback; 
+
+  if (! OG_IS_L (text[0]) || ! OG_IS_V (text[1]) || 
+      (length == 3 && ! OG_IS_T (text[2])))
+    goto fallback;
+
+
+  /*  Now that text[0..2] are identified as L,V, and T, it's safe to 
+   *  shift them back to U+1100 block although their ranges overlap
+   *  each other.
+   */
+
+  text[0] -= LC_OFFSET;
+  text[1] -= VO_OFFSET;
+  if (length==3)
+    text[2] -= TC_OFFSET;
+
+  if (length != 3)
+    {
+      text[0] = __ogulim_lc_gidx[text[0] - LBASE] * 6 + 
+                __ogulim_v2l_map[text[1] - VFILL] + OG_LBASE;
+      text[1] = __ogulim_vo_gidx[text[1] - VFILL] * 2 + OG_VBASE;
+    }
+  else 
+    {
+      text[0] = __ogulim_lc_gidx[text[0] - LBASE] * 6 + 
+                __ogulim_v2lt_map[text[1] - VFILL] + OG_LBASE;
+      text[2] = __ogulim_tc_gidx[text[2] - TSTART] * 4 + 
+                __ogulim_v2t_map[text[1] - VFILL] + OG_TBASE; 
+      text[1] = __ogulim_vo_gidx[text[1] - VFILL] * 2 + OG_VBASE + 1; 
+    }
+
+  for (i = 0; i < length; i++)
+    {
+      index = find_char (font, text[i]);
+      pango_glyph_string_set_size (glyphs, *n_glyphs + 1);
+      if (!index)
+	set_glyph (font, glyphs, *n_glyphs, cluster_offset,
+		   pango_xft_font_get_unknown_glyph (font, index));
+      else
+	set_glyph (font, glyphs, *n_glyphs, cluster_offset, index);
+      (*n_glyphs)++;
+    }
+
+  g_free (text);
+
+  return; 
+
+
+  /* If jamo sequence is not convertible to a jamo cluster,
+   * just enumerate stand-alone jamos. Prepend V and T with  Lf.
+   *
+   * XXX: It might be better to search for a sub-sequence (not just at the
+   * beginning of a cluster but also in the middle or at the end.) 
+   * that can be rendered as precomposed and render it as such and enumerate
+   * jamos in the rest. This approach is useful when a simple Xkb-based input
+   * is used. The same is true in render_...._with_ngulim().
+   */
+
+fallback: 
+  for (i = 0; i < length; i++)
+    {
+      gunichar wc2=0;
+      /* skip Lfill and Vfill if they're not the sole char. in a cluster */
+      if ( length > 1 && 
+	   (text[i] - LC_OFFSET == LFILL || text[i] - VO_OFFSET == VFILL))
+	continue;
+      else if (OG_IS_L (text[i]))
+         wc = __ogulim_lc_gidx[text[i] - LC_OFFSET - LBASE] * 6 + OG_LBASE;
+      else 
+        {
+	  /* insert Lfill glyph to advance cursor pos. for V and T */
+	  wc = OG_LBASE;
+	  /* don't have to draw Vfill. Drawing Lfill is sufficient. */ 
+	  if (text[i] - VO_OFFSET != VFILL) 
+	    wc2 = OG_IS_V (text[i]) ? 
+	        __ogulim_vo_gidx[text[i] - VO_OFFSET - VFILL] * 2 + OG_VBASE:
+	        __ogulim_tc_gidx[text[i] - TC_OFFSET - TSTART] * 4 + OG_TBASE + 3;
+        }
+
+        index = find_char (font, wc); 
+        pango_glyph_string_set_size (glyphs, *n_glyphs + 1);
+        set_glyph (font, glyphs, *n_glyphs, cluster_offset, index);
+        (*n_glyphs)++;
+	if (wc2) {
+          index =  find_char (font, wc2); 
+          pango_glyph_string_set_size (glyphs, *n_glyphs + 1);
+          set_glyph (font, glyphs, *n_glyphs, cluster_offset, index);
+          (*n_glyphs)++;
+        }
+    }
+
+  g_free (text);
+}
+
+static int
+ojns_comp (const void *p1, const void *p2)
+{
+  if (((OgJamosToNgSyllable *) p1)->seq[0] != ((OgJamosToNgSyllable *) p2)->seq[0])
+    return (((OgJamosToNgSyllable *) p1)->seq[0] - ((OgJamosToNgSyllable *) p2)->seq[0]);
+  else if (((OgJamosToNgSyllable *) p1)->seq[1] != ((OgJamosToNgSyllable *) p2)->seq[1])
+    return (((OgJamosToNgSyllable *) p1)->seq[1] - ((OgJamosToNgSyllable *) p2)->seq[1]);
+  else 
+    return (((OgJamosToNgSyllable *) p1)->seq[2] - ((OgJamosToNgSyllable *) p2)->seq[2]);
+}
+
+static void
+render_syllable_with_ngulim (PangoFont	      *font, 
+			     gunichar	      *text, 
+			     int	      length,
+			     PangoGlyphString *glyphs, 
+			     int	      *n_glyphs, 
+			     int	      cluster_offset)
+{
+  int index;
+  gunichar wc;
+  int i;
+  gunichar *text0 = NULL;
+  OgJamosToNgSyllable key,*match;
+
+#if 0
+  gunichar buf_static[9];
+  guint buf_size = G_N_ELEMENTS (buf_static);
+  gunichar *text1 = buf_static;
+  int length1;
+#endif
+
+  text = _normalize_jamo (text, &length);
+  text0 = text;
+
+  if (length == 1) 
+    {
+#if 1
+      text[0] += LC_OFFSET;  /* fallback assumes OG position */
+#else
+      text1[0] = text[0];
+      length1 = 1;
+#endif
+      goto fallback;
+    }
+
+
+  text += render_as_precomp_syllable (font, text, &length, glyphs, n_glyphs,
+          cluster_offset, FALSE);
+
+  if (! length)
+    {
+      g_free (text0);
+      return;
+    }
+
+#if 0
+  if (length > buf_siz)
+    text1 = g_new (gunichar, length);
+  memcpy (text1, text, length * sizeof (gunichar));
+  length1 = length;
+#endif
+
+  og_transform (text, &length);
+
+  if (length != 2 && length != 3)
+    goto fallback; 
+
+  if (! OG_IS_L (text[0]) || ! OG_IS_V (text[1]) || 
+      (length == 3 && ! OG_IS_T (text[2])))
+    goto fallback;
+
+  /* Look-up the precomposed syllable table */
+
+  key.seq[0] = text[0];
+  key.seq[1] = text[1];
+  key.seq[2] = length == 3 ? text[2] : 0; 
+  match = bsearch (&key, __og_jamos_to_ng_syllable, 
+           	   G_N_ELEMENTS (__og_jamos_to_ng_syllable), 
+		   sizeof (key), &ojns_comp);
+
+  if (match)
+    {
+      index = find_char (font, match->liga);
+      pango_glyph_string_set_size (glyphs, *n_glyphs + 1);
+      if (!index)
+	set_glyph (font, glyphs, *n_glyphs, cluster_offset,
+		   pango_xft_font_get_unknown_glyph (font, index));
+      else
+	set_glyph (font, glyphs, *n_glyphs, cluster_offset, index);
+      (*n_glyphs)++;
+    }
+
+  /* Use Jamo glyphs for simple over-striking */
+  else 
+    {
+      text[0] = __ogulim_lc_gidx[text[0] - LBASE - LC_OFFSET] + NG_LBASE;
+      text[1] = __ogulim_vo_gidx[text[1] - VFILL - VO_OFFSET] + NG_VBASE;
+
+  /* Unless a character is explicitly specified in fonts.conf file 
+   * as beling allowed to have a blank glyph, fontconfig regards it as 
+   * invalid and tries to come up with  sth. else. LFILL will be included 
+   * in fonts.conf distribution as a blank characters
+   * wheras we cannot expect ordinary users to add font-specific PUA 
+   * codepoints to  blank character list. Therefore, use LFILL in place 
+   * of Filler in PUA. NG_VBASE (VFill) is skipped below because it's 
+   * not only blank but also has zero-width so that its absence makes 
+   * no difference in  rendering. 
+   */
+      if (text[0] == NG_LBASE )
+        text[0] = LFILL; 
+
+      if (length == 3)
+        text[2] = __ogulim_tc_gidx[text[2] - TSTART - TC_OFFSET] + NG_TBASE;
+
+      for (i = 0; i < length; i++)
+        {
+          if (text[i] == NG_VBASE)  /* skip VFILL in PUA */
+            continue;
+          index = find_char (font, text[i]);
+          pango_glyph_string_set_size (glyphs, *n_glyphs + 1);
+          if (!index)
+            set_glyph (font, glyphs, *n_glyphs, cluster_offset,
+            pango_xft_font_get_unknown_glyph (font, index));
+          else
+    	    set_glyph (font, glyphs, *n_glyphs, cluster_offset, index);
+          (*n_glyphs)++;
+        }
+    }
+
+  g_free (text0);
+#if 0
+  if (length1 > buf_size)
+    g_free (text1);
+#endif
+
+  return; 
+
+
+  /* If jamo sequence is not convertible to a jamo cluster,
+   * just enumerate stand-alone jamos. 
+   * XXX : Would it be better to reverse the og_transform (the content of text[]
+   * can be stowed into text1[]  before OG_Transform and be retrieved here.)
+   * and render stand-alone Jamos with glyphs at U+1100 block? 
+   */ 
+
+fallback: 
+#if 1
+  for (i = 0; i < length; i++)
+    {
+      gunichar wc2=0;
+
+      /* skip Lfill and Vfill if they're not the sole char. in a cluster */
+      if (length > 1 && 
+	  (text[i] - LC_OFFSET == LFILL || text[i] - VO_OFFSET == VFILL))
+	continue;
+      else if (OG_IS_L (text[i]))
+        wc=__ogulim_lc_gidx[text[i] - LC_OFFSET - LBASE]  + NG_LBASE;
+      else 
+        {
+	  /* insert Lfill glyph in non-PUA to advance cursor pos. for V and T */
+	  wc = LFILL;  
+	  if (text[i] != VO_TMPPOS) /* don't have to render VFill */
+	    wc2 = OG_IS_V (text[i]) ? 
+	        __ogulim_vo_gidx[text[i] - VO_OFFSET - VFILL]  + NG_VBASE :
+	        __ogulim_tc_gidx[text[i] - TC_OFFSET - TSTART]  + NG_TBASE;
+        }
+
+
+      index = find_char (font, wc); 
+      pango_glyph_string_set_size (glyphs, *n_glyphs + 1);
+      if (!index)
+        set_glyph (font, glyphs, *n_glyphs, cluster_offset,
+           pango_xft_font_get_unknown_glyph (font, index));
+      else
+        set_glyph (font, glyphs, *n_glyphs, cluster_offset, index);
+      (*n_glyphs)++;
+
+      if (wc2) 
+        {
+          index = find_char (font, wc2); 
+          pango_glyph_string_set_size (glyphs, *n_glyphs + 1);
+          if (!index)
+  	    set_glyph (font, glyphs, *n_glyphs, cluster_offset,
+	               pango_xft_font_get_unknown_glyph (font, index));
+          else
+  	    set_glyph (font, glyphs, *n_glyphs, cluster_offset, index);
+          (*n_glyphs)++;
+        }
+    }
+#else 
+  for (i = 0; i < length1; i++)
+    {
+      index =  find_char (font, text1[i]);
+      pango_glyph_string_set_size (glyphs, *n_glyphs + 1);
+      set_glyph (font, glyphs, *n_glyphs, cluster_offset, index);
+      (*n_glyphs)++;
+    }
+  if (length1 > buf_size)
+    g_free (text1);
+#endif
+
+  g_free (text0);
+
+}
+
+
+static
+void set_render_func (PangoFont          *font, 
+		      RenderSyllableFunc *render_func)
+{
+  guint gindex;
+  FT_Face face=pango_xft_font_lock_face (font); 
+
+  if ( ! strcmp (face->family_name,"Gulim OldHangul Jamo") ||
+       ! strcmp (face->family_name,"Batng OldHangul Jamo") ||
+       ! strcmp (face->family_name,"Gunseo OldHangul Jamo")|| 
+       ! strcmp (face->family_name,"Dotum OldHangul Jamo"))
+    *render_func = render_syllable_with_ogulim;
+  else if ( ! strcmp ( face->family_name,"New Gulim") ||
+	    ! strcmp (face->family_name,"New Batng")  ||
+	    ! strcmp (face->family_name,"New Gunseo") || 
+	    ! strcmp (face->family_name,"New Dotum"))
+    *render_func = render_syllable_with_ngulim;
+  else if ((gindex=find_char (font, VBASE)))
+    {
+      PangoRectangle l_rect;
+      pango_font_get_glyph_extents (font, (PangoGlyph) gindex, NULL, &l_rect);
+      if ( ! l_rect.width ) 
+	*render_func = render_syllable_with_combining_jamo;
+      else 
+	*render_func = render_syllable_with_spacing_jamo;
+    }
+  else
+    *render_func = render_syllable_with_spacing_jamo;
 }
 
 static void 
@@ -142,11 +596,16 @@
   gunichar *jamos = jamos_static;
   int n_jamos;
 
+  RenderSyllableFunc render_func = NULL;
+
   n_chars = g_utf8_strlen (text, length);
   n_glyphs = 0;
   start = p = text;
   n_jamos = 0;
 
+
+  set_render_func (font,&render_func);
+
   for (i = 0; i < n_chars; i++)
     {
       gunichar wc;
@@ -160,8 +619,7 @@
 	   (IS_T (jamos[n_jamos - 1]) && IS_V (wc))))
 	{
 	  /* Draw a syllable. */
-	  render_syllable (font, jamos, n_jamos, glyphs,
-			   &n_glyphs, start - text);
+	  render_func (font, jamos, n_jamos, glyphs, &n_glyphs, start - text);
 	  n_jamos = 0;
 	  start = p;
 	}
@@ -172,7 +630,7 @@
 	  if (jamos == jamos_static)
 	    {
 	      jamos = g_new (gunichar, max_jamos);
-	      memcpy(jamos, jamos_static, n_jamos*sizeof(gunichar));
+	      memcpy (jamos, jamos_static, n_jamos * sizeof (gunichar));
 	    }
 	  else
 	    jamos = g_renew (gunichar, jamos, max_jamos);
@@ -182,12 +640,11 @@
       p = g_utf8_next_char (p);
     }
 
-  if (n_jamos != 0)
-    render_syllable (font, jamos, n_jamos, glyphs, &n_glyphs,
-		     start - text);
+  if (n_jamos != 0) 
+    render_func (font, jamos, n_jamos, glyphs, &n_glyphs, start - text);
 
   if (jamos != jamos_static)
-    g_free(jamos);
+    g_free (jamos);
 }
 
 static PangoCoverage *
@@ -197,8 +654,7 @@
   PangoCoverage *result = pango_coverage_new ();
   int i;
 
-  /* Well, no unicode rendering engine could render Hangul Jamo area
-     _exactly_, I sure.  */
+  /* XXX : If font is Oxxx or Nxxx, set to PANGO_COVERAGE_EXACT for U+1100 Jamos */
   for (i = 0x1100; i <= 0x11FF; i++)
     pango_coverage_set (result, i, PANGO_COVERAGE_FALLBACK);
   return result;
