m17n-fc.c

   1 /* Pango
   2  * m17n-fc.c: Generic shaper using the m17n library for FreeType-based backends
   3
   4    Copyright (C) 2004, 2005, 2006
   5      National Institute of Advanced Industrial Science and Technology (AIST)
   6      Registration Number H16PRO276
   7
   8    This file is part of the pango-m17n library.
   9
  10    The pango-m17n library is free software; you can redistribute it
  11    and/or modify it under the terms of the GNU Lesser General Public
  12    License as published by the Free Software Foundation; either
  13    version 2.1 of the License, or (at your option) any later version.
  14
  15    The pango-m17n library is distributed in the hope that it will be
  16    useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  17    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU Lesser General Public License for more details.
  19
  20    You should have received a copy of the GNU Lesser General Public
  21    License along with the pango-m17n library; if not, write to the
  22    Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  23    MA 02111-1307, USA.  */
  24
  25 #include <string.h>
  26 #include <stdlib.h>
  27
  28 #include <pango/pango-engine.h>
  29 #include <pango/pango-utils.h>
  30 #include <pango/pangofc-font.h>
  31
  32 #include <m17n-gui.h>
  33 #include <m17n-misc.h>
  34
  35 #ifdef G_LOG_DOMAIN
  36 #undef G_LOG_DOMAIN
  37 #endif
  38 #define G_LOG_DOMAIN "Pango-M17N-FC"
  39
  40 /* Control printing of debug information.  It is initialized from the
  41    environment variable PANGO_M17N_FC_DEBUG.  Currently, any positive
  42    value turns on all debug messages.  */
  43 static int debug_level;
  44
  45 /* Commonly used frame on nulldevice.  */
  46 static MFrame *frame;
  47
  48 /* Commonly used "generic" fontset.  */
  49 static MFontset *fontset;
  50
  51 /* Initialize this module.  The main task is to open a frame on
  52    nulldevice.  */
  53
  54 static void
  55 init_module ()
  56 {
  57   const char *envvar = g_getenv ("PANGO_M17N_FC_DEBUG");
  58   MPlist *param;
  59   MFace *face;
  60
  61   debug_level = envvar ? atoi (envvar) : 0;
  62
  63   param = mplist ();
  64   face = mface ();
  65   fontset = (mdatabase_find (Mfontset, msymbol ("generic"), Mnil, Mnil)
  66              ? mfontset ("generic") : mfontset (NULL));
  67   mface_put_prop (face, Mfontset, fontset);
  68   mplist_put (param, Mface, face);
  69   mplist_put (param, Mdevice, Mnil);
  70   frame = mframe (param);
  71   m17n_object_unref (face);
  72   m17n_object_unref (param);
  73 }
  74
  75 /* Finalize this module by freeing frame.  */
  76
  77 static void
  78 fini_module ()
  79 {
  80   m17n_object_unref (frame);
  81   m17n_object_unref (fontset);
  82 }
  83
  84 /* No extra fields needed for these structures.  */
  85 typedef PangoEngineShape      M17NEngineFc;
  86 typedef PangoEngineShapeClass M17NEngineFcClass;
  87
  88 #define SCRIPT_ENGINE_NAME "M17NScriptEngineFc"
  89 #define RENDER_TYPE PANGO_RENDER_TYPE_FC
  90
  91 static PangoEngineScriptInfo m17n_scripts[] = {
  92   { PANGO_SCRIPT_ARABIC,   "*" },
  93   { PANGO_SCRIPT_ARMENIAN, "*" },
  94   { PANGO_SCRIPT_BENGALI,  "*" },
  95   { PANGO_SCRIPT_BOPOMOFO, "*" },
  96   { PANGO_SCRIPT_CHEROKEE, "*" },
  97   { PANGO_SCRIPT_COPTIC,   "*" },
  98   { PANGO_SCRIPT_CYRILLIC, "*" },
  99   { PANGO_SCRIPT_DESERET,  "*" },
 100   { PANGO_SCRIPT_DEVANAGARI, "*" },
 101   { PANGO_SCRIPT_ETHIOPIC, "*" },
 102   { PANGO_SCRIPT_GEORGIAN, "*" },
 103   { PANGO_SCRIPT_GOTHIC,   "*" },
 104   { PANGO_SCRIPT_GREEK,    "*" },
 105   { PANGO_SCRIPT_GUJARATI, "*" },
 106   { PANGO_SCRIPT_GURMUKHI, "*" },
 107   { PANGO_SCRIPT_HAN,      "*" },
 108   { PANGO_SCRIPT_HANGUL,   "*" },
 109   { PANGO_SCRIPT_HEBREW,   "*" },
 110   { PANGO_SCRIPT_HIRAGANA, "*" },
 111   { PANGO_SCRIPT_KANNADA,  "*" },
 112   { PANGO_SCRIPT_KATAKANA, "*" },
 113   { PANGO_SCRIPT_KHMER,    "*" },
 114   { PANGO_SCRIPT_LAO,      "*" },
 115   { PANGO_SCRIPT_MALAYALAM, "*" },
 116   { PANGO_SCRIPT_MYANMAR,  "*" },
 117   { PANGO_SCRIPT_OGHAM,    "*" },
 118   { PANGO_SCRIPT_OLD_ITALIC, "*" },
 119   { PANGO_SCRIPT_ORIYA,     "*" },
 120   { PANGO_SCRIPT_RUNIC,     "*" },
 121   { PANGO_SCRIPT_SINHALA,   "*" },
 122   { PANGO_SCRIPT_SYRIAC,    "*" },
 123   { PANGO_SCRIPT_TAMIL,     "*" },
 124   { PANGO_SCRIPT_TELUGU,    "*" },
 125   { PANGO_SCRIPT_THAANA,    "*" },
 126   { PANGO_SCRIPT_THAI,      "*" },
 127   { PANGO_SCRIPT_TIBETAN,   "*" },
 128   { PANGO_SCRIPT_CANADIAN_ABORIGINAL, "*" },
 129   { PANGO_SCRIPT_YI,       "*" },
 130
 131 #ifdef PANGO_SCRIPT_BRAILLE
 132   { PANGO_SCRIPT_BRAILLE,  "*" },
 133   { PANGO_SCRIPT_CYPRIOT,  "*" },
 134   { PANGO_SCRIPT_LIMBU,    "*" },
 135   { PANGO_SCRIPT_OSMANYA,  "*" },
 136   { PANGO_SCRIPT_SHAVIAN,  "*" },
 137   { PANGO_SCRIPT_LINEAR_B, "*" },
 138   { PANGO_SCRIPT_TAI_LE,   "*" },
 139   { PANGO_SCRIPT_UGARITIC, "*" },
 140 #endif  /* PANGO_SCRIPT_BRAILLE */
 141
 142 #ifdef PANGO_SCRIPT_NEW_TAI_LUE
 143   { PANGO_SCRIPT_NEW_TAI_LUE, "*" },
 144   { PANGO_SCRIPT_BUGINESE, "*" },
 145   { PANGO_SCRIPT_GLAGOLITIC, "*" },
 146   { PANGO_SCRIPT_TIFINAGH, "*" },
 147   { PANGO_SCRIPT_SYLOTI_NAGRI, "*" },
 148   { PANGO_SCRIPT_OLD_PERSIAN, "*" },
 149   { PANGO_SCRIPT_KHAROSHTHI, "*" },
 150 #endif  /* PANGO_SCRIPT_NEW_TAI_LUE */
 151
 152   { PANGO_SCRIPT_COMMON,   "" }
 153 };
 154
 155 static PangoEngineInfo script_engines[] = {
 156   {
 157     SCRIPT_ENGINE_NAME,
 158     PANGO_ENGINE_TYPE_SHAPE,
 159     RENDER_TYPE,
 160     m17n_scripts, G_N_ELEMENTS (m17n_scripts)
 161   }
 162 };
 163
 164 static char *
 165 m17n_fc_get_family (PangoFont *pango_font)
 166 {
 167   PangoFcFont *pango_fc_font = PANGO_FC_FONT (pango_font);
 168   FcChar8 *family;
 169
 170   if (FcPatternGetString (pango_fc_font->font_pattern, FC_FAMILY, 0, &family)
 171       == FcResultMatch)
 172     return (char *) family;
 173   return "";
 174 }
 175
 176 /* Convert PANGO_LANGUAGE to m17n-lib's language symbol.  If m17n-lib
 177    doesn't know about PANGO_LANGUAGE, return Mnil.  */
 178
 179 static MSymbol
 180 m17n_fc_get_language (PangoLanguage *pango_language)
 181 {
 182   MSymbol language;
 183
 184   if (pango_language)
 185     {
 186       const char *lang = pango_language_to_string (pango_language);
 187
 188       language = msymbol (lang);
 189       if (! msymbol_get (language, Mlanguage))
 190         {
 191           if (strlen (lang) <= 2)
 192             language = Mnil;
 193           else
 194             {
 195               /* Remove region part (e.g. "zh_CN" -> "zh").  */
 196               char shortlang[3];
 197
 198               shortlang[0] = lang[0], shortlang[1] = lang[1], shortlang[2] = 0;
 199               language = msymbol (shortlang);
 200               if (! msymbol_get (language, Mlanguage))
 201                 language = Mnil;
 202             }
 203         }
 204     }
 205   else
 206     language = Mnil;
 207   return language;
 208 }
 209
 210
 211 /* Return a list of FONT-SPECs specified in the current fontset for
 212    displaying SCRIPT in LANGUAGE.  Callers must unref the returned
 213    plist.  */
 214
 215 MPlist *
 216 m17n_fc_lookup_fontset (MSymbol script, MSymbol language)
 217 {
 218   MPlist *plist = mfontset_lookup (fontset, script, language, Mnil);
 219
 220   if (mplist_key (plist) == Mnil)
 221     {
 222       /* List up languages that have entries for SCRIPT.  */
 223       MPlist *ll = mfontset_lookup (fontset, script, Mt, Mnil);
 224
 225       if (! ll)
 226         {
 227           /* No entry for SCRIPT.  Return fallback FONT-SPECs. */
 228           m17n_object_unref (plist);
 229           plist = mfontset_lookup (fontset, Mnil, Mnil, Mnil);
 230         }
 231       else
 232         {
 233           if (mplist_length (ll) == 1)
 234             {
 235               /* If there's just one language, return FONT-SPECs for it.  */
 236               m17n_object_unref (plist);
 237               language = mplist_key (ll);
 238               if (language == Mt)
 239                 language = Mnil;
 240               plist = mfontset_lookup (fontset, script, mplist_key (ll), Mnil);
 241             }
 242           else
 243             /* Sumup FONT-SPECs for all languages.  */
 244             for (; mplist_key (ll) != Mnil; ll = mplist_next (ll))
 245               {
 246                 MPlist *pl;
 247
 248                 language = mplist_key (ll);
 249                 if (language == Mt)
 250                   language = Mnil;
 251                 for (pl = mfontset_lookup (fontset, script, language, Mnil);
 252                      mplist_key (pl) != Mnil; pl = mplist_next (pl))
 253                   mplist_add (plist, mplist_key (pl), mplist_value (pl));
 254             }
 255         }
 256     }
 257   return plist;
 258 }
 259
 260
 261 typedef struct
 262 {
 263   PangoFcFont *pango_fc_font;
 264   MFont *font;
 265 } M17NFontInfo;
 266
 267 static void
 268 m17n_fc_free_font_info (gpointer data)
 269 {
 270   M17NFontInfo *font_info = data;
 271
 272   if (font_info->font)
 273     {
 274       mfont_close (font_info->font);
 275       pango_fc_font_unlock_face (font_info->pango_fc_font);
 276     }
 277   g_free (data);
 278 }
 279
 280 static MFont *
 281 m17n_fc_get_font (PangoFont *pango_font)
 282 {
 283   GQuark info_id = g_quark_from_string ("m17n-font-info");
 284   M17NFontInfo *font_info;
 285
 286   font_info = g_object_get_qdata (G_OBJECT (pango_font), info_id);
 287   if (! font_info)
 288     {
 289       PangoFcFont *pango_fc_font = PANGO_FC_FONT (pango_font);
 290       FT_Face ft_face = pango_fc_font_lock_face (pango_fc_font);
 291
 292       font_info = g_new (M17NFontInfo, 1);
 293       font_info->pango_fc_font = pango_fc_font;
 294       font_info->font = mfont_encapsulate (frame, Mfreetype, ft_face);
 295       g_object_set_qdata_full (G_OBJECT (pango_font), info_id, font_info,
 296                                (GDestroyNotify) m17n_fc_free_font_info);
 297     }
 298   return font_info->font;
 299 }
 300
 301
 302 /* Shaper function.  */
 303
 304 static void
 305 m17n_fc_engine_shape (PangoEngineShape *engine,
 306                       PangoFont        *pango_font,
 307                       const char       *text,
 308                       int              length,
 309                       const PangoAnalysis    *analysis,
 310                       PangoGlyphString *glyphs)
 311 {
 312   /* Symbols for character property `category'.  */
 313   static MSymbol MZs, MCf;
 314   static MDrawControl control;
 315   MSymbol language;
 316   PangoGlyphInfo *g;
 317   MText *mt;
 318   MDrawGlyph *m_glyphs;
 319   int nchars, nglyphs;
 320   MFont *font;
 321   int i;
 322   const char *p;
 323   int *offsets;
 324
 325   g_return_if_fail (pango_font != NULL);
 326   g_return_if_fail (text != NULL);
 327   g_return_if_fail (length >= 0);
 328   g_return_if_fail (analysis != NULL);
 329
 330   if (debug_level > 0)
 331     {
 332       char *msg = alloca (length + 1);
 333
 334       if (msg)
 335         {
 336           memcpy (msg, text, length);
 337           msg[length] = '\0';
 338         }
 339       else
 340         msg = "...";
 341       g_debug ("shape \"%s\"", msg);
 342     }
 343
 344   if (! MZs)
 345     {
 346       MZs = msymbol ("Zs");
 347       MCf = msymbol ("Cf");
 348     }
 349
 350   language = m17n_fc_get_language (analysis->language);
 351
 352   mt = mtext_from_data (text, length, MTEXT_FORMAT_UTF_8);
 353   nchars = mtext_len (mt);
 354   offsets = alloca (sizeof (int) * nchars);
 355   g_return_if_fail (offsets != NULL);
 356   for (i = 0, p = text; i < nchars; i++, p = g_utf8_next_char (p))
 357     offsets[i] = p - text;
 358
 359   font = m17n_fc_get_font (pango_font);
 360   g_return_if_fail (font != NULL);
 361
 362   mtext_put_prop (mt, 0, nchars, Mfont, font);
 363   if (language != Mnil)
 364     mtext_put_prop (mt, 0, nchars, Mlanguage, language);
 365
 366   control.enable_bidi = 1;
 367   m_glyphs = alloca (sizeof (MDrawGlyph) * nchars * 2);
 368   g_return_if_fail (m_glyphs != NULL);
 369   if (mdraw_glyph_list (frame, mt, 0, nchars, &control, m_glyphs,
 370                         nchars * 2, &nglyphs) < 0)
 371     {
 372       m_glyphs = alloca (sizeof (MDrawGlyph) * nglyphs);
 373       g_return_if_fail (m_glyphs != NULL);
 374       mdraw_glyph_list (frame, mt, 0, nchars, &control, m_glyphs,
 375                         nglyphs, &nglyphs);
 376     }
 377
 378   pango_glyph_string_set_size (glyphs, nglyphs);
 379
 380   for (i = 0, g = glyphs->glyphs; i < nglyphs; i++, g++)
 381     {
 382       if (m_glyphs[i].glyph_code >= 0)
 383         {
 384           g->glyph = m_glyphs[i].glyph_code;
 385           g->geometry.x_offset = m_glyphs[i].x_off * PANGO_SCALE;
 386           g->geometry.y_offset = m_glyphs[i].y_off * PANGO_SCALE;
 387           g->geometry.width = m_glyphs[i].x_advance * PANGO_SCALE;
 388         }
 389       else
 390         {
 391           int c = mtext_ref_char (mt, m_glyphs[i].from);
 392           MSymbol category = mchar_get_prop (c, Mcategory);
 393           PangoRectangle logical_rect;
 394
 395           if (category == MZs)
 396             {
 397               g->glyph = 0;
 398               g->geometry.width = m_glyphs[i].x_advance * PANGO_SCALE;
 399             }
 400           else if (category == MCf)
 401             {
 402               g->glyph = 0;
 403               g->geometry.width = 0;
 404             }
 405           else
 406             {
 407               g->glyph = (pango_fc_font_get_unknown_glyph
 408                           (PANGO_FC_FONT (pango_font), c));
 409               pango_font_get_glyph_extents (pango_font, g->glyph, NULL,
 410                                             &logical_rect);
 411               g->geometry.width = logical_rect.width;
 412             }
 413           g->geometry.x_offset = 0;
 414           g->geometry.y_offset = 0;
 415         }
 416       g->attr.is_cluster_start
 417         = (i == 0
 418            || m_glyphs[i - 1].from != m_glyphs[i].from);
 419       glyphs->log_clusters[i] = offsets[m_glyphs[i].from];
 420     }
 421
 422   m17n_object_unref (mt);
 423 }
 424
 425 /* Check if PANGO_FONT is suitable for the character WC.  */
 426
 427 static PangoCoverageLevel
 428 m17n_fc_engine_covers (PangoEngineShape *engine,
 429                        PangoFont        *pango_font,
 430                        PangoLanguage    *pango_language,
 431                        gunichar          wc)
 432 {
 433   static gunichar last_wc = 0;
 434   /* Symbols for character property `script'.  */
 435   static MSymbol Mlatin, Mcommon, Minherited;
 436   PangoCoverage *coverage;
 437   PangoCoverageLevel result;
 438   MSymbol script, language;
 439   MPlist *spec_list, *p;
 440   MFont *font;
 441
 442   if (! Mlatin)
 443     {
 444       Mlatin = msymbol ("latin");
 445       Mcommon = msymbol ("common");
 446       Minherited = msymbol ("inherited");
 447     }
 448
 449   if (debug_level > 0 && wc != last_wc)
 450     {
 451       g_debug ("covers for U+%04X", wc);
 452       last_wc = wc;
 453     }
 454
 455   coverage = pango_font_get_coverage (pango_font, pango_language);
 456   result = pango_coverage_get (coverage, wc);
 457   pango_coverage_unref (coverage);
 458
 459   if (result == PANGO_COVERAGE_NONE)
 460     {
 461       if (debug_level > 0)
 462         g_debug ("  %s none", m17n_fc_get_family (pango_font));
 463       return result;
 464     }
 465
 466   language = m17n_fc_get_language (pango_language);
 467   if (wc < 0x100)
 468     script = Mlatin;
 469   else
 470     {
 471       script = mchar_get_prop ((int) wc, Mscript);
 472       if (script == Mcommon || script == Minherited)
 473         script = mchar_get_prop ((int) wc, msymbol ("block"));
 474     }
 475
 476   font = m17n_fc_get_font (pango_font);
 477   spec_list = m17n_fc_lookup_fontset (script, language);
 478
 479   result = PANGO_COVERAGE_NONE;
 480   for (p = spec_list; mplist_key (p) != Mnil; p = mplist_next (p))
 481     if (mfont_match_p (font, mplist_value (p)))
 482       {
 483         result = PANGO_COVERAGE_EXACT;
 484         break;
 485       }
 486   m17n_object_unref (spec_list);
 487   if (debug_level > 0)
 488     g_debug ("  (%s,%s): %s %s",
 489              (script ? msymbol_name (script) : ""),
 490              (language ? msymbol_name (language) : ""),
 491              m17n_fc_get_family (pango_font),
 492              result == PANGO_COVERAGE_EXACT ? "exact" : "none");
 493
 494   return result;
 495 }
 496
 497 static void
 498 m17n_engine_fc_class_init (PangoEngineShapeClass *class)
 499 {
 500   class->script_shape = m17n_fc_engine_shape;
 501   class->covers = m17n_fc_engine_covers;
 502 }
 503
 504 PANGO_ENGINE_SHAPE_DEFINE_TYPE (M17NEngineFc, m17n_engine_fc,
 505                                 m17n_engine_fc_class_init, NULL)
 506
 507 void
 508 PANGO_MODULE_ENTRY(init) (GTypeModule *module)
 509 {
 510   m17n_engine_fc_register_type (module);
 511
 512   M17N_INIT ();
 513   init_module ();
 514 }
 515
 516 void
 517 PANGO_MODULE_ENTRY(exit) (void)
 518 {
 519   fini_module ();
 520   M17N_FINI ();
 521 }
 522
 523 void
 524 PANGO_MODULE_ENTRY(list) (PangoEngineInfo **engines,
 525                           int              *n_engines)
 526 {
 527   *engines = script_engines;
 528   *n_engines = G_N_ELEMENTS (script_engines);
 529 }
 530
 531 PangoEngine *
 532 PANGO_MODULE_ENTRY(create) (const char *id)
 533 {
 534   return (!strcmp (id, SCRIPT_ENGINE_NAME)
 535           ? g_object_new (m17n_engine_fc_type, NULL)
 536           : NULL);
 537 }