]> git.wh0rd.org - fontconfig.git/blob - src/fccfg.c
git.wh0rd.org / fontconfig.git / blob
? search:


6d55f171e216ca886ec6cbe4e78dc4137b4e2959
[fontconfig.git] / src / fccfg.c
1 /*
2 * fontconfig/src/fccfg.c
3 *
4 * Copyright © 2000 Keith Packard
5 *
6 * Permission to use, copy, modify, distribute, and sell this software and its
7 * documentation for any purpose is hereby granted without fee, provided that
8 * the above copyright notice appear in all copies and that both that
9 * copyright notice and this permission notice appear in supporting
10 * documentation, and that the name of the author(s) not be used in
11 * advertising or publicity pertaining to distribution of the software without
12 * specific, written prior permission. The authors make no
13 * representations about the suitability of this software for any purpose. It
14 * is provided "as is" without express or implied warranty.
15 *
16 * THE AUTHOR(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
17 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
18 * EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR
19 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
20 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
21 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
22 * PERFORMANCE OF THIS SOFTWARE.
23 */
24
25 #include "fcint.h"
26 #include <dirent.h>
27 #include <sys/types.h>
28
29 #if defined (_WIN32) && (defined (PIC) || defined (DLL_EXPORT))
30 #define STRICT
31 #include <windows.h>
32 #undef STRICT
33 #endif
34
35 #if defined (_WIN32) && !defined (R_OK)
36 #define R_OK 4
37 #endif
38
39 FcConfig *_fcConfig;
40
41 FcConfig *
42 FcConfigCreate (void)
43 {
44 FcSetName set;
45 FcConfig *config;
46
47 config = malloc (sizeof (FcConfig));
48 if (!config)
49 goto bail0;
50 FcMemAlloc (FC_MEM_CONFIG, sizeof (FcConfig));
51
52 config->configDirs = FcStrSetCreate ();
53 if (!config->configDirs)
54 goto bail1;
55
56 config->configFiles = FcStrSetCreate ();
57 if (!config->configFiles)
58 goto bail2;
59
60 config->fontDirs = FcStrSetCreate ();
61 if (!config->fontDirs)
62 goto bail3;
63
64 config->acceptGlobs = FcStrSetCreate ();
65 if (!config->acceptGlobs)
66 goto bail4;
67
68 config->rejectGlobs = FcStrSetCreate ();
69 if (!config->rejectGlobs)
70 goto bail5;
71
72 config->acceptPatterns = FcFontSetCreate ();
73 if (!config->acceptPatterns)
74 goto bail6;
75
76 config->rejectPatterns = FcFontSetCreate ();
77 if (!config->rejectPatterns)
78 goto bail7;
79
80 config->cacheDirs = FcStrSetCreate ();
81 if (!config->cacheDirs)
82 goto bail8;
83
84 config->blanks = 0;
85
86 config->substPattern = 0;
87 config->substFont = 0;
88 config->substScan = 0;
89 config->maxObjects = 0;
90 for (set = FcSetSystem; set <= FcSetApplication; set++)
91 config->fonts[set] = 0;
92
93 config->rescanTime = time(0);
94 config->rescanInterval = 30;
95
96 config->expr_pool = NULL;
97
98 config->ref = 1;
99
100 return config;
101
102 bail8:
103 FcFontSetDestroy (config->rejectPatterns);
104 bail7:
105 FcFontSetDestroy (config->acceptPatterns);
106 bail6:
107 FcStrSetDestroy (config->rejectGlobs);
108 bail5:
109 FcStrSetDestroy (config->acceptGlobs);
110 bail4:
111 FcStrSetDestroy (config->fontDirs);
112 bail3:
113 FcStrSetDestroy (config->configFiles);
114 bail2:
115 FcStrSetDestroy (config->configDirs);
116 bail1:
117 free (config);
118 FcMemFree (FC_MEM_CONFIG, sizeof (FcConfig));
119 bail0:
120 return 0;
121 }
122
123 static FcFileTime
124 FcConfigNewestFile (FcStrSet *files)
125 {
126 FcStrList *list = FcStrListCreate (files);
127 FcFileTime newest = { 0, FcFalse };
128 FcChar8 *file;
129 struct stat statb;
130
131 if (list)
132 {
133 while ((file = FcStrListNext (list)))
134 if (FcStat (file, &statb) == 0)
135 if (!newest.set || statb.st_mtime - newest.time > 0)
136 {
137 newest.set = FcTrue;
138 newest.time = statb.st_mtime;
139 }
140 FcStrListDone (list);
141 }
142 return newest;
143 }
144
145 FcBool
146 FcConfigUptoDate (FcConfig *config)
147 {
148 FcFileTime config_time, config_dir_time, font_time;
149 time_t now = time(0);
150 if (!config)
151 {
152 config = FcConfigGetCurrent ();
153 if (!config)
154 return FcFalse;
155 }
156 config_time = FcConfigNewestFile (config->configFiles);
157 config_dir_time = FcConfigNewestFile (config->configDirs);
158 font_time = FcConfigNewestFile (config->fontDirs);
159 if ((config_time.set && config_time.time - config->rescanTime > 0) ||
160 (config_dir_time.set && (config_dir_time.time - config->rescanTime) > 0) ||
161 (font_time.set && (font_time.time - config->rescanTime) > 0))
162 {
163 /* We need to check for potential clock problems here (OLPC ticket #6046) */
164 if ((config_time.set && (config_time.time - now) > 0) ||
165 (config_dir_time.set && (config_dir_time.time - now) > 0) ||
166 (font_time.set && (font_time.time - now) > 0))
167 {
168 fprintf (stderr,
169 "Fontconfig warning: Directory/file mtime in the future. New fonts may not be detected\n");
170 config->rescanTime = now;
171 return FcTrue;
172 }
173 else
174 return FcFalse;
175 }
176 config->rescanTime = now;
177 return FcTrue;
178 }
179
180 static void
181 FcSubstDestroy (FcSubst *s)
182 {
183 FcSubst *n;
184
185 while (s)
186 {
187 n = s->next;
188 if (s->test)
189 FcTestDestroy (s->test);
190 if (s->edit)
191 FcEditDestroy (s->edit);
192 free (s);
193 FcMemFree (FC_MEM_SUBST, sizeof (FcSubst));
194 s = n;
195 }
196 }
197
198 FcExpr *
199 FcConfigAllocExpr (FcConfig *config)
200 {
201 if (!config->expr_pool || config->expr_pool->next == config->expr_pool->end)
202 {
203 FcExprPage *new_page;
204
205 new_page = malloc (sizeof (FcExprPage));
206 if (!new_page)
207 return 0;
208 FcMemAlloc (FC_MEM_EXPR, sizeof (FcExprPage));
209
210 new_page->next_page = config->expr_pool;
211 new_page->next = new_page->exprs;
212 config->expr_pool = new_page;
213 }
214
215 return config->expr_pool->next++;
216 }
217
218 FcConfig *
219 FcConfigReference (FcConfig *config)
220 {
221 if (!config)
222 {
223 config = FcConfigGetCurrent ();
224 if (!config)
225 return 0;
226 }
227
228 config->ref++;
229
230 return config;
231 }
232
233 void
234 FcConfigDestroy (FcConfig *config)
235 {
236 FcSetName set;
237 FcExprPage *page;
238
239 if (--config->ref > 0)
240 return;
241
242 if (config == _fcConfig)
243 _fcConfig = 0;
244
245 FcStrSetDestroy (config->configDirs);
246 FcStrSetDestroy (config->fontDirs);
247 FcStrSetDestroy (config->cacheDirs);
248 FcStrSetDestroy (config->configFiles);
249 FcStrSetDestroy (config->acceptGlobs);
250 FcStrSetDestroy (config->rejectGlobs);
251 FcFontSetDestroy (config->acceptPatterns);
252 FcFontSetDestroy (config->rejectPatterns);
253
254 if (config->blanks)
255 FcBlanksDestroy (config->blanks);
256
257 FcSubstDestroy (config->substPattern);
258 FcSubstDestroy (config->substFont);
259 FcSubstDestroy (config->substScan);
260 for (set = FcSetSystem; set <= FcSetApplication; set++)
261 if (config->fonts[set])
262 FcFontSetDestroy (config->fonts[set]);
263
264 page = config->expr_pool;
265 while (page)
266 {
267 FcExprPage *next = page->next_page;
268 FcMemFree (FC_MEM_EXPR, sizeof (FcExprPage));
269 free (page);
270 page = next;
271 }
272
273 free (config);
274 FcMemFree (FC_MEM_CONFIG, sizeof (FcConfig));
275 }
276
277 /*
278 * Add cache to configuration, adding fonts and directories
279 */
280
281 FcBool
282 FcConfigAddCache (FcConfig *config, FcCache *cache,
283 FcSetName set, FcStrSet *dirSet)
284 {
285 FcFontSet *fs;
286 intptr_t *dirs;
287 int i;
288
289 /*
290 * Add fonts
291 */
292 fs = FcCacheSet (cache);
293 if (fs)
294 {
295 int nref = 0;
296
297 for (i = 0; i < fs->nfont; i++)
298 {
299 FcPattern *font = FcFontSetFont (fs, i);
300 FcChar8 *font_file;
301
302 /*
303 * Check to see if font is banned by filename
304 */
305 if (FcPatternObjectGetString (font, FC_FILE_OBJECT,
306 0, &font_file) == FcResultMatch &&
307 !FcConfigAcceptFilename (config, font_file))
308 {
309 continue;
310 }
311
312 /*
313 * Check to see if font is banned by pattern
314 */
315 if (!FcConfigAcceptFont (config, font))
316 continue;
317
318 nref++;
319 FcFontSetAdd (config->fonts[set], font);
320 }
321 FcDirCacheReference (cache, nref);
322 }
323
324 /*
325 * Add directories
326 */
327 dirs = FcCacheDirs (cache);
328 if (dirs)
329 {
330 for (i = 0; i < cache->dirs_count; i++)
331 {
332 FcChar8 *dir = FcOffsetToPtr (dirs, dirs[i], FcChar8);
333 if (FcConfigAcceptFilename (config, dir))
334 FcStrSetAddFilename (dirSet, dir);
335 }
336 }
337 return FcTrue;
338 }
339
340 static FcBool
341 FcConfigAddDirList (FcConfig *config, FcSetName set, FcStrSet *dirSet)
342 {
343 FcStrList *dirlist;
344 FcChar8 *dir;
345 FcCache *cache;
346
347 dirlist = FcStrListCreate (dirSet);
348 if (!dirlist)
349 return FcFalse;
350
351 while ((dir = FcStrListNext (dirlist)))
352 {
353 if (FcDebug () & FC_DBG_FONTSET)
354 printf ("adding fonts from%s\n", dir);
355 cache = FcDirCacheRead (dir, FcFalse, config);
356 if (!cache)
357 continue;
358 FcConfigAddCache (config, cache, set, dirSet);
359 FcDirCacheUnload (cache);
360 }
361 FcStrListDone (dirlist);
362 return FcTrue;
363 }
364
365 /*
366 * Scan the current list of directories in the configuration
367 * and build the set of available fonts.
368 */
369
370 FcBool
371 FcConfigBuildFonts (FcConfig *config)
372 {
373 FcFontSet *fonts;
374
375 if (!config)
376 {
377 config = FcConfigGetCurrent ();
378 if (!config)
379 return FcFalse;
380 }
381
382 fonts = FcFontSetCreate ();
383 if (!fonts)
384 return FcFalse;
385
386 FcConfigSetFonts (config, fonts, FcSetSystem);
387
388 if (!FcConfigAddDirList (config, FcSetSystem, config->fontDirs))
389 return FcFalse;
390 if (FcDebug () & FC_DBG_FONTSET)
391 FcFontSetPrint (fonts);
392 return FcTrue;
393 }
394
395 FcBool
396 FcConfigSetCurrent (FcConfig *config)
397 {
398 if (config == _fcConfig)
399 return FcTrue;
400
401 if (!config->fonts)
402 if (!FcConfigBuildFonts (config))
403 return FcFalse;
404
405 if (_fcConfig)
406 FcConfigDestroy (_fcConfig);
407 _fcConfig = config;
408 return FcTrue;
409 }
410
411 FcConfig *
412 FcConfigGetCurrent (void)
413 {
414 if (!_fcConfig)
415 if (!FcInit ())
416 return 0;
417 return _fcConfig;
418 }
419
420 FcBool
421 FcConfigAddConfigDir (FcConfig *config,
422 const FcChar8 *d)
423 {
424 return FcStrSetAddFilename (config->configDirs, d);
425 }
426
427 FcStrList *
428 FcConfigGetConfigDirs (FcConfig *config)
429 {
430 if (!config)
431 {
432 config = FcConfigGetCurrent ();
433 if (!config)
434 return 0;
435 }
436 return FcStrListCreate (config->configDirs);
437 }
438
439 FcBool
440 FcConfigAddFontDir (FcConfig *config,
441 const FcChar8 *d)
442 {
443 return FcStrSetAddFilename (config->fontDirs, d);
444 }
445
446 FcBool
447 FcConfigAddDir (FcConfig *config,
448 const FcChar8 *d)
449 {
450 return (FcConfigAddConfigDir (config, d) &&
451 FcConfigAddFontDir (config, d));
452 }
453
454 FcStrList *
455 FcConfigGetFontDirs (FcConfig *config)
456 {
457 if (!config)
458 {
459 config = FcConfigGetCurrent ();
460 if (!config)
461 return 0;
462 }
463 return FcStrListCreate (config->fontDirs);
464 }
465
466 FcBool
467 FcConfigAddCacheDir (FcConfig *config,
468 const FcChar8 *d)
469 {
470 return FcStrSetAddFilename (config->cacheDirs, d);
471 }
472
473 FcStrList *
474 FcConfigGetCacheDirs (FcConfig *config)
475 {
476 if (!config)
477 {
478 config = FcConfigGetCurrent ();
479 if (!config)
480 return 0;
481 }
482 return FcStrListCreate (config->cacheDirs);
483 }
484
485 FcBool
486 FcConfigAddConfigFile (FcConfig *config,
487 const FcChar8 *f)
488 {
489 FcBool ret;
490 FcChar8 *file = FcConfigFilename (f);
491
492 if (!file)
493 return FcFalse;
494
495 ret = FcStrSetAdd (config->configFiles, file);
496 FcStrFree (file);
497 return ret;
498 }
499
500 FcStrList *
501 FcConfigGetConfigFiles (FcConfig *config)
502 {
503 if (!config)
504 {
505 config = FcConfigGetCurrent ();
506 if (!config)
507 return 0;
508 }
509 return FcStrListCreate (config->configFiles);
510 }
511
512 FcChar8 *
513 FcConfigGetCache (FcConfig *config)
514 {
515 return NULL;
516 }
517
518 FcFontSet *
519 FcConfigGetFonts (FcConfig *config,
520 FcSetName set)
521 {
522 if (!config)
523 {
524 config = FcConfigGetCurrent ();
525 if (!config)
526 return 0;
527 }
528 return config->fonts[set];
529 }
530
531 void
532 FcConfigSetFonts (FcConfig *config,
533 FcFontSet *fonts,
534 FcSetName set)
535 {
536 if (config->fonts[set])
537 FcFontSetDestroy (config->fonts[set]);
538 config->fonts[set] = fonts;
539 }
540
541 FcBlanks *
542 FcConfigGetBlanks (FcConfig *config)
543 {
544 if (!config)
545 {
546 config = FcConfigGetCurrent ();
547 if (!config)
548 return 0;
549 }
550 return config->blanks;
551 }
552
553 FcBool
554 FcConfigAddBlank (FcConfig *config,
555 FcChar32 blank)
556 {
557 FcBlanks *b, *freeme = 0;
558
559 b = config->blanks;
560 if (!b)
561 {
562 freeme = b = FcBlanksCreate ();
563 if (!b)
564 return FcFalse;
565 }
566 if (!FcBlanksAdd (b, blank))
567 {
568 if (freeme)
569 FcBlanksDestroy (freeme);
570 return FcFalse;
571 }
572 config->blanks = b;
573 return FcTrue;
574 }
575
576 int
577 FcConfigGetRescanInterval (FcConfig *config)
578 {
579 if (!config)
580 {
581 config = FcConfigGetCurrent ();
582 if (!config)
583 return 0;
584 }
585 return config->rescanInterval;
586 }
587
588 FcBool
589 FcConfigSetRescanInterval (FcConfig *config, int rescanInterval)
590 {
591 if (!config)
592 {
593 config = FcConfigGetCurrent ();
594 if (!config)
595 return FcFalse;
596 }
597 config->rescanInterval = rescanInterval;
598 return FcTrue;
599 }
600
601 /*
602 * A couple of typos escaped into the library
603 */
604 int
605 FcConfigGetRescanInverval (FcConfig *config)
606 {
607 return FcConfigGetRescanInterval (config);
608 }
609
610 FcBool
611 FcConfigSetRescanInverval (FcConfig *config, int rescanInterval)
612 {
613 return FcConfigSetRescanInterval (config, rescanInterval);
614 }
615
616
617 FcBool
618 FcConfigAddEdit (FcConfig *config,
619 FcTest *test,
620 FcEdit *edit,
621 FcMatchKind kind)
622 {
623 FcSubst *subst, **prev;
624 FcTest *t;
625 int num;
626
627 switch (kind) {
628 case FcMatchPattern:
629 prev = &config->substPattern;
630 break;
631 case FcMatchFont:
632 prev = &config->substFont;
633 break;
634 case FcMatchScan:
635 prev = &config->substScan;
636 break;
637 default:
638 return FcFalse;
639 }
640 subst = (FcSubst *) malloc (sizeof (FcSubst));
641 if (!subst)
642 return FcFalse;
643 FcMemAlloc (FC_MEM_SUBST, sizeof (FcSubst));
644 for (; *prev; prev = &(*prev)->next);
645 *prev = subst;
646 subst->next = 0;
647 subst->test = test;
648 subst->edit = edit;
649 num = 0;
650 for (t = test; t; t = t->next)
651 {
652 if (t->kind == FcMatchDefault)
653 t->kind = kind;
654 num++;
655 }
656 if (config->maxObjects < num)
657 config->maxObjects = num;
658 if (FcDebug () & FC_DBG_EDIT)
659 {
660 printf ("Add Subst ");
661 FcSubstPrint (subst);
662 }
663 return FcTrue;
664 }
665
666 typedef struct _FcSubState {
667 FcPatternElt *elt;
668 FcValueList *value;
669 } FcSubState;
670
671 static FcValue
672 FcConfigPromote (FcValue v, FcValue u)
673 {
674 if (v.type == FcTypeInteger)
675 {
676 v.type = FcTypeDouble;
677 v.u.d = (double) v.u.i;
678 }
679 else if (v.type == FcTypeVoid && u.type == FcTypeMatrix)
680 {
681 v.u.m = &FcIdentityMatrix;
682 v.type = FcTypeMatrix;
683 }
684 else if (v.type == FcTypeString && u.type == FcTypeLangSet)
685 {
686 v.u.l = FcLangSetPromote (v.u.s);
687 v.type = FcTypeLangSet;
688 }
689 return v;
690 }
691
692 FcBool
693 FcConfigCompareValue (const FcValue *left_o,
694 FcOp op,
695 const FcValue *right_o)
696 {
697 FcValue left = FcValueCanonicalize(left_o);
698 FcValue right = FcValueCanonicalize(right_o);
699 FcBool ret = FcFalse;
700
701 left = FcConfigPromote (left, right);
702 right = FcConfigPromote (right, left);
703 if (left.type == right.type)
704 {
705 switch (left.type) {
706 case FcTypeInteger:
707 break; /* FcConfigPromote prevents this from happening */
708 case FcTypeDouble:
709 switch (op) {
710 case FcOpEqual:
711 case FcOpContains:
712 case FcOpListing:
713 ret = left.u.d == right.u.d;
714 break;
715 case FcOpNotEqual:
716 case FcOpNotContains:
717 ret = left.u.d != right.u.d;
718 break;
719 case FcOpLess:
720 ret = left.u.d < right.u.d;
721 break;
722 case FcOpLessEqual:
723 ret = left.u.d <= right.u.d;
724 break;
725 case FcOpMore:
726 ret = left.u.d > right.u.d;
727 break;
728 case FcOpMoreEqual:
729 ret = left.u.d >= right.u.d;
730 break;
731 default:
732 break;
733 }
734 break;
735 case FcTypeBool:
736 switch (op) {
737 case FcOpEqual:
738 case FcOpContains:
739 case FcOpListing:
740 ret = left.u.b == right.u.b;
741 break;
742 case FcOpNotEqual:
743 case FcOpNotContains:
744 ret = left.u.b != right.u.b;
745 break;
746 default:
747 break;
748 }
749 break;
750 case FcTypeString:
751 switch (op) {
752 case FcOpEqual:
753 case FcOpListing:
754 ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) == 0;
755 break;
756 case FcOpContains:
757 ret = FcStrStrIgnoreCase (left.u.s, right.u.s) != 0;
758 break;
759 case FcOpNotEqual:
760 ret = FcStrCmpIgnoreCase (left.u.s, right.u.s) != 0;
761 break;
762 case FcOpNotContains:
763 ret = FcStrStrIgnoreCase (left.u.s, right.u.s) == 0;
764 break;
765 default:
766 break;
767 }
768 break;
769 case FcTypeMatrix:
770 switch (op) {
771 case FcOpEqual:
772 case FcOpContains:
773 case FcOpListing:
774 ret = FcMatrixEqual (left.u.m, right.u.m);
775 break;
776 case FcOpNotEqual:
777 case FcOpNotContains:
778 ret = !FcMatrixEqual (left.u.m, right.u.m);
779 break;
780 default:
781 break;
782 }
783 break;
784 case FcTypeCharSet:
785 switch (op) {
786 case FcOpContains:
787 case FcOpListing:
788 /* left contains right if right is a subset of left */
789 ret = FcCharSetIsSubset (right.u.c, left.u.c);
790 break;
791 case FcOpNotContains:
792 /* left contains right if right is a subset of left */
793 ret = !FcCharSetIsSubset (right.u.c, left.u.c);
794 break;
795 case FcOpEqual:
796 ret = FcCharSetEqual (left.u.c, right.u.c);
797 break;
798 case FcOpNotEqual:
799 ret = !FcCharSetEqual (left.u.c, right.u.c);
800 break;
801 default:
802 break;
803 }
804 break;
805 case FcTypeLangSet:
806 switch (op) {
807 case FcOpContains:
808 case FcOpListing:
809 ret = FcLangSetContains (left.u.l, right.u.l);
810 break;
811 case FcOpNotContains:
812 ret = !FcLangSetContains (left.u.l, right.u.l);
813 break;
814 case FcOpEqual:
815 ret = FcLangSetEqual (left.u.l, right.u.l);
816 break;
817 case FcOpNotEqual:
818 ret = !FcLangSetEqual (left.u.l, right.u.l);
819 break;
820 default:
821 break;
822 }
823 break;
824 case FcTypeVoid:
825 switch (op) {
826 case FcOpEqual:
827 case FcOpContains:
828 case FcOpListing:
829 ret = FcTrue;
830 break;
831 default:
832 break;
833 }
834 break;
835 case FcTypeFTFace:
836 switch (op) {
837 case FcOpEqual:
838 case FcOpContains:
839 case FcOpListing:
840 ret = left.u.f == right.u.f;
841 break;
842 case FcOpNotEqual:
843 case FcOpNotContains:
844 ret = left.u.f != right.u.f;
845 break;
846 default:
847 break;
848 }
849 break;
850 }
851 }
852 else
853 {
854 if (op == FcOpNotEqual || op == FcOpNotContains)
855 ret = FcTrue;
856 }
857 return ret;
858 }
859
860
861 #define _FcDoubleFloor(d) ((int) (d))
862 #define _FcDoubleCeil(d) ((double) (int) (d) == (d) ? (int) (d) : (int) ((d) + 1))
863 #define FcDoubleFloor(d) ((d) >= 0 ? _FcDoubleFloor(d) : -_FcDoubleCeil(-(d)))
864 #define FcDoubleCeil(d) ((d) >= 0 ? _FcDoubleCeil(d) : -_FcDoubleFloor(-(d)))
865 #define FcDoubleRound(d) FcDoubleFloor ((d) + 0.5)
866 #define FcDoubleTrunc(d) ((d) >= 0 ? _FcDoubleFloor (d) : -_FcDoubleFloor (-(d)))
867
868 static FcValue
869 FcConfigEvaluate (FcPattern *p, FcExpr *e)
870 {
871 FcValue v, vl, vr;
872 FcResult r;
873 FcMatrix *m;
874 FcChar8 *str;
875
876 switch (e->op) {
877 case FcOpInteger:
878 v.type = FcTypeInteger;
879 v.u.i = e->u.ival;
880 break;
881 case FcOpDouble:
882 v.type = FcTypeDouble;
883 v.u.d = e->u.dval;
884 break;
885 case FcOpString:
886 v.type = FcTypeString;
887 v.u.s = e->u.sval;
888 v = FcValueSave (v);
889 break;
890 case FcOpMatrix:
891 v.type = FcTypeMatrix;
892 v.u.m = e->u.mval;
893 v = FcValueSave (v);
894 break;
895 case FcOpCharSet:
896 v.type = FcTypeCharSet;
897 v.u.c = e->u.cval;
898 v = FcValueSave (v);
899 break;
900 case FcOpLangSet:
901 v.type = FcTypeLangSet;
902 v.u.l = e->u.lval;
903 v = FcValueSave (v);
904 break;
905 case FcOpBool:
906 v.type = FcTypeBool;
907 v.u.b = e->u.bval;
908 break;
909 case FcOpField:
910 r = FcPatternObjectGet (p, e->u.object, 0, &v);
911 if (r != FcResultMatch)
912 v.type = FcTypeVoid;
913 v = FcValueSave (v);
914 break;
915 case FcOpConst:
916 if (FcNameConstant (e->u.constant, &v.u.i))
917 v.type = FcTypeInteger;
918 else
919 v.type = FcTypeVoid;
920 break;
921 case FcOpQuest:
922 vl = FcConfigEvaluate (p, e->u.tree.left);
923 if (vl.type == FcTypeBool)
924 {
925 if (vl.u.b)
926 v = FcConfigEvaluate (p, e->u.tree.right->u.tree.left);
927 else
928 v = FcConfigEvaluate (p, e->u.tree.right->u.tree.right);
929 }
930 else
931 v.type = FcTypeVoid;
932 FcValueDestroy (vl);
933 break;
934 case FcOpEqual:
935 case FcOpNotEqual:
936 case FcOpLess:
937 case FcOpLessEqual:
938 case FcOpMore:
939 case FcOpMoreEqual:
940 case FcOpContains:
941 case FcOpNotContains:
942 case FcOpListing:
943 vl = FcConfigEvaluate (p, e->u.tree.left);
944 vr = FcConfigEvaluate (p, e->u.tree.right);
945 v.type = FcTypeBool;
946 v.u.b = FcConfigCompareValue (&vl, e->op, &vr);
947 FcValueDestroy (vl);
948 FcValueDestroy (vr);
949 break;
950 case FcOpOr:
951 case FcOpAnd:
952 case FcOpPlus:
953 case FcOpMinus:
954 case FcOpTimes:
955 case FcOpDivide:
956 vl = FcConfigEvaluate (p, e->u.tree.left);
957 vr = FcConfigEvaluate (p, e->u.tree.right);
958 vl = FcConfigPromote (vl, vr);
959 vr = FcConfigPromote (vr, vl);
960 if (vl.type == vr.type)
961 {
962 switch (vl.type) {
963 case FcTypeDouble:
964 switch (e->op) {
965 case FcOpPlus:
966 v.type = FcTypeDouble;
967 v.u.d = vl.u.d + vr.u.d;
968 break;
969 case FcOpMinus:
970 v.type = FcTypeDouble;
971 v.u.d = vl.u.d - vr.u.d;
972 break;
973 case FcOpTimes:
974 v.type = FcTypeDouble;
975 v.u.d = vl.u.d * vr.u.d;
976 break;
977 case FcOpDivide:
978 v.type = FcTypeDouble;
979 v.u.d = vl.u.d / vr.u.d;
980 break;
981 default:
982 v.type = FcTypeVoid;
983 break;
984 }
985 if (v.type == FcTypeDouble &&
986 v.u.d == (double) (int) v.u.d)
987 {
988 v.type = FcTypeInteger;
989 v.u.i = (int) v.u.d;
990 }
991 break;
992 case FcTypeBool:
993 switch (e->op) {
994 case FcOpOr:
995 v.type = FcTypeBool;
996 v.u.b = vl.u.b || vr.u.b;
997 break;
998 case FcOpAnd:
999 v.type = FcTypeBool;
1000 v.u.b = vl.u.b && vr.u.b;
1001 break;
1002 default:
1003 v.type = FcTypeVoid;
1004 break;
1005 }
1006 break;
1007 case FcTypeString:
1008 switch (e->op) {
1009 case FcOpPlus:
1010 v.type = FcTypeString;
1011 str = FcStrPlus (vl.u.s, vr.u.s);
1012 v.u.s = FcStrStaticName (str);
1013 FcStrFree (str);
1014
1015 if (!v.u.s)
1016 v.type = FcTypeVoid;
1017 break;
1018 default:
1019 v.type = FcTypeVoid;
1020 break;
1021 }
1022 break;
1023 case FcTypeMatrix:
1024 switch (e->op) {
1025 case FcOpTimes:
1026 v.type = FcTypeMatrix;
1027 m = malloc (sizeof (FcMatrix));
1028 if (m)
1029 {
1030 FcMemAlloc (FC_MEM_MATRIX, sizeof (FcMatrix));
1031 FcMatrixMultiply (m, vl.u.m, vr.u.m);
1032 v.u.m = m;
1033 }
1034 else
1035 {
1036 v.type = FcTypeVoid;
1037 }
1038 break;
1039 default:
1040 v.type = FcTypeVoid;
1041 break;
1042 }
1043 break;
1044 case FcTypeCharSet:
1045 switch (e->op) {
1046 case FcOpPlus:
1047 v.type = FcTypeCharSet;
1048 v.u.c = FcCharSetUnion (vl.u.c, vr.u.c);
1049 if (!v.u.c)
1050 v.type = FcTypeVoid;
1051 break;
1052 case FcOpMinus:
1053 v.type = FcTypeCharSet;
1054 v.u.c = FcCharSetSubtract (vl.u.c, vr.u.c);
1055 if (!v.u.c)
1056 v.type = FcTypeVoid;
1057 break;
1058 default:
1059 v.type = FcTypeVoid;
1060 break;
1061 }
1062 break;
1063 case FcTypeLangSet:
1064 switch (e->op) {
1065 case FcOpPlus:
1066 v.type = FcTypeLangSet;
1067 v.u.l = FcLangSetUnion (vl.u.l, vr.u.l);
1068 if (!v.u.l)
1069 v.type = FcTypeVoid;
1070 break;
1071 case FcOpMinus:
1072 v.type = FcTypeLangSet;
1073 v.u.l = FcLangSetSubtract (vl.u.l, vr.u.l);
1074 if (!v.u.l)
1075 v.type = FcTypeVoid;
1076 break;
1077 default:
1078 v.type = FcTypeVoid;
1079 break;
1080 }
1081 break;
1082 default:
1083 v.type = FcTypeVoid;
1084 break;
1085 }
1086 }
1087 else
1088 v.type = FcTypeVoid;
1089 FcValueDestroy (vl);
1090 FcValueDestroy (vr);
1091 break;
1092 case FcOpNot:
1093 vl = FcConfigEvaluate (p, e->u.tree.left);
1094 switch (vl.type) {
1095 case FcTypeBool:
1096 v.type = FcTypeBool;
1097 v.u.b = !vl.u.b;
1098 break;
1099 default:
1100 v.type = FcTypeVoid;
1101 break;
1102 }
1103 FcValueDestroy (vl);
1104 break;
1105 case FcOpFloor:
1106 vl = FcConfigEvaluate (p, e->u.tree.left);
1107 switch (vl.type) {
1108 case FcTypeInteger:
1109 v = vl;
1110 break;
1111 case FcTypeDouble:
1112 v.type = FcTypeInteger;
1113 v.u.i = FcDoubleFloor (vl.u.d);
1114 break;
1115 default:
1116 v.type = FcTypeVoid;
1117 break;
1118 }
1119 FcValueDestroy (vl);
1120 break;
1121 case FcOpCeil:
1122 vl = FcConfigEvaluate (p, e->u.tree.left);
1123 switch (vl.type) {
1124 case FcTypeInteger:
1125 v = vl;
1126 break;
1127 case FcTypeDouble:
1128 v.type = FcTypeInteger;
1129 v.u.i = FcDoubleCeil (vl.u.d);
1130 break;
1131 default:
1132 v.type = FcTypeVoid;
1133 break;
1134 }
1135 FcValueDestroy (vl);
1136 break;
1137 case FcOpRound:
1138 vl = FcConfigEvaluate (p, e->u.tree.left);
1139 switch (vl.type) {
1140 case FcTypeInteger:
1141 v = vl;
1142 break;
1143 case FcTypeDouble:
1144 v.type = FcTypeInteger;
1145 v.u.i = FcDoubleRound (vl.u.d);
1146 break;
1147 default:
1148 v.type = FcTypeVoid;
1149 break;
1150 }
1151 FcValueDestroy (vl);
1152 break;
1153 case FcOpTrunc:
1154 vl = FcConfigEvaluate (p, e->u.tree.left);
1155 switch (vl.type) {
1156 case FcTypeInteger:
1157 v = vl;
1158 break;
1159 case FcTypeDouble:
1160 v.type = FcTypeInteger;
1161 v.u.i = FcDoubleTrunc (vl.u.d);
1162 break;
1163 default:
1164 v.type = FcTypeVoid;
1165 break;
1166 }
1167 FcValueDestroy (vl);
1168 break;
1169 default:
1170 v.type = FcTypeVoid;
1171 break;
1172 }
1173 return v;
1174 }
1175
1176 static FcValueList *
1177 FcConfigMatchValueList (FcPattern *p,
1178 FcTest *t,
1179 FcValueList *values)
1180 {
1181 FcValueList *ret = 0;
1182 FcExpr *e = t->expr;
1183 FcValue value;
1184 FcValueList *v;
1185
1186 while (e)
1187 {
1188 /* Compute the value of the match expression */
1189 if (e->op == FcOpComma)
1190 {
1191 value = FcConfigEvaluate (p, e->u.tree.left);
1192 e = e->u.tree.right;
1193 }
1194 else
1195 {
1196 value = FcConfigEvaluate (p, e);
1197 e = 0;
1198 }
1199
1200 for (v = values; v; v = FcValueListNext(v))
1201 {
1202 /* Compare the pattern value to the match expression value */
1203 if (FcConfigCompareValue (&v->value, t->op, &value))
1204 {
1205 if (!ret)
1206 ret = v;
1207 }
1208 else
1209 {
1210 if (t->qual == FcQualAll)
1211 {
1212 ret = 0;
1213 break;
1214 }
1215 }
1216 }
1217 FcValueDestroy (value);
1218 }
1219 return ret;
1220 }
1221
1222 static FcValueList *
1223 FcConfigValues (FcPattern *p, FcExpr *e, FcValueBinding binding)
1224 {
1225 FcValueList *l;
1226
1227 if (!e)
1228 return 0;
1229 l = (FcValueList *) malloc (sizeof (FcValueList));
1230 if (!l)
1231 return 0;
1232 FcMemAlloc (FC_MEM_VALLIST, sizeof (FcValueList));
1233 if (e->op == FcOpComma)
1234 {
1235 l->value = FcConfigEvaluate (p, e->u.tree.left);
1236 l->next = FcConfigValues (p, e->u.tree.right, binding);
1237 }
1238 else
1239 {
1240 l->value = FcConfigEvaluate (p, e);
1241 l->next = NULL;
1242 }
1243 l->binding = binding;
1244 if (l->value.type == FcTypeVoid)
1245 {
1246 FcValueList *next = FcValueListNext(l);
1247
1248 FcMemFree (FC_MEM_VALLIST, sizeof (FcValueList));
1249 free (l);
1250 l = next;
1251 }
1252
1253 return l;
1254 }
1255
1256 static FcBool
1257 FcConfigAdd (FcValueListPtr *head,
1258 FcValueList *position,
1259 FcBool append,
1260 FcValueList *new)
1261 {
1262 FcValueListPtr *prev, last, v;
1263 FcValueBinding sameBinding;
1264
1265 if (position)
1266 sameBinding = position->binding;
1267 else
1268 sameBinding = FcValueBindingWeak;
1269 for (v = new; v != NULL; v = FcValueListNext(v))
1270 if (v->binding == FcValueBindingSame)
1271 v->binding = sameBinding;
1272 if (append)
1273 {
1274 if (position)
1275 prev = &position->next;
1276 else
1277 for (prev = head; *prev != NULL;
1278 prev = &(*prev)->next)
1279 ;
1280 }
1281 else
1282 {
1283 if (position)
1284 {
1285 for (prev = head; *prev != NULL;
1286 prev = &(*prev)->next)
1287 {
1288 if (*prev == position)
1289 break;
1290 }
1291 }
1292 else
1293 prev = head;
1294
1295 if (FcDebug () & FC_DBG_EDIT)
1296 {
1297 if (*prev == NULL)
1298 printf ("position not on list\n");
1299 }
1300 }
1301
1302 if (FcDebug () & FC_DBG_EDIT)
1303 {
1304 printf ("%s list before ", append ? "Append" : "Prepend");
1305 FcValueListPrint (*head);
1306 printf ("\n");
1307 }
1308
1309 if (new)
1310 {
1311 last = new;
1312 while (last->next != NULL)
1313 last = last->next;
1314
1315 last->next = *prev;
1316 *prev = new;
1317 }
1318
1319 if (FcDebug () & FC_DBG_EDIT)
1320 {
1321 printf ("%s list after ", append ? "Append" : "Prepend");
1322 FcValueListPrint (*head);
1323 printf ("\n");
1324 }
1325
1326 return FcTrue;
1327 }
1328
1329 static void
1330 FcConfigDel (FcValueListPtr *head,
1331 FcValueList *position)
1332 {
1333 FcValueListPtr *prev;
1334
1335 for (prev = head; *prev != NULL; prev = &(*prev)->next)
1336 {
1337 if (*prev == position)
1338 {
1339 *prev = position->next;
1340 position->next = NULL;
1341 FcValueListDestroy (position);
1342 break;
1343 }
1344 }
1345 }
1346
1347 static void
1348 FcConfigPatternAdd (FcPattern *p,
1349 FcObject object,
1350 FcValueList *list,
1351 FcBool append)
1352 {
1353 if (list)
1354 {
1355 FcPatternElt *e = FcPatternObjectInsertElt (p, object);
1356
1357 if (!e)
1358 return;
1359 FcConfigAdd (&e->values, 0, append, list);
1360 }
1361 }
1362
1363 /*
1364 * Delete all values associated with a field
1365 */
1366 static void
1367 FcConfigPatternDel (FcPattern *p,
1368 FcObject object)
1369 {
1370 FcPatternElt *e = FcPatternObjectFindElt (p, object);
1371 if (!e)
1372 return;
1373 while (e->values != NULL)
1374 FcConfigDel (&e->values, e->values);
1375 }
1376
1377 static void
1378 FcConfigPatternCanon (FcPattern *p,
1379 FcObject object)
1380 {
1381 FcPatternElt *e = FcPatternObjectFindElt (p, object);
1382 if (!e)
1383 return;
1384 if (e->values == NULL)
1385 FcPatternObjectDel (p, object);
1386 }
1387
1388 FcBool
1389 FcConfigSubstituteWithPat (FcConfig *config,
1390 FcPattern *p,
1391 FcPattern *p_pat,
1392 FcMatchKind kind)
1393 {
1394 FcSubst *s;
1395 FcSubState *st;
1396 int i;
1397 FcTest *t;
1398 FcEdit *e;
1399 FcValueList *l;
1400 FcPattern *m;
1401
1402 if (!config)
1403 {
1404 config = FcConfigGetCurrent ();
1405 if (!config)
1406 return FcFalse;
1407 }
1408
1409 switch (kind) {
1410 case FcMatchPattern:
1411 s = config->substPattern;
1412 break;
1413 case FcMatchFont:
1414 s = config->substFont;
1415 break;
1416 case FcMatchScan:
1417 s = config->substScan;
1418 break;
1419 default:
1420 return FcFalse;
1421 }
1422
1423 st = (FcSubState *) malloc (config->maxObjects * sizeof (FcSubState));
1424 if (!st && config->maxObjects)
1425 return FcFalse;
1426 FcMemAlloc (FC_MEM_SUBSTATE, config->maxObjects * sizeof (FcSubState));
1427
1428 if (FcDebug () & FC_DBG_EDIT)
1429 {
1430 printf ("FcConfigSubstitute ");
1431 FcPatternPrint (p);
1432 }
1433 for (; s; s = s->next)
1434 {
1435 /*
1436 * Check the tests to see if
1437 * they all match the pattern
1438 */
1439 for (t = s->test, i = 0; t; t = t->next, i++)
1440 {
1441 if (FcDebug () & FC_DBG_EDIT)
1442 {
1443 printf ("FcConfigSubstitute test ");
1444 FcTestPrint (t);
1445 }
1446 st[i].elt = 0;
1447 if (kind == FcMatchFont && t->kind == FcMatchPattern)
1448 m = p_pat;
1449 else
1450 m = p;
1451 if (m)
1452 st[i].elt = FcPatternObjectFindElt (m, t->object);
1453 else
1454 st[i].elt = 0;
1455 /*
1456 * If there's no such field in the font,
1457 * then FcQualAll matches while FcQualAny does not
1458 */
1459 if (!st[i].elt)
1460 {
1461 if (t->qual == FcQualAll)
1462 {
1463 st[i].value = 0;
1464 continue;
1465 }
1466 else
1467 break;
1468 }
1469 /*
1470 * Check to see if there is a match, mark the location
1471 * to apply match-relative edits
1472 */
1473 st[i].value = FcConfigMatchValueList (m, t, st[i].elt->values);
1474 if (!st[i].value)
1475 break;
1476 if (t->qual == FcQualFirst && st[i].value != st[i].elt->values)
1477 break;
1478 if (t->qual == FcQualNotFirst && st[i].value == st[i].elt->values)
1479 break;
1480 }
1481 if (t)
1482 {
1483 if (FcDebug () & FC_DBG_EDIT)
1484 printf ("No match\n");
1485 continue;
1486 }
1487 if (FcDebug () & FC_DBG_EDIT)
1488 {
1489 printf ("Substitute ");
1490 FcSubstPrint (s);
1491 }
1492 for (e = s->edit; e; e = e->next)
1493 {
1494 /*
1495 * Evaluate the list of expressions
1496 */
1497 l = FcConfigValues (p, e->expr, e->binding);
1498 /*
1499 * Locate any test associated with this field, skipping
1500 * tests associated with the pattern when substituting in
1501 * the font
1502 */
1503 for (t = s->test, i = 0; t; t = t->next, i++)
1504 {
1505 if ((t->kind == FcMatchFont || kind == FcMatchPattern) &&
1506 t->object == e->object)
1507 {
1508 /*
1509 * KLUDGE - the pattern may have been reallocated or
1510 * things may have been inserted or deleted above
1511 * this element by other edits. Go back and find
1512 * the element again
1513 */
1514 if (e != s->edit && st[i].elt)
1515 st[i].elt = FcPatternObjectFindElt (p, t->object);
1516 if (!st[i].elt)
1517 t = 0;
1518 break;
1519 }
1520 }
1521 switch (e->op) {
1522 case FcOpAssign:
1523 /*
1524 * If there was a test, then replace the matched
1525 * value with the new list of values
1526 */
1527 if (t)
1528 {
1529 FcValueList *thisValue = st[i].value;
1530 FcValueList *nextValue = thisValue;
1531
1532 /*
1533 * Append the new list of values after the current value
1534 */
1535 FcConfigAdd (&st[i].elt->values, thisValue, FcTrue, l);
1536 /*
1537 * Delete the marked value
1538 */
1539 if (thisValue)
1540 FcConfigDel (&st[i].elt->values, thisValue);
1541 /*
1542 * Adjust any pointers into the value list to ensure
1543 * future edits occur at the same place
1544 */
1545 for (t = s->test, i = 0; t; t = t->next, i++)
1546 {
1547 if (st[i].value == thisValue)
1548 st[i].value = nextValue;
1549 }
1550 break;
1551 }
1552 /* fall through ... */
1553 case FcOpAssignReplace:
1554 /*
1555 * Delete all of the values and insert
1556 * the new set
1557 */
1558 FcConfigPatternDel (p, e->object);
1559 FcConfigPatternAdd (p, e->object, l, FcTrue);
1560 /*
1561 * Adjust any pointers into the value list as they no
1562 * longer point to anything valid
1563 */
1564 if (t)
1565 {
1566 FcPatternElt *thisElt = st[i].elt;
1567 for (t = s->test, i = 0; t; t = t->next, i++)
1568 {
1569 if (st[i].elt == thisElt)
1570 st[i].value = 0;
1571 }
1572 }
1573 break;
1574 case FcOpPrepend:
1575 if (t)
1576 {
1577 FcConfigAdd (&st[i].elt->values, st[i].value, FcFalse, l);
1578 break;
1579 }
1580 /* fall through ... */
1581 case FcOpPrependFirst:
1582 FcConfigPatternAdd (p, e->object, l, FcFalse);
1583 break;
1584 case FcOpAppend:
1585 if (t)
1586 {
1587 FcConfigAdd (&st[i].elt->values, st[i].value, FcTrue, l);
1588 break;
1589 }
1590 /* fall through ... */
1591 case FcOpAppendLast:
1592 FcConfigPatternAdd (p, e->object, l, FcTrue);
1593 break;
1594 default:
1595 FcValueListDestroy (l);
1596 break;
1597 }
1598 }
1599 /*
1600 * Now go through the pattern and eliminate
1601 * any properties without data
1602 */
1603 for (e = s->edit; e; e = e->next)
1604 FcConfigPatternCanon (p, e->object);
1605
1606 if (FcDebug () & FC_DBG_EDIT)
1607 {
1608 printf ("FcConfigSubstitute edit");
1609 FcPatternPrint (p);
1610 }
1611 }
1612 FcMemFree (FC_MEM_SUBSTATE, config->maxObjects * sizeof (FcSubState));
1613 free (st);
1614 if (FcDebug () & FC_DBG_EDIT)
1615 {
1616 printf ("FcConfigSubstitute done");
1617 FcPatternPrint (p);
1618 }
1619 return FcTrue;
1620 }
1621
1622 FcBool
1623 FcConfigSubstitute (FcConfig *config,
1624 FcPattern *p,
1625 FcMatchKind kind)
1626 {
1627 return FcConfigSubstituteWithPat (config, p, 0, kind);
1628 }
1629
1630 #if defined (_WIN32)
1631
1632 # define WIN32_LEAN_AND_MEAN
1633 # define WIN32_EXTRA_LEAN
1634 # include <windows.h>
1635
1636 static FcChar8 fontconfig_path[1000] = "";
1637
1638 # if (defined (PIC) || defined (DLL_EXPORT))
1639
1640 BOOL WINAPI
1641 DllMain (HINSTANCE hinstDLL,
1642 DWORD fdwReason,
1643 LPVOID lpvReserved)
1644 {
1645 FcChar8 *p;
1646
1647 switch (fdwReason) {
1648 case DLL_PROCESS_ATTACH:
1649 if (!GetModuleFileName ((HMODULE) hinstDLL, fontconfig_path,
1650 sizeof (fontconfig_path)))
1651 break;
1652
1653 /* If the fontconfig DLL is in a "bin" or "lib" subfolder,
1654 * assume it's a Unix-style installation tree, and use
1655 * "etc/fonts" in there as FONTCONFIG_PATH. Otherwise use the
1656 * folder where the DLL is as FONTCONFIG_PATH.
1657 */
1658 p = strrchr (fontconfig_path, '\\');
1659 if (p)
1660 {
1661 *p = '\0';
1662 p = strrchr (fontconfig_path, '\\');
1663 if (p && (FcStrCmpIgnoreCase (p + 1, "bin") == 0 ||
1664 FcStrCmpIgnoreCase (p + 1, "lib") == 0))
1665 *p = '\0';
1666 strcat (fontconfig_path, "\\etc\\fonts");
1667 }
1668 else
1669 fontconfig_path[0] = '\0';
1670
1671 break;
1672 }
1673
1674 return TRUE;
1675 }
1676
1677 # endif /* !PIC */
1678
1679 #undef FONTCONFIG_PATH
1680 #define FONTCONFIG_PATH fontconfig_path
1681
1682 #endif /* !_WIN32 */
1683
1684 #ifndef FONTCONFIG_FILE
1685 #define FONTCONFIG_FILE "fonts.conf"
1686 #endif
1687
1688 static FcChar8 *
1689 FcConfigFileExists (const FcChar8 *dir, const FcChar8 *file)
1690 {
1691 FcChar8 *path;
1692
1693 if (!dir)
1694 dir = (const FcChar8 *) "";
1695
1696 path = FcStrPathPlus (dir, file, NULL);
1697 if (access ((char *) path, R_OK) == 0)
1698 return path;
1699
1700 FcStrFree (path);
1701 return 0;
1702 }
1703
1704 static FcChar8 **
1705 FcConfigGetPath (void)
1706 {
1707 FcChar8 **path;
1708 FcChar8 *env, *e, *colon;
1709 FcChar8 *dir;
1710 int npath;
1711 int i;
1712
1713 npath = 2; /* default dir + null */
1714 env = (FcChar8 *) getenv ("FONTCONFIG_PATH");
1715 if (env)
1716 {
1717 e = env;
1718 npath++;
1719 while (*e)
1720 if (*e++ == FC_SEARCH_PATH_SEPARATOR)
1721 npath++;
1722 }
1723 path = calloc (npath, sizeof (FcChar8 *));
1724 if (!path)
1725 goto bail0;
1726 i = 0;
1727
1728 if (env)
1729 {
1730 e = env;
1731 while (*e)
1732 {
1733 colon = (FcChar8 *) strchr ((char *) e, FC_SEARCH_PATH_SEPARATOR);
1734 if (!colon)
1735 colon = e + strlen ((char *) e);
1736 path[i] = malloc (colon - e + 1);
1737 if (!path[i])
1738 goto bail1;
1739 strncpy ((char *) path[i], (const char *) e, colon - e);
1740 path[i][colon - e] = '\0';
1741 if (*colon)
1742 e = colon + 1;
1743 else
1744 e = colon;
1745 i++;
1746 }
1747 }
1748
1749 #ifdef _WIN32
1750 if (fontconfig_path[0] == '\0')
1751 {
1752 char *p;
1753 if(!GetModuleFileName(NULL, fontconfig_path, sizeof(fontconfig_path)))
1754 goto bail1;
1755 p = strrchr (fontconfig_path, '\\');
1756 if (p) *p = '\0';
1757 strcat (fontconfig_path, "\\fonts");
1758 }
1759 #endif
1760 dir = (FcChar8 *) FONTCONFIG_PATH;
1761 path[i] = malloc (strlen ((char *) dir) + 1);
1762 if (!path[i])
1763 goto bail1;
1764 strcpy ((char *) path[i], (const char *) dir);
1765 return path;
1766
1767 bail1:
1768 for (i = 0; path[i]; i++)
1769 free (path[i]);
1770 free (path);
1771 bail0:
1772 return 0;
1773 }
1774
1775 static void
1776 FcConfigFreePath (FcChar8 **path)
1777 {
1778 FcChar8 **p;
1779
1780 for (p = path; *p; p++)
1781 free (*p);
1782 free (path);
1783 }
1784
1785 static FcBool _FcConfigHomeEnabled = FcTrue;
1786
1787 FcChar8 *
1788 FcConfigHome (void)
1789 {
1790 if (_FcConfigHomeEnabled)
1791 {
1792 char *home = getenv ("HOME");
1793
1794 #ifdef _WIN32
1795 if (home == NULL)
1796 home = getenv ("USERPROFILE");
1797 #endif
1798
1799 return (FcChar8 *) home;
1800 }
1801 return 0;
1802 }
1803
1804 FcBool
1805 FcConfigEnableHome (FcBool enable)
1806 {
1807 FcBool prev = _FcConfigHomeEnabled;
1808 _FcConfigHomeEnabled = enable;
1809 return prev;
1810 }
1811
1812 FcChar8 *
1813 FcConfigFilename (const FcChar8 *url)
1814 {
1815 FcChar8 *file, *dir, **path, **p;
1816
1817 if (!url || !*url)
1818 {
1819 url = (FcChar8 *) getenv ("FONTCONFIG_FILE");
1820 if (!url)
1821 url = (FcChar8 *) FONTCONFIG_FILE;
1822 }
1823 file = 0;
1824
1825 #ifdef _WIN32
1826 if (isalpha (*url) &&
1827 url[1] == ':' &&
1828 (url[2] == '/' || url[2] == '\\'))
1829 goto absolute_path;
1830 #endif
1831
1832 switch (*url) {
1833 case '~':
1834 dir = FcConfigHome ();
1835 if (dir)
1836 file = FcConfigFileExists (dir, url + 1);
1837 else
1838 file = 0;
1839 break;
1840 #ifdef _WIN32
1841 case '\\':
1842 absolute_path:
1843 #endif
1844 case '/':
1845 file = FcConfigFileExists (0, url);
1846 break;
1847 default:
1848 path = FcConfigGetPath ();
1849 if (!path)
1850 return 0;
1851 for (p = path; *p; p++)
1852 {
1853 file = FcConfigFileExists (*p, url);
1854 if (file)
1855 break;
1856 }
1857 FcConfigFreePath (path);
1858 break;
1859 }
1860 return file;
1861 }
1862
1863 /*
1864 * Manage the application-specific fonts
1865 */
1866
1867 FcBool
1868 FcConfigAppFontAddFile (FcConfig *config,
1869 const FcChar8 *file)
1870 {
1871 FcFontSet *set;
1872 FcStrSet *subdirs;
1873 FcStrList *sublist;
1874 FcChar8 *subdir;
1875
1876 if (!config)
1877 {
1878 config = FcConfigGetCurrent ();
1879 if (!config)
1880 return FcFalse;
1881 }
1882
1883 subdirs = FcStrSetCreate ();
1884 if (!subdirs)
1885 return FcFalse;
1886
1887 set = FcConfigGetFonts (config, FcSetApplication);
1888 if (!set)
1889 {
1890 set = FcFontSetCreate ();
1891 if (!set)
1892 {
1893 FcStrSetDestroy (subdirs);
1894 return FcFalse;
1895 }
1896 FcConfigSetFonts (config, set, FcSetApplication);
1897 }
1898
1899 if (!FcFileScanConfig (set, subdirs, config->blanks, file, config))
1900 {
1901 FcStrSetDestroy (subdirs);
1902 return FcFalse;
1903 }
1904 if ((sublist = FcStrListCreate (subdirs)))
1905 {
1906 while ((subdir = FcStrListNext (sublist)))
1907 {
1908 FcConfigAppFontAddDir (config, subdir);
1909 }
1910 FcStrListDone (sublist);
1911 }
1912 FcStrSetDestroy (subdirs);
1913 return FcTrue;
1914 }
1915
1916 FcBool
1917 FcConfigAppFontAddDir (FcConfig *config,
1918 const FcChar8 *dir)
1919 {
1920 FcFontSet *set;
1921 FcStrSet *dirs;
1922
1923 if (!config)
1924 {
1925 config = FcConfigGetCurrent ();
1926 if (!config)
1927 return FcFalse;
1928 }
1929
1930 dirs = FcStrSetCreate ();
1931 if (!dirs)
1932 return FcFalse;
1933
1934 set = FcConfigGetFonts (config, FcSetApplication);
1935 if (!set)
1936 {
1937 set = FcFontSetCreate ();
1938 if (!set)
1939 {
1940 FcStrSetDestroy (dirs);
1941 return FcFalse;
1942 }
1943 FcConfigSetFonts (config, set, FcSetApplication);
1944 }
1945
1946 FcStrSetAddFilename (dirs, dir);
1947
1948 if (!FcConfigAddDirList (config, FcSetApplication, dirs))
1949 {
1950 FcStrSetDestroy (dirs);
1951 return FcFalse;
1952 }
1953 FcStrSetDestroy (dirs);
1954 return FcTrue;
1955 }
1956
1957 void
1958 FcConfigAppFontClear (FcConfig *config)
1959 {
1960 if (!config)
1961 {
1962 config = FcConfigGetCurrent ();
1963 if (!config)
1964 return;
1965 }
1966
1967 FcConfigSetFonts (config, 0, FcSetApplication);
1968 }
1969
1970 /*
1971 * Manage filename-based font source selectors
1972 */
1973
1974 FcBool
1975 FcConfigGlobAdd (FcConfig *config,
1976 const FcChar8 *glob,
1977 FcBool accept)
1978 {
1979 FcStrSet *set = accept ? config->acceptGlobs : config->rejectGlobs;
1980
1981 return FcStrSetAdd (set, glob);
1982 }
1983
1984 static FcBool
1985 FcConfigGlobMatch (const FcChar8 *glob,
1986 const FcChar8 *string)
1987 {
1988 FcChar8 c;
1989
1990 while ((c = *glob++))
1991 {
1992 switch (c) {
1993 case '*':
1994 /* short circuit common case */
1995 if (!*glob)
1996 return FcTrue;
1997 /* short circuit another common case */
1998 if (strchr ((char *) glob, '*') == 0)
1999 string += strlen ((char *) string) - strlen ((char *) glob);
2000 while (*string)
2001 {
2002 if (FcConfigGlobMatch (glob, string))
2003 return FcTrue;
2004 string++;
2005 }
2006 return FcFalse;
2007 case '?':
2008 if (*string++ == '\0')
2009 return FcFalse;
2010 break;
2011 default:
2012 if (*string++ != c)
2013 return FcFalse;
2014 break;
2015 }
2016 }
2017 return *string == '\0';
2018 }
2019
2020 static FcBool
2021 FcConfigGlobsMatch (const FcStrSet *globs,
2022 const FcChar8 *string)
2023 {
2024 int i;
2025
2026 for (i = 0; i < globs->num; i++)
2027 if (FcConfigGlobMatch (globs->strs[i], string))
2028 return FcTrue;
2029 return FcFalse;
2030 }
2031
2032 FcBool
2033 FcConfigAcceptFilename (FcConfig *config,
2034 const FcChar8 *filename)
2035 {
2036 if (FcConfigGlobsMatch (config->acceptGlobs, filename))
2037 return FcTrue;
2038 if (FcConfigGlobsMatch (config->rejectGlobs, filename))
2039 return FcFalse;
2040 return FcTrue;
2041 }
2042
2043 /*
2044 * Manage font-pattern based font source selectors
2045 */
2046
2047 FcBool
2048 FcConfigPatternsAdd (FcConfig *config,
2049 FcPattern *pattern,
2050 FcBool accept)
2051 {
2052 FcFontSet *set = accept ? config->acceptPatterns : config->rejectPatterns;
2053
2054 return FcFontSetAdd (set, pattern);
2055 }
2056
2057 static FcBool
2058 FcConfigPatternsMatch (const FcFontSet *patterns,
2059 const FcPattern *font)
2060 {
2061 int i;
2062
2063 for (i = 0; i < patterns->nfont; i++)
2064 if (FcListPatternMatchAny (patterns->fonts[i], font))
2065 return FcTrue;
2066 return FcFalse;
2067 }
2068
2069 FcBool
2070 FcConfigAcceptFont (FcConfig *config,
2071 const FcPattern *font)
2072 {
2073 if (FcConfigPatternsMatch (config->acceptPatterns, font))
2074 return FcTrue;
2075 if (FcConfigPatternsMatch (config->rejectPatterns, font))
2076 return FcFalse;
2077 return FcTrue;
2078 }
2079 #define __fccfg__
2080 #include "fcaliastail.h"
2081 #undef __fccfg__
http://fontconfig.org/