w32uniscribe.c 37.5 KB
Newer Older
1
/* Font backend for the Microsoft W32 Uniscribe API.
Paul Eggert's avatar
Paul Eggert committed
2
   Copyright (C) 2008-2019 Free Software Foundation, Inc.
3 4 5

This file is part of GNU Emacs.

6
GNU Emacs is free software: you can redistribute it and/or modify
7
it under the terms of the GNU General Public License as published by
8 9
the Free Software Foundation, either version 3 of the License, or (at
your option) any later version.
10 11 12 13 14 15 16

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
Paul Eggert's avatar
Paul Eggert committed
17
along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
18 19 20


#include <config.h>
Eli Zaretskii's avatar
Eli Zaretskii committed
21 22
/* Override API version - Uniscribe is only available as standard
   since Windows 2000, though most users of older systems will have it
23
   since it installs with Internet Explorer 5.0 and other software.
Eli Zaretskii's avatar
Eli Zaretskii committed
24 25 26 27
   Also, MinGW64 w32api headers by default define OPENTYPE_TAG typedef
   only if _WIN32_WINNT >= 0x0600.  We only use the affected APIs if
   they are available, so there is no chance of calling non-existent
   functions.  */
28
#undef _WIN32_WINNT
Eli Zaretskii's avatar
Eli Zaretskii committed
29
#define _WIN32_WINNT 0x0600
30 31 32 33 34 35
#include <windows.h>
#include <usp10.h>

#include "lisp.h"
#include "w32term.h"
#include "frame.h"
36
#include "composite.h"
37 38
#include "font.h"
#include "w32font.h"
Daniel Colascione's avatar
Daniel Colascione committed
39
#include "pdumper.h"
40
#include "w32common.h"
41 42 43 44 45 46 47 48 49 50

struct uniscribe_font_info
{
  struct w32font_info w32_font;
  SCRIPT_CACHE cache;
};

int uniscribe_available = 0;

/* EnumFontFamiliesEx callback.  */
51 52 53
static int CALLBACK ALIGN_STACK add_opentype_font_name_to_list (ENUMLOGFONTEX *,
								NEWTEXTMETRICEX *,
								DWORD, LPARAM);
54
/* Used by uniscribe_otf_capability.  */
55
static Lisp_Object otf_features (HDC context, const char *table);
56 57

static int
58
memq_no_quit (Lisp_Object elt, Lisp_Object list)
59 60 61 62 63 64 65 66 67
{
  while (CONSP (list) && ! EQ (XCAR (list), elt))
    list = XCDR (list);
  return (CONSP (list));
}


/* Font backend interface implementation.  */
static Lisp_Object
Dmitry Antipov's avatar
Dmitry Antipov committed
68
uniscribe_list (struct frame *f, Lisp_Object font_spec)
69
{
70
  Lisp_Object fonts = w32font_list_internal (f, font_spec, true);
71
  FONT_ADD_LOG ("uniscribe-list", font_spec, fonts);
72
  return fonts;
73 74 75
}

static Lisp_Object
Dmitry Antipov's avatar
Dmitry Antipov committed
76
uniscribe_match (struct frame *f, Lisp_Object font_spec)
77
{
78
  Lisp_Object entity = w32font_match_internal (f, font_spec, true);
79
  FONT_ADD_LOG ("uniscribe-match", font_spec, entity);
80
  return entity;
81 82 83
}

static Lisp_Object
Dmitry Antipov's avatar
Dmitry Antipov committed
84
uniscribe_list_family (struct frame *f)
85 86 87 88 89
{
  Lisp_Object list = Qnil;
  LOGFONT font_match_pattern;
  HDC dc;

90
  memset (&font_match_pattern, 0, sizeof (font_match_pattern));
91 92 93
  /* Limit enumerated fonts to outline fonts to save time.  */
  font_match_pattern.lfOutPrecision = OUT_OUTLINE_PRECIS;

94 95 96 97 98 99
  /* Prevent quitting while EnumFontFamiliesEx runs and conses the
     list it will return.  That's because get_frame_dc acquires the
     critical section, so we cannot quit before we release it in
     release_frame_dc.  */
  Lisp_Object prev_quit = Vinhibit_quit;
  Vinhibit_quit = Qt;
100 101 102 103 104 105
  dc = get_frame_dc (f);

  EnumFontFamiliesEx (dc, &font_match_pattern,
                      (FONTENUMPROC) add_opentype_font_name_to_list,
                      (LPARAM) &list, 0);
  release_frame_dc (f, dc);
106
  Vinhibit_quit = prev_quit;
107 108 109 110

  return list;
}

111
static Lisp_Object
Dmitry Antipov's avatar
Dmitry Antipov committed
112
uniscribe_open (struct frame *f, Lisp_Object font_entity, int pixel_size)
113
{
114
  Lisp_Object font_object
115 116
    = font_make_object (VECSIZE (struct uniscribe_font_info),
			font_entity, pixel_size);
117
  struct uniscribe_font_info *uniscribe_font
118
    = (struct uniscribe_font_info *) XFONT_OBJECT (font_object);
119

120 121
  ASET (font_object, FONT_TYPE_INDEX, Quniscribe);

122
  if (!w32font_open_internal (f, font_entity, pixel_size, font_object))
123
    {
124
      return Qnil;
125 126 127 128
    }

  /* Initialize the cache for this font.  */
  uniscribe_font->cache = NULL;
129

130 131 132
  /* Uniscribe backend uses glyph indices.  */
  uniscribe_font->w32_font.glyph_idx = ETO_GLYPH_INDEX;

133 134
  uniscribe_font->w32_font.font.driver = &uniscribe_font_driver;

135
  return font_object;
136 137 138
}

static void
139
uniscribe_close (struct font *font)
140 141 142 143 144
{
  struct uniscribe_font_info *uniscribe_font
    = (struct uniscribe_font_info *) font;

  if (uniscribe_font->cache)
145
    ScriptFreeCache (&(uniscribe_font->cache));
146

147
  w32font_close (font);
148 149 150
}

/* Return a list describing which scripts/languages FONT supports by
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
   which GSUB/GPOS features of OpenType tables.

   Implementation note: otf_features called by this function uses
   GetFontData to access the font tables directly, instead of using
   ScriptGetFontScriptTags etc. APIs even if those are available.  The
   reason is that font-get, which uses the result of this function,
   expects a cons cell (GSUB . GPOS) where the features are reported
   separately for these 2 OTF tables, while the Uniscribe APIs report
   the features as a single list.  There doesn't seem to be a reason
   for returning the features in 2 separate parts, except for
   compatibility with libotf; the features are disjoint (each can
   appear only in one of the 2 slots), and no client of this data
   discerns between the two slots: the few that request this data all
   look in both slots.  If use of the Uniscribe APIs ever becomes
   necessary here, and the 2 separate slots are still required, it
   should be possible to split the feature list the APIs return into 2
   because each sub-list is alphabetically sorted, so the place where
   the sorting order breaks is where the GSUB features end and GPOS
   features begin.  But for now, this is not necessary, so we leave
   the original code in place.  */
171
static Lisp_Object
172
uniscribe_otf_capability (struct font *font)
173 174 175 176 177 178 179 180
{
  HDC context;
  HFONT old_font;
  struct frame *f;
  Lisp_Object capability = Fcons (Qnil, Qnil);
  Lisp_Object features;

  f = XFRAME (selected_frame);
181 182 183 184 185
  /* Prevent quitting while we cons the lists in otf_features.
     That's because get_frame_dc acquires the critical section, so we
     cannot quit before we release it in release_frame_dc.  */
  Lisp_Object prev_quit = Vinhibit_quit;
  Vinhibit_quit = Qt;
186
  context = get_frame_dc (f);
187
  old_font = SelectObject (context, FONT_HANDLE (font));
188 189 190 191 192 193 194 195

  features = otf_features (context, "GSUB");
  XSETCAR (capability, features);
  features = otf_features (context, "GPOS");
  XSETCDR (capability, features);

  SelectObject (context, old_font);
  release_frame_dc (f, context);
196
  Vinhibit_quit = prev_quit;
197 198 199 200 201 202

  return capability;
}

/* Uniscribe implementation of shape for font backend.

203 204 205 206 207
   Shape text in LGSTRING.  See the docstring of
   `composition-get-gstring' for the format of LGSTRING.  If the
   (N+1)th element of LGSTRING is nil, input of shaping is from the
   1st to (N)th elements.  In each input glyph, FROM, TO, CHAR, and
   CODE are already set.
208 209 210
   DIRECTION is either L2R or R2L, or nil if unknown.  During
   redisplay, this comes from applying the UBA, is passed from
   composition_reseat_it, and is used by the HarfBuzz shaper.
211 212 213 214 215

   This function updates all fields of the input glyphs.  If the
   output glyphs (M) are more than the input glyphs (N), (N+1)th
   through (M)th elements of LGSTRING are updated possibly by making
   a new glyph object and storing it in LGSTRING.  If (M) is greater
216 217
   than the length of LGSTRING, nil should be returned.  In that case,
   this function is called again with a larger LGSTRING.  */
218
static Lisp_Object
219
uniscribe_shape (Lisp_Object lgstring, Lisp_Object direction)
220
{
221 222 223
  struct font *font = CHECK_FONT_GET_OBJECT (LGSTRING_FONT (lgstring));
  struct uniscribe_font_info *uniscribe_font
    = (struct uniscribe_font_info *) font;
224
  EMACS_UINT nchars;
225
  int nitems, max_items, i, max_glyphs, done_glyphs;
226 227 228 229 230 231 232 233
  wchar_t *chars;
  WORD *glyphs, *clusters;
  SCRIPT_ITEM *items;
  SCRIPT_VISATTR *attributes;
  int *advances;
  GOFFSET *offsets;
  ABC overall_metrics;
  HRESULT result;
234 235 236
  struct frame * f = NULL;
  HDC context = NULL;
  HFONT old_font = NULL;
237 238

  /* Get the chars from lgstring in a form we can use with uniscribe.  */
239
  max_glyphs = nchars = LGSTRING_GLYPH_LEN (lgstring);
240
  done_glyphs = 0;
241
  chars = (wchar_t *) alloca (nchars * sizeof (wchar_t));
242 243 244
  /* FIXME: This loop assumes that characters in the input LGSTRING
     are all inside the BMP.  Need to encode characters beyond the BMP
     as UTF-16.  */
245 246 247 248 249 250 251 252 253 254 255 256 257 258
  for (i = 0; i < nchars; i++)
    {
      /* lgstring can be bigger than the number of characters in it, in
	 the case where more glyphs are required to display those characters.
         If that is the case, note the real number of characters.  */
      if (NILP (LGSTRING_GLYPH (lgstring, i)))
	nchars = i;
      else
	chars[i] = LGLYPH_CHAR (LGSTRING_GLYPH (lgstring, i));
    }

  /* First we need to break up the glyph string into runs of glyphs that
     can be treated together.  First try a single run.  */
  max_items = 2;
Dmitry Antipov's avatar
Dmitry Antipov committed
259
  items = xmalloc (sizeof (SCRIPT_ITEM) * max_items + 1);
260

261
  while ((result = ScriptItemize (chars, nchars, max_items, NULL, NULL,
262 263 264 265 266
				  items, &nitems)) == E_OUTOFMEMORY)
    {
      /* If that wasn't enough, keep trying with one more run.  */
      max_items++;
      items = (SCRIPT_ITEM *) xrealloc (items,
267
					sizeof (SCRIPT_ITEM) * max_items + 1);
268 269
    }

270
  if (FAILED (result))
271 272 273 274 275 276 277 278 279 280 281 282 283
    {
      xfree (items);
      return Qnil;
    }

  glyphs = alloca (max_glyphs * sizeof (WORD));
  clusters = alloca (nchars * sizeof (WORD));
  attributes = alloca (max_glyphs * sizeof (SCRIPT_VISATTR));
  advances = alloca (max_glyphs * sizeof (int));
  offsets = alloca (max_glyphs * sizeof (GOFFSET));

  for (i = 0; i < nitems; i++)
    {
284
      int nglyphs, nchars_in_run;
285
      nchars_in_run = items[i+1].iCharPos - items[i].iCharPos;
286 287 288 289
      /* Force ScriptShape to generate glyphs in the same order as
	 they are in the input LGSTRING, which is in the logical
	 order.  */
      items[i].a.fLogicalOrder = 1;
290

291 292
      /* Context may be NULL here, in which case the cache should be
         used without needing to select the font.  */
293 294 295 296
      result = ScriptShape (context, &(uniscribe_font->cache),
			    chars + items[i].iCharPos, nchars_in_run,
			    max_glyphs - done_glyphs, &(items[i].a),
			    glyphs, clusters, attributes, &nglyphs);
297 298 299 300 301 302 303 304

      if (result == E_PENDING && !context)
	{
	  /* This assumes the selected frame is on the same display as the
	     one we are drawing.  It would be better for the frame to be
	     passed in.  */
	  f = XFRAME (selected_frame);
	  context = get_frame_dc (f);
305
	  old_font = SelectObject (context, FONT_HANDLE (font));
306 307 308 309 310 311 312

	  result = ScriptShape (context, &(uniscribe_font->cache),
				chars + items[i].iCharPos, nchars_in_run,
				max_glyphs - done_glyphs, &(items[i].a),
				glyphs, clusters, attributes, &nglyphs);
	}

313 314 315 316 317 318
      if (result == E_OUTOFMEMORY)
	{
	  /* Need a bigger lgstring.  */
	  lgstring = Qnil;
	  break;
	}
319
      else if (FAILED (result))
320 321 322 323
	{
	  /* Can't shape this run - return results so far if any.  */
	  break;
	}
324 325 326 327 328 329
      else if (items[i].a.fNoGlyphIndex)
	{
	  /* Glyph indices not supported by this font (or OS), means we
	     can't really do any meaningful shaping.  */
	  break;
	}
330 331 332 333 334
      else
	{
	  result = ScriptPlace (context, &(uniscribe_font->cache),
				glyphs, nglyphs, attributes, &(items[i].a),
				advances, offsets, &overall_metrics);
335 336 337 338 339
	  if (result == E_PENDING && !context)
	    {
	      /* Cache not complete...  */
	      f = XFRAME (selected_frame);
	      context = get_frame_dc (f);
340
	      old_font = SelectObject (context, FONT_HANDLE (font));
341 342 343 344 345 346

	      result = ScriptPlace (context, &(uniscribe_font->cache),
				    glyphs, nglyphs, attributes, &(items[i].a),
				    advances, offsets, &overall_metrics);
	    }
          if (SUCCEEDED (result))
347
	    {
348 349
	      int j, from, to, adj_offset = 0;

350
	      from = 0;
351
	      to = from;
352 353 354 355 356

	      for (j = 0; j < nglyphs; j++)
		{
		  int lglyph_index = j + done_glyphs;
		  Lisp_Object lglyph = LGSTRING_GLYPH (lgstring, lglyph_index);
357
		  ABC char_metric;
358
		  unsigned gl;
359 360 361

		  if (NILP (lglyph))
		    {
362
		      lglyph = LGLYPH_NEW ();
363 364
		      LGSTRING_SET_GLYPH (lgstring, lglyph_index, lglyph);
		    }
365 366 367 368 369
		  /* Copy to a 32-bit data type to shut up the
		     compiler warning in LGLYPH_SET_CODE about
		     comparison being always false.  */
		  gl = glyphs[j];
		  LGLYPH_SET_CODE (lglyph, gl);
370

371 372
		  /* Detect clusters, for linking codes back to
		     characters.  */
373
		  if (attributes[j].fClusterStart)
374
		    {
375 376 377
		      while (from < nchars_in_run && clusters[from] < j)
			from++;
		      if (from >= nchars_in_run)
378
			from = to = nchars_in_run - 1;
379 380 381
		      else
			{
			  int k;
382 383
			  to = nchars_in_run - 1;
			  for (k = from + 1; k < nchars_in_run; k++)
384 385 386
			    {
			      if (clusters[k] > j)
				{
387
				  to = k - 1;
388 389 390 391
				  break;
				}
			    }
			}
392 393 394 395 396 397 398 399 400 401 402 403 404 405 406

		      /* For RTL text, the Uniscribe shaper prepares
			 the values in ADVANCES array for layout in
			 reverse order, whereby "advance width" is
			 applied to move the pen in reverse direction
			 and _before_ drawing the glyph.  Since we
			 draw glyphs in their normal left-to-right
			 order, we need to adjust the coordinates of
			 each non-base glyph in a grapheme cluster via
			 X-OFF component of the gstring's ADJUSTMENT
			 sub-vector.  This loop computes, for each
			 grapheme cluster, the initial value of the
			 adjustment for the base character, which is
			 then updated for each successive glyph in the
			 grapheme cluster.  */
407 408
		      /* FIXME: Should we use DIRECTION here instead
			 of what ScriptItemize guessed?  */
409 410 411 412 413 414 415 416 417 418 419
		      if (items[i].a.fRTL)
			{
			  int j1 = j;

			  adj_offset = 0;
			  while (j1 < nglyphs && !attributes[j1].fClusterStart)
			    {
			      adj_offset += advances[j1];
			      j1++;
			    }
			}
420 421
		    }

422 423 424 425
		  LGLYPH_SET_CHAR (lglyph, chars[items[i].iCharPos
						 + from]);
		  LGLYPH_SET_FROM (lglyph, items[i].iCharPos + from);
		  LGLYPH_SET_TO (lglyph, items[i].iCharPos + to);
426

427 428 429 430 431 432 433 434
		  /* Metrics.  */
		  LGLYPH_SET_WIDTH (lglyph, advances[j]);
		  LGLYPH_SET_ASCENT (lglyph, font->ascent);
		  LGLYPH_SET_DESCENT (lglyph, font->descent);

		  result = ScriptGetGlyphABCWidth (context,
						   &(uniscribe_font->cache),
						   glyphs[j], &char_metric);
435 436 437 438 439
		  if (result == E_PENDING && !context)
		    {
		      /* Cache incomplete... */
		      f = XFRAME (selected_frame);
		      context = get_frame_dc (f);
440
		      old_font = SelectObject (context, FONT_HANDLE (font));
441 442 443 444
		      result = ScriptGetGlyphABCWidth (context,
						       &(uniscribe_font->cache),
						       glyphs[j], &char_metric);
		    }
445

446
		  if (SUCCEEDED (result))
447
		    {
448 449 450 451 452
		      int lbearing = char_metric.abcA;
		      int rbearing = char_metric.abcA + char_metric.abcB;

		      LGLYPH_SET_LBEARING (lglyph, lbearing);
		      LGLYPH_SET_RBEARING (lglyph, rbearing);
453 454
		    }
		  else
455
		    {
456 457
		      LGLYPH_SET_LBEARING (lglyph, 0);
		      LGLYPH_SET_RBEARING (lglyph, advances[j]);
458
		    }
459

460 461 462 463 464
		  if (offsets[j].du || offsets[j].dv
		      /* For non-base glyphs of RTL grapheme clusters,
			 adjust the X offset even if both DU and DV
			 are zero.  */
		      || (!attributes[j].fClusterStart && items[i].a.fRTL))
465
		    {
466 467
		      Lisp_Object vec = make_uninit_vector (3);

468 469 470 471 472 473 474 475
		      if (items[i].a.fRTL)
			{
			  /* Empirically, it looks like Uniscribe
			     interprets DU in reverse direction for
			     RTL clusters.  E.g., if we don't reverse
			     the direction, the Hebrew point HOLAM is
			     drawn above the right edge of the base
			     consonant, instead of above the left edge.  */
476
			  ASET (vec, 0, make_fixnum (-offsets[j].du
477 478 479 480 481 482
						     + adj_offset));
			  /* Update the adjustment value for the width
			     advance of the glyph we just emitted.  */
			  adj_offset -= 2 * advances[j];
			}
		      else
483
			ASET (vec, 0, make_fixnum (offsets[j].du + adj_offset));
484 485 486 487
		      /* In the font definition coordinate system, the
			 Y coordinate points up, while in our screen
			 coordinates Y grows downwards.  So we need to
			 reverse the sign of Y-OFFSET here.  */
488
		      ASET (vec, 1, make_fixnum (-offsets[j].dv));
489
		      /* Based on what ftfont.c does... */
490
		      ASET (vec, 2, make_fixnum (advances[j]));
491
		      LGLYPH_SET_ADJUSTMENT (lglyph, vec);
492
		    }
493
		  else
494 495 496 497 498 499 500
		    {
		      LGLYPH_SET_ADJUSTMENT (lglyph, Qnil);
		      /* Update the adjustment value to compensate for
			 the width of the base character.  */
		      if (items[i].a.fRTL)
			adj_offset -= advances[j];
		    }
501 502
		}
	    }
503 504 505 506 507
	}
      done_glyphs += nglyphs;
    }

  xfree (items);
508 509 510 511 512 513

  if (context)
    {
      SelectObject (context, old_font);
      release_frame_dc (f, context);
    }
514 515 516 517

  if (NILP (lgstring))
    return Qnil;
  else
518
    return make_fixnum (done_glyphs);
519 520 521
}

/* Uniscribe implementation of encode_char for font backend.
522
   Return a glyph code of FONT for character C (Unicode code point).
523 524
   If FONT doesn't have such a glyph, return FONT_INVALID_CODE.  */
static unsigned
525
uniscribe_encode_char (struct font *font, int c)
526
{
527 528 529
  HDC context = NULL;
  struct frame *f = NULL;
  HFONT old_font = NULL;
530
  unsigned code = FONT_INVALID_CODE;
531 532 533 534 535 536
  wchar_t ch[2];
  int len;
  SCRIPT_ITEM* items;
  int nitems;
  struct uniscribe_font_info *uniscribe_font
    = (struct uniscribe_font_info *)font;
537 538 539

  if (c < 0x10000)
    {
540 541
      ch[0] = (wchar_t) c;
      len = 1;
542 543
    }
  else
544 545
    {
      DWORD surrogate = c - 0x10000;
546

547
      /* High surrogate: U+D800 - U+DBFF.  */
548
      ch[0] = 0xD800 + ((surrogate >> 10) & 0x03FF);
549
      /* Low surrogate: U+DC00 - U+DFFF.  */
550
      ch[1] = 0xDC00 + (surrogate & 0x03FF);
551 552
      len = 2;
    }
553

554 555
  /* Non BMP characters must be handled by the uniscribe shaping
     engine as GDI functions (except blindly displaying lines of
Juanma Barranquero's avatar
Juanma Barranquero committed
556
     Unicode text) and the promising looking ScriptGetCMap do not
557 558
     convert surrogate pairs to glyph indexes correctly.  */
    {
559
      items = (SCRIPT_ITEM *) alloca (sizeof (SCRIPT_ITEM) * 2 + 1);
560 561 562
      if (SUCCEEDED (ScriptItemize (ch, len, 2, NULL, NULL, items, &nitems)))
	{
	  HRESULT result;
563 564 565 566 567 568
          /* Surrogates seem to need 2 here, even though only one glyph is
	     returned.  Indic characters can also produce 2 or more glyphs for
	     a single code point, but they need to use uniscribe_shape
	     above for correct display.  */
          WORD glyphs[2], clusters[2];
          SCRIPT_VISATTR attrs[2];
569 570
          int nglyphs;

571 572 573 574
	  /* Force ScriptShape to generate glyphs in the logical
	     order.  */
	  items[0].a.fLogicalOrder = 1;

575
          result = ScriptShape (context, &(uniscribe_font->cache),
576
                                ch, len, 2, &(items[0].a),
577 578 579 580 581 582 583 584
                                glyphs, clusters, attrs, &nglyphs);

          if (result == E_PENDING)
            {
              /* Use selected frame until API is updated to pass
                 the frame.  */
              f = XFRAME (selected_frame);
              context = get_frame_dc (f);
585
              old_font = SelectObject (context, FONT_HANDLE (font));
586 587 588 589 590 591
              result = ScriptShape (context, &(uniscribe_font->cache),
                                    ch, len, 2, &(items[0].a),
                                    glyphs, clusters, attrs, &nglyphs);
            }

          if (SUCCEEDED (result) && nglyphs == 1)
592
            {
593
	      /* Some fonts return .notdef glyphs instead of failing.
Juanma Barranquero's avatar
Juanma Barranquero committed
594
	         (TrueType spec reserves glyph code 0 for .notdef)  */
595 596
	      if (glyphs[0])
		code = glyphs[0];
597
            }
598 599 600 601 602 603 604 605
          else if (SUCCEEDED (result) || result == E_OUTOFMEMORY)
            {
              /* This character produces zero or more than one glyph
                 when shaped. But we still need the return from here
                 to be valid for the shaping engine to be invoked
                 later.  */
              result = ScriptGetCMap (context, &(uniscribe_font->cache),
                                      ch, len, 0, glyphs);
606
              if (SUCCEEDED (result) && glyphs[0])
607
                code = glyphs[0];
608 609
            }
	}
610
    }
611 612 613 614 615
    if (context)
      {
	SelectObject (context, old_font);
	release_frame_dc (f, context);
      }
616

617
    return code;
618 619 620 621 622 623 624
}

/*
   Shared with w32font:
   Lisp_Object uniscribe_get_cache (Lisp_Object frame);
   void uniscribe_free_entity (Lisp_Object font_entity);
   int uniscribe_has_char (Lisp_Object entity, int c);
625 626
   void uniscribe_text_extents (struct font *font, unsigned *code,
                                int nglyphs, struct font_metrics *metrics);
627 628 629 630
   int uniscribe_draw (struct glyph_string *s, int from, int to,
                       int x, int y, int with_background);

   Unused:
Dmitry Antipov's avatar
Dmitry Antipov committed
631 632
   int uniscribe_prepare_face (struct frame *f, struct face *face);
   void uniscribe_done_face (struct frame *f, struct face *face);
633 634 635 636 637
   int uniscribe_get_bitmap (struct font *font, unsigned code,
                             struct font_bitmap *bitmap, int bits_per_pixel);
   void uniscribe_free_bitmap (struct font *font, struct font_bitmap *bitmap);
   int uniscribe_anchor_point (struct font *font, unsigned code,
                               int index, int *x, int *y);
Dmitry Antipov's avatar
Dmitry Antipov committed
638 639
   int uniscribe_start_for_frame (struct frame *f);
   int uniscribe_end_for_frame (struct frame *f);
640 641 642 643 644 645 646

*/


/* Callback function for EnumFontFamiliesEx.
   Adds the name of opentype fonts to a Lisp list (passed in as the
   lParam arg). */
647
static int CALLBACK ALIGN_STACK
648 649 650
add_opentype_font_name_to_list (ENUMLOGFONTEX *logical_font,
				NEWTEXTMETRICEX *physical_font,
				DWORD font_type, LPARAM list_object)
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665
{
  Lisp_Object* list = (Lisp_Object *) list_object;
  Lisp_Object family;

  /* Skip vertical fonts (intended only for printing)  */
  if (logical_font->elfLogFont.lfFaceName[0] == '@')
    return 1;

  /* Skip non opentype fonts.  Count old truetype fonts as opentype,
     as some of them do contain GPOS and GSUB data that Uniscribe
     can make use of.  */
  if (!(physical_font->ntmTm.ntmFlags & NTMFLAGS_OPENTYPE)
      && font_type != TRUETYPE_FONTTYPE)
    return 1;

Juanma Barranquero's avatar
Juanma Barranquero committed
666
  /* Skip fonts that have no Unicode coverage.  */
667 668 669 670 671 672
  if (!physical_font->ntmFontSig.fsUsb[3]
      && !physical_font->ntmFontSig.fsUsb[2]
      && !physical_font->ntmFontSig.fsUsb[1]
      && !(physical_font->ntmFontSig.fsUsb[0] & 0x3fffffff))
    return 1;

673
  family = intern_font_name (logical_font->elfLogFont.lfFaceName);
674 675 676 677 678 679 680 681 682
  if (! memq_no_quit (family, *list))
    *list = Fcons (family, *list);

  return 1;
}


/* :otf property handling.
   Since the necessary Uniscribe APIs for getting font tag information
683
   are only available in Vista, we may need to parse the font data directly
684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713
   according to the OpenType Specification.  */

/* Push into DWORD backwards to cope with endianness.  */
#define OTF_TAG(STR)                                          \
  ((STR[3] << 24) | (STR[2] << 16) | (STR[1] << 8) | STR[0])

#define OTF_INT16_VAL(TABLE, OFFSET, PTR)		     \
  do {							     \
    BYTE temp, data[2];					     \
    if (GetFontData (context, TABLE, OFFSET, data, 2) != 2)  \
      goto font_table_error;				     \
    temp = data[0], data[0] = data[1], data[1] = temp;	     \
    memcpy (PTR, data, 2);				     \
  } while (0)

/* Do not reverse the bytes, because we will compare with a OTF_TAG value
   that has them reversed already.  */
#define OTF_DWORDTAG_VAL(TABLE, OFFSET, PTR)                    \
  do {								\
    if (GetFontData (context, TABLE, OFFSET, PTR, 4) != 4)	\
      goto font_table_error;					\
  } while (0)

#define OTF_TAG_VAL(TABLE, OFFSET, STR)			     \
  do {							     \
    if (GetFontData (context, TABLE, OFFSET, STR, 4) != 4)   \
      goto font_table_error;				     \
    STR[4] = '\0';                                           \
  } while (0)

714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877
#define SNAME(VAL) SSDATA (SYMBOL_NAME (VAL))

/* Uniscribe APIs available only since Windows Vista.  */
typedef HRESULT (WINAPI *ScriptGetFontScriptTags_Proc)
  (HDC, SCRIPT_CACHE *, SCRIPT_ANALYSIS *, int, OPENTYPE_TAG *, int *);

typedef HRESULT (WINAPI *ScriptGetFontLanguageTags_Proc)
  (HDC, SCRIPT_CACHE *, SCRIPT_ANALYSIS *, OPENTYPE_TAG, int, OPENTYPE_TAG *, int *);

typedef HRESULT (WINAPI *ScriptGetFontFeatureTags_Proc)
  (HDC, SCRIPT_CACHE *, SCRIPT_ANALYSIS *, OPENTYPE_TAG, OPENTYPE_TAG, int, OPENTYPE_TAG *, int *);

ScriptGetFontScriptTags_Proc script_get_font_scripts_fn;
ScriptGetFontLanguageTags_Proc script_get_font_languages_fn;
ScriptGetFontFeatureTags_Proc script_get_font_features_fn;

static bool uniscribe_new_apis;

/* Verify that all the required features in FEATURES, each of whose
   elements is a list or nil, can be found among the N feature tags in
   FTAGS.  Return 'true' if the required features are supported,
   'false' if not.  Each list in FEATURES can include an element of
   nil, which means all the elements after it must not be in FTAGS.  */
static bool
uniscribe_check_features (Lisp_Object features[2], OPENTYPE_TAG *ftags, int n)
{
  int j;

  for (j = 0; j < 2; j++)
    {
      bool negative = false;
      Lisp_Object rest;

      for (rest = features[j]; CONSP (rest); rest = XCDR (rest))
	{
	  Lisp_Object feature = XCAR (rest);

	  /* The font must NOT have any of the features after nil.
	     See the doc string of 'font-spec', under ':otf'.  */
	  if (NILP (feature))
	    negative = true;
	  else
	    {
	      OPENTYPE_TAG feature_tag = OTF_TAG (SNAME (feature));
	      int i;

	      for (i = 0; i < n; i++)
		{
		  if (ftags[i] == feature_tag)
		    {
		      /* Test fails if we find a feature that the font
			 must NOT have.  */
		      if (negative)
			return false;
		      break;
		    }
		}

	      /* Test fails if we do NOT find a feature that the font
		 should have.  */
	      if (i >= n && !negative)
		return false;
	    }
	}
    }

  return true;
}

/* Check if font supports the required OTF script/language/features
   using the Unsicribe APIs available since Windows Vista.  We prefer
   these APIs as a kind of future-proofing Emacs: they seem to
   retrieve script tags that the old code (and also libotf) doesn't
   seem to be able to get, e.g., some fonts that claim support for
   "dev2" script don't show "deva", but the new APIs do report it.  */
static int
uniscribe_check_otf_1 (HDC context, Lisp_Object script, Lisp_Object lang,
		       Lisp_Object features[2], int *retval)
{
  SCRIPT_CACHE cache = NULL;
  OPENTYPE_TAG tags[32], script_tag, lang_tag;
  int max_tags = ARRAYELTS (tags);
  int ntags, i, ret = 0;
  HRESULT rslt;

  *retval = 0;

  rslt = script_get_font_scripts_fn (context, &cache, NULL, max_tags,
				     tags, &ntags);
  if (FAILED (rslt))
    {
      DebPrint (("ScriptGetFontScriptTags failed with 0x%x\n", rslt));
      ret = -1;
      goto no_support;
    }
  if (NILP (script))
    script_tag = OTF_TAG ("DFLT");
  else
    script_tag = OTF_TAG (SNAME (script));
  for (i = 0; i < ntags; i++)
    if (tags[i] == script_tag)
      break;

  if (i >= ntags)
    goto no_support;

  if (NILP (lang))
    lang_tag = OTF_TAG ("dflt");
  else
    {
      rslt = script_get_font_languages_fn (context, &cache, NULL, script_tag,
					   max_tags, tags, &ntags);
      if (FAILED (rslt))
	{
	  DebPrint (("ScriptGetFontLanguageTags failed with 0x%x\n", rslt));
	  ret = -1;
	  goto no_support;
	}
      if (ntags == 0)
	lang_tag = OTF_TAG ("dflt");
      else
	{
	  lang_tag = OTF_TAG (SNAME (lang));
	  for (i = 0; i < ntags; i++)
	    if (tags[i] == lang_tag)
	      break;

	  if (i >= ntags)
	    goto no_support;
	}
    }

  if (!NILP (features[0]))
    {
      /* Are the 2 feature lists valid?  */
      if (!CONSP (features[0])
	  || (!NILP (features[1]) && !CONSP (features[1])))
	goto no_support;
      rslt = script_get_font_features_fn (context, &cache, NULL,
					  script_tag, lang_tag,
					  max_tags, tags, &ntags);
      if (FAILED (rslt))
	{
	  DebPrint (("ScriptGetFontFeatureTags failed with 0x%x\n", rslt));
	  ret = -1;
	  goto no_support;
	}

      /* ScriptGetFontFeatureTags doesn't let us query features
	 separately for GSUB and GPOS, so we check them all together.
	 It doesn't really matter, since the features in GSUB and GPOS
	 are disjoint, i.e. no feature can appear in both tables.  */
      if (!uniscribe_check_features (features, tags, ntags))
	goto no_support;
    }

  ret = 1;
  *retval = 1;

 no_support:
  if (cache)
    ScriptFreeCache (&cache);
  return ret;
}
878 879 880 881

/* Check if font supports the otf script/language/features specified.
   OTF_SPEC is in the format
     (script lang [(gsub_feature ...)|nil] [(gpos_feature ...)]?) */
882 883
int
uniscribe_check_otf (LOGFONT *font, Lisp_Object otf_spec)
884 885 886 887 888 889 890 891 892 893
{
  Lisp_Object script, lang, rest;
  Lisp_Object features[2];
  DWORD feature_tables[2];
  DWORD script_tag, default_script, lang_tag = 0;
  struct frame * f;
  HDC context;
  HFONT check_font, old_font;
  int i, retval = 0;

894
  /* Check the spec is in the right format.  */
Tom Tromey's avatar
Tom Tromey committed
895
  if (!CONSP (otf_spec) || XFIXNUM (Flength (otf_spec)) < 3)
896 897
    return 0;

898 899 900 901 902 903 904 905 906 907 908 909 910 911
  /* Break otf_spec into its components.  */
  script = XCAR (otf_spec);
  rest = XCDR (otf_spec);

  lang = XCAR (rest);
  rest = XCDR (rest);

  features[0] = XCAR (rest);
  rest = XCDR (rest);
  if (NILP (rest))
    features[1] = Qnil;
  else
    features[1] = XCAR (rest);

912 913 914 915 916 917 918 919 920 921 922 923
  /* Set up graphics context so we can use the font.  */
  f = XFRAME (selected_frame);
  context = get_frame_dc (f);
  check_font = CreateFontIndirect (font);
  old_font = SelectObject (context, check_font);

  /* If we are on Vista or later, use the new APIs.  */
  if (uniscribe_new_apis
      && !w32_disable_new_uniscribe_apis
      && uniscribe_check_otf_1 (context, script, lang, features, &retval) != -1)
    goto done;

924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942
  /* Set up tags we will use in the search.  */
  feature_tables[0] = OTF_TAG ("GSUB");
  feature_tables[1] = OTF_TAG ("GPOS");
  default_script = OTF_TAG ("DFLT");
  if (NILP (script))
    script_tag = default_script;
  else
    script_tag = OTF_TAG (SNAME (script));
  if (!NILP (lang))
    lang_tag = OTF_TAG (SNAME (lang));

  /* Scan GSUB and GPOS tables.  */
  for (i = 0; i < 2; i++)
    {
      int j, n_match_features;
      unsigned short scriptlist_table, feature_table, n_scripts;
      unsigned short script_table, langsys_table, n_langs;
      unsigned short feature_index, n_features;
      DWORD tbl = feature_tables[i];
943 944
      DWORD feature_id, *ftags;
      Lisp_Object farray[2];
945 946 947 948 949

      /* Skip if no features requested from this table.  */
      if (NILP (features[i]))
	continue;

950 951 952 953
      /* If features is not a cons, this font spec is messed up.  */
      if (!CONSP (features[i]))
	goto no_support;

954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969
      /* Read GPOS/GSUB header.  */
      OTF_INT16_VAL (tbl, 4, &scriptlist_table);
      OTF_INT16_VAL (tbl, 6, &feature_table);
      OTF_INT16_VAL (tbl, scriptlist_table, &n_scripts);

      /* Find the appropriate script table.  */
      script_table = 0;
      for (j = 0; j < n_scripts; j++)
	{
	  DWORD script_id;
	  OTF_DWORDTAG_VAL (tbl, scriptlist_table + 2 + j * 6, &script_id);
	  if (script_id == script_tag)
	    {
	      OTF_INT16_VAL (tbl, scriptlist_table + 6 + j * 6, &script_table);
	      break;
	    }
970
#if 0	  /* Causes false positives.  */
971 972 973 974
	  /* If there is a DFLT script defined in the font, use it
	     if the specified script is not found.  */
	  else if (script_id == default_script)
	    OTF_INT16_VAL (tbl, scriptlist_table + 6 + j * 6, &script_table);
975
#endif
976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011
	}
      /* If no specific or default script table was found, then this font
	 does not support the script.  */
      if (!script_table)
	goto no_support;

      /* Offset is from beginning of scriptlist_table.  */
      script_table += scriptlist_table;

      /* Get default langsys table.  */
      OTF_INT16_VAL (tbl, script_table, &langsys_table);

      /* If lang was specified, see if font contains a specific entry.  */
      if (!NILP (lang))
	{
	  OTF_INT16_VAL (tbl, script_table + 2, &n_langs);

	  for (j = 0; j < n_langs; j++)
	    {
	      DWORD lang_id;
	      OTF_DWORDTAG_VAL (tbl, script_table + 4 + j * 6, &lang_id);
	      if (lang_id == lang_tag)
		{
		  OTF_INT16_VAL (tbl, script_table + 8 + j * 6, &langsys_table);
		  break;
		}
	    }
	}

      if (!langsys_table)
	goto no_support;

      /* Offset is from beginning of script table.  */
      langsys_table += script_table;

      /* If there are no features to check, skip checking.  */
1012
      if (NILP (features[i]))
1013
	continue;
1014 1015 1016 1017
      if (!CONSP (features[i]))
	goto no_support;

      n_match_features = 0;
1018

1019
      /* First get required feature (if any).  */
1020
      OTF_INT16_VAL (tbl, langsys_table + 2, &feature_index);
1021 1022 1023 1024 1025 1026 1027
      if (feature_index != 0xFFFF)
	n_match_features = 1;
      OTF_INT16_VAL (tbl, langsys_table + 4, &n_features);
      n_match_features += n_features;
      USE_SAFE_ALLOCA;
      SAFE_NALLOCA (ftags, 1, n_match_features);
      int k = 0;
1028 1029
      if (feature_index != 0xFFFF)
	{
1030 1031 1032
	  OTF_DWORDTAG_VAL (tbl, feature_table + 2 + feature_index * 6,
			    &feature_id);
	  ftags[k++] = feature_id;
1033
	}
1034
      /* Now get all the other features.  */
1035 1036 1037
      for (j = 0; j < n_features; j++)
	{
	  OTF_INT16_VAL (tbl, langsys_table + 6 + j * 2, &feature_index);
1038 1039 1040
	  OTF_DWORDTAG_VAL (tbl, feature_table + 2 + feature_index * 6,
			    &feature_id);
	  ftags[k++] = feature_id;
1041 1042
	}

1043 1044 1045 1046
      /* Check the features for this table.  */
      farray[0] = features[i];
      farray[1] = Qnil;
      if (!uniscribe_check_features (farray, ftags, n_match_features))
1047
	goto no_support;
1048
      SAFE_FREE ();
1049 1050 1051 1052
    }

  retval = 1;

1053
 done:
1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064
 no_support:
 font_table_error:
  /* restore graphics context.  */
  SelectObject (context, old_font);
  DeleteObject (check_font);
  release_frame_dc (f, context);

  return retval;
}

static Lisp_Object
1065
otf_features (HDC context, const char *table)
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
{
  Lisp_Object script_list = Qnil;
  unsigned short scriptlist_table, n_scripts, feature_table;
  DWORD tbl = OTF_TAG (table);
  int i, j, k;

  /* Look for scripts in the table.  */
  OTF_INT16_VAL (tbl, 4, &scriptlist_table);
  OTF_INT16_VAL (tbl, 6, &feature_table);
  OTF_INT16_VAL (tbl, scriptlist_table, &n_scripts);

1077
  for (i = n_scripts - 1; i >= 0; i--)
1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
    {
      char script[5], lang[5];
      unsigned short script_table, lang_count, langsys_table, feature_count;
      Lisp_Object script_tag, langsys_list, langsys_tag, feature_list;
      unsigned short record_offset = scriptlist_table + 2 + i * 6;
      OTF_TAG_VAL (tbl, record_offset, script);
      OTF_INT16_VAL (tbl, record_offset + 4, &script_table);

      /* Offset is from beginning of script table.  */
      script_table += scriptlist_table;

      script_tag = intern (script);
      langsys_list = Qnil;

      /* Optional default lang.  */
      OTF_INT16_VAL (tbl, script_table, &langsys_table);
      if (langsys_table)
	{
	  /* Offset is from beginning of script table.  */
	  langsys_table += script_table;

	  langsys_tag = Qnil;
	  feature_list = Qnil;
	  OTF_INT16_VAL (tbl, langsys_table + 4, &feature_count);
1102
	  for (k = feature_count - 1; k >= 0; k--)
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116
	    {
	      char feature[5];
	      unsigned short index;
	      OTF_INT16_VAL (tbl, langsys_table + 6 + k * 2, &index);
	      OTF_TAG_VAL (tbl, feature_table + 2 + index * 6, feature);
	      feature_list = Fcons (intern (feature), feature_list);
	    }
	  langsys_list = Fcons (Fcons (langsys_tag, feature_list),
				langsys_list);
	}

      /* List of supported languages.  */
      OTF_INT16_VAL (tbl, script_table + 2, &lang_count);

1117
      for (j = lang_count - 1; j >= 0; j--)
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
	{
	  record_offset = script_table + 4 + j * 6;
	  OTF_TAG_VAL (tbl, record_offset, lang);
	  OTF_INT16_VAL (tbl, record_offset + 4, &langsys_table);

	  /* Offset is from beginning of script table.  */
	  langsys_table += script_table;

	  langsys_tag = intern (lang);
	  feature_list = Qnil;
	  OTF_INT16_VAL (tbl, langsys_table + 4, &feature_count);
1129
	  for (k = feature_count - 1; k >= 0; k--)
1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
	    {
	      char feature[5];
	      unsigned short index;
	      OTF_INT16_VAL (tbl, langsys_table + 6 + k * 2, &index);
	      OTF_TAG_VAL (tbl, feature_table + 2 + index * 6, feature);
	      feature_list = Fcons (intern (feature), feature_list);
	    }
	  langsys_list = Fcons (Fcons (langsys_tag, feature_list),
				langsys_list);

	}

      script_list = Fcons (Fcons (script_tag, langsys_list), script_list);
    }

  return script_list;

font_table_error:
  return Qnil;
}

#undef OTF_INT16_VAL
#undef OTF_TAG_VAL
#undef OTF_TAG


struct font_driver uniscribe_font_driver =
  {
1158
    LISPSYM_INITIALLY (Quniscribe),
1159
    0, /* case insensitive */
1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
    w32font_get_cache,
    uniscribe_list,
    uniscribe_match,
    uniscribe_list_family,
    NULL, /* free_entity */
    uniscribe_open,
    uniscribe_close,
    NULL, /* prepare_face */
    NULL, /* done_face */
    w32font_has_char,
    uniscribe_encode_char,
    w32font_text_extents,
    w32font_draw,
    NULL, /* get_bitmap */
    NULL, /* free_bitmap */
    NULL, /* anchor_point */
1176
    uniscribe_otf_capability, /* Defined so (font-get FONTOBJ :otf) works.  */
1177 1178 1179
    NULL, /* otf_drive - use shape instead.  */
    NULL, /* start_for_frame */
    NULL, /* end_for_frame */
1180 1181 1182 1183 1184
    uniscribe_shape,
    NULL, /* check */
    NULL, /* get_variation_glyphs */
    NULL, /* filter_properties */
    NULL, /* cached_font_ok */
1185 1186 1187 1188
  };

/* Note that this should be called at every startup, not just when dumping,
   as it needs to test for the existence of the Uniscribe library.  */
1189 1190
void syms_of_w32uniscribe (void);

Daniel Colascione's avatar
Daniel Colascione committed
1191 1192
static void syms_of_w32uniscribe_for_pdumper (void);

1193
void
1194
syms_of_w32uniscribe (void)
Daniel Colascione's avatar
Daniel Colascione committed
1195 1196 1197 1198 1199 1200
{
  pdumper_do_now_and_after_load (syms_of_w32uniscribe_for_pdumper);
}

static void
syms_of_w32uniscribe_for_pdumper (void)
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
{
  HMODULE uniscribe;

  /* Don't init uniscribe when dumping */
  if (!initialized)
    return;

  /* Don't register if uniscribe is not available.  */
  uniscribe = GetModuleHandle ("usp10");
  if (!uniscribe)
    return;

  uniscribe_available = 1;

  register_font_driver (&uniscribe_font_driver, NULL);
1216 1217

  script_get_font_scripts_fn = (ScriptGetFontScriptTags_Proc)
1218
    get_proc_addr (uniscribe, "ScriptGetFontScriptTags");
1219
  script_get_font_languages_fn = (ScriptGetFontLanguageTags_Proc)
1220
    get_proc_addr (uniscribe, "ScriptGetFontLanguageTags");
1221
  script_get_font_features_fn = (ScriptGetFontFeatureTags_Proc)
1222
    get_proc_addr (uniscribe, "ScriptGetFontFeatureTags");
1223 1224 1225 1226 1227 1228
  if (script_get_font_scripts_fn
      && script_get_font_languages_fn
      && script_get_font_features_fn)
    uniscribe_new_apis = true;
  else
    uniscribe_new_apis = false;
1229
}