src/fontmanager.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * fontmanager.cpp:
   4  *
   5  * Contact:
   6  *   Moonlight List (moonlight-list@lists.ximian.com)
   7  *
   8  * Copyright 2009 Novell, Inc. (http://www.novell.com)
   9  *
  10  * See the LICENSE file included with the distribution for details.
  11  */
  12
  13 #include <config.h>
  14
  15 #include <glib/gstdio.h>
  16 #include <fcntl.h>
  17 #include <errno.h>
  18 #include <ctype.h>
  19
  20 #include "fontmanager.h"
  21 #include "zip/unzip.h"
  22 #include "debug.h"
  23 #include "utils.h"
  24 #include "list.h"
  25
  26 #include <fontconfig/fontconfig.h>
  27 #include <fontconfig/fcfreetype.h>
  28 #include FT_TRUETYPE_TABLES_H
  29 #include FT_OUTLINE_H
  30 #include FT_SYSTEM_H
  31 #include FT_GLYPH_H
  32
  33
  34 //
  35 // OpenType's OS/2 fsSelection Table:
  36 //
  37 // http://www.microsoft.com/typography/otspec/os2.htm#fss
  38 //
  39 enum fsSelection {
  40         fsSelectionItalic         = (1 << 0),
  41         fsSelectionUnderscore     = (1 << 1),
  42         fsSelectionNegative       = (1 << 2),
  43         fsSelectionOutlined       = (1 << 3),
  44         fsSelectionStrikeout      = (1 << 4),
  45         fsSelectionBold           = (1 << 5),
  46         fsSelectionRegular        = (1 << 6),
  47         fsSelectionUseTypoMetrics = (1 << 7),
  48         fsSelectionWWS            = (1 << 8),
  49         fsSelectionOblique        = (1 << 9),
  50 };
  51
  52 #define FONT_FACE_SIZE 41.0
  53
  54 #define DOUBLE_TO_26_6(d) ((FT_F26Dot6)((d) * 64.0))
  55 #define DOUBLE_FROM_26_6(t) ((double)(t) / 64.0)
  56 #define DOUBLE_TO_16_16(d) ((FT_Fixed)((d) * 65536.0))
  57 #define DOUBLE_FROM_16_16(t) ((double)(t) / 65536.0)
  58
  59 #define EMBOLDEN_STRENGTH 0.75
  60 #define EMBOLDEN_STRENGTH_26_6 DOUBLE_TO_26_6 (EMBOLDEN_STRENGTH)
  61 #define EMBOLDEN_STRENGTH_16_16 DOUBLE_TO_16_16 (EMBOLDEN_STRENGTH)
  62
  63 #define ITALIC_SLANT -17.5
  64 #define ITALIC_SLANT_RADIANS (ITALIC_SLANT * M_PI / 180.0)
  65
  66 static const FT_Matrix italicize = {
  67         DOUBLE_TO_16_16 (1.0), DOUBLE_TO_16_16 (tan (ITALIC_SLANT_RADIANS)),
  68         DOUBLE_TO_16_16 (0.0), DOUBLE_TO_16_16 (1.0)
  69 };
  70
  71 #define LOAD_FLAGS (FT_LOAD_NO_BITMAP | /*FT_LOAD_NO_HINTING | FT_LOAD_NO_AUTOHINT |*/ FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH | FT_LOAD_TARGET_NORMAL)
  72
  73
  74
  75 //
  76 // Silverlight -> FontConfig enumeration conversion utilities
  77 //
  78
  79 #ifndef FC_WEIGHT_EXTRABLACK
  80 #define FC_WEIGHT_EXTRABLACK 215
  81 #endif
  82 #ifndef FC_WEIGHT_ULTRABLACK
  83 #define FC_WEIGHT_ULTRABLACK FC_WEIGHT_EXTRABLACK
  84 #endif
  85
  86 // Silverlight accepts negative values ]0,-475[ as bold and everything over 1023 as normal
  87 #define FONT_LOWER_BOLD_LIMIT   -475
  88 #define FONT_UPPER_BOLD_LIMIT   1024
  89
  90 bool
  91 FontWeightIsBold (FontWeights weight)
  92 {
  93         if (weight > FONT_LOWER_BOLD_LIMIT)
  94                 return weight < 0 || (weight >= FontWeightsSemiBold && weight < FONT_UPPER_BOLD_LIMIT);
  95
  96         return false;
  97 }
  98
  99 static int
 100 fc_weight (FontWeights weight)
 101 {
 102         if ((weight < 0) && (weight > FONT_LOWER_BOLD_LIMIT))
 103                 return FC_WEIGHT_BLACK;
 104         else if (weight < (FontWeightsThin + FontWeightsLight) / 2)
 105                 return FC_WEIGHT_ULTRALIGHT;
 106         else if (weight < (FontWeightsLight + FontWeightsNormal) / 2)
 107                 return FC_WEIGHT_LIGHT;
 108         else if (weight < (FontWeightsNormal + FontWeightsMedium) / 2)
 109                 return FC_WEIGHT_NORMAL;
 110         else if (weight < (FontWeightsMedium + FontWeightsSemiBold) / 2)
 111                 return FC_WEIGHT_MEDIUM;
 112         else if (weight < (FontWeightsSemiBold + FontWeightsBold) / 2)
 113                 return FC_WEIGHT_SEMIBOLD;
 114         else if (weight < (FontWeightsBold + FontWeightsExtraBold) / 2)
 115                 return FC_WEIGHT_BOLD;
 116         else if (weight < (FontWeightsExtraBold + FontWeightsBlack) / 2)
 117                 return FC_WEIGHT_ULTRABOLD;
 118         else if (weight < FONT_UPPER_BOLD_LIMIT)
 119                 return FC_WEIGHT_BLACK;
 120         else
 121                 return FC_WEIGHT_NORMAL;
 122 }
 123
 124 static int
 125 fc_width (FontStretches stretch)
 126 {
 127         switch (stretch) {
 128         case FontStretchesUltraCondensed:
 129                 return FC_WIDTH_ULTRACONDENSED;
 130         case FontStretchesExtraCondensed:
 131                 return FC_WIDTH_EXTRACONDENSED;
 132         case FontStretchesCondensed:
 133                 return FC_WIDTH_CONDENSED;
 134         case FontStretchesSemiCondensed:
 135                 return FC_WIDTH_SEMICONDENSED;
 136         case FontStretchesNormal:
 137                 return FC_WIDTH_NORMAL;
 138 #if 0
 139         case FontStretchesMedium:
 140                 return FC_WIDTH_NORMAL;
 141 #endif
 142         case FontStretchesSemiExpanded:
 143                 return FC_WIDTH_SEMIEXPANDED;
 144         case FontStretchesExpanded:
 145                 return FC_WIDTH_EXPANDED;
 146         case FontStretchesExtraExpanded:
 147                 return FC_WIDTH_EXTRAEXPANDED;
 148         case FontStretchesUltraExpanded:
 149                 return FC_WIDTH_ULTRAEXPANDED;
 150         default:
 151                 return FC_WIDTH_NORMAL;
 152         }
 153 }
 154
 155 static int
 156 fc_slant (FontStyles style)
 157 {
 158         switch (style) {
 159         case FontStylesNormal:
 160                 return FC_SLANT_ROMAN;
 161         // technically Olbique does not exists in SL 1.0 or 2.0 (it's in WPF) but the parser allows it
 162         case FontStylesOblique:
 163                 return FC_SLANT_OBLIQUE;
 164         case FontStylesItalic:
 165         // Silverlight defaults bad values to Italic
 166         default:
 167                 return FC_SLANT_ITALIC;
 168         }
 169 }
 170
 171
 172 //
 173 // Font-style parser utils
 174 //
 175
 176 #define Width  (1 << 0)
 177 #define Weight (1 << 1)
 178 #define Slant  (1 << 2)
 179
 180 struct FontStyleInfo {
 181         char *family_name;
 182         FontStretches width;
 183         FontWeights weight;
 184         FontStyles slant;
 185         int set;
 186 };
 187
 188 static struct {
 189         const char *name;
 190         size_t len;
 191         int type;
 192         int value;
 193 } style_hints[] = {
 194         // widths
 195         { "Ultra-Condensed", 15, Width,  FontStretchesUltraCondensed },
 196         { "Extra-Condensed", 15, Width,  FontStretchesExtraCondensed },
 197         { "Semi-Condensed",  14, Width,  FontStretchesSemiCondensed  },
 198         { "UltraCondensed",  14, Width,  FontStretchesUltraCondensed },
 199         { "ExtraCondensed",  14, Width,  FontStretchesExtraCondensed },
 200         { "SemiCondensed",   13, Width,  FontStretchesSemiCondensed  },
 201         { "Condensed",        9, Width,  FontStretchesCondensed      },
 202         { "Cond",             4, Width,  FontStretchesCondensed      },
 203         { "Ultra-Expanded",  14, Width,  FontStretchesUltraExpanded  },
 204         { "Extra-Expanded",  14, Width,  FontStretchesExtraExpanded  },
 205         { "Semi-Expanded",   13, Width,  FontStretchesSemiExpanded   },
 206         { "UltraExpanded",   13, Width,  FontStretchesUltraExpanded  },
 207         { "ExtraExpanded",   13, Width,  FontStretchesExtraExpanded  },
 208         { "SemiExpanded",    12, Width,  FontStretchesSemiExpanded   },
 209         { "Expanded",         8, Width,  FontStretchesExpanded       },
 210
 211         // weights
 212         { "Thin",             4, Weight, FontWeightsThin             },
 213         { "Ultra-Light",     11, Weight, FontWeightsExtraLight       },
 214         { "Extra-Light",     11, Weight, FontWeightsExtraLight       },
 215         { "UltraLight",      10, Weight, FontWeightsExtraLight       },
 216         { "ExtraLight",      10, Weight, FontWeightsExtraLight       },
 217         { "Light",            5, Weight, FontWeightsLight            },
 218         { "Book",             4, Weight, FontWeightsNormal           },
 219         { "Medium",           6, Weight, FontWeightsMedium           },
 220         { "Demi-Bold",        9, Weight, FontWeightsSemiBold         },
 221         { "Semi-Bold",        9, Weight, FontWeightsSemiBold         },
 222         { "DemiBold",         8, Weight, FontWeightsSemiBold         },
 223         { "SemiBold",         8, Weight, FontWeightsSemiBold         },
 224         { "Bold",             4, Weight, FontWeightsBold             },
 225         { "Extra-Bold",      10, Weight, FontWeightsExtraBold        },
 226         { "Ultra-Bold",      10, Weight, FontWeightsExtraBold        },
 227         { "ExtraBold",        9, Weight, FontWeightsExtraBold        },
 228         { "UltraBold",        9, Weight, FontWeightsExtraBold        },
 229         { "Black",            5, Weight, FontWeightsBlack            },
 230         { "Heavy",            5, Weight, FontWeightsBlack            },
 231         { "Extra-Black",     11, Weight, FontWeightsExtraBlack       },
 232         { "Ultra-Black",     11, Weight, FontWeightsExtraBlack       },
 233         { "ExtraBlack",      10, Weight, FontWeightsExtraBlack       },
 234         { "UltraBlack",      10, Weight, FontWeightsExtraBlack       },
 235
 236         // slants
 237         { "Oblique",          7, Slant,  FontStylesOblique           },
 238         { "Italic",           6, Slant,  FontStylesItalic            },
 239         { "Kursiv",           6, Slant,  FontStylesItalic            },
 240
 241         // changes nothing
 242         { "Regular",          7, 0,      0                           },
 243         { "W3",               2, 0,      0                           },  // as in Hiragino Mincho Pro W3
 244 };
 245
 246 static void
 247 style_info_parse (const char *style, FontStyleInfo *info, bool family)
 248 {
 249         register const char *inptr = style;
 250         const char *first_hint = NULL;
 251         const char *token;
 252         guint tokens = 0;
 253         size_t len;
 254         guint i;
 255
 256         if (!style)
 257                 return;
 258
 259         while (*inptr) {
 260                 while (*inptr && isspace ((int) ((unsigned char) *inptr)))
 261                         inptr++;
 262
 263                 if (*inptr == '\0')
 264                         break;
 265
 266                 token = inptr;
 267                 while (*inptr && !isspace ((int) ((unsigned char) *inptr)))
 268                         inptr++;
 269
 270                 tokens++;
 271
 272                 if (family && tokens == 1) {
 273                         // if parsing the family_name, first token must not be interpreted as a style hint
 274                         continue;
 275                 }
 276
 277                 len = (size_t) (inptr - token);
 278                 for (i = 0; i < G_N_ELEMENTS (style_hints); i++) {
 279                         if (style_hints[i].len == len && !strncmp (style_hints[i].name, token, len)) {
 280                                 switch (style_hints[i].type) {
 281                                 case Width:
 282                                         info->width = (FontStretches) style_hints[i].value;
 283                                         info->set |= Width;
 284                                         break;
 285                                 case Weight:
 286                                         info->weight = (FontWeights) style_hints[i].value;
 287                                         info->set |= Weight;
 288                                         break;
 289                                 case Slant:
 290                                         info->slant = (FontStyles) style_hints[i].value;
 291                                         info->set |= Slant;
 292                                         break;
 293                                 }
 294
 295                                 if (!first_hint)
 296                                         first_hint = token;
 297                                 break;
 298                         }
 299                 }
 300
 301                 if (family && i == G_N_ELEMENTS (style_hints)) {
 302                         // if we come across an unknown style hint when
 303                         // parsing the family_name, assume that any previously
 304                         // found style hints were not actually style hints,
 305                         // but instead just part of the family name.
 306                         info->width = FontStretchesNormal;
 307                         info->weight = FontWeightsNormal;
 308                         info->slant = FontStylesNormal;
 309                         info->set = 0;
 310
 311                         first_hint = NULL;
 312                 }
 313         }
 314
 315         if (family) {
 316                 if (first_hint)
 317                         info->family_name = g_strndup (style, first_hint - style);
 318                 else
 319                         info->family_name = g_strdup (style);
 320
 321                 g_strstrip (info->family_name);
 322         }
 323 }
 324
 325 #ifdef DEBUG
 326 static const char *
 327 style_info_to_string (FontStretches stretch, FontWeights weight, FontStyles style)
 328 {
 329         static char namebuf[256];
 330         guint i = 0;
 331         char *p;
 332
 333         namebuf[0] = '\0';
 334         p = namebuf;
 335
 336         if (stretch != FontStretchesNormal) {
 337                 while (style_hints[i].type == Width) {
 338                         if (style_hints[i].value == stretch) {
 339                                 p = g_stpcpy (p, style_hints[i].name);
 340                                 break;
 341                         }
 342
 343                         i++;
 344                 }
 345         }
 346
 347         if (weight != FontWeightsNormal) {
 348                 while (style_hints[i].type != Weight)
 349                         i++;
 350
 351                 while (style_hints[i].type == Weight) {
 352                         if (style_hints[i].value == weight) {
 353                                 if (p != namebuf)
 354                                         *p++ = ' ';
 355
 356                                 p = g_stpcpy (p, style_hints[i].name);
 357                                 break;
 358                         }
 359
 360                         i++;
 361                 }
 362         }
 363
 364         if (style != FontStylesNormal) {
 365                 while (style_hints[i].type != Slant)
 366                         i++;
 367
 368                 while (i < G_N_ELEMENTS (style_hints)) {
 369                         if (style_hints[i].value == style) {
 370                                 if (p != namebuf)
 371                                         *p++ = ' ';
 372
 373                                 p = g_stpcpy (p, style_hints[i].name);
 374                                 break;
 375                         }
 376
 377                         i++;
 378                 }
 379         }
 380
 381         return namebuf;
 382 }
 383 #endif
 384
 385 static bool
 386 is_odttf (const char *name)
 387 {
 388         size_t len = strlen (name);
 389
 390         if (len > 6 && !g_ascii_strcasecmp (name + len - 6, ".odttf"))
 391                 return true;
 392
 393         return false;
 394 }
 395
 396
 397 //
 398 // FontStream
 399 //
 400
 401 struct FontStream {
 402         bool obfuscated;
 403         char guid[16];
 404         FILE *fp;
 405 };
 406
 407 static const char *
 408 path_get_basename (const char *path)
 409 {
 410         const char *name;
 411
 412         if (!(name = strrchr (path, '/')))
 413                 return path;
 414
 415         return name + 1;
 416 }
 417
 418 static bool
 419 decode_guid (const char *in, char *guid)
 420 {
 421         const char *inptr = in;
 422         int i = 16;
 423
 424         while (i > 0 && *inptr && *inptr != '.') {
 425                 if (*inptr == '-')
 426                         inptr++;
 427
 428                 i--;
 429
 430                 if (*inptr >= '0' && *inptr <= '9')
 431                         guid[i] = (*inptr - '0') * 16;
 432                 else if (*inptr >= 'a' && *inptr <= 'f')
 433                         guid[i] = ((*inptr - 'a') + 10) * 16;
 434                 else if (*inptr >= 'A' && *inptr <= 'F')
 435                         guid[i] = ((*inptr - 'A') + 10) * 16;
 436                 else
 437                         return false;
 438
 439                 inptr++;
 440
 441                 if (*inptr >= '0' && *inptr <= '9')
 442                         guid[i] += (*inptr - '0');
 443                 else if (*inptr >= 'a' && *inptr <= 'f')
 444                         guid[i] += ((*inptr - 'a') + 10);
 445                 else if (*inptr >= 'A' && *inptr <= 'F')
 446                         guid[i] += ((*inptr - 'A') + 10);
 447                 else
 448                         return false;
 449
 450                 inptr++;
 451         }
 452
 453         if (i > 0)
 454                 return false;
 455
 456         return true;
 457 }
 458
 459 static bool
 460 font_stream_set_guid (FT_Stream stream, const char *guid)
 461 {
 462         FontStream *fs = (FontStream *) stream->descriptor.pointer;
 463
 464         if (guid) {
 465                 fs->obfuscated = decode_guid (guid, fs->guid);
 466         } else {
 467                 fs->obfuscated = false;
 468         }
 469
 470         return fs->obfuscated;
 471 }
 472
 473 static unsigned long
 474 font_stream_read (FT_Stream stream, unsigned long offset, unsigned char *buffer, unsigned long count)
 475 {
 476         FontStream *fs = (FontStream *) stream->descriptor.pointer;
 477         size_t nread;
 478
 479         if (fseek (fs->fp, (long) offset, SEEK_SET) == -1)
 480                 return 0;
 481
 482         if (count == 0 || buffer == NULL)
 483                 return 0;
 484
 485         nread = fread (buffer, 1, count, fs->fp);
 486
 487         if (fs->obfuscated && offset < 32 && nread > 0) {
 488                 /* obfuscated font... need to deobfuscate */
 489                 unsigned long i = offset;
 490                 unsigned long j = 0;
 491
 492                 for ( ; i < 32 && j < nread; i++, j++)
 493                         buffer[j] = buffer[j] ^ fs->guid[i % 16];
 494         }
 495
 496         return nread;
 497 }
 498
 499 static void
 500 font_stream_reset (FT_Stream stream)
 501 {
 502         FontStream *fs = (FontStream *) stream->descriptor.pointer;
 503
 504         rewind (fs->fp);
 505         stream->pos = 0;
 506 }
 507
 508 static void
 509 font_stream_close (FT_Stream stream)
 510 {
 511         // no-op
 512 }
 513
 514 static FT_Stream
 515 font_stream_new (const char *filename, const char *guid)
 516 {
 517         FT_Stream stream;
 518         FontStream *fs;
 519         FILE *fp;
 520
 521         if (!(fp = fopen (filename, "r")))
 522                 return NULL;
 523
 524         fs = (FontStream *) g_malloc (sizeof (FontStream));
 525         fs->obfuscated = false;
 526         fs->fp = fp;
 527
 528         stream = (FT_Stream) g_malloc0 (sizeof (FT_StreamRec));
 529         stream->close = font_stream_close;
 530         stream->read = font_stream_read;
 531         stream->descriptor.pointer = fs;
 532
 533         fseek (fp, 0, SEEK_END);
 534         stream->size = ftell (fp);
 535         fseek (fp, 0, SEEK_SET);
 536
 537         font_stream_set_guid (stream, guid);
 538
 539         return stream;
 540 }
 541
 542 static void
 543 font_stream_destroy (FT_Stream stream)
 544 {
 545         FontStream *fs = (FontStream *) stream->descriptor.pointer;
 546
 547         g_free (stream);
 548         fclose (fs->fp);
 549         g_free (fs);
 550 }
 551
 552
 553 //
 554 // FaceInfo
 555 //
 556
 557 struct FontFile : public List::Node {
 558         GPtrArray *faces;
 559         char *path, *guid;
 560
 561         FontFile (const char *path, const char *guid);
 562         ~FontFile ();
 563 };
 564
 565 struct FaceInfo {
 566         FontStyleInfo style;
 567         char *family_name;
 568         FontFile *file;
 569         int index;
 570
 571         FaceInfo (FontFile *file, FT_Face face, int index);
 572         ~FaceInfo ();
 573 };
 574
 575 FaceInfo::FaceInfo (FontFile *file, FT_Face face, int index)
 576 {
 577         LOG_FONT (stderr, "      * indexing %s[%d]: family=\"%s\"; style=\"%s\"\n",
 578                   path_get_basename (file->path), index, face->family_name, face->style_name);
 579
 580         style.width = FontStretchesNormal;
 581         style.weight = FontWeightsNormal;
 582         style.slant = FontStylesNormal;
 583         style.family_name = NULL;
 584         style.set = 0;
 585
 586         // extract whatever little style info we can from the family name
 587         style_info_parse (face->family_name, &style, true);
 588
 589         // style info parsed from style_name overrides anything we got from family_name
 590         style_info_parse (face->style_name, &style, false);
 591
 592         family_name = style.family_name;
 593
 594         LOG_FONT (stderr, "        * indexed as %s; %s\n", family_name,
 595                   style_info_to_string (style.width, style.weight, style.slant));
 596
 597         this->index = index;
 598         this->file = file;
 599 }
 600
 601 FaceInfo::~FaceInfo ()
 602 {
 603         g_free (family_name);
 604 }
 605
 606
 607 //
 608 // FontFile
 609 //
 610
 611 FontFile::FontFile (const char *path, const char *guid)
 612 {
 613         this->path = g_strdup (path);
 614         this->guid = g_strdup (guid);
 615         faces = NULL;
 616 }
 617
 618 FontFile::~FontFile ()
 619 {
 620         if (faces != NULL) {
 621                 FaceInfo *face;
 622
 623                 for (guint i = 0; i < faces->len; i++) {
 624                         face = (FaceInfo *) faces->pdata[i];
 625                         delete face;
 626                 }
 627
 628                 g_ptr_array_free (faces, true);
 629         }
 630
 631         g_free (path);
 632         g_free (guid);
 633 }
 634
 635
 636 //
 637 // FontIndex
 638 //
 639
 640 struct FontIndex {
 641         List *fonts;
 642         char *name;
 643         char *path;
 644
 645         FontIndex (const char *name);
 646         ~FontIndex ();
 647
 648         void CacheFontInfo (FT_Library libft2, const char *filename, FT_Stream stream, FT_Face face, const char *guid);
 649 };
 650
 651 FontIndex::FontIndex (const char *name)
 652 {
 653         this->name = g_strdup (name);
 654         fonts = new List ();
 655         path = NULL;
 656 }
 657
 658 FontIndex::~FontIndex ()
 659 {
 660         g_free (name);
 661         g_free (path);
 662         delete fonts;
 663 }
 664
 665 void
 666 FontIndex::CacheFontInfo (FT_Library libft2, const char *filename, FT_Stream stream, FT_Face face, const char *guid)
 667 {
 668         int i = 0, nfaces = face->num_faces;
 669         FT_Open_Args args;
 670         FontFile *file;
 671         FaceInfo *fi;
 672
 673         LOG_FONT (stderr, "    * caching font info for `%s'...\n", filename);
 674
 675         file = new FontFile (filename, guid);
 676         file->faces = g_ptr_array_new ();
 677
 678         do {
 679                 args.flags = FT_OPEN_STREAM;
 680                 args.stream = stream;
 681
 682                 if (i > 0 && FT_Open_Face (libft2, &args, i, &face) != 0)
 683                         break;
 684
 685                 fi = new FaceInfo (file, face, i);
 686                 g_ptr_array_add (file->faces, fi);
 687
 688                 FT_Done_Face (face);
 689
 690                 font_stream_reset (stream);
 691
 692                 i++;
 693         } while (i < nfaces);
 694
 695         fonts->Append (file);
 696 }
 697
 698 static void
 699 font_index_destroy (gpointer user_data)
 700 {
 701         delete ((FontIndex *) user_data);
 702 }
 703
 704
 705 //
 706 // FontFace
 707 //
 708
 709 FontFace::FontFace (FontManager *manager, FT_Face face, char *key)
 710 {
 711         FT_Set_Pixel_Sizes (face, 0, (int) FONT_FACE_SIZE);
 712         this->cur_size = FONT_FACE_SIZE;
 713         this->manager = manager;
 714         this->ref_count = 1;
 715         this->face = face;
 716         this->key = key;
 717
 718         g_hash_table_insert (manager->faces, key, this);
 719 }
 720
 721 FontFace::~FontFace ()
 722 {
 723         FT_Stream stream;
 724
 725         g_hash_table_steal (manager->faces, key);
 726
 727         stream = face->stream;
 728         FT_Done_Face (face);
 729         font_stream_destroy (stream);
 730         g_free (key);
 731 }
 732
 733 void
 734 FontFace::ref ()
 735 {
 736         ref_count++;
 737 }
 738
 739 void
 740 FontFace::unref ()
 741 {
 742         ref_count--;
 743
 744         if (ref_count == 0)
 745                 delete this;
 746 }
 747
 748 const char *
 749 FontFace::GetFamilyName ()
 750 {
 751         return face->family_name;
 752 }
 753
 754 const char *
 755 FontFace::GetStyleName ()
 756 {
 757         return face->style_name;
 758 }
 759
 760 bool
 761 FontFace::IsScalable ()
 762 {
 763         return FT_IS_SCALABLE (face);
 764 }
 765
 766 bool
 767 FontFace::IsItalic ()
 768 {
 769         return (face->style_flags & FT_STYLE_FLAG_ITALIC);
 770 }
 771
 772 bool
 773 FontFace::IsBold ()
 774 {
 775         return (face->style_flags & FT_STYLE_FLAG_BOLD);
 776 }
 777
 778 gunichar
 779 FontFace::GetCharFromIndex (guint32 index)
 780 {
 781         gunichar unichar;
 782         guint32 idx;
 783
 784         if (index == 0)
 785                 return 0;
 786
 787         unichar = FT_Get_First_Char (face, &idx);
 788         while (idx != index && idx != 0)
 789                 unichar = FT_Get_Next_Char (face, unichar, &idx);
 790
 791         if (idx == 0)
 792                 unichar = 0;
 793
 794         return unichar;
 795 }
 796
 797 guint32
 798 FontFace::GetCharIndex (gunichar unichar)
 799 {
 800         return FcFreeTypeCharIndex (face, unichar);
 801 }
 802
 803 bool
 804 FontFace::HasChar (gunichar unichar)
 805 {
 806         return FcFreeTypeCharIndex (face, unichar) != 0;
 807 }
 808
 809 void
 810 FontFace::GetExtents (double size, FontFaceExtents *extents)
 811 {
 812         double scale = size / face->units_per_EM;
 813
 814         if (FT_IS_SFNT (face)) {
 815                 TT_HoriHeader *hhea = (TT_HoriHeader *) FT_Get_Sfnt_Table (face, ft_sfnt_hhea);
 816                 TT_OS2 *os2 = (TT_OS2 *) FT_Get_Sfnt_Table (face, ft_sfnt_os2);
 817                 int height, ascender, descender;
 818
 819                 if (os2 && (os2->fsSelection & fsSelectionUseTypoMetrics)) {
 820                         // Use the typographic Ascender, Descender, and LineGap values for everything.
 821                         height = os2->sTypoAscender - os2->sTypoDescender + os2->sTypoLineGap;
 822                         descender = -os2->sTypoDescender;
 823                         ascender = os2->sTypoAscender;
 824                 } else {
 825                         // Calculate the LineSpacing for both the hhea table and the OS/2 table.
 826                         int hhea_height = hhea->Ascender + abs (hhea->Descender) + hhea->Line_Gap;
 827                         int os2_height = os2 ? (os2->usWinAscent + os2->usWinDescent) : 0;
 828
 829                         // The LineSpacing is the maximum of the two sumations.
 830                         height = MAX (hhea_height, os2_height);
 831
 832                         // If the OS/2 table exists, use usWinAscent as the
 833                         // ascender. Otherwise use hhea's Ascender value.
 834                         ascender = os2 ? os2->usWinAscent : hhea->Ascender;
 835
 836                         // The Descender becomes the difference between the
 837                         // LineSpacing and the Ascender.
 838                         descender = height - ascender;
 839                 }
 840
 841                 extents->descent = -descender * scale;
 842                 extents->ascent = ascender * scale;
 843                 extents->height = height * scale;
 844         } else {
 845                 // Fall back to the default FreeType2 values.
 846                 extents->descent = face->descender * scale;
 847                 extents->ascent = face->ascender * scale;
 848                 extents->height = face->height * scale;
 849         }
 850
 851         extents->underline_thickness = face->underline_thickness * scale;
 852         extents->underline_position = -face->underline_position * scale;
 853         extents->underline_position += ((extents->underline_thickness + 1) / 2.0);
 854
 855         if (extents->underline_thickness < 1.0)
 856                 extents->underline_thickness = 1.0;
 857 }
 858
 859 double
 860 FontFace::Kerning (double size, guint32 left, guint32 right)
 861 {
 862         FT_Vector kerning;
 863
 864         if (!FT_HAS_KERNING (face) || left == 0 || right == 0)
 865                 return 0.0;
 866
 867         if (size <= FONT_FACE_SIZE) {
 868                 if (cur_size != FONT_FACE_SIZE) {
 869                         FT_Set_Pixel_Sizes (face, 0, (int) FONT_FACE_SIZE);
 870                         cur_size = FONT_FACE_SIZE;
 871                 }
 872
 873                 FT_Get_Kerning (face, left, right, FT_KERNING_DEFAULT, &kerning);
 874
 875                 return (kerning.x * size) / (FONT_FACE_SIZE * 64.0);
 876         } else {
 877                 if (cur_size != size) {
 878                         FT_Set_Pixel_Sizes (face, 0, (int) size);
 879                         cur_size = size;
 880                 }
 881
 882                 FT_Get_Kerning (face, left, right, FT_KERNING_DEFAULT, &kerning);
 883
 884                 return kerning.x / 64.0;
 885         }
 886 }
 887
 888 static int
 889 font_move_to (FT_Vector *to, void *user_data)
 890 {
 891         moon_path *path = (moon_path *) user_data;
 892         double x, y;
 893
 894         x = DOUBLE_FROM_26_6 (to->x);
 895         y = DOUBLE_FROM_26_6 (to->y);
 896
 897         moon_move_to (path, x, y);
 898
 899         return 0;
 900 }
 901
 902 static int
 903 font_line_to (FT_Vector *to, void *user_data)
 904 {
 905         moon_path *path = (moon_path *) user_data;
 906         double x, y;
 907
 908         x = DOUBLE_FROM_26_6 (to->x);
 909         y = DOUBLE_FROM_26_6 (to->y);
 910
 911         moon_line_to (path, x, y);
 912
 913         return 0;
 914 }
 915
 916 static int
 917 font_conic_to (FT_Vector *control, FT_Vector *to, void *user_data)
 918 {
 919         moon_path *path = (moon_path *) user_data;
 920         double x3, y3;
 921         double x, y;
 922
 923         x = DOUBLE_FROM_26_6 (control->x);
 924         y = DOUBLE_FROM_26_6 (control->y);
 925
 926         x3 = DOUBLE_FROM_26_6 (to->x);
 927         y3 = DOUBLE_FROM_26_6 (to->y);
 928
 929         moon_quad_curve_to (path, x, y, x3, y3);
 930
 931         return 0;
 932 }
 933
 934 static int
 935 font_cubic_to (FT_Vector *control1, FT_Vector *control2, FT_Vector *to, void *user_data)
 936 {
 937         moon_path *path = (moon_path *) user_data;
 938         double x0, y0;
 939         double x1, y1;
 940         double x2, y2;
 941
 942         x0 = DOUBLE_FROM_26_6 (control1->x);
 943         y0 = DOUBLE_FROM_26_6 (control1->y);
 944
 945         x1 = DOUBLE_FROM_26_6 (control2->x);
 946         y1 = DOUBLE_FROM_26_6 (control2->y);
 947
 948         x2 = DOUBLE_FROM_26_6 (to->x);
 949         y2 = DOUBLE_FROM_26_6 (to->y);
 950
 951         moon_curve_to (path, x0, y0, x1, y1, x2, y2);
 952
 953         return 0;
 954 }
 955
 956 static const FT_Outline_Funcs outline_funcs = {
 957         (FT_Outline_MoveToFunc) font_move_to,
 958         (FT_Outline_LineToFunc) font_line_to,
 959         (FT_Outline_ConicToFunc) font_conic_to,
 960         (FT_Outline_CubicToFunc) font_cubic_to,
 961         0, /* shift */
 962         0, /* delta */
 963 };
 964
 965 bool
 966 FontFace::LoadGlyph (double size, GlyphInfo *glyph, StyleSimulations simulate)
 967 {
 968         FT_Glyph_Metrics *metrics;
 969         FT_Fixed hori_adj = 0;
 970         FT_Pos bbox_adj = 0;
 971         FT_Matrix matrix;
 972         double scale;
 973
 974         if (!face)
 975                 return false;
 976
 977         if (size <= FONT_FACE_SIZE) {
 978                 if (cur_size != FONT_FACE_SIZE) {
 979                         FT_Set_Pixel_Sizes (face, 0, (int) FONT_FACE_SIZE);
 980                         cur_size = FONT_FACE_SIZE;
 981                 }
 982
 983                 scale = size / FONT_FACE_SIZE;
 984         } else {
 985                 if (cur_size != size) {
 986                         FT_Set_Pixel_Sizes (face, 0, (int) size);
 987                         cur_size = size;
 988                 }
 989
 990                 scale = 1.0;
 991         }
 992
 993         if (FT_Load_Glyph (face, glyph->index, LOAD_FLAGS) != 0)
 994                 return false;
 995
 996         if (FT_Render_Glyph (face->glyph, FT_RENDER_MODE_NORMAL) != 0)
 997                 return false;
 998
 999         // invert the glyph over the y-axis and scale
1000         matrix.xx = DOUBLE_TO_16_16 (scale);
1001         matrix.xy = 0;
1002         matrix.yx = 0;
1003         matrix.yy = -DOUBLE_TO_16_16 (scale);
1004
1005         if ((simulate & StyleSimulationsBold) != 0) {
1006                 FT_Outline_Embolden (&face->glyph->outline, EMBOLDEN_STRENGTH_26_6);
1007                 hori_adj = EMBOLDEN_STRENGTH_16_16;
1008                 bbox_adj = EMBOLDEN_STRENGTH_26_6;
1009         }
1010
1011         if ((simulate & StyleSimulationsItalic) != 0)
1012                 FT_Matrix_Multiply (&italicize, &matrix);
1013
1014         glyph->path = moon_path_new (8);
1015         FT_Outline_Transform (&face->glyph->outline, &matrix);
1016         FT_Outline_Decompose (&face->glyph->outline, &outline_funcs, glyph->path);
1017
1018         metrics = &face->glyph->metrics;
1019
1020         glyph->metrics.horiBearingX = DOUBLE_FROM_26_6 (metrics->horiBearingX) * scale;
1021         //glyph->metrics.horiBearingY = DOUBLE_FROM_26_6 (metrics->horiBearingY) * scale;
1022         // always prefer linearHoriAdvance over horiAdvance since the later is rounded to an integer
1023         glyph->metrics.horiAdvance = DOUBLE_FROM_16_16 (face->glyph->linearHoriAdvance + hori_adj) * scale;
1024         //glyph->metrics.height = DOUBLE_FROM_26_6 (metrics->height + bbox_adj) * scale;
1025         //glyph->metrics.width = DOUBLE_FROM_26_6 (metrics->width + bbox_adj) * scale;
1026
1027         return true;
1028 }
1029
1030 static void
1031 font_face_destroy (gpointer data)
1032 {
1033         FontFace *face = (FontFace *) data;
1034
1035         delete face;
1036 }
1037
1038
1039 //
1040 // FontManager
1041 //
1042
1043 FontManager::FontManager ()
1044 {
1045         FcPattern *pattern;
1046
1047         resources = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, font_index_destroy);
1048         faces = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, font_face_destroy);
1049         system_faces = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
1050
1051         FT_Init_FreeType (&libft2);
1052
1053         pattern = FcPatternBuild (NULL, FC_FAMILY, FcTypeString, "Sans",
1054                                   FC_SIZE, FcTypeDouble, 10.0, NULL);
1055
1056         if (FcPatternGetDouble (pattern, FC_DPI, 0, &dpi) != FcResultMatch)
1057                 dpi = 72.0;
1058
1059         FcPatternDestroy (pattern);
1060         root = NULL;
1061 }
1062
1063 FontManager::~FontManager ()
1064 {
1065         g_hash_table_destroy (system_faces);
1066         g_hash_table_destroy (resources);
1067         g_hash_table_destroy (faces);
1068         FT_Done_FreeType (libft2);
1069
1070         if (root) {
1071                 RemoveDir (root);
1072                 g_free (root);
1073         }
1074 }
1075
1076 static bool
1077 IndexFontSubdirectory (FT_Library libft2, const char *name, GString *path, FontIndex **out)
1078 {
1079         FontIndex *fontdir = *out;
1080         const gchar *dirname;
1081         FT_Open_Args args;
1082         FT_Stream stream;
1083         bool obfuscated;
1084         struct stat st;
1085         FT_Face face;
1086         size_t len;
1087         GDir *dir;
1088
1089         if (!(dir = g_dir_open (path->str, 0, NULL)))
1090                 return fontdir != NULL;
1091
1092         LOG_FONT (stderr, "  * indexing font directory `%s'...\n", path->str);
1093
1094         g_string_append_c (path, G_DIR_SEPARATOR);
1095         len = path->len;
1096
1097         while ((dirname = g_dir_read_name (dir))) {
1098                 if (!strcmp (dirname, "..") ||
1099                     !strcmp (dirname, "."))
1100                         continue;
1101
1102                 g_string_append (path, dirname);
1103
1104                 if (g_stat (path->str, &st) == -1)
1105                         goto next;
1106
1107                 if (S_ISDIR (st.st_mode)) {
1108                         IndexFontSubdirectory (libft2, name, path, &fontdir);
1109                         goto next;
1110                 }
1111
1112                 if (!(stream = font_stream_new (path->str, NULL)))
1113                         goto next;
1114
1115                 args.flags = FT_OPEN_STREAM;
1116                 args.stream = stream;
1117
1118                 obfuscated = false;
1119
1120                 if (FT_Open_Face (libft2, &args, 0, &face) != 0) {
1121                         // not a valid font file... is it maybe an obfuscated font?
1122                         if (!is_odttf (dirname) || !font_stream_set_guid (stream, dirname)) {
1123                                 font_stream_destroy (stream);
1124                                 goto next;
1125                         }
1126
1127                         font_stream_reset (stream);
1128
1129                         args.flags = FT_OPEN_STREAM;
1130                         args.stream = stream;
1131
1132                         if (FT_Open_Face (libft2, &args, 0, &face) != 0) {
1133                                 font_stream_destroy (stream);
1134                                 goto next;
1135                         }
1136
1137                         obfuscated = true;
1138                 }
1139
1140                 if (fontdir == NULL)
1141                         fontdir = new FontIndex (name);
1142
1143                 // cache font info
1144                 fontdir->CacheFontInfo (libft2, path->str, stream, face, obfuscated ? dirname : NULL);
1145
1146                 font_stream_destroy (stream);
1147
1148          next:
1149                 g_string_truncate (path, len);
1150         }
1151
1152         g_dir_close (dir);
1153
1154         *out = fontdir;
1155
1156         return fontdir != NULL;
1157 }
1158
1159 static FontIndex *
1160 IndexFontDirectory (FT_Library libft2, const char *name, const char *dirname)
1161 {
1162         FontIndex *fontdir = NULL;
1163         GString *path;
1164         size_t len;
1165
1166         path = g_string_new (dirname);
1167         len = path->len;
1168
1169         if (!IndexFontSubdirectory (libft2, name, path, &fontdir)) {
1170                 g_string_free (path, true);
1171                 return NULL;
1172         }
1173
1174         g_string_truncate (path, len);
1175         fontdir->path = path->str;
1176
1177         g_string_free (path, false);
1178
1179         return fontdir;
1180 }
1181
1182 static FontIndex *
1183 IndexFontFile (FT_Library libft2, const char *name, const char *path)
1184 {
1185         const char *filename = path_get_basename (name);
1186         FontIndex *index = NULL;
1187         FT_Open_Args args;
1188         FT_Stream stream;
1189         bool obfuscated;
1190         FT_Face face;
1191
1192         LOG_FONT (stderr, "  * indexing font file `%s'...\n", path);
1193
1194         if (!(stream = font_stream_new (path, NULL)))
1195                 return NULL;
1196
1197         args.flags = FT_OPEN_STREAM;
1198         args.stream = stream;
1199
1200         obfuscated = false;
1201
1202         if (FT_Open_Face (libft2, &args, 0, &face) != 0) {
1203                 // not a valid font file... is it maybe an obfuscated font?
1204                 if (!is_odttf (filename) || !font_stream_set_guid (stream, filename)) {
1205                         font_stream_destroy (stream);
1206                         return NULL;
1207                 }
1208
1209                 font_stream_reset (stream);
1210
1211                 args.flags = FT_OPEN_STREAM;
1212                 args.stream = stream;
1213
1214                 if (FT_Open_Face (libft2, &args, 0, &face) != 0) {
1215                         font_stream_destroy (stream);
1216                         return NULL;
1217                 }
1218
1219                 obfuscated = true;
1220         }
1221
1222         index = new FontIndex (name);
1223         index->path = g_strdup (path);
1224
1225         // cache font info
1226         index->CacheFontInfo (libft2, path, stream, face, obfuscated ? filename : NULL);
1227
1228         font_stream_destroy (stream);
1229
1230         return index;
1231 }
1232
1233 void
1234 FontManager::AddResource (const char *resource, const char *path)
1235 {
1236         FontIndex *index;
1237         struct stat st;
1238
1239         LOG_FONT (stderr, "Adding font resource '%s' at %s\n", resource, path);
1240
1241         if ((index = (FontIndex *) g_hash_table_lookup (resources, resource)))
1242                 return;
1243
1244         if (stat (path, &st) == -1)
1245                 return;
1246
1247         if (S_ISDIR (st.st_mode))
1248                 index = IndexFontDirectory (libft2, resource, path);
1249         else if (S_ISREG (st.st_mode))
1250                 index = IndexFontFile (libft2, resource, path);
1251         else
1252                 return;
1253
1254         if (index)
1255                 g_hash_table_insert (resources, index->name, index);
1256 }
1257
1258 char *
1259 FontManager::AddResource (ManagedStreamCallbacks *stream)
1260 {
1261         char buf[4096], *resource, *dirname, *path;
1262         unzFile zipfile;
1263         int nread, fd;
1264         gint64 pos;
1265
1266         if (!stream->CanRead (stream->handle))
1267                 return NULL;
1268
1269         if (!root && !(root = CreateTempDir ("moonlight-fonts")))
1270                 return NULL;
1271
1272         // check if we've already added this resource
1273         resource = g_strdup_printf ("font-source://%p", stream->handle);
1274         if (g_hash_table_lookup (resources, resource) != NULL)
1275                 return resource;
1276
1277         snprintf (buf, sizeof (buf), "%p", stream->handle);
1278         path = g_build_filename (root, buf, NULL);
1279
1280         if ((fd = g_open (path, O_CREAT | O_EXCL | O_WRONLY, 0600)) == -1) {
1281                 g_free (resource);
1282                 g_free (path);
1283                 return NULL;
1284         }
1285
1286         // write the managed stream to disk
1287         pos = stream->Position (stream->handle);
1288
1289         if (stream->CanSeek (stream->handle))
1290                 stream->Seek (stream->handle, 0, SEEK_SET);
1291
1292         while ((nread = stream->Read (stream->handle, buf, 0, sizeof (buf))) > 0) {
1293                 if (write_all (fd, buf, (size_t) nread) == -1) {
1294                         g_free (resource);
1295                         close (fd);
1296                         g_unlink (path);
1297                         g_free (path);
1298                         return NULL;
1299                 }
1300         }
1301
1302         // reset the stream to the original state
1303         if (stream->CanSeek (stream->handle) && pos != -1)
1304                 stream->Seek (stream->handle, pos, SEEK_SET);
1305
1306         close (fd);
1307
1308         // check to see if the resource is zipped
1309         if ((zipfile = unzOpen (path))) {
1310                 snprintf (buf, sizeof (buf), "%p.zip", stream->handle);
1311                 dirname = g_build_filename (root, buf, NULL);
1312
1313                 // create a directory to contain our unzipped content
1314                 if (g_mkdir (dirname, 0700) == -1) {
1315                         unzClose (zipfile);
1316                         g_free (resource);
1317                         g_free (dirname);
1318                         g_unlink (path);
1319                         g_free (path);
1320                         return NULL;
1321                 }
1322
1323                 // unzip the contents
1324                 if (!ExtractAll (zipfile, dirname, CanonModeNone)) {
1325                         RemoveDir (dirname);
1326                         unzClose (zipfile);
1327                         g_free (resource);
1328                         g_free (dirname);
1329                         g_unlink (path);
1330                         g_free (path);
1331                         return NULL;
1332                 }
1333
1334                 unzClose (zipfile);
1335                 g_unlink (path);
1336                 g_free (path);
1337
1338                 path = dirname;
1339         }
1340
1341         AddResource (resource, path);
1342
1343         g_free (path);
1344
1345         return resource;
1346 }
1347
1348 static int
1349 style_diff (FontStyleInfo *actual, FontStyleInfo *desired)
1350 {
1351 #if 0
1352         // we convert to FontConfig for 2 reasons:
1353         // 1. negative values and values > 1023
1354         // 2. smaller ranges
1355         int weight = abs (fc_weight (actual->weight) - fc_weight (desired->weight));
1356
1357         if (actual->slant == desired->slant)
1358                 return weight;
1359
1360         if (actual->slant == FontStylesNormal) {
1361                 // we can emulate italic/oblique, but we would still prefer the real
1362                 // italic font if we can find it so apply a slight penalty
1363                 return 1000 + weight;
1364         }
1365
1366         // ouch, apply a huge penalty
1367         return 1000000 + weight;
1368 #else
1369         // convert to FontConfig values so that each style property fits within 8 bits
1370         int weight = abs (fc_weight (actual->weight) - fc_weight (desired->weight));
1371         int width = abs (fc_width (actual->width) - fc_width (desired->width));
1372         int slant = abs (fc_slant (actual->slant) - fc_slant (desired->slant));
1373
1374         // weight has the highest priority, followed by weight and then slant
1375         return ((width & 0xff) << 16) | ((weight & 0xff) << 8) | (slant & 0xff);
1376 #endif
1377 }
1378
1379 static void
1380 canon_font_family_and_style (FontStyleInfo *desired, const char *family, FontStretches stretch, FontWeights weight, FontStyles style)
1381 {
1382         desired->width = FontStretchesNormal;
1383         desired->weight = FontWeightsNormal;
1384         desired->slant = FontStylesNormal;
1385         desired->family_name = NULL;
1386         desired->set = 0;
1387
1388         // extract whatever little style info we can from the family name
1389         style_info_parse (family, desired, true);
1390
1391         // override style with user-specified attributes
1392         if (!(desired->set & Width))
1393                 desired->width = stretch;
1394         if (!(desired->set & Weight))
1395                 desired->weight = weight;
1396         if (!(desired->set & Slant))
1397                 desired->slant = style;
1398 }
1399
1400 static FaceInfo *
1401 IndexMatchFace (FontIndex *index, const char *family, FontStretches stretch, FontWeights weight, FontStyles style)
1402 {
1403         FontFile *file = (FontFile *) index->fonts->First ();
1404         FaceInfo *face, *best = NULL;
1405         FontStyleInfo desired;
1406         int closest = G_MAXINT;
1407         int diff;
1408         guint i;
1409
1410         LOG_FONT (stderr, "  * searching index for %s; %s\n", family, style_info_to_string (stretch, weight, style));
1411
1412         canon_font_family_and_style (&desired, family, stretch, weight, style);
1413
1414         LOG_FONT (stderr, "    * canonicalized family/style: %s; %s\n", desired.family_name,
1415                   style_info_to_string (desired.width, desired.weight, desired.slant));
1416
1417         while (file != NULL) {
1418                 for (i = 0; i < file->faces->len; i++) {
1419                         face = (FaceInfo *) file->faces->pdata[i];
1420
1421                         if (!g_ascii_strcasecmp (face->family_name, desired.family_name)) {
1422                                 diff = style_diff (&face->style, &desired);
1423                                 if (diff < closest) {
1424                                         closest = diff;
1425                                         best = face;
1426                                 }
1427                         }
1428                 }
1429
1430                 file = (FontFile *) file->next;
1431         }
1432
1433         g_free (desired.family_name);
1434
1435         return best;
1436 }
1437
1438 FontFace *
1439 FontManager::OpenFontFace (const char *filename, const char *guid, int index)
1440 {
1441         FT_Open_Args args;
1442         FT_Stream stream;
1443         FontFace *ff;
1444         FT_Face face;
1445         char *key;
1446
1447         key = g_strdup_printf ("%s#%d", filename, index);
1448         if ((ff = (FontFace *) g_hash_table_lookup (faces, key))) {
1449                 g_free (key);
1450                 ff->ref ();
1451                 return ff;
1452         }
1453
1454         if (!(stream = font_stream_new (filename, guid))) {
1455                 g_free (key);
1456                 return NULL;
1457         }
1458
1459         args.flags = FT_OPEN_STREAM;
1460         args.stream = stream;
1461
1462         if (FT_Open_Face (libft2, &args, index, &face) != 0) {
1463                 font_stream_destroy (stream);
1464                 g_free (key);
1465                 return NULL;
1466         }
1467
1468         if (!FT_IS_SCALABLE (face)) {
1469                 FT_Done_Face (face);
1470                 font_stream_destroy (stream);
1471                 g_free (key);
1472                 return NULL;
1473         }
1474
1475         return new FontFace (this, face, key);
1476 }
1477
1478 FontFace *
1479 FontManager::OpenFontResource (const char *resource, const char *family, int idx, FontStretches stretch, FontWeights weight, FontStyles style)
1480 {
1481         FontIndex *index;
1482         FontFile *file;
1483         FontFace *face;
1484         FaceInfo *fi;
1485
1486         LOG_FONT (stderr, "OpenFontResource (\"%s\", \"%s\", %d, %s)\n", resource ? resource : "(null)",
1487                   family ? family : "(null)", idx, style_info_to_string (stretch, weight, style));
1488
1489         if (!(index = (FontIndex *) g_hash_table_lookup (resources, resource))) {
1490                 LOG_FONT (stderr, "  * error: no such resource\n");
1491                 return NULL;
1492         }
1493
1494         if (family != NULL) {
1495                 // open by family
1496                 if (!(fi = IndexMatchFace (index, family, stretch, weight, style))) {
1497                         LOG_FONT (stderr, "  * error: resource does not contain requested font\n");
1498                         return NULL;
1499                 }
1500         } else if (idx >= 0) {
1501                 // open by index
1502                 if (!(file = (FontFile *) index->fonts->First ()) || file->next != NULL)
1503                         return NULL;
1504
1505                 if ((int) file->faces->len <= idx)
1506                         return NULL;
1507
1508                 fi = (FaceInfo *) file->faces->pdata[idx];
1509         } else {
1510                 // no family or index specified... error?
1511                 return NULL;
1512         }
1513
1514         if (!(face = OpenFontFace (fi->file->path, fi->file->guid, fi->index)))
1515                 return NULL;
1516
1517         LOG_FONT (stderr, "  * opened %s; %s\n", face->GetFamilyName (), face->GetStyleName ());
1518
1519         return face;
1520 }
1521
1522 FontFace *
1523 FontManager::OpenSystemFont (const char *family, FontStretches stretch, FontWeights weight, FontStyles style)
1524 {
1525         FcPattern *pattern, *matched;
1526         FontStyleInfo desired;
1527         FcChar8 *filename;
1528         FcResult result;
1529         FontFace *face;
1530         int index;
1531         char *key;
1532
1533         key = g_strdup_printf ("%s:%d:%d:%d", family, stretch, weight, style);
1534         LOG_FONT (stderr, "Attempting to open system font: %s %s ... ", family, style_info_to_string (stretch, weight, style));
1535         if (g_hash_table_lookup_extended (system_faces, key, NULL, (gpointer *) &face)) {
1536                 LOG_FONT (stderr, "found!\n");
1537                 g_free (key);
1538                 if (face)
1539                         face->ref ();
1540                 return face;
1541         }
1542         LOG_FONT (stderr, "not found in cache.\n");
1543
1544         for (int attempt = 0; attempt < 2; attempt++) {
1545                 if (attempt == 0) {
1546                         desired.family_name = g_strdup (family);
1547                         desired.width = stretch;
1548                         desired.weight = weight;
1549                         desired.slant = style;
1550                 } else {
1551                         g_free (desired.family_name);
1552                         canon_font_family_and_style (&desired, family, stretch, weight, style);
1553                 }
1554
1555                 LOG_FONT (stderr, "Attempting to load installed font: %s %s... ", desired.family_name,
1556                           style_info_to_string (desired.width, desired.weight, desired.slant));
1557
1558                 pattern = FcPatternCreate ();
1559                 FcPatternAddDouble (pattern, FC_DPI, dpi);
1560                 FcPatternAddString (pattern, FC_FAMILY, (const FcChar8 *) desired.family_name);
1561                 FcPatternAddInteger (pattern, FC_WIDTH, fc_width (desired.width));
1562                 FcPatternAddInteger (pattern, FC_WEIGHT, fc_weight (desired.weight));
1563                 FcPatternAddInteger (pattern, FC_SLANT, fc_slant (desired.slant));
1564                 FcDefaultSubstitute (pattern);
1565
1566                 if (!(matched = FcFontMatch (NULL, pattern, &result))) {
1567                         LOG_FONT (stderr, "no matches\n");
1568                         FcPatternDestroy (pattern);
1569                         continue;
1570                 }
1571
1572                 FcPatternDestroy (pattern);
1573
1574                 if (FcPatternGetString (matched, FC_FILE, 0, &filename) != FcResultMatch) {
1575                         LOG_FONT (stderr, "no filename\n");
1576                         FcPatternDestroy (matched);
1577                         continue;
1578                 }
1579
1580                 if (FcPatternGetInteger (matched, FC_INDEX, 0, &index) != FcResultMatch) {
1581                         LOG_FONT (stderr, "no index\n");
1582                         FcPatternDestroy (matched);
1583                         continue;
1584                 }
1585
1586                 if ((face = OpenFontFace ((const char *) filename, NULL, index))) {
1587                         if (!g_ascii_strcasecmp (face->GetFamilyName (), desired.family_name)) {
1588                                 LOG_FONT (stderr, "got %s %s\n", face->GetFamilyName (), face->GetStyleName ());
1589                                 face->ref ();
1590                                 g_hash_table_insert (system_faces, key, face); // the key is freed when the hash table is destroyed
1591                                 g_free (desired.family_name);
1592                                 FcPatternDestroy (matched);
1593                                 return face;
1594                         }
1595
1596                         LOG_FONT (stderr, "family mismatch\n");
1597                         face->unref ();
1598                 } else {
1599                         LOG_FONT (stderr, "family not found\n");
1600                 }
1601
1602                 FcPatternDestroy (matched);
1603         }
1604
1605         g_hash_table_insert (system_faces, key, NULL); // the key is freed when the hash table is destroyed
1606         g_free (desired.family_name);
1607
1608         return NULL;
1609 }
1610
1611 FontFace *
1612 FontManager::OpenFont (const char *name, FontStretches stretch, FontWeights weight, FontStyles style)
1613 {
1614         const char *family;
1615         FontFace *face;
1616         //char *end;
1617         //int index;
1618
1619         if ((family = strchr (name, '#'))) {
1620                 char *resource = g_strndup (name, family - name);
1621
1622                 family++;
1623
1624                 //if ((index = strtol (family, &end, 10)) >= 0 && index < G_MAXINT && *end == '\0')
1625                 //      face = OpenFontResource (resource, NULL, index, stretch, weight, style);
1626                 //else
1627                 face = OpenFontResource (resource, family, -1, stretch, weight, style);
1628
1629                 g_free (resource);
1630         } else {
1631                 face = OpenSystemFont (name, stretch, weight, style);
1632         }
1633
1634         return face;
1635 }
1636
1637 FontFace *
1638 FontManager::OpenFont (const char *name, int index)
1639 {
1640         return OpenFontResource (name, NULL, index, FontStretchesNormal, FontWeightsNormal, FontStylesNormal);
1641 }