basic-x.c

Pango is a library for layout and rendering of text, with an emphasis on internationalization. Pang

  g_iconv (cd, (char **)&inptr, &inbytesleft, &outptr, &outbytesleft);

  if ((guchar)outbuf[0] < 128)
    return outbuf[0];
  else
    return ((guchar)outbuf[0] & 0x7f) * 256 + ((guchar)outbuf[1] & 0x7f);
}

static PangoGlyph
conv_16bit_MSB_on (CharCache  *cache,
		   GIConv      cd,
		   const char *input)
{
  char outbuf[2];

  const char *inptr = input;
  size_t inbytesleft;
  char *outptr = outbuf;
  size_t outbytesleft = 2;

  inbytesleft = g_utf8_next_char (input) - input;

  g_iconv (cd, (char **)&inptr, &inbytesleft, &outptr, &outbytesleft);

  if ((guchar)outbuf[0] < 128)
    return outbuf[0];
  else
    return (guchar)outbuf[0] * 256 + (guchar)outbuf[1];
}

static PangoGlyph
conv_gb18030_1 (CharCache  *cache,
		GIConv      cd,
		const char *input)
{
  char outbuf[4];

  const char *inptr = input;
  size_t inbytesleft;
  char *outptr = outbuf;
  size_t outbytesleft = 4;


  inbytesleft = g_utf8_next_char (input) - input;

  g_iconv (cd, (char **)&inptr, &inbytesleft, &outptr, &outbytesleft);

  if ((guchar)outbuf[0] < 128)
    return outbuf[0];
  else
    return  12600 * ((guchar)outbuf[0] - 0x81) + 1260 * ((guchar)outbuf[1] - 0x30) + 10 * ((guchar)outbuf[2] - 0x81) + ((guchar)outbuf[3] - 0x30);
}

static PangoGlyph
conv_euctw (CharCache  *cache,
	    GIConv      cd,
	    const char *input)
{
  char outbuf[4];

  const char *inptr = input;
  size_t inbytesleft;
  char *outptr = outbuf;
  size_t outbytesleft = 4;

  inbytesleft = g_utf8_next_char (input) - input;

  g_iconv (cd, (char **)&inptr, &inbytesleft, &outptr, &outbytesleft);

  /* The first two bytes determine which page of CNS to use; we
   * get this information from tables-big.i, so ignore them
   */
  if ((guchar)outbuf[0] < 128)
    return outbuf[0];
  else
    return ((guchar)outbuf[2] & 0x7f) * 256 + ((guchar)outbuf[3] & 0x7f);
}

static PangoGlyph
conv_ucs4 (CharCache  *cache,
	   GIConv      cd,
	   const char *input)
{
  return g_utf8_get_char (input);
}

static void
swap_range (PangoGlyphString *glyphs, int start, int end)
{
  int i, j;

  for (i = start, j = end - 1; i < j; i++, j--)
    {
      PangoGlyphInfo glyph_info;
      gint log_cluster;

      glyph_info = glyphs->glyphs[i];
      glyphs->glyphs[i] = glyphs->glyphs[j];
      glyphs->glyphs[j] = glyph_info;

      log_cluster = glyphs->log_clusters[i];
      glyphs->log_clusters[i] = glyphs->log_clusters[j];
      glyphs->log_clusters[j] = log_cluster;
    }
}

static void
char_caches_free (GSList *caches)
{
  GSList *tmp_list = caches;
  while (tmp_list)
    {
      CharCachePointer *pointer = tmp_list->data;

      pointer->cache->ref_count--;
      if (pointer->cache->ref_count == 0)
	char_cache_free (pointer->cache);
      g_free (pointer);

      tmp_list = tmp_list->next;
    }
  g_slist_free (caches);
}

static CharsetOrdering *
ordering_for_lang (PangoLanguage *lang)
{
  int i;

  for (i = 0; i < (int)G_N_ELEMENTS (charset_orderings) - 1; i++)
    {
      if (pango_language_matches (lang, charset_orderings[i].langs))
	return &charset_orderings[i];
    }

  return &charset_orderings[i];
}

static CharCache *
get_char_cache (PangoFont     *font,
		PangoLanguage *lang)
{
  GQuark cache_id = g_quark_from_string ("basic-char-cache");
  CharCache *cache = NULL;
  CharCachePointer *pointer;
  CharsetOrdering *ordering;
  GSList *caches;
  GSList *tmp_list;

  caches = g_object_get_qdata (G_OBJECT (font), cache_id);
  tmp_list = caches;
  while (tmp_list)
    {
      pointer = tmp_list->data;
      if (pointer->lang == lang)
	return pointer->cache;

      tmp_list = tmp_list->next;
    }

  ordering = ordering_for_lang (lang);

  tmp_list = caches;
  while (tmp_list)
    {
      pointer = tmp_list->data;
      if (pointer->cache->ordering == ordering)
	{
	  cache = pointer->cache;
	  break;
	}

      tmp_list = tmp_list->next;
    }

  if (!cache)
    cache = char_cache_new (ordering);
  else
    cache->ref_count++;

  pointer = g_new (CharCachePointer, 1);
  pointer->lang = lang;
  pointer->cache = cache;

  caches = g_slist_prepend (caches, pointer);

  g_object_steal_qdata (G_OBJECT (font), cache_id);
  g_object_set_qdata_full (G_OBJECT (font), cache_id,
			   caches, (GDestroyNotify)char_caches_free);

  return cache;
}

static void
basic_engine_shape (PangoEngineShape *engine,
		    PangoFont        *font,
		    const char       *text,
		    gint              length,
		    const PangoAnalysis *analysis,
		    PangoGlyphString *glyphs)
{
  int n_chars;
  int i;
  const char *p;

  CharCache *cache;

  g_return_if_fail (font != NULL);
  g_return_if_fail (text != NULL);
  g_return_if_fail (length >= 0);
  g_return_if_fail (analysis != NULL);

  cache = get_char_cache (font, analysis->language);

  n_chars = g_utf8_strlen (text, length);
  pango_glyph_string_set_size (glyphs, n_chars);

  p = text;
  for (i=0; i < n_chars; i++)
    {
      gunichar wc;
      gunichar mirrored_ch;
      PangoGlyph index;
      char buf[6];
      const char *input;

      wc = g_utf8_get_char (p);

      input = p;
      if (analysis->level % 2)
	if (pango_get_mirror_char (wc, &mirrored_ch))
	  {
	    wc = mirrored_ch;

	    g_unichar_to_utf8 (wc, buf);
	    input = buf;
	  }

      if (wc == 0xa0)	/* non-break-space */
	{
	  wc = 0x20;

	  g_unichar_to_utf8 (wc, buf);
	  input = buf;
	}

      if (pango_is_zero_width (wc))
	{
	  set_glyph (font, glyphs, i, p - text, PANGO_GLYPH_EMPTY);
	}
      else
	{
	  index = find_char (cache, font, wc, input);
	  if (index)
	    {
	      set_glyph (font, glyphs, i, p - text, index);

	      if (g_unichar_type (wc) == G_UNICODE_NON_SPACING_MARK)
		{
		  if (i > 0)
		    {
		      PangoRectangle logical_rect, ink_rect;

		      glyphs->glyphs[i].geometry.width = MAX (glyphs->glyphs[i-1].geometry.width,
							      glyphs->glyphs[i].geometry.width);
		      glyphs->glyphs[i-1].geometry.width = 0;
		      glyphs->log_clusters[i] = glyphs->log_clusters[i-1];

		      /* Some heuristics to try to guess how overstrike glyphs are
		       * done and compensate
		       */
		      pango_font_get_glyph_extents (font, glyphs->glyphs[i].glyph, &ink_rect, &logical_rect);
		      if (logical_rect.width == 0 && ink_rect.x == 0)
			glyphs->glyphs[i].geometry.x_offset = (glyphs->glyphs[i].geometry.width - ink_rect.width) / 2;
		    }
		}
	    }
	  else
	    set_glyph (font, glyphs, i, p - text, PANGO_GET_UNKNOWN_GLYPH (wc));
	}

      p = g_utf8_next_char (p);
    }

  /* Simple bidi support... may have separate modules later */

  if (analysis->level % 2)
    {
      int start, end;

      /* Swap all glyphs */
      swap_range (glyphs, 0, n_chars);

      /* Now reorder glyphs within each cluster back to LTR */
      for (start=0; start<n_chars;)
	{
	  end = start;
	  while (end < n_chars &&
		 glyphs->log_clusters[end] == glyphs->log_clusters[start])
	    end++;

	  swap_range (glyphs, start, end);
	  start = end;
	}
    }
}

static PangoCoverageLevel
basic_engine_covers (PangoEngineShape *engine,
		     PangoFont        *font,
		     PangoLanguage    *lang,
		     gunichar          wc)
{
  CharCache *cache = get_char_cache (font, lang);
  char buf[6];

  g_unichar_to_utf8 (wc, buf);

  return find_char (cache, font, wc, buf) ? PANGO_COVERAGE_EXACT : PANGO_COVERAGE_NONE;
}

static void
basic_engine_x_class_init (PangoEngineShapeClass *class)
{
  class->covers = basic_engine_covers;
  class->script_shape = basic_engine_shape;
}

PANGO_ENGINE_SHAPE_DEFINE_TYPE (BasicEngineX, basic_engine_x,
				basic_engine_x_class_init, NULL)

void
PANGO_MODULE_ENTRY(init) (GTypeModule *module)
{
  basic_engine_x_register_type (module);
}

void
PANGO_MODULE_ENTRY(exit) (void)
{
}

void
PANGO_MODULE_ENTRY(list) (PangoEngineInfo **engines,
			  int              *n_engines)
{
  *engines = script_engines;
  *n_engines = G_N_ELEMENTS (script_engines);
}

PangoEngine *
PANGO_MODULE_ENTRY(create) (const char *id)
{
  if (!strcmp (id, SCRIPT_ENGINE_NAME))
    return g_object_new (basic_engine_x_type, NULL);
  else
    return NULL;
}