"Fossies" - the Fresh Open Source Software Archive 
Member "xpdf-4.04/xpdf/GlobalParams.cc" (18 Apr 2022, 103543 Bytes) of package /linux/misc/xpdf-4.04.tar.gz:
As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style:
standard) with prefixed line numbers and
code folding option.
Alternatively you can here
view or
download the uninterpreted source code file.
For more information about "GlobalParams.cc" see the
Fossies "Dox" file reference documentation and the latest
Fossies "Diffs" side-by-side code changes report:
4.03_vs_4.04.
1 //========================================================================
2 //
3 // GlobalParams.cc
4 //
5 // Copyright 2001-2003 Glyph & Cog, LLC
6 //
7 //========================================================================
8
9 #include <aconf.h>
10
11 #ifdef USE_GCC_PRAGMAS
12 #pragma implementation
13 #endif
14
15 #include <string.h>
16 #include <stdio.h>
17 #include <stdarg.h>
18 #include <ctype.h>
19 #include <time.h>
20 #ifdef _WIN32
21 # include <shlobj.h>
22 #endif
23 #if HAVE_PAPER_H
24 #include <paper.h>
25 #endif
26 #if HAVE_FONTCONFIG
27 # include <fontconfig/fontconfig.h>
28 #endif
29 #include "gmem.h"
30 #include "gmempp.h"
31 #include "GString.h"
32 #include "GList.h"
33 #include "GHash.h"
34 #include "gfile.h"
35 #include "FoFiIdentifier.h"
36 #include "Error.h"
37 #include "NameToCharCode.h"
38 #include "CharCodeToUnicode.h"
39 #include "UnicodeRemapping.h"
40 #include "UnicodeMap.h"
41 #include "CMap.h"
42 #include "BuiltinFontTables.h"
43 #include "FontEncodingTables.h"
44 #include "GlobalParams.h"
45
46 #ifdef _WIN32
47 # define strcasecmp stricmp
48 # define strncasecmp strnicmp
49 #endif
50
51 #if MULTITHREADED
52 # define lockGlobalParams gLockMutex(&mutex)
53 # define lockUnicodeMapCache gLockMutex(&unicodeMapCacheMutex)
54 # define lockCMapCache gLockMutex(&cMapCacheMutex)
55 # define unlockGlobalParams gUnlockMutex(&mutex)
56 # define unlockUnicodeMapCache gUnlockMutex(&unicodeMapCacheMutex)
57 # define unlockCMapCache gUnlockMutex(&cMapCacheMutex)
58 #else
59 # define lockGlobalParams
60 # define lockUnicodeMapCache
61 # define lockCMapCache
62 # define unlockGlobalParams
63 # define unlockUnicodeMapCache
64 # define unlockCMapCache
65 #endif
66
67 #include "NameToUnicodeTable.h"
68 #include "UnicodeMapTables.h"
69 #include "UTF8.h"
70
71 //------------------------------------------------------------------------
72
73 #define cidToUnicodeCacheSize 4
74 #define unicodeToUnicodeCacheSize 4
75
76 //------------------------------------------------------------------------
77
78 static struct {
79 const char *name;
80 const char *t1FileName;
81 const char *ttFileName;
82 const char *macFileName; // may be .dfont, .ttf, or .ttc
83 const char *macFontName; // font name inside .dfont or .ttc
84 const char *obliqueFont; // name of font to oblique
85 double obliqueFactor; // oblique sheer factor
86 } displayFontTab[] = {
87 {"Courier", "n022003l.pfb", "cour.ttf", "Courier", "Courier", NULL, 0},
88 {"Courier-Bold", "n022004l.pfb", "courbd.ttf", "Courier", "Courier Bold", NULL, 0},
89 {"Courier-BoldOblique", "n022024l.pfb", "courbi.ttf", "Courier", "Courier Bold Oblique", "Courier-Bold", 0.212557},
90 {"Courier-Oblique", "n022023l.pfb", "couri.ttf", "Courier", "Courier Oblique", "Courier", 0.212557},
91 {"Helvetica", "n019003l.pfb", "arial.ttf", "Helvetica", "Helvetica", NULL, 0},
92 {"Helvetica-Bold", "n019004l.pfb", "arialbd.ttf", "Helvetica", "Helvetica Bold", NULL, 0},
93 {"Helvetica-BoldOblique", "n019024l.pfb", "arialbi.ttf", "Helvetica", "Helvetica Bold Oblique", "Helvetica-Bold", 0.212557},
94 {"Helvetica-Oblique", "n019023l.pfb", "ariali.ttf", "Helvetica", "Helvetica Oblique", "Helvetica", 0.212557},
95 {"Symbol", "s050000l.pfb", NULL, "Symbol", "Symbol", NULL, 0},
96 {"Times-Bold", "n021004l.pfb", "timesbd.ttf", "Times", "Times Bold", NULL, 0},
97 {"Times-BoldItalic", "n021024l.pfb", "timesbi.ttf", "Times", "Times Bold Italic", NULL, 0},
98 {"Times-Italic", "n021023l.pfb", "timesi.ttf", "Times", "Times Italic", NULL, 0},
99 {"Times-Roman", "n021003l.pfb", "times.ttf", "Times", "Times Roman", NULL, 0},
100 {"ZapfDingbats", "d050000l.pfb", NULL, "ZapfDingbats", "Zapf Dingbats", NULL, 0},
101 {NULL}
102 };
103
104 #ifdef _WIN32
105 static const char *displayFontDirs[] = {
106 "c:/windows/fonts",
107 "c:/winnt/fonts",
108 NULL
109 };
110 #else
111 static const char *displayFontDirs[] = {
112 "/usr/share/ghostscript/fonts",
113 "/usr/local/share/ghostscript/fonts",
114 "/usr/share/fonts/default/Type1",
115 "/usr/share/fonts/default/ghostscript",
116 "/usr/share/fonts/type1/gsfonts",
117 #if defined(__sun) && defined(__SVR4)
118 "/usr/sfw/share/ghostscript/fonts",
119 #endif
120 NULL
121 };
122 #endif
123
124 #ifdef __APPLE__
125 static const char *macSystemFontPath = "/System/Library/Fonts";
126 #endif
127
128 struct Base14FontInfo {
129 Base14FontInfo(GString *fileNameA, int fontNumA, double obliqueA) {
130 fileName = fileNameA;
131 fontNum = fontNumA;
132 oblique = obliqueA;
133 }
134 ~Base14FontInfo() {
135 delete fileName;
136 }
137 GString *fileName;
138 int fontNum;
139 double oblique;
140 };
141
142 //------------------------------------------------------------------------
143
144 GlobalParams *globalParams = NULL;
145
146 const char *GlobalParams::defaultTextEncoding = "Latin1";
147
148 //------------------------------------------------------------------------
149 // PSFontParam16
150 //------------------------------------------------------------------------
151
152 PSFontParam16::PSFontParam16(GString *nameA, int wModeA,
153 GString *psFontNameA, GString *encodingA) {
154 name = nameA;
155 wMode = wModeA;
156 psFontName = psFontNameA;
157 encoding = encodingA;
158 }
159
160 PSFontParam16::~PSFontParam16() {
161 delete name;
162 delete psFontName;
163 delete encoding;
164 }
165
166 //------------------------------------------------------------------------
167 // SysFontInfo
168 //------------------------------------------------------------------------
169
170 class SysFontInfo {
171 public:
172
173 GString *name;
174 GString *path;
175 SysFontType type;
176 int fontNum; // for TrueType collections
177
178 SysFontInfo(GString *nameA, GString *pathA, SysFontType typeA, int fontNumA);
179 ~SysFontInfo();
180 GString *mungeName1(GString *in);
181 GString *mungeName2(GString *in);
182 void mungeName3(GString *name, GBool *bold, GBool *italic);
183 int match(GString *nameA);
184 };
185
186 SysFontInfo::SysFontInfo(GString *nameA, GString *pathA,
187 SysFontType typeA, int fontNumA) {
188 name = nameA;
189 path = pathA;
190 type = typeA;
191 fontNum = fontNumA;
192 }
193
194 SysFontInfo::~SysFontInfo() {
195 delete name;
196 delete path;
197 }
198
199 // Remove space/comma/dash/underscore chars.
200 // Uppercase the name.
201 GString *SysFontInfo::mungeName1(GString *in) {
202 GString *out = new GString();
203 for (char *p = in->getCString(); *p; ++p) {
204 if (*p == ' ' || *p == ',' || *p == '-' || *p == '_') {
205 // skip
206 } else if (*p >= 'a' && *p <= 'z') {
207 out->append((char)(*p & 0xdf));
208 } else {
209 out->append(*p);
210 }
211 }
212 return out;
213 }
214
215 // Remove trailing encoding tags from the name.
216 // Split the name into tokens at space/comma/dash/underscore.
217 // Remove trailing "MT" or "BT" from tokens.
218 // Remove trailing "PS" and "WGL4" from tokens.
219 // Uppercase each token.
220 // Concatenate tokens (dropping the space/comma/dash chars).
221 GString *SysFontInfo::mungeName2(GString *in) {
222 GString *out = new GString();
223 char *p0 = in->getCString();
224 while (*p0) {
225 if (!strcmp(p0, "Identity-H") || !strcmp(p0, "Identity-V") ||
226 !strcmp(p0, "GB2312") ||
227 !strcmp(p0, "UniGB-UCS2-H") || !strcmp(p0, "UniGB-UCS2-V")) {
228 break;
229 }
230 char *p1;
231 for (p1 = p0 + 1;
232 *p1 && *p1 != ' ' && *p1 != ',' && *p1 != '-' && *p1 != '_';
233 ++p1) ;
234 char *p2 = p1;
235 if (p2 - p0 >= 2 && (p2[-2] == 'B' || p2[-2] == 'M') && p2[-1] == 'T') {
236 p2 -= 2;
237 }
238 if (p2 - p0 >= 2 && p2[-2] == 'P' && p2[-1] == 'S') {
239 p2 -= 2;
240 }
241 if (p2 - p0 >= 4 &&
242 p2[-4] == 'W' && p2[-3] == 'G' && p2[-2] == 'L' && p2[-1] == '4') {
243 p2 -= 4;
244 }
245 for (; p0 < p2; ++p0) {
246 if (*p0 >= 'a' && *p0 <= 'z') {
247 out->append((char)(*p0 & 0xdf));
248 } else {
249 out->append(*p0);
250 }
251 }
252 for (p0 = p1; *p0 == ' ' || *p0 == ',' || *p0 == '-' || *p0 == '_'; ++p0) ;
253 }
254 return out;
255 }
256
257 // Remove trailing bold/italic/regular/roman tags from the name.
258 // (Note: the names have already been uppercased by mungeName1/2.)
259 void SysFontInfo::mungeName3(GString *name, GBool *bold, GBool *italic) {
260 *bold = gFalse;
261 *italic = gFalse;
262 int n = name->getLength();
263 while (1) {
264 if (n >= 4 && !strcmp(name->getCString() + n - 4, "BOLD")) {
265 name->del(n - 4, 4);
266 n -= 4;
267 *bold = gTrue;
268 } else if (n >= 6 && !strcmp(name->getCString() + n - 6, "ITALIC")) {
269 name->del(n - 6, 6);
270 n -= 6;
271 *italic = gTrue;
272 } else if (n >= 7 && !strcmp(name->getCString() + n - 7, "REGULAR")) {
273 name->del(n - 7, 7);
274 n -= 7;
275 } else if (n >= 5 && !strcmp(name->getCString() + n - 5, "ROMAN")) {
276 name->del(n - 5, 5);
277 n -= 5;
278 } else {
279 break;
280 }
281 }
282 }
283
284 // Returns a score indicating how well this font matches [nameA]. A
285 // higher score is better. Zero indicates a non-match.
286 int SysFontInfo::match(GString *nameA) {
287 // fast fail: check if the first two letters match
288 if (strncasecmp(name->getCString(), nameA->getCString(), 2)) {
289 return 0;
290 }
291
292 GString *pdfName1 = mungeName1(nameA);
293 GString *sysName1 = mungeName1(name);
294 if (!pdfName1->cmp(sysName1)) {
295 delete pdfName1;
296 delete sysName1;
297 return 8;
298 }
299
300 GString *pdfName2 = mungeName2(nameA);
301 GString *sysName2 = mungeName2(name);
302 if (!pdfName2->cmp(sysName2)) {
303 delete pdfName1;
304 delete sysName1;
305 delete pdfName2;
306 delete sysName2;
307 return 7;
308 }
309
310 GBool pdfBold1, pdfItalic1, sysBold1, sysItalic1;
311 mungeName3(pdfName1, &pdfBold1, &pdfItalic1);
312 mungeName3(sysName1, &sysBold1, &sysItalic1);
313 int eq1 = !pdfName1->cmp(sysName1);
314
315 GBool pdfBold2, pdfItalic2, sysBold2, sysItalic2;
316 mungeName3(pdfName2, &pdfBold2, &pdfItalic2);
317 mungeName3(sysName2, &sysBold2, &sysItalic2);
318 int eq2 =!pdfName2->cmp(sysName2);
319
320 delete pdfName1;
321 delete sysName1;
322 delete pdfName2;
323 delete sysName2;
324
325 if (eq1 && pdfBold1 == sysBold1 && pdfItalic1 == sysItalic1) {
326 return 6;
327 }
328 if (eq2 && pdfBold2 == sysBold2 && pdfItalic2 == sysItalic2) {
329 return 5;
330 }
331 if (eq1 && pdfItalic1 == sysItalic1) {
332 return 4;
333 }
334 if (eq2 && pdfItalic2 == sysItalic2) {
335 return 3;
336 }
337 if (eq1) {
338 return 2;
339 }
340 if (eq2) {
341 return 1;
342 }
343
344 return 0;
345 }
346
347 //------------------------------------------------------------------------
348 // SysFontList
349 //------------------------------------------------------------------------
350
351 class SysFontList {
352 public:
353
354 SysFontList();
355 ~SysFontList();
356 SysFontInfo *find(GString *name);
357
358 #ifdef _WIN32
359 void scanWindowsFonts(char *winFontDir);
360 #endif
361
362 #if HAVE_FONTCONFIG
363 void scanFontconfigFonts();
364 #endif
365
366 private:
367
368 #ifdef _WIN32
369 SysFontInfo *makeWindowsFont(char *name, int fontNum,
370 char *path);
371 #endif
372
373 GList *fonts; // [SysFontInfo]
374 };
375
376 SysFontList::SysFontList() {
377 fonts = new GList();
378 }
379
380 SysFontList::~SysFontList() {
381 deleteGList(fonts, SysFontInfo);
382 }
383
384 SysFontInfo *SysFontList::find(GString *name) {
385 SysFontInfo *match = NULL;
386 int score = 0;
387 for (int i = 0; i < fonts->getLength(); ++i) {
388 SysFontInfo *fi = (SysFontInfo *)fonts->get(i);
389 int s = fi->match(name);
390 if (s > score) {
391 match = fi;
392 score = s;
393 }
394 }
395 return match;
396 }
397
398 #ifdef _WIN32
399 void SysFontList::scanWindowsFonts(char *winFontDir) {
400 OSVERSIONINFO version;
401 const char *path;
402 DWORD idx, valNameLen, dataLen, type;
403 HKEY regKey;
404 char valName[1024], data[1024];
405 int n, fontNum;
406 char *p0, *p1;
407 GString *fontPath;
408
409 version.dwOSVersionInfoSize = sizeof(version);
410 GetVersionEx(&version);
411 if (version.dwPlatformId == VER_PLATFORM_WIN32_NT) {
412 path = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts\\";
413 } else {
414 path = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Fonts\\";
415 }
416 if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, path, 0,
417 KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS,
418 ®Key) == ERROR_SUCCESS) {
419 idx = 0;
420 while (1) {
421 valNameLen = sizeof(valName) - 1;
422 dataLen = sizeof(data) - 1;
423 if (RegEnumValueA(regKey, idx, valName, &valNameLen, NULL,
424 &type, (LPBYTE)data, &dataLen) != ERROR_SUCCESS) {
425 break;
426 }
427 if (type == REG_SZ &&
428 valNameLen > 0 && valNameLen < sizeof(valName) &&
429 dataLen > 0 && dataLen < sizeof(data)) {
430 valName[valNameLen] = '\0';
431 data[dataLen] = '\0';
432 n = (int)strlen(data);
433 if (!strcasecmp(data + n - 4, ".ttf") ||
434 !strcasecmp(data + n - 4, ".ttc") ||
435 !strcasecmp(data + n - 4, ".otf")) {
436 fontPath = new GString(data);
437 if (!(dataLen >= 3 && data[1] == ':' && data[2] == '\\')) {
438 fontPath->insert(0, '\\');
439 fontPath->insert(0, winFontDir);
440 }
441 p0 = valName;
442 fontNum = 0;
443 while (*p0) {
444 p1 = strstr(p0, " & ");
445 if (p1) {
446 *p1 = '\0';
447 p1 = p1 + 3;
448 } else {
449 p1 = p0 + strlen(p0);
450 }
451 fonts->append(makeWindowsFont(p0, fontNum,
452 fontPath->getCString()));
453 p0 = p1;
454 ++fontNum;
455 }
456 delete fontPath;
457 }
458 }
459 ++idx;
460 }
461 RegCloseKey(regKey);
462 }
463 }
464
465 SysFontInfo *SysFontList::makeWindowsFont(char *name, int fontNum,
466 char *path) {
467 int n = (int)strlen(name);
468
469 // remove trailing ' (TrueType)' or ' (OpenType)'
470 if (n > 11 && (!strncmp(name + n - 11, " (TrueType)", 11) ||
471 !strncmp(name + n - 11, " (OpenType)", 11))) {
472 n -= 11;
473 }
474
475 SysFontType type;
476 if (!strcasecmp(path + strlen(path) - 4, ".ttc")) {
477 type = sysFontTTC;
478 } else if (!strcasecmp(path + strlen(path) - 4, ".otf")) {
479 type = sysFontOTF;
480 } else {
481 type = sysFontTTF;
482 }
483
484 return new SysFontInfo(new GString(name, n), new GString(path),
485 type, fontNum);
486 }
487 #endif // _WIN32
488
489 #if HAVE_FONTCONFIG
490 void SysFontList::scanFontconfigFonts() {
491 FcConfig *cfg;
492 FcPattern *pattern;
493 FcObjectSet *objSet;
494 FcFontSet *fontSet;
495 char *name, *file;
496 SysFontType type;
497 int fontNum, i, n;
498
499 if (!(cfg = FcInitLoadConfigAndFonts())) {
500 return;
501 }
502
503 pattern = FcPatternBuild(NULL,
504 FC_OUTLINE, FcTypeBool, FcTrue,
505 FC_SCALABLE, FcTypeBool, FcTrue,
506 NULL);
507 objSet = FcObjectSetBuild(FC_FULLNAME, FC_FILE, FC_INDEX, NULL);
508 fontSet = FcFontList(cfg, pattern, objSet);
509 FcPatternDestroy(pattern);
510 FcObjectSetDestroy(objSet);
511
512 if (fontSet) {
513 for (i = 0; i < fontSet->nfont; ++i) {
514
515 //--- font file, font type
516 if (FcPatternGetString(fontSet->fonts[i], FC_FILE, 0,
517 (FcChar8 **)&file)
518 != FcResultMatch) {
519 continue;
520 }
521 n = (int)strlen(file);
522 if (n > 4 && !strcasecmp(file + n - 4, ".pfa")) {
523 type = sysFontPFA;
524 } else if (n > 4 && !strcasecmp(file + n - 4, ".pfb")) {
525 type = sysFontPFB;
526 } else if (n > 4 && !strcasecmp(file + n - 4, ".ttf")) {
527 type = sysFontTTF;
528 } else if (n > 4 && !strcasecmp(file + n - 4, ".otf")) {
529 type = sysFontOTF;
530 } else {
531 continue;
532 }
533
534 //--- font number
535 if (FcPatternGetInteger(fontSet->fonts[i], FC_INDEX, 0, &fontNum)
536 != FcResultMatch) {
537 fontNum = 0;
538 }
539
540 //--- font name
541 if (FcPatternGetString(fontSet->fonts[i], FC_FULLNAME, 0,
542 (FcChar8 **)&name)
543 != FcResultMatch) {
544 continue;
545 }
546
547 fonts->append(new SysFontInfo(new GString(name), new GString(file),
548 type, fontNum));
549 }
550
551 FcFontSetDestroy(fontSet);
552 }
553
554 FcConfigDestroy(cfg);
555 }
556 #endif // HAVE_FONTCONFIG
557
558 //------------------------------------------------------------------------
559 // KeyBinding
560 //------------------------------------------------------------------------
561
562 KeyBinding::KeyBinding(int codeA, int modsA, int contextA, const char *cmd0) {
563 code = codeA;
564 mods = modsA;
565 context = contextA;
566 cmds = new GList();
567 cmds->append(new GString(cmd0));
568 }
569
570 KeyBinding::KeyBinding(int codeA, int modsA, int contextA,
571 const char *cmd0, const char *cmd1) {
572 code = codeA;
573 mods = modsA;
574 context = contextA;
575 cmds = new GList();
576 cmds->append(new GString(cmd0));
577 cmds->append(new GString(cmd1));
578 }
579
580 KeyBinding::KeyBinding(int codeA, int modsA, int contextA, GList *cmdsA) {
581 code = codeA;
582 mods = modsA;
583 context = contextA;
584 cmds = cmdsA;
585 }
586
587 KeyBinding::~KeyBinding() {
588 deleteGList(cmds, GString);
589 }
590
591 //------------------------------------------------------------------------
592 // PopupMenuCmd
593 //------------------------------------------------------------------------
594
595 PopupMenuCmd::PopupMenuCmd(GString *labelA, GList *cmdsA) {
596 label = labelA;
597 cmds = cmdsA;
598 }
599
600 PopupMenuCmd::~PopupMenuCmd() {
601 delete label;
602 deleteGList(cmds, GString);
603 }
604
605 //------------------------------------------------------------------------
606 // parsing
607 //------------------------------------------------------------------------
608
609 GlobalParams::GlobalParams(const char *cfgFileName) {
610 UnicodeMap *map;
611 GString *fileName;
612 FILE *f;
613 int i;
614
615 #if MULTITHREADED
616 gInitMutex(&mutex);
617 gInitMutex(&unicodeMapCacheMutex);
618 gInitMutex(&cMapCacheMutex);
619 #endif
620
621 #ifdef _WIN32
622 tlsWin32ErrorInfo = TlsAlloc();
623 #endif
624
625 initBuiltinFontTables();
626
627 // scan the encoding in reverse because we want the lowest-numbered
628 // index for each char name ('space' is encoded twice)
629 macRomanReverseMap = new NameToCharCode();
630 for (i = 255; i >= 0; --i) {
631 if (macRomanEncoding[i]) {
632 macRomanReverseMap->add(macRomanEncoding[i], (CharCode)i);
633 }
634 }
635
636 #ifdef _WIN32
637 // baseDir will be set by a call to setBaseDir
638 baseDir = new GString();
639 #else
640 baseDir = appendToPath(getHomeDir(), ".xpdf");
641 #endif
642 configFileVars = new GHash(gTrue);
643 setDataDirVar();
644 nameToUnicode = new NameToCharCode();
645 cidToUnicodes = new GHash(gTrue);
646 unicodeToUnicodes = new GHash(gTrue);
647 residentUnicodeMaps = new GHash();
648 unicodeMaps = new GHash(gTrue);
649 cMapDirs = new GHash(gTrue);
650 toUnicodeDirs = new GList();
651 unicodeRemapping = new UnicodeRemapping();
652 fontFiles = new GHash(gTrue);
653 fontDirs = new GList();
654 ccFontFiles = new GHash(gTrue);
655 base14SysFonts = new GHash(gTrue);
656 sysFonts = new SysFontList();
657 #if HAVE_PAPER_H
658 char *paperName;
659 const struct paper *paperType;
660 paperinit();
661 if ((paperName = systempapername())) {
662 paperType = paperinfo(paperName);
663 psPaperWidth = (int)paperpswidth(paperType);
664 psPaperHeight = (int)paperpsheight(paperType);
665 } else {
666 error(errConfig, -1, "No paper information available - using defaults");
667 psPaperWidth = defPaperWidth;
668 psPaperHeight = defPaperHeight;
669 }
670 paperdone();
671 #else
672 psPaperWidth = defPaperWidth;
673 psPaperHeight = defPaperHeight;
674 #endif
675 psImageableLLX = psImageableLLY = 0;
676 psImageableURX = psPaperWidth;
677 psImageableURY = psPaperHeight;
678 psCrop = gTrue;
679 psUseCropBoxAsPage = gFalse;
680 psExpandSmaller = gFalse;
681 psShrinkLarger = gTrue;
682 psCenter = gTrue;
683 psDuplex = gFalse;
684 psLevel = psLevel2;
685 psResidentFonts = new GHash(gTrue);
686 psResidentFonts16 = new GList();
687 psResidentFontsCC = new GList();
688 psEmbedType1 = gTrue;
689 psEmbedTrueType = gTrue;
690 psEmbedCIDPostScript = gTrue;
691 psEmbedCIDTrueType = gTrue;
692 psFontPassthrough = gFalse;
693 psPreload = gFalse;
694 psOPI = gFalse;
695 psASCIIHex = gFalse;
696 psLZW = gTrue;
697 psUncompressPreloadedImages = gFalse;
698 psMinLineWidth = 0;
699 psRasterResolution = 300;
700 psRasterMono = gFalse;
701 psRasterSliceSize = 20000000;
702 psAlwaysRasterize = gFalse;
703 psNeverRasterize = gFalse;
704 textEncoding = new GString(defaultTextEncoding);
705 #if defined(_WIN32)
706 textEOL = eolDOS;
707 #else
708 textEOL = eolUnix;
709 #endif
710 textPageBreaks = gTrue;
711 textKeepTinyChars = gTrue;
712 initialZoom = new GString("125");
713 defaultFitZoom = 0;
714 initialDisplayMode = new GString("continuous");
715 initialToolbarState = gTrue;
716 initialSidebarState = gTrue;
717 initialSidebarWidth = 0;
718 initialSelectMode = new GString("linear");
719 maxTileWidth = 1500;
720 maxTileHeight = 1500;
721 tileCacheSize = 10;
722 workerThreads = 1;
723 enableFreeType = gTrue;
724 disableFreeTypeHinting = gFalse;
725 antialias = gTrue;
726 vectorAntialias = gTrue;
727 imageMaskAntialias = gTrue;
728 antialiasPrinting = gFalse;
729 strokeAdjust = strokeAdjustNormal;
730 screenType = screenUnset;
731 screenSize = -1;
732 screenDotRadius = -1;
733 screenGamma = 1.0;
734 screenBlackThreshold = 0.0;
735 screenWhiteThreshold = 1.0;
736 minLineWidth = 0.0;
737 enablePathSimplification = gFalse;
738 drawAnnotations = gTrue;
739 drawFormFields = gTrue;
740 enableXFA = gTrue;
741 overprintPreview = gFalse;
742 paperColor = new GString("#ffffff");
743 matteColor = new GString("#808080");
744 fullScreenMatteColor = new GString("#000000");
745 selectionColor = new GString("#8080ff");
746 reverseVideoInvertImages = gFalse;
747 launchCommand = NULL;
748 movieCommand = NULL;
749 defaultPrinter = NULL;
750 mapNumericCharNames = gTrue;
751 mapUnknownCharNames = gFalse;
752 mapExtTrueTypeFontsViaUnicode = gTrue;
753 useTrueTypeUnicodeMapping = gFalse;
754 droppedFonts = new GHash(gTrue);
755 createDefaultKeyBindings();
756 popupMenuCmds = new GList();
757 tabStateFile = appendToPath(getHomeDir(), ".xpdf.tab-state");
758 savePageNumbers = gTrue;
759 printCommands = gFalse;
760 printStatusInfo = gFalse;
761 errQuiet = gFalse;
762 debugLogFile = NULL;
763
764 cidToUnicodeCache = new CharCodeToUnicodeCache(cidToUnicodeCacheSize);
765 unicodeToUnicodeCache =
766 new CharCodeToUnicodeCache(unicodeToUnicodeCacheSize);
767 unicodeMapCache = new UnicodeMapCache();
768 cMapCache = new CMapCache();
769
770 // set up the initial nameToUnicode table
771 for (i = 0; nameToUnicodeTab[i].name; ++i) {
772 nameToUnicode->add(nameToUnicodeTab[i].name, nameToUnicodeTab[i].u);
773 }
774
775 // set up the residentUnicodeMaps table
776 map = new UnicodeMap("Latin1", gFalse,
777 latin1UnicodeMapRanges, latin1UnicodeMapLen);
778 residentUnicodeMaps->add(map->getEncodingName(), map);
779 map = new UnicodeMap("ASCII7", gFalse,
780 ascii7UnicodeMapRanges, ascii7UnicodeMapLen);
781 residentUnicodeMaps->add(map->getEncodingName(), map);
782 map = new UnicodeMap("Symbol", gFalse,
783 symbolUnicodeMapRanges, symbolUnicodeMapLen);
784 residentUnicodeMaps->add(map->getEncodingName(), map);
785 map = new UnicodeMap("ZapfDingbats", gFalse, zapfDingbatsUnicodeMapRanges,
786 zapfDingbatsUnicodeMapLen);
787 residentUnicodeMaps->add(map->getEncodingName(), map);
788 map = new UnicodeMap("UTF-8", gTrue, &mapUTF8);
789 residentUnicodeMaps->add(map->getEncodingName(), map);
790 map = new UnicodeMap("UCS-2", gTrue, &mapUCS2);
791 residentUnicodeMaps->add(map->getEncodingName(), map);
792
793 // look for a user config file, then a system-wide config file
794 f = NULL;
795 fileName = NULL;
796 if (cfgFileName && cfgFileName[0]) {
797 fileName = new GString(cfgFileName);
798 if (!(f = fopen(fileName->getCString(), "r"))) {
799 delete fileName;
800 }
801 }
802 if (!f) {
803 fileName = appendToPath(getHomeDir(), xpdfUserConfigFile);
804 if (!(f = fopen(fileName->getCString(), "r"))) {
805 delete fileName;
806 }
807 }
808 if (!f) {
809 #ifdef _WIN32
810 char buf[512];
811 i = GetModuleFileNameA(NULL, buf, sizeof(buf));
812 if (i <= 0 || i >= sizeof(buf)) {
813 // error or path too long for buffer - just use the current dir
814 buf[0] = '\0';
815 }
816 fileName = grabPath(buf);
817 appendToPath(fileName, xpdfSysConfigFile);
818 #else
819 fileName = new GString(xpdfSysConfigFile);
820 #endif
821 if (!(f = fopen(fileName->getCString(), "r"))) {
822 delete fileName;
823 }
824 }
825 if (f) {
826 parseFile(fileName, f);
827 delete fileName;
828 fclose(f);
829 }
830 }
831
832 void GlobalParams::setDataDirVar() {
833 GString *dir;
834
835 #if defined(XPDFRC_DATADIR)
836 dir = new GString(XPDFRC_DATADIR);
837 #elif defined(_WIN32)
838 wchar_t buf[512];
839 DWORD n = GetModuleFileNameW(NULL, buf, sizeof(buf) / sizeof(wchar_t));
840 if (n <= 0 || n >= sizeof(buf)) {
841 // error or path too long for buffer - just use the current dir
842 buf[0] = L'\0';
843 }
844 GString *path = fileNameToUTF8(buf);
845 dir = grabPath(path->getCString());
846 delete path;
847 appendToPath(dir, "data");
848 #else
849 //~ may be useful to allow the options of using the install dir
850 //~ and/or the user's home dir (?)
851 dir = new GString("./data");
852 #endif
853
854 configFileVars->add(new GString("DATADIR"), dir);
855 }
856
857 void GlobalParams::createDefaultKeyBindings() {
858 keyBindings = new GList();
859
860 //----- mouse buttons
861 keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress1, xpdfKeyModNone,
862 xpdfKeyContextAny, "startSelection"));
863 keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress1, xpdfKeyModShift,
864 xpdfKeyContextAny,
865 "startExtendedSelection"));
866 keyBindings->append(new KeyBinding(xpdfKeyCodeMouseRelease1, xpdfKeyModNone,
867 xpdfKeyContextAny, "endSelection"));
868 keyBindings->append(new KeyBinding(xpdfKeyCodeMouseRelease1, xpdfKeyModShift,
869 xpdfKeyContextAny,
870 "endSelection"));
871 keyBindings->append(new KeyBinding(xpdfKeyCodeMouseDoubleClick1,
872 xpdfKeyModNone, xpdfKeyContextAny,
873 "selectWord"));
874 keyBindings->append(new KeyBinding(xpdfKeyCodeMouseTripleClick1,
875 xpdfKeyModNone, xpdfKeyContextAny,
876 "selectLine"));
877 keyBindings->append(new KeyBinding(xpdfKeyCodeMouseClick1, xpdfKeyModNone,
878 xpdfKeyContextAny, "followLinkNoSel"));
879 keyBindings->append(new KeyBinding(xpdfKeyCodeMouseClick2, xpdfKeyModNone,
880 xpdfKeyContextOverLink,
881 "followLinkInNewTab"));
882 keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress2, xpdfKeyModNone,
883 xpdfKeyContextAny, "startPan"));
884 keyBindings->append(new KeyBinding(xpdfKeyCodeMouseRelease2, xpdfKeyModNone,
885 xpdfKeyContextAny, "endPan"));
886 keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress3, xpdfKeyModNone,
887 xpdfKeyContextAny, "postPopupMenu"));
888 keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress4, xpdfKeyModNone,
889 xpdfKeyContextAny,
890 "scrollUpPrevPage(16)"));
891 keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress5, xpdfKeyModNone,
892 xpdfKeyContextAny,
893 "scrollDownNextPage(16)"));
894 keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress6, xpdfKeyModNone,
895 xpdfKeyContextAny, "scrollLeft(16)"));
896 keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress7, xpdfKeyModNone,
897 xpdfKeyContextAny, "scrollRight(16)"));
898 keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress4, xpdfKeyModCtrl,
899 xpdfKeyContextAny, "zoomIn"));
900 keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress5, xpdfKeyModCtrl,
901 xpdfKeyContextAny, "zoomOut"));
902
903 //----- control keys
904 keyBindings->append(new KeyBinding('o', xpdfKeyModCtrl,
905 xpdfKeyContextAny, "open"));
906 keyBindings->append(new KeyBinding('r', xpdfKeyModCtrl,
907 xpdfKeyContextAny, "reload"));
908 keyBindings->append(new KeyBinding('f', xpdfKeyModCtrl,
909 xpdfKeyContextAny, "find"));
910 keyBindings->append(new KeyBinding('g', xpdfKeyModCtrl,
911 xpdfKeyContextAny, "findNext"));
912 keyBindings->append(new KeyBinding('c', xpdfKeyModCtrl,
913 xpdfKeyContextAny, "copy"));
914 keyBindings->append(new KeyBinding('p', xpdfKeyModCtrl,
915 xpdfKeyContextAny, "print"));
916 keyBindings->append(new KeyBinding('0', xpdfKeyModCtrl,
917 xpdfKeyContextAny, "zoomPercent(125)"));
918 keyBindings->append(new KeyBinding('+', xpdfKeyModCtrl,
919 xpdfKeyContextAny, "zoomIn"));
920 keyBindings->append(new KeyBinding('=', xpdfKeyModCtrl,
921 xpdfKeyContextAny, "zoomIn"));
922 keyBindings->append(new KeyBinding('-', xpdfKeyModCtrl,
923 xpdfKeyContextAny, "zoomOut"));
924 keyBindings->append(new KeyBinding('s', xpdfKeyModCtrl,
925 xpdfKeyContextAny, "saveAs"));
926 keyBindings->append(new KeyBinding('t', xpdfKeyModCtrl,
927 xpdfKeyContextAny, "newTab"));
928 keyBindings->append(new KeyBinding('n', xpdfKeyModCtrl,
929 xpdfKeyContextAny, "newWindow"));
930 keyBindings->append(new KeyBinding('w', xpdfKeyModCtrl,
931 xpdfKeyContextAny, "closeTabOrQuit"));
932 keyBindings->append(new KeyBinding('l', xpdfKeyModCtrl,
933 xpdfKeyContextAny,
934 "toggleFullScreenMode"));
935 keyBindings->append(new KeyBinding('q', xpdfKeyModCtrl,
936 xpdfKeyContextAny, "quit"));
937 keyBindings->append(new KeyBinding(xpdfKeyCodeTab, xpdfKeyModCtrl,
938 xpdfKeyContextAny, "nextTab"));
939 keyBindings->append(new KeyBinding(xpdfKeyCodeTab,
940 xpdfKeyModShift | xpdfKeyModCtrl,
941 xpdfKeyContextAny, "prevTab"));
942 keyBindings->append(new KeyBinding('?', xpdfKeyModCtrl,
943 xpdfKeyContextAny, "help"));
944
945 //----- alt keys
946 keyBindings->append(new KeyBinding(xpdfKeyCodeLeft, xpdfKeyModAlt,
947 xpdfKeyContextAny, "goBackward"));
948 keyBindings->append(new KeyBinding(xpdfKeyCodeRight, xpdfKeyModAlt,
949 xpdfKeyContextAny, "goForward"));
950
951 //----- home/end keys
952 keyBindings->append(new KeyBinding(xpdfKeyCodeHome, xpdfKeyModCtrl,
953 xpdfKeyContextAny, "gotoPage(1)"));
954 keyBindings->append(new KeyBinding(xpdfKeyCodeHome, xpdfKeyModNone,
955 xpdfKeyContextAny, "scrollToTopLeft"));
956 keyBindings->append(new KeyBinding(xpdfKeyCodeEnd, xpdfKeyModCtrl,
957 xpdfKeyContextAny, "gotoLastPage"));
958 keyBindings->append(new KeyBinding(xpdfKeyCodeEnd, xpdfKeyModNone,
959 xpdfKeyContextAny,
960 "scrollToBottomRight"));
961
962 //----- pgup/pgdn keys
963 keyBindings->append(new KeyBinding(xpdfKeyCodePgUp, xpdfKeyModNone,
964 xpdfKeyContextAny, "pageUp"));
965 keyBindings->append(new KeyBinding(xpdfKeyCodePgDn, xpdfKeyModNone,
966 xpdfKeyContextAny, "pageDown"));
967 keyBindings->append(new KeyBinding(xpdfKeyCodePgUp, xpdfKeyModCtrl,
968 xpdfKeyContextAny, "prevPage"));
969 keyBindings->append(new KeyBinding(xpdfKeyCodePgDn, xpdfKeyModCtrl,
970 xpdfKeyContextAny, "nextPage"));
971 keyBindings->append(new KeyBinding(xpdfKeyCodePgUp, xpdfKeyModCtrl,
972 xpdfKeyContextScrLockOn,
973 "prevPageNoScroll"));
974 keyBindings->append(new KeyBinding(xpdfKeyCodePgDn, xpdfKeyModCtrl,
975 xpdfKeyContextScrLockOn,
976 "nextPageNoScroll"));
977
978 //----- esc key
979 keyBindings->append(new KeyBinding(xpdfKeyCodeEsc, xpdfKeyModNone,
980 xpdfKeyContextFullScreen,
981 "windowMode"));
982
983 //----- arrow keys
984 keyBindings->append(new KeyBinding(xpdfKeyCodeLeft, xpdfKeyModNone,
985 xpdfKeyContextAny, "scrollLeft(16)"));
986 keyBindings->append(new KeyBinding(xpdfKeyCodeRight, xpdfKeyModNone,
987 xpdfKeyContextAny, "scrollRight(16)"));
988 keyBindings->append(new KeyBinding(xpdfKeyCodeUp, xpdfKeyModNone,
989 xpdfKeyContextAny, "scrollUp(16)"));
990 keyBindings->append(new KeyBinding(xpdfKeyCodeDown, xpdfKeyModNone,
991 xpdfKeyContextAny, "scrollDown(16)"));
992 keyBindings->append(new KeyBinding(xpdfKeyCodeUp, xpdfKeyModCtrl,
993 xpdfKeyContextAny, "prevPage"));
994 keyBindings->append(new KeyBinding(xpdfKeyCodeDown, xpdfKeyModCtrl,
995 xpdfKeyContextAny, "nextPage"));
996 keyBindings->append(new KeyBinding(xpdfKeyCodeUp, xpdfKeyModCtrl,
997 xpdfKeyContextScrLockOn,
998 "prevPageNoScroll"));
999 keyBindings->append(new KeyBinding(xpdfKeyCodeDown, xpdfKeyModCtrl,
1000 xpdfKeyContextScrLockOn,
1001 "nextPageNoScroll"));
1002
1003 //----- letter keys
1004 keyBindings->append(new KeyBinding(' ', xpdfKeyModNone,
1005 xpdfKeyContextAny, "pageDown"));
1006 keyBindings->append(new KeyBinding('g', xpdfKeyModNone,
1007 xpdfKeyContextAny, "focusToPageNum"));
1008 keyBindings->append(new KeyBinding('z', xpdfKeyModNone,
1009 xpdfKeyContextAny, "zoomFitPage"));
1010 keyBindings->append(new KeyBinding('w', xpdfKeyModNone,
1011 xpdfKeyContextAny, "zoomFitWidth"));
1012 }
1013
1014 void GlobalParams::parseFile(GString *fileName, FILE *f) {
1015 int line;
1016 char buf[512];
1017
1018 line = 1;
1019 while (getLine(buf, sizeof(buf) - 1, f)) {
1020 parseLine(buf, fileName, line);
1021 ++line;
1022 }
1023 }
1024
1025 void GlobalParams::parseLine(char *buf, GString *fileName, int line) {
1026 GList *tokens;
1027 GString *cmd, *incFile;
1028 FILE *f2;
1029
1030 // break the line into tokens
1031 tokens = parseLineTokens(buf, fileName, line);
1032
1033 // parse the line
1034 if (tokens->getLength() > 0 &&
1035 ((GString *)tokens->get(0))->getChar(0) != '#') {
1036 cmd = (GString *)tokens->get(0);
1037 if (!cmd->cmp("include")) {
1038 if (tokens->getLength() == 2) {
1039 incFile = (GString *)tokens->get(1);
1040 if ((f2 = openFile(incFile->getCString(), "r"))) {
1041 parseFile(incFile, f2);
1042 fclose(f2);
1043 } else {
1044 error(errConfig, -1,
1045 "Couldn't find included config file: '{0:t}' ({1:t}:{2:d})",
1046 incFile, fileName, line);
1047 }
1048 } else {
1049 error(errConfig, -1, "Bad 'include' config file command ({0:t}:{1:d})",
1050 fileName, line);
1051 }
1052 } else if (!cmd->cmp("nameToUnicode")) {
1053 parseNameToUnicode(tokens, fileName, line);
1054 } else if (!cmd->cmp("cidToUnicode")) {
1055 parseCIDToUnicode(tokens, fileName, line);
1056 } else if (!cmd->cmp("unicodeToUnicode")) {
1057 parseUnicodeToUnicode(tokens, fileName, line);
1058 } else if (!cmd->cmp("unicodeMap")) {
1059 parseUnicodeMap(tokens, fileName, line);
1060 } else if (!cmd->cmp("cMapDir")) {
1061 parseCMapDir(tokens, fileName, line);
1062 } else if (!cmd->cmp("toUnicodeDir")) {
1063 parseToUnicodeDir(tokens, fileName, line);
1064 } else if (!cmd->cmp("unicodeRemapping")) {
1065 parseUnicodeRemapping(tokens, fileName, line);
1066 } else if (!cmd->cmp("fontFile")) {
1067 parseFontFile(tokens, fileName, line);
1068 } else if (!cmd->cmp("fontDir")) {
1069 parseFontDir(tokens, fileName, line);
1070 } else if (!cmd->cmp("fontFileCC")) {
1071 parseFontFileCC(tokens, fileName, line);
1072 } else if (!cmd->cmp("psPaperSize")) {
1073 parsePSPaperSize(tokens, fileName, line);
1074 } else if (!cmd->cmp("psImageableArea")) {
1075 parsePSImageableArea(tokens, fileName, line);
1076 } else if (!cmd->cmp("psCrop")) {
1077 parseYesNo("psCrop", &psCrop, tokens, fileName, line);
1078 } else if (!cmd->cmp("psUseCropBoxAsPage")) {
1079 parseYesNo("psUseCropBoxAsPage", &psUseCropBoxAsPage,
1080 tokens, fileName, line);
1081 } else if (!cmd->cmp("psExpandSmaller")) {
1082 parseYesNo("psExpandSmaller", &psExpandSmaller,
1083 tokens, fileName, line);
1084 } else if (!cmd->cmp("psShrinkLarger")) {
1085 parseYesNo("psShrinkLarger", &psShrinkLarger, tokens, fileName, line);
1086 } else if (!cmd->cmp("psCenter")) {
1087 parseYesNo("psCenter", &psCenter, tokens, fileName, line);
1088 } else if (!cmd->cmp("psDuplex")) {
1089 parseYesNo("psDuplex", &psDuplex, tokens, fileName, line);
1090 } else if (!cmd->cmp("psLevel")) {
1091 parsePSLevel(tokens, fileName, line);
1092 } else if (!cmd->cmp("psResidentFont")) {
1093 parsePSResidentFont(tokens, fileName, line);
1094 } else if (!cmd->cmp("psResidentFont16")) {
1095 parsePSResidentFont16(tokens, fileName, line);
1096 } else if (!cmd->cmp("psResidentFontCC")) {
1097 parsePSResidentFontCC(tokens, fileName, line);
1098 } else if (!cmd->cmp("psEmbedType1Fonts")) {
1099 parseYesNo("psEmbedType1", &psEmbedType1, tokens, fileName, line);
1100 } else if (!cmd->cmp("psEmbedTrueTypeFonts")) {
1101 parseYesNo("psEmbedTrueType", &psEmbedTrueType,
1102 tokens, fileName, line);
1103 } else if (!cmd->cmp("psEmbedCIDPostScriptFonts")) {
1104 parseYesNo("psEmbedCIDPostScript", &psEmbedCIDPostScript,
1105 tokens, fileName, line);
1106 } else if (!cmd->cmp("psEmbedCIDTrueTypeFonts")) {
1107 parseYesNo("psEmbedCIDTrueType", &psEmbedCIDTrueType,
1108 tokens, fileName, line);
1109 } else if (!cmd->cmp("psFontPassthrough")) {
1110 parseYesNo("psFontPassthrough", &psFontPassthrough,
1111 tokens, fileName, line);
1112 } else if (!cmd->cmp("psPreload")) {
1113 parseYesNo("psPreload", &psPreload, tokens, fileName, line);
1114 } else if (!cmd->cmp("psOPI")) {
1115 parseYesNo("psOPI", &psOPI, tokens, fileName, line);
1116 } else if (!cmd->cmp("psASCIIHex")) {
1117 parseYesNo("psASCIIHex", &psASCIIHex, tokens, fileName, line);
1118 } else if (!cmd->cmp("psLZW")) {
1119 parseYesNo("psLZW", &psLZW, tokens, fileName, line);
1120 } else if (!cmd->cmp("psUncompressPreloadedImages")) {
1121 parseYesNo("psUncompressPreloadedImages", &psUncompressPreloadedImages,
1122 tokens, fileName, line);
1123 } else if (!cmd->cmp("psMinLineWidth")) {
1124 parseFloat("psMinLineWidth", &psMinLineWidth,
1125 tokens, fileName, line);
1126 } else if (!cmd->cmp("psRasterResolution")) {
1127 parseFloat("psRasterResolution", &psRasterResolution,
1128 tokens, fileName, line);
1129 } else if (!cmd->cmp("psRasterMono")) {
1130 parseYesNo("psRasterMono", &psRasterMono, tokens, fileName, line);
1131 } else if (!cmd->cmp("psRasterSliceSize")) {
1132 parseInteger("psRasterSliceSize", &psRasterSliceSize,
1133 tokens, fileName, line);
1134 } else if (!cmd->cmp("psAlwaysRasterize")) {
1135 parseYesNo("psAlwaysRasterize", &psAlwaysRasterize,
1136 tokens, fileName, line);
1137 } else if (!cmd->cmp("psNeverRasterize")) {
1138 parseYesNo("psNeverRasterize", &psNeverRasterize,
1139 tokens, fileName, line);
1140 } else if (!cmd->cmp("textEncoding")) {
1141 parseString("textEncoding", &textEncoding, tokens, fileName, line);
1142 } else if (!cmd->cmp("textEOL")) {
1143 parseTextEOL(tokens, fileName, line);
1144 } else if (!cmd->cmp("textPageBreaks")) {
1145 parseYesNo("textPageBreaks", &textPageBreaks,
1146 tokens, fileName, line);
1147 } else if (!cmd->cmp("textKeepTinyChars")) {
1148 parseYesNo("textKeepTinyChars", &textKeepTinyChars,
1149 tokens, fileName, line);
1150 } else if (!cmd->cmp("initialZoom")) {
1151 parseString("initialZoom", &initialZoom, tokens, fileName, line);
1152 } else if (!cmd->cmp("defaultFitZoom")) {
1153 parseInteger("defaultFitZoom", &defaultFitZoom, tokens, fileName, line);
1154 } else if (!cmd->cmp("initialDisplayMode")) {
1155 parseString("initialDisplayMode", &initialDisplayMode,
1156 tokens, fileName, line);
1157 } else if (!cmd->cmp("initialToolbarState")) {
1158 parseYesNo("initialToolbarState", &initialToolbarState,
1159 tokens, fileName, line);
1160 } else if (!cmd->cmp("initialSidebarState")) {
1161 parseYesNo("initialSidebarState", &initialSidebarState,
1162 tokens, fileName, line);
1163 } else if (!cmd->cmp("initialSidebarWidth")) {
1164 parseInteger("initialSidebarWidth", &initialSidebarWidth,
1165 tokens, fileName, line);
1166 } else if (!cmd->cmp("initialSelectMode")) {
1167 parseString("initialSelectMode", &initialSelectMode,
1168 tokens, fileName, line);
1169 } else if (!cmd->cmp("maxTileWidth")) {
1170 parseInteger("maxTileWidth", &maxTileWidth, tokens, fileName, line);
1171 } else if (!cmd->cmp("maxTileHeight")) {
1172 parseInteger("maxTileHeight", &maxTileHeight, tokens, fileName, line);
1173 } else if (!cmd->cmp("tileCacheSize")) {
1174 parseInteger("tileCacheSize", &tileCacheSize, tokens, fileName, line);
1175 } else if (!cmd->cmp("workerThreads")) {
1176 parseInteger("workerThreads", &workerThreads, tokens, fileName, line);
1177 } else if (!cmd->cmp("enableFreeType")) {
1178 parseYesNo("enableFreeType", &enableFreeType, tokens, fileName, line);
1179 } else if (!cmd->cmp("disableFreeTypeHinting")) {
1180 parseYesNo("disableFreeTypeHinting", &disableFreeTypeHinting,
1181 tokens, fileName, line);
1182 } else if (!cmd->cmp("antialias")) {
1183 parseYesNo("antialias", &antialias, tokens, fileName, line);
1184 } else if (!cmd->cmp("vectorAntialias")) {
1185 parseYesNo("vectorAntialias", &vectorAntialias,
1186 tokens, fileName, line);
1187 } else if (!cmd->cmp("imageMaskAntialias")) {
1188 parseYesNo("imageMaskAntialias", &imageMaskAntialias,
1189 tokens, fileName, line);
1190 } else if (!cmd->cmp("antialiasPrinting")) {
1191 parseYesNo("antialiasPrinting", &antialiasPrinting,
1192 tokens, fileName, line);
1193 } else if (!cmd->cmp("strokeAdjust")) {
1194 parseStrokeAdjust(tokens, fileName, line);
1195 } else if (!cmd->cmp("screenType")) {
1196 parseScreenType(tokens, fileName, line);
1197 } else if (!cmd->cmp("screenSize")) {
1198 parseInteger("screenSize", &screenSize, tokens, fileName, line);
1199 } else if (!cmd->cmp("screenDotRadius")) {
1200 parseInteger("screenDotRadius", &screenDotRadius,
1201 tokens, fileName, line);
1202 } else if (!cmd->cmp("screenGamma")) {
1203 parseFloat("screenGamma", &screenGamma,
1204 tokens, fileName, line);
1205 } else if (!cmd->cmp("screenBlackThreshold")) {
1206 parseFloat("screenBlackThreshold", &screenBlackThreshold,
1207 tokens, fileName, line);
1208 } else if (!cmd->cmp("screenWhiteThreshold")) {
1209 parseFloat("screenWhiteThreshold", &screenWhiteThreshold,
1210 tokens, fileName, line);
1211 } else if (!cmd->cmp("minLineWidth")) {
1212 parseFloat("minLineWidth", &minLineWidth,
1213 tokens, fileName, line);
1214 } else if (!cmd->cmp("enablePathSimplification")) {
1215 parseYesNo("enablePathSimplification", &enablePathSimplification,
1216 tokens, fileName, line);
1217 } else if (!cmd->cmp("drawAnnotations")) {
1218 parseYesNo("drawAnnotations", &drawAnnotations,
1219 tokens, fileName, line);
1220 } else if (!cmd->cmp("drawFormFields")) {
1221 parseYesNo("drawFormFields", &drawFormFields,
1222 tokens, fileName, line);
1223 } else if (!cmd->cmp("enableXFA")) {
1224 parseYesNo("enableXFA", &enableXFA,
1225 tokens, fileName, line);
1226 } else if (!cmd->cmp("overprintPreview")) {
1227 parseYesNo("overprintPreview", &overprintPreview,
1228 tokens, fileName, line);
1229 } else if (!cmd->cmp("paperColor")) {
1230 parseString("paperColor", &paperColor, tokens, fileName, line);
1231 } else if (!cmd->cmp("matteColor")) {
1232 parseString("matteColor", &matteColor, tokens, fileName, line);
1233 } else if (!cmd->cmp("fullScreenMatteColor")) {
1234 parseString("fullScreenMatteColor", &fullScreenMatteColor,
1235 tokens, fileName, line);
1236 } else if (!cmd->cmp("selectionColor")) {
1237 parseString("selectionColor", &selectionColor, tokens, fileName, line);
1238 } else if (!cmd->cmp("reverseVideoInvertImages")) {
1239 parseYesNo("reverseVideoInvertImages", &reverseVideoInvertImages,
1240 tokens, fileName, line);
1241 } else if (!cmd->cmp("launchCommand")) {
1242 parseString("launchCommand", &launchCommand, tokens, fileName, line);
1243 } else if (!cmd->cmp("movieCommand")) {
1244 parseString("movieCommand", &movieCommand, tokens, fileName, line);
1245 } else if (!cmd->cmp("defaultPrinter")) {
1246 parseString("defaultPrinter", &defaultPrinter, tokens, fileName, line);
1247 } else if (!cmd->cmp("mapNumericCharNames")) {
1248 parseYesNo("mapNumericCharNames", &mapNumericCharNames,
1249 tokens, fileName, line);
1250 } else if (!cmd->cmp("mapUnknownCharNames")) {
1251 parseYesNo("mapUnknownCharNames", &mapUnknownCharNames,
1252 tokens, fileName, line);
1253 } else if (!cmd->cmp("mapExtTrueTypeFontsViaUnicode")) {
1254 parseYesNo("mapExtTrueTypeFontsViaUnicode",
1255 &mapExtTrueTypeFontsViaUnicode,
1256 tokens, fileName, line);
1257 } else if (!cmd->cmp("useTrueTypeUnicodeMapping")) {
1258 parseYesNo("useTrueTypeUnicodeMapping",
1259 &useTrueTypeUnicodeMapping,
1260 tokens, fileName, line);
1261 } else if (!cmd->cmp("dropFont")) {
1262 parseDropFont(tokens, fileName, line);
1263 } else if (!cmd->cmp("bind")) {
1264 parseBind(tokens, fileName, line);
1265 } else if (!cmd->cmp("unbind")) {
1266 parseUnbind(tokens, fileName, line);
1267 } else if (!cmd->cmp("popupMenuCmd")) {
1268 parsePopupMenuCmd(tokens, fileName, line);
1269 } else if (!cmd->cmp("tabStateFile")) {
1270 parseString("tabStateFile", &tabStateFile, tokens, fileName, line);
1271 } else if (!cmd->cmp("savePageNumbers")) {
1272 parseYesNo("savePageNumbers", &savePageNumbers, tokens, fileName, line);
1273 } else if (!cmd->cmp("printCommands")) {
1274 parseYesNo("printCommands", &printCommands, tokens, fileName, line);
1275 } else if (!cmd->cmp("printStatusInfo")) {
1276 parseYesNo("printStatusInfo", &printStatusInfo, tokens, fileName, line);
1277 } else if (!cmd->cmp("errQuiet")) {
1278 parseYesNo("errQuiet", &errQuiet, tokens, fileName, line);
1279 } else if (!cmd->cmp("debugLogFile")) {
1280 parseString("debugLogFile", &debugLogFile, tokens, fileName, line);
1281 } else {
1282 error(errConfig, -1, "Unknown config file command '{0:t}' ({1:t}:{2:d})",
1283 cmd, fileName, line);
1284 if (!cmd->cmp("displayFontX") ||
1285 !cmd->cmp("displayNamedCIDFontX") ||
1286 !cmd->cmp("displayCIDFontX")) {
1287 error(errConfig, -1, "Xpdf no longer supports X fonts");
1288 } else if (!cmd->cmp("enableT1lib")) {
1289 error(errConfig, -1, "Xpdf no longer uses t1lib");
1290 } else if (!cmd->cmp("t1libControl") || !cmd->cmp("freetypeControl")) {
1291 error(errConfig, -1,
1292 "The t1libControl and freetypeControl options have been replaced by the enableT1lib, enableFreeType, and antialias options");
1293 } else if (!cmd->cmp("fontpath") || !cmd->cmp("fontmap")) {
1294 error(errConfig, -1,
1295 "The config file format has changed since Xpdf 0.9x");
1296 }
1297 }
1298 }
1299
1300 deleteGList(tokens, GString);
1301 }
1302
1303 // Split a line into a sequence of tokens. Tokens are separated by
1304 // whitespace. Each token is one of:
1305 // - unquoted string, which can contain any char other than
1306 // whitespace, and which cannot start with a single quote, double
1307 // quote, or at-double-quote (xxxx)
1308 // - single-quoted string, which can contain any char other than the
1309 // single quote ('xxxx')
1310 // - double-quoted string, which can contain any char other than the
1311 // double quote ("xxxx")
1312 // - at-double-quoted string, which can contain variables and escape
1313 // chars (@"xxxx")
1314 // - variables look like ${name}
1315 // - special chars (${}") can be escaped with %, e.g.,
1316 // @"foo%"bar", @"foo%$bar", @"foo%%bar"
1317 GList *GlobalParams::parseLineTokens(char *buf, GString *fileName, int line) {
1318 GList *tokens = new GList();
1319 char *p1 = buf;
1320 while (*p1) {
1321 for (; *p1 && isspace(*p1); ++p1) ;
1322 if (!*p1) {
1323 break;
1324 }
1325 if (*p1 == '"' || *p1 == '\'') {
1326 char *p2;
1327 for (p2 = p1 + 1; *p2 && *p2 != *p1; ++p2) ;
1328 ++p1;
1329 tokens->append(new GString(p1, (int)(p2 - p1)));
1330 p1 = *p2 ? p2 + 1 : p2;
1331 } else if (*p1 == '@' && p1[1] == '"') {
1332 GString *token = new GString();
1333 char *p2 = p1 + 2;
1334 while (*p2 && *p2 != '"') {
1335 if (*p2 == '%' && p2[1]) {
1336 token->append(p2[1]);
1337 p2 += 2;
1338 } else if (*p2 == '$' && p2[1] == '{') {
1339 p2 += 2;
1340 char *p3;
1341 for (p3 = p2; *p3 && *p3 != '}'; ++p3) ;
1342 GString *varName = new GString(p2, (int)(p3 - p2));
1343 GString *varValue = (GString *)configFileVars->lookup(varName);
1344 if (varValue) {
1345 token->append(varValue);
1346 } else {
1347 error(errConfig, -1, "Unknown config file variable '%t'", varName);
1348 }
1349 delete varName;
1350 p2 = *p3 ? p3 + 1 : p3;
1351 } else {
1352 token->append(*p2);
1353 ++p2;
1354 }
1355 }
1356 tokens->append(token);
1357 p1 = *p2 ? p2 + 1 : p2;
1358 } else {
1359 char *p2;
1360 for (p2 = p1 + 1; *p2 && !isspace(*p2); ++p2) ;
1361 tokens->append(new GString(p1, (int)(p2 - p1)));
1362 p1 = p2;
1363 }
1364 }
1365 return tokens;
1366 }
1367
1368 void GlobalParams::parseNameToUnicode(GList *tokens, GString *fileName,
1369 int line) {
1370 GString *name;
1371 char *tok1, *tok2;
1372 FILE *f;
1373 char buf[256];
1374 int line2;
1375 Unicode u;
1376
1377 if (tokens->getLength() != 2) {
1378 error(errConfig, -1,
1379 "Bad 'nameToUnicode' config file command ({0:t}:{1:d})",
1380 fileName, line);
1381 return;
1382 }
1383 name = (GString *)tokens->get(1);
1384 if (!(f = openFile(name->getCString(), "r"))) {
1385 error(errConfig, -1, "Couldn't open 'nameToUnicode' file '{0:t}'", name);
1386 return;
1387 }
1388 line2 = 1;
1389 while (getLine(buf, sizeof(buf), f)) {
1390 tok1 = strtok(buf, " \t\r\n");
1391 tok2 = strtok(NULL, " \t\r\n");
1392 if (tok1 && tok2) {
1393 sscanf(tok1, "%x", &u);
1394 nameToUnicode->add(tok2, u);
1395 } else {
1396 error(errConfig, -1, "Bad line in 'nameToUnicode' file ({0:t}:{1:d})",
1397 name, line2);
1398 }
1399 ++line2;
1400 }
1401 fclose(f);
1402 }
1403
1404 void GlobalParams::parseCIDToUnicode(GList *tokens, GString *fileName,
1405 int line) {
1406 GString *collection, *name, *old;
1407
1408 if (tokens->getLength() != 3) {
1409 error(errConfig, -1,
1410 "Bad 'cidToUnicode' config file command ({0:t}:{1:d})",
1411 fileName, line);
1412 return;
1413 }
1414 collection = (GString *)tokens->get(1);
1415 name = (GString *)tokens->get(2);
1416 if ((old = (GString *)cidToUnicodes->remove(collection))) {
1417 delete old;
1418 }
1419 cidToUnicodes->add(collection->copy(), name->copy());
1420 }
1421
1422 void GlobalParams::parseUnicodeToUnicode(GList *tokens, GString *fileName,
1423 int line) {
1424 GString *font, *file, *old;
1425
1426 if (tokens->getLength() != 3) {
1427 error(errConfig, -1,
1428 "Bad 'unicodeToUnicode' config file command ({0:t}:{1:d})",
1429 fileName, line);
1430 return;
1431 }
1432 font = (GString *)tokens->get(1);
1433 file = (GString *)tokens->get(2);
1434 if ((old = (GString *)unicodeToUnicodes->remove(font))) {
1435 delete old;
1436 }
1437 unicodeToUnicodes->add(font->copy(), file->copy());
1438 }
1439
1440 void GlobalParams::parseUnicodeMap(GList *tokens, GString *fileName,
1441 int line) {
1442 GString *encodingName, *name, *old;
1443
1444 if (tokens->getLength() != 3) {
1445 error(errConfig, -1, "Bad 'unicodeMap' config file command ({0:t}:{1:d})",
1446 fileName, line);
1447 return;
1448 }
1449 encodingName = (GString *)tokens->get(1);
1450 name = (GString *)tokens->get(2);
1451 if ((old = (GString *)unicodeMaps->remove(encodingName))) {
1452 delete old;
1453 }
1454 unicodeMaps->add(encodingName->copy(), name->copy());
1455 }
1456
1457 void GlobalParams::parseCMapDir(GList *tokens, GString *fileName, int line) {
1458 GString *collection, *dir;
1459 GList *list;
1460
1461 if (tokens->getLength() != 3) {
1462 error(errConfig, -1, "Bad 'cMapDir' config file command ({0:t}:{1:d})",
1463 fileName, line);
1464 return;
1465 }
1466 collection = (GString *)tokens->get(1);
1467 dir = (GString *)tokens->get(2);
1468 if (!(list = (GList *)cMapDirs->lookup(collection))) {
1469 list = new GList();
1470 cMapDirs->add(collection->copy(), list);
1471 }
1472 list->append(dir->copy());
1473 }
1474
1475 void GlobalParams::parseToUnicodeDir(GList *tokens, GString *fileName,
1476 int line) {
1477 if (tokens->getLength() != 2) {
1478 error(errConfig, -1,
1479 "Bad 'toUnicodeDir' config file command ({0:t}:{1:d})",
1480 fileName, line);
1481 return;
1482 }
1483 toUnicodeDirs->append(((GString *)tokens->get(1))->copy());
1484 }
1485
1486 void GlobalParams::parseUnicodeRemapping(GList *tokens, GString *fileName,
1487 int line) {
1488 if (tokens->getLength() != 2) {
1489 error(errConfig, -1,
1490 "Bad 'unicodeRemapping' config file command ({0:t}:{1:d})",
1491 fileName, line);
1492 return;
1493 }
1494 unicodeRemapping->parseFile((GString *)tokens->get(1));
1495 }
1496
1497 void GlobalParams::parseFontFile(GList *tokens, GString *fileName, int line) {
1498 if (tokens->getLength() != 3) {
1499 error(errConfig, -1, "Bad 'fontFile' config file command ({0:t}:{1:d})",
1500 fileName, line);
1501 return;
1502 }
1503 fontFiles->add(((GString *)tokens->get(1))->copy(),
1504 ((GString *)tokens->get(2))->copy());
1505 }
1506
1507 void GlobalParams::parseFontDir(GList *tokens, GString *fileName, int line) {
1508 if (tokens->getLength() != 2) {
1509 error(errConfig, -1, "Bad 'fontDir' config file command ({0:t}:{1:d})",
1510 fileName, line);
1511 return;
1512 }
1513 fontDirs->append(((GString *)tokens->get(1))->copy());
1514 }
1515
1516 void GlobalParams::parseFontFileCC(GList *tokens, GString *fileName,
1517 int line) {
1518 if (tokens->getLength() != 3) {
1519 error(errConfig, -1, "Bad 'fontFileCC' config file command ({0:t}:{1:d})",
1520 fileName, line);
1521 return;
1522 }
1523 ccFontFiles->add(((GString *)tokens->get(1))->copy(),
1524 ((GString *)tokens->get(2))->copy());
1525 }
1526
1527 void GlobalParams::parsePSPaperSize(GList *tokens, GString *fileName,
1528 int line) {
1529 GString *tok;
1530
1531 if (tokens->getLength() == 2) {
1532 tok = (GString *)tokens->get(1);
1533 if (!setPSPaperSize(tok->getCString())) {
1534 error(errConfig, -1,
1535 "Bad 'psPaperSize' config file command ({0:s}:{1:d})",
1536 fileName, line);
1537 }
1538 } else if (tokens->getLength() == 3) {
1539 tok = (GString *)tokens->get(1);
1540 psPaperWidth = atoi(tok->getCString());
1541 tok = (GString *)tokens->get(2);
1542 psPaperHeight = atoi(tok->getCString());
1543 psImageableLLX = psImageableLLY = 0;
1544 psImageableURX = psPaperWidth;
1545 psImageableURY = psPaperHeight;
1546 } else {
1547 error(errConfig, -1, "Bad 'psPaperSize' config file command ({0:t}:{1:d})",
1548 fileName, line);
1549 }
1550 }
1551
1552 void GlobalParams::parsePSImageableArea(GList *tokens, GString *fileName,
1553 int line) {
1554 if (tokens->getLength() != 5) {
1555 error(errConfig, -1,
1556 "Bad 'psImageableArea' config file command ({0:t}:{1:d})",
1557 fileName, line);
1558 return;
1559 }
1560 psImageableLLX = atoi(((GString *)tokens->get(1))->getCString());
1561 psImageableLLY = atoi(((GString *)tokens->get(2))->getCString());
1562 psImageableURX = atoi(((GString *)tokens->get(3))->getCString());
1563 psImageableURY = atoi(((GString *)tokens->get(4))->getCString());
1564 }
1565
1566 void GlobalParams::parsePSLevel(GList *tokens, GString *fileName, int line) {
1567 GString *tok;
1568
1569 if (tokens->getLength() != 2) {
1570 error(errConfig, -1, "Bad 'psLevel' config file command ({0:t}:{1:d})",
1571 fileName, line);
1572 return;
1573 }
1574 tok = (GString *)tokens->get(1);
1575 if (!tok->cmp("level1")) {
1576 psLevel = psLevel1;
1577 } else if (!tok->cmp("level1sep")) {
1578 psLevel = psLevel1Sep;
1579 } else if (!tok->cmp("level2")) {
1580 psLevel = psLevel2;
1581 } else if (!tok->cmp("level2gray")) {
1582 psLevel = psLevel2Gray;
1583 } else if (!tok->cmp("level2sep")) {
1584 psLevel = psLevel2Sep;
1585 } else if (!tok->cmp("level3")) {
1586 psLevel = psLevel3;
1587 } else if (!tok->cmp("level3gray")) {
1588 psLevel = psLevel3Gray;
1589 } else if (!tok->cmp("level3Sep")) {
1590 psLevel = psLevel3Sep;
1591 } else {
1592 error(errConfig, -1, "Bad 'psLevel' config file command ({0:t}:{1:d})",
1593 fileName, line);
1594 }
1595 }
1596
1597 void GlobalParams::parsePSResidentFont(GList *tokens, GString *fileName,
1598 int line) {
1599 if (tokens->getLength() != 3) {
1600 error(errConfig, -1, "Bad 'psResidentFont' config file command ({0:t}:{1:d})",
1601 fileName, line);
1602 return;
1603 }
1604 psResidentFonts->add(((GString *)tokens->get(1))->copy(),
1605 ((GString *)tokens->get(2))->copy());
1606 }
1607
1608 void GlobalParams::parsePSResidentFont16(GList *tokens, GString *fileName,
1609 int line) {
1610 PSFontParam16 *param;
1611 int wMode;
1612 GString *tok;
1613
1614 if (tokens->getLength() != 5) {
1615 error(errConfig, -1, "Bad 'psResidentFont16' config file command ({0:t}:{1:d})",
1616 fileName, line);
1617 return;
1618 }
1619 tok = (GString *)tokens->get(2);
1620 if (!tok->cmp("H")) {
1621 wMode = 0;
1622 } else if (!tok->cmp("V")) {
1623 wMode = 1;
1624 } else {
1625 error(errConfig, -1, "Bad wMode in psResidentFont16 config file command ({1:t}:{2:d})",
1626 fileName, line);
1627 return;
1628 }
1629 param = new PSFontParam16(((GString *)tokens->get(1))->copy(),
1630 wMode,
1631 ((GString *)tokens->get(3))->copy(),
1632 ((GString *)tokens->get(4))->copy());
1633 psResidentFonts16->append(param);
1634 }
1635
1636 void GlobalParams::parsePSResidentFontCC(GList *tokens, GString *fileName,
1637 int line) {
1638 PSFontParam16 *param;
1639 int wMode;
1640 GString *tok;
1641
1642 if (tokens->getLength() != 5) {
1643 error(errConfig, -1, "Bad 'psResidentFontCC' config file command ({0:t}:{1:d})",
1644 fileName, line);
1645 return;
1646 }
1647 tok = (GString *)tokens->get(2);
1648 if (!tok->cmp("H")) {
1649 wMode = 0;
1650 } else if (!tok->cmp("V")) {
1651 wMode = 1;
1652 } else {
1653 error(errConfig, -1, "Bad wMode in psResidentFontCC config file command ({1:t}:{2:d})",
1654 fileName, line);
1655 return;
1656 }
1657 param = new PSFontParam16(((GString *)tokens->get(1))->copy(),
1658 wMode,
1659 ((GString *)tokens->get(3))->copy(),
1660 ((GString *)tokens->get(4))->copy());
1661 psResidentFontsCC->append(param);
1662 }
1663
1664 void GlobalParams::parseTextEOL(GList *tokens, GString *fileName, int line) {
1665 GString *tok;
1666
1667 if (tokens->getLength() != 2) {
1668 error(errConfig, -1, "Bad 'textEOL' config file command ({0:t}:{1:d})",
1669 fileName, line);
1670 return;
1671 }
1672 tok = (GString *)tokens->get(1);
1673 if (!tok->cmp("unix")) {
1674 textEOL = eolUnix;
1675 } else if (!tok->cmp("dos")) {
1676 textEOL = eolDOS;
1677 } else if (!tok->cmp("mac")) {
1678 textEOL = eolMac;
1679 } else {
1680 error(errConfig, -1, "Bad 'textEOL' config file command ({0:t}:{1:d})",
1681 fileName, line);
1682 }
1683 }
1684
1685 void GlobalParams::parseStrokeAdjust(GList *tokens, GString *fileName,
1686 int line) {
1687 GString *tok;
1688
1689 if (tokens->getLength() != 2) {
1690 error(errConfig, -1,
1691 "Bad 'strokeAdjust' config file command ({0:t}:{1:d})",
1692 fileName, line);
1693 return;
1694 }
1695 tok = (GString *)tokens->get(1);
1696 if (!tok->cmp("no")) {
1697 strokeAdjust = strokeAdjustOff;
1698 } else if (!tok->cmp("yes")) {
1699 strokeAdjust = strokeAdjustNormal;
1700 } else if (!tok->cmp("cad")) {
1701 strokeAdjust = strokeAdjustCAD;
1702 } else {
1703 error(errConfig, -1,
1704 "Bad 'strokeAdjust' config file command ({0:t}:{1:d})",
1705 fileName, line);
1706 }
1707 }
1708
1709 void GlobalParams::parseScreenType(GList *tokens, GString *fileName,
1710 int line) {
1711 GString *tok;
1712
1713 if (tokens->getLength() != 2) {
1714 error(errConfig, -1, "Bad 'screenType' config file command ({0:t}:{1:d})",
1715 fileName, line);
1716 return;
1717 }
1718 tok = (GString *)tokens->get(1);
1719 if (!tok->cmp("dispersed")) {
1720 screenType = screenDispersed;
1721 } else if (!tok->cmp("clustered")) {
1722 screenType = screenClustered;
1723 } else if (!tok->cmp("stochasticClustered")) {
1724 screenType = screenStochasticClustered;
1725 } else {
1726 error(errConfig, -1, "Bad 'screenType' config file command ({0:t}:{1:d})",
1727 fileName, line);
1728 }
1729 }
1730
1731 void GlobalParams::parseDropFont(GList *tokens, GString *fileName, int line) {
1732 if (tokens->getLength() != 2) {
1733 error(errConfig, -1, "Bad 'dropFont' config file command ({0:t}:{1:d})",
1734 fileName, line);
1735 return;
1736 }
1737 droppedFonts->add(((GString *)tokens->get(1))->copy(), 1);
1738 }
1739
1740 void GlobalParams::parseBind(GList *tokens, GString *fileName, int line) {
1741 KeyBinding *binding;
1742 GList *cmds;
1743 int code, mods, context, i;
1744
1745 if (tokens->getLength() < 4) {
1746 error(errConfig, -1, "Bad 'bind' config file command ({0:t}:{1:d})",
1747 fileName, line);
1748 return;
1749 }
1750 if (!parseKey((GString *)tokens->get(1), (GString *)tokens->get(2),
1751 &code, &mods, &context,
1752 "bind", tokens, fileName, line)) {
1753 return;
1754 }
1755 for (i = 0; i < keyBindings->getLength(); ++i) {
1756 binding = (KeyBinding *)keyBindings->get(i);
1757 if (binding->code == code &&
1758 binding->mods == mods &&
1759 binding->context == context) {
1760 delete (KeyBinding *)keyBindings->del(i);
1761 break;
1762 }
1763 }
1764 cmds = new GList();
1765 for (i = 3; i < tokens->getLength(); ++i) {
1766 cmds->append(((GString *)tokens->get(i))->copy());
1767 }
1768 keyBindings->append(new KeyBinding(code, mods, context, cmds));
1769 }
1770
1771 void GlobalParams::parseUnbind(GList *tokens, GString *fileName, int line) {
1772 KeyBinding *binding;
1773 int code, mods, context, i;
1774
1775 if (tokens->getLength() != 3) {
1776 error(errConfig, -1, "Bad 'unbind' config file command ({0:t}:{1:d})",
1777 fileName, line);
1778 return;
1779 }
1780 if (!parseKey((GString *)tokens->get(1), (GString *)tokens->get(2),
1781 &code, &mods, &context,
1782 "unbind", tokens, fileName, line)) {
1783 return;
1784 }
1785 for (i = 0; i < keyBindings->getLength(); ++i) {
1786 binding = (KeyBinding *)keyBindings->get(i);
1787 if (binding->code == code &&
1788 binding->mods == mods &&
1789 binding->context == context) {
1790 delete (KeyBinding *)keyBindings->del(i);
1791 break;
1792 }
1793 }
1794 }
1795
1796 GBool GlobalParams::parseKey(GString *modKeyStr, GString *contextStr,
1797 int *code, int *mods, int *context,
1798 const char *cmdName,
1799 GList *tokens, GString *fileName, int line) {
1800 char *p0;
1801 int btn;
1802
1803 *mods = xpdfKeyModNone;
1804 p0 = modKeyStr->getCString();
1805 while (1) {
1806 if (!strncmp(p0, "shift-", 6)) {
1807 *mods |= xpdfKeyModShift;
1808 p0 += 6;
1809 } else if (!strncmp(p0, "ctrl-", 5)) {
1810 *mods |= xpdfKeyModCtrl;
1811 p0 += 5;
1812 } else if (!strncmp(p0, "alt-", 4)) {
1813 *mods |= xpdfKeyModAlt;
1814 p0 += 4;
1815 } else {
1816 break;
1817 }
1818 }
1819
1820 if (!strcmp(p0, "space")) {
1821 *code = ' ';
1822 } else if (!strcmp(p0, "tab")) {
1823 *code = xpdfKeyCodeTab;
1824 } else if (!strcmp(p0, "return")) {
1825 *code = xpdfKeyCodeReturn;
1826 } else if (!strcmp(p0, "enter")) {
1827 *code = xpdfKeyCodeEnter;
1828 } else if (!strcmp(p0, "backspace")) {
1829 *code = xpdfKeyCodeBackspace;
1830 } else if (!strcmp(p0, "esc")) {
1831 *code = xpdfKeyCodeEsc;
1832 } else if (!strcmp(p0, "insert")) {
1833 *code = xpdfKeyCodeInsert;
1834 } else if (!strcmp(p0, "delete")) {
1835 *code = xpdfKeyCodeDelete;
1836 } else if (!strcmp(p0, "home")) {
1837 *code = xpdfKeyCodeHome;
1838 } else if (!strcmp(p0, "end")) {
1839 *code = xpdfKeyCodeEnd;
1840 } else if (!strcmp(p0, "pgup")) {
1841 *code = xpdfKeyCodePgUp;
1842 } else if (!strcmp(p0, "pgdn")) {
1843 *code = xpdfKeyCodePgDn;
1844 } else if (!strcmp(p0, "left")) {
1845 *code = xpdfKeyCodeLeft;
1846 } else if (!strcmp(p0, "right")) {
1847 *code = xpdfKeyCodeRight;
1848 } else if (!strcmp(p0, "up")) {
1849 *code = xpdfKeyCodeUp;
1850 } else if (!strcmp(p0, "down")) {
1851 *code = xpdfKeyCodeDown;
1852 } else if (p0[0] == 'f' && p0[1] >= '1' && p0[1] <= '9' && !p0[2]) {
1853 *code = xpdfKeyCodeF1 + (p0[1] - '1');
1854 } else if (p0[0] == 'f' &&
1855 ((p0[1] >= '1' && p0[1] <= '2' && p0[2] >= '0' && p0[2] <= '9') ||
1856 (p0[1] == '3' && p0[2] >= '0' && p0[2] <= '5')) &&
1857 !p0[3]) {
1858 *code = xpdfKeyCodeF1 + 10 * (p0[1] - '0') + (p0[2] - '0') - 1;
1859 } else if (!strncmp(p0, "mousePress", 10) &&
1860 p0[10] >= '0' && p0[10] <= '9' &&
1861 (!p0[11] || (p0[11] >= '0' && p0[11] <= '9' && !p0[12])) &&
1862 (btn = atoi(p0 + 10)) >= 1 && btn <= 32) {
1863 *code = xpdfKeyCodeMousePress1 + btn - 1;
1864 } else if (!strncmp(p0, "mouseRelease", 12) &&
1865 p0[12] >= '0' && p0[12] <= '9' &&
1866 (!p0[13] || (p0[13] >= '0' && p0[13] <= '9' && !p0[14])) &&
1867 (btn = atoi(p0 + 12)) >= 1 && btn <= 32) {
1868 *code = xpdfKeyCodeMouseRelease1 + btn - 1;
1869 } else if (!strncmp(p0, "mouseClick", 10) &&
1870 p0[10] >= '0' && p0[10] <= '9' &&
1871 (!p0[11] || (p0[11] >= '0' && p0[11] <= '9' && !p0[12])) &&
1872 (btn = atoi(p0 + 10)) >= 1 && btn <= 32) {
1873 *code = xpdfKeyCodeMouseClick1 + btn - 1;
1874 } else if (!strncmp(p0, "mouseDoubleClick", 16) &&
1875 p0[16] >= '0' && p0[16] <= '9' &&
1876 (!p0[17] || (p0[17] >= '0' && p0[17] <= '9' && !p0[18])) &&
1877 (btn = atoi(p0 + 16)) >= 1 && btn <= 32) {
1878 *code = xpdfKeyCodeMouseDoubleClick1 + btn - 1;
1879 } else if (!strncmp(p0, "mouseTripleClick", 16) &&
1880 p0[16] >= '0' && p0[16] <= '9' &&
1881 (!p0[17] || (p0[17] >= '0' && p0[17] <= '9' && !p0[18])) &&
1882 (btn = atoi(p0 + 16)) >= 1 && btn <= 32) {
1883 *code = xpdfKeyCodeMouseTripleClick1 + btn - 1;
1884 } else if (*p0 >= 0x20 && *p0 <= 0x7e && !p0[1]) {
1885 *code = (int)*p0;
1886 } else {
1887 error(errConfig, -1,
1888 "Bad key/modifier in '{0:s}' config file command ({1:t}:{2:d})",
1889 cmdName, fileName, line);
1890 return gFalse;
1891 }
1892
1893 p0 = contextStr->getCString();
1894 if (!strcmp(p0, "any")) {
1895 *context = xpdfKeyContextAny;
1896 } else {
1897 *context = xpdfKeyContextAny;
1898 while (1) {
1899 if (!strncmp(p0, "fullScreen", 10)) {
1900 *context |= xpdfKeyContextFullScreen;
1901 p0 += 10;
1902 } else if (!strncmp(p0, "window", 6)) {
1903 *context |= xpdfKeyContextWindow;
1904 p0 += 6;
1905 } else if (!strncmp(p0, "continuous", 10)) {
1906 *context |= xpdfKeyContextContinuous;
1907 p0 += 10;
1908 } else if (!strncmp(p0, "singlePage", 10)) {
1909 *context |= xpdfKeyContextSinglePage;
1910 p0 += 10;
1911 } else if (!strncmp(p0, "overLink", 8)) {
1912 *context |= xpdfKeyContextOverLink;
1913 p0 += 8;
1914 } else if (!strncmp(p0, "offLink", 7)) {
1915 *context |= xpdfKeyContextOffLink;
1916 p0 += 7;
1917 } else if (!strncmp(p0, "outline", 7)) {
1918 *context |= xpdfKeyContextOutline;
1919 p0 += 7;
1920 } else if (!strncmp(p0, "mainWin", 7)) {
1921 *context |= xpdfKeyContextMainWin;
1922 p0 += 7;
1923 } else if (!strncmp(p0, "scrLockOn", 9)) {
1924 *context |= xpdfKeyContextScrLockOn;
1925 p0 += 9;
1926 } else if (!strncmp(p0, "scrLockOff", 10)) {
1927 *context |= xpdfKeyContextScrLockOff;
1928 p0 += 10;
1929 } else {
1930 error(errConfig, -1,
1931 "Bad context in '{0:s}' config file command ({1:t}:{2:d})",
1932 cmdName, fileName, line);
1933 return gFalse;
1934 }
1935 if (!*p0) {
1936 break;
1937 }
1938 if (*p0 != ',') {
1939 error(errConfig, -1,
1940 "Bad context in '{0:s}' config file command ({1:t}:{2:d})",
1941 cmdName, fileName, line);
1942 return gFalse;
1943 }
1944 ++p0;
1945 }
1946 }
1947
1948 return gTrue;
1949 }
1950
1951 void GlobalParams::parsePopupMenuCmd(GList *tokens,
1952 GString *fileName, int line) {
1953 GList *cmds;
1954 int i;
1955
1956 if (tokens->getLength() < 3) {
1957 error(errConfig, -1,
1958 "Bad 'popupMenuCmd' config file command ({0:t}:{1:d})",
1959 fileName, line);
1960 return;
1961 }
1962 cmds = new GList();
1963 for (i = 2; i < tokens->getLength(); ++i) {
1964 cmds->append(((GString *)tokens->get(i))->copy());
1965 }
1966 popupMenuCmds->append(new PopupMenuCmd(((GString *)tokens->get(1))->copy(),
1967 cmds));
1968 }
1969
1970 void GlobalParams::parseYesNo(const char *cmdName, GBool *flag,
1971 GList *tokens, GString *fileName, int line) {
1972 GString *tok;
1973
1974 if (tokens->getLength() != 2) {
1975 error(errConfig, -1, "Bad '{0:s}' config file command ({1:t}:{2:d})",
1976 cmdName, fileName, line);
1977 return;
1978 }
1979 tok = (GString *)tokens->get(1);
1980 if (!parseYesNo2(tok->getCString(), flag)) {
1981 error(errConfig, -1, "Bad '{0:s}' config file command ({1:t}:{2:d})",
1982 cmdName, fileName, line);
1983 }
1984 }
1985
1986 GBool GlobalParams::parseYesNo2(char *token, GBool *flag) {
1987 if (!strcmp(token, "yes")) {
1988 *flag = gTrue;
1989 } else if (!strcmp(token, "no")) {
1990 *flag = gFalse;
1991 } else {
1992 return gFalse;
1993 }
1994 return gTrue;
1995 }
1996
1997 void GlobalParams::parseString(const char *cmdName, GString **s,
1998 GList *tokens, GString *fileName, int line) {
1999 if (tokens->getLength() != 2) {
2000 error(errConfig, -1, "Bad '{0:s}' config file command ({1:t}:{2:d})",
2001 cmdName, fileName, line);
2002 return;
2003 }
2004 if (*s) {
2005 delete *s;
2006 }
2007 *s = ((GString *)tokens->get(1))->copy();
2008 }
2009
2010 void GlobalParams::parseInteger(const char *cmdName, int *val,
2011 GList *tokens, GString *fileName, int line) {
2012 GString *tok;
2013 int i;
2014
2015 if (tokens->getLength() != 2) {
2016 error(errConfig, -1, "Bad '{0:s}' config file command ({1:t}:{2:d})",
2017 cmdName, fileName, line);
2018 return;
2019 }
2020 tok = (GString *)tokens->get(1);
2021 if (tok->getLength() == 0) {
2022 error(errConfig, -1, "Bad '{0:s}' config file command ({1:t}:{2:d})",
2023 cmdName, fileName, line);
2024 return;
2025 }
2026 if (tok->getChar(0) == '-') {
2027 i = 1;
2028 } else {
2029 i = 0;
2030 }
2031 for (; i < tok->getLength(); ++i) {
2032 if (tok->getChar(i) < '0' || tok->getChar(i) > '9') {
2033 error(errConfig, -1, "Bad '{0:s}' config file command ({1:t}:{2:d})",
2034 cmdName, fileName, line);
2035 return;
2036 }
2037 }
2038 *val = atoi(tok->getCString());
2039 }
2040
2041 void GlobalParams::parseFloat(const char *cmdName, double *val,
2042 GList *tokens, GString *fileName, int line) {
2043 GString *tok;
2044 int i;
2045
2046 if (tokens->getLength() != 2) {
2047 error(errConfig, -1, "Bad '{0:s}' config file command ({1:t}:{2:d})",
2048 cmdName, fileName, line);
2049 return;
2050 }
2051 tok = (GString *)tokens->get(1);
2052 if (tok->getLength() == 0) {
2053 error(errConfig, -1, "Bad '{0:s}' config file command ({1:t}:{2:d})",
2054 cmdName, fileName, line);
2055 return;
2056 }
2057 if (tok->getChar(0) == '-') {
2058 i = 1;
2059 } else {
2060 i = 0;
2061 }
2062 for (; i < tok->getLength(); ++i) {
2063 if (!((tok->getChar(i) >= '0' && tok->getChar(i) <= '9') ||
2064 tok->getChar(i) == '.')) {
2065 error(errConfig, -1, "Bad '{0:s}' config file command ({1:t}:{2:d})",
2066 cmdName, fileName, line);
2067 return;
2068 }
2069 }
2070 *val = atof(tok->getCString());
2071 }
2072
2073 GlobalParams::~GlobalParams() {
2074 GHashIter *iter;
2075 GString *key;
2076 GList *list;
2077
2078 freeBuiltinFontTables();
2079
2080 delete macRomanReverseMap;
2081
2082 delete baseDir;
2083 deleteGHash(configFileVars, GString);
2084 delete nameToUnicode;
2085 deleteGHash(cidToUnicodes, GString);
2086 deleteGHash(unicodeToUnicodes, GString);
2087 deleteGHash(residentUnicodeMaps, UnicodeMap);
2088 deleteGHash(unicodeMaps, GString);
2089 deleteGList(toUnicodeDirs, GString);
2090 delete unicodeRemapping;
2091 deleteGHash(fontFiles, GString);
2092 deleteGList(fontDirs, GString);
2093 deleteGHash(ccFontFiles, GString);
2094 deleteGHash(base14SysFonts, Base14FontInfo);
2095 delete sysFonts;
2096 deleteGHash(psResidentFonts, GString);
2097 deleteGList(psResidentFonts16, PSFontParam16);
2098 deleteGList(psResidentFontsCC, PSFontParam16);
2099 delete textEncoding;
2100 delete initialZoom;
2101 delete initialDisplayMode;
2102 delete initialSelectMode;
2103 if (paperColor) {
2104 delete paperColor;
2105 }
2106 if (matteColor) {
2107 delete matteColor;
2108 }
2109 if (fullScreenMatteColor) {
2110 delete fullScreenMatteColor;
2111 }
2112 if (selectionColor) {
2113 delete selectionColor;
2114 }
2115 if (launchCommand) {
2116 delete launchCommand;
2117 }
2118 if (movieCommand) {
2119 delete movieCommand;
2120 }
2121 if (defaultPrinter) {
2122 delete defaultPrinter;
2123 }
2124 delete droppedFonts;
2125 deleteGList(keyBindings, KeyBinding);
2126 deleteGList(popupMenuCmds, PopupMenuCmd);
2127 delete tabStateFile;
2128 delete debugLogFile;
2129
2130 cMapDirs->startIter(&iter);
2131 while (cMapDirs->getNext(&iter, &key, (void **)&list)) {
2132 deleteGList(list, GString);
2133 }
2134 delete cMapDirs;
2135
2136 delete cidToUnicodeCache;
2137 delete unicodeToUnicodeCache;
2138 delete unicodeMapCache;
2139 delete cMapCache;
2140
2141 #if MULTITHREADED
2142 gDestroyMutex(&mutex);
2143 gDestroyMutex(&unicodeMapCacheMutex);
2144 gDestroyMutex(&cMapCacheMutex);
2145 #endif
2146 }
2147
2148 //------------------------------------------------------------------------
2149
2150 void GlobalParams::setBaseDir(const char *dir) {
2151 delete baseDir;
2152 baseDir = new GString(dir);
2153 }
2154
2155 #ifdef _WIN32
2156 static void getWinFontDir(char *winFontDir) {
2157 HMODULE shell32Lib;
2158 BOOL (__stdcall *SHGetSpecialFolderPathFunc)(HWND hwndOwner,
2159 LPSTR lpszPath,
2160 int nFolder,
2161 BOOL fCreate);
2162 char *p;
2163 int i;
2164
2165 // SHGetSpecialFolderPath isn't available in older versions of
2166 // shell32.dll (Win95 and WinNT4), so do a dynamic load
2167 winFontDir[0] = '\0';
2168 if ((shell32Lib = LoadLibraryA("shell32.dll"))) {
2169 if ((SHGetSpecialFolderPathFunc =
2170 (BOOL (__stdcall *)(HWND hwndOwner, LPSTR lpszPath,
2171 int nFolder, BOOL fCreate))
2172 GetProcAddress(shell32Lib, "SHGetSpecialFolderPathA"))) {
2173 if (!(*SHGetSpecialFolderPathFunc)(NULL, winFontDir,
2174 CSIDL_FONTS, FALSE)) {
2175 winFontDir[0] = '\0';
2176 }
2177 // kludge: Terminal Server changes CSIDL_FONTS to something like
2178 // "C:\Users\whatever\Windows\Fonts", which doesn't actually
2179 // contain any fonts -- kill that, so we hit the fallback code
2180 // below.
2181 for (p = winFontDir; *p; ++p) {
2182 if (!strncasecmp(p, "\\Users\\", 7)) {
2183 winFontDir[0] = '\0';
2184 break;
2185 }
2186 }
2187 }
2188 FreeLibrary(shell32Lib);
2189 }
2190 // if something went wrong, or we're on a Terminal Server, try using
2191 // %SYSTEMROOT%\Fonts
2192 if (!winFontDir[0]) {
2193 GetSystemWindowsDirectoryA(winFontDir, MAX_PATH - 6);
2194 winFontDir[MAX_PATH - 7] = '\0';
2195 i = (int)strlen(winFontDir);
2196 if (winFontDir[i-1] != '\\') {
2197 winFontDir[i++] = '\\';
2198 }
2199 strcpy(winFontDir + i, "Fonts");
2200 }
2201 }
2202 #endif
2203
2204 #ifdef __APPLE__
2205 // Apple dfonts and ttc fonts seem to randomly and interchangeably use
2206 // space and hyphen, and sometimes drop the separator entirely.
2207 static GBool macFontNameMatches(GString *name1, const char *name2) {
2208 const char *p1, *p2;
2209 char c1, c2;
2210
2211 p1 = name1->getCString();
2212 p2 = name2;
2213 while (*p1 && *p2) {
2214 c1 = *p1;
2215 c2 = *p2;
2216 if (c2 == ' ') {
2217 // * space or hyphen matches a space in the pattern
2218 // * separators can also be dropped, in which case we move to
2219 // the next char in the pattern
2220 if (c1 == ' ' || c1 == '-') {
2221 ++p1;
2222 }
2223 } else {
2224 if (c1 != c2) {
2225 return gFalse;
2226 }
2227 ++p1;
2228 }
2229 ++p2;
2230 }
2231 if (*p1 || *p2) {
2232 return gFalse;
2233 }
2234 return gTrue;
2235 }
2236 #endif
2237
2238 void GlobalParams::setupBaseFonts(const char *dir) {
2239 GString *fontName;
2240 GString *fileName;
2241 int fontNum;
2242 const char *s;
2243 Base14FontInfo *base14;
2244 #ifdef _WIN32
2245 char winFontDir[MAX_PATH];
2246 #endif
2247 #ifdef __APPLE__
2248 static const char *macFontExts[3] = { "dfont", "ttc", "ttf" };
2249 GList *dfontFontNames;
2250 GBool found;
2251 int k;
2252 #endif
2253 FILE *f;
2254 int i, j;
2255
2256 #ifdef _WIN32
2257 getWinFontDir(winFontDir);
2258 #endif
2259 #ifdef __APPLE__
2260 dfontFontNames = NULL;
2261 #endif
2262 for (i = 0; displayFontTab[i].name; ++i) {
2263 if (fontFiles->lookup(displayFontTab[i].name)) {
2264 continue;
2265 }
2266 fontName = new GString(displayFontTab[i].name);
2267 fileName = NULL;
2268 fontNum = 0;
2269 if (dir) {
2270 fileName = appendToPath(new GString(dir), displayFontTab[i].t1FileName);
2271 if ((f = fopen(fileName->getCString(), "rb"))) {
2272 fclose(f);
2273 } else {
2274 delete fileName;
2275 fileName = NULL;
2276 }
2277 }
2278 #ifdef _WIN32
2279 if (!fileName && winFontDir[0] && displayFontTab[i].ttFileName) {
2280 fileName = appendToPath(new GString(winFontDir),
2281 displayFontTab[i].ttFileName);
2282 if ((f = fopen(fileName->getCString(), "rb"))) {
2283 fclose(f);
2284 } else {
2285 delete fileName;
2286 fileName = NULL;
2287 }
2288 }
2289 #endif
2290 #ifdef __APPLE__
2291 // Check for Mac OS X system fonts.
2292 s = displayFontTab[i].macFileName;
2293 if (dfontFontNames && i > 0 &&
2294 (!s || strcmp(s, displayFontTab[i-1].macFileName))) {
2295 deleteGList(dfontFontNames, GString);
2296 dfontFontNames = NULL;
2297 }
2298 if (!fileName && s) {
2299 for (j = 0; j < 3; ++j) {
2300 fileName = GString::format("{0:s}/{1:s}.{2:s}",
2301 macSystemFontPath, s, macFontExts[j]);
2302 if (!(f = fopen(fileName->getCString(), "rb"))) {
2303 delete fileName;
2304 fileName = NULL;
2305 } else {
2306 fclose(f);
2307 found = gFalse;
2308 // for .dfont or .ttc, we need to scan the font list
2309 if (j < 2) {
2310 if (!dfontFontNames) {
2311 dfontFontNames =
2312 FoFiIdentifier::getFontList(fileName->getCString());
2313 }
2314 if (dfontFontNames) {
2315 for (k = 0; k < dfontFontNames->getLength(); ++k) {
2316 if (macFontNameMatches((GString *)dfontFontNames->get(k),
2317 displayFontTab[i].macFontName)) {
2318 fontNum = k;
2319 found = gTrue;
2320 break;
2321 }
2322 }
2323 }
2324 // for .ttf, we just use the font
2325 } else {
2326 found = gTrue;
2327 }
2328 if (!found) {
2329 delete fileName;
2330 fileName = NULL;
2331 }
2332 break;
2333 }
2334 }
2335 }
2336 #endif // __APPLE__
2337 // On Linux, this checks the "standard" ghostscript font
2338 // directories. On Windows, it checks the "standard" system font
2339 // directories (because SHGetSpecialFolderPath(CSIDL_FONTS)
2340 // doesn't work on Win 2k Server or Win2003 Server, or with older
2341 // versions of shell32.dll).
2342 #ifdef _WIN32
2343 s = displayFontTab[i].ttFileName;
2344 #else
2345 s = displayFontTab[i].t1FileName;
2346 #endif
2347 if (!fileName && s) {
2348 for (j = 0; !fileName && displayFontDirs[j]; ++j) {
2349 fileName = appendToPath(new GString(displayFontDirs[j]), s);
2350 if ((f = fopen(fileName->getCString(), "rb"))) {
2351 fclose(f);
2352 } else {
2353 delete fileName;
2354 fileName = NULL;
2355 }
2356 }
2357 }
2358 if (!fileName) {
2359 delete fontName;
2360 continue;
2361 }
2362 base14SysFonts->add(fontName, new Base14FontInfo(fileName, fontNum, 0));
2363 }
2364 #ifdef __APPLE__
2365 if (dfontFontNames) {
2366 deleteGList(dfontFontNames, GString);
2367 }
2368 #endif
2369 for (i = 0; displayFontTab[i].name; ++i) {
2370 if (!base14SysFonts->lookup(displayFontTab[i].name) &&
2371 !fontFiles->lookup(displayFontTab[i].name)) {
2372 if (displayFontTab[i].obliqueFont &&
2373 ((base14 = (Base14FontInfo *)base14SysFonts
2374 ->lookup(displayFontTab[i].obliqueFont)))) {
2375 base14SysFonts->add(
2376 new GString(displayFontTab[i].name),
2377 new Base14FontInfo(base14->fileName->copy(),
2378 base14->fontNum,
2379 displayFontTab[i].obliqueFactor));
2380 } else {
2381 error(errConfig, -1, "No display font for '{0:s}'",
2382 displayFontTab[i].name);
2383 }
2384 }
2385 }
2386 #ifdef _WIN32
2387 if (winFontDir[0]) {
2388 sysFonts->scanWindowsFonts(winFontDir);
2389 }
2390 #endif
2391 #if HAVE_FONTCONFIG
2392 sysFonts->scanFontconfigFonts();
2393 #endif
2394 }
2395
2396 //------------------------------------------------------------------------
2397 // accessors
2398 //------------------------------------------------------------------------
2399
2400 CharCode GlobalParams::getMacRomanCharCode(char *charName) {
2401 // no need to lock - macRomanReverseMap is constant
2402 return macRomanReverseMap->lookup(charName);
2403 }
2404
2405 GString *GlobalParams::getBaseDir() {
2406 GString *s;
2407
2408 lockGlobalParams;
2409 s = baseDir->copy();
2410 unlockGlobalParams;
2411 return s;
2412 }
2413
2414 Unicode GlobalParams::mapNameToUnicode(const char *charName) {
2415 // no need to lock - nameToUnicode is constant
2416 return nameToUnicode->lookup(charName);
2417 }
2418
2419 UnicodeMap *GlobalParams::getResidentUnicodeMap(GString *encodingName) {
2420 UnicodeMap *map;
2421
2422 lockGlobalParams;
2423 map = (UnicodeMap *)residentUnicodeMaps->lookup(encodingName);
2424 unlockGlobalParams;
2425 if (map) {
2426 map->incRefCnt();
2427 }
2428 return map;
2429 }
2430
2431 FILE *GlobalParams::getUnicodeMapFile(GString *encodingName) {
2432 GString *fileName;
2433 FILE *f;
2434
2435 lockGlobalParams;
2436 if ((fileName = (GString *)unicodeMaps->lookup(encodingName))) {
2437 f = openFile(fileName->getCString(), "r");
2438 } else {
2439 f = NULL;
2440 }
2441 unlockGlobalParams;
2442 return f;
2443 }
2444
2445 FILE *GlobalParams::findCMapFile(GString *collection, GString *cMapName) {
2446 GList *list;
2447 GString *dir;
2448 GString *fileName;
2449 FILE *f;
2450 int i;
2451
2452 lockGlobalParams;
2453 if (!(list = (GList *)cMapDirs->lookup(collection))) {
2454 unlockGlobalParams;
2455 return NULL;
2456 }
2457 for (i = 0; i < list->getLength(); ++i) {
2458 dir = (GString *)list->get(i);
2459 fileName = appendToPath(dir->copy(), cMapName->getCString());
2460 f = openFile(fileName->getCString(), "r");
2461 delete fileName;
2462 if (f) {
2463 unlockGlobalParams;
2464 return f;
2465 }
2466 }
2467 unlockGlobalParams;
2468 return NULL;
2469 }
2470
2471 FILE *GlobalParams::findToUnicodeFile(GString *name) {
2472 GString *dir, *fileName;
2473 FILE *f;
2474 int i;
2475
2476 lockGlobalParams;
2477 for (i = 0; i < toUnicodeDirs->getLength(); ++i) {
2478 dir = (GString *)toUnicodeDirs->get(i);
2479 fileName = appendToPath(dir->copy(), name->getCString());
2480 f = openFile(fileName->getCString(), "r");
2481 delete fileName;
2482 if (f) {
2483 unlockGlobalParams;
2484 return f;
2485 }
2486 }
2487 unlockGlobalParams;
2488 return NULL;
2489 }
2490
2491 UnicodeRemapping *GlobalParams::getUnicodeRemapping() {
2492 return unicodeRemapping;
2493 }
2494
2495 GString *GlobalParams::findFontFile(GString *fontName) {
2496 static const char *exts[] = { ".pfa", ".pfb", ".ttf", ".ttc", ".otf" };
2497 GString *path, *dir;
2498 #ifdef _WIN32
2499 GString *fontNameU;
2500 #endif
2501 const char *ext;
2502 FILE *f;
2503 int i, j;
2504
2505 lockGlobalParams;
2506 if ((path = (GString *)fontFiles->lookup(fontName))) {
2507 path = path->copy();
2508 unlockGlobalParams;
2509 return path;
2510 }
2511 for (i = 0; i < fontDirs->getLength(); ++i) {
2512 dir = (GString *)fontDirs->get(i);
2513 for (j = 0; j < (int)(sizeof(exts) / sizeof(exts[0])); ++j) {
2514 ext = exts[j];
2515 #ifdef _WIN32
2516 fontNameU = fileNameToUTF8(fontName->getCString());
2517 path = appendToPath(dir->copy(), fontNameU->getCString());
2518 delete fontNameU;
2519 #else
2520 path = appendToPath(dir->copy(), fontName->getCString());
2521 #endif
2522 path->append(ext);
2523 if ((f = openFile(path->getCString(), "rb"))) {
2524 fclose(f);
2525 unlockGlobalParams;
2526 return path;
2527 }
2528 delete path;
2529 }
2530 }
2531 unlockGlobalParams;
2532 return NULL;
2533 }
2534
2535 GString *GlobalParams::findBase14FontFile(GString *fontName, int *fontNum,
2536 double *oblique) {
2537 Base14FontInfo *fi;
2538 GString *path;
2539
2540 lockGlobalParams;
2541 if ((fi = (Base14FontInfo *)base14SysFonts->lookup(fontName))) {
2542 path = fi->fileName->copy();
2543 *fontNum = fi->fontNum;
2544 *oblique = fi->oblique;
2545 unlockGlobalParams;
2546 return path;
2547 }
2548 unlockGlobalParams;
2549 *fontNum = 0;
2550 *oblique = 0;
2551 return findFontFile(fontName);
2552 }
2553
2554 GString *GlobalParams::findSystemFontFile(GString *fontName,
2555 SysFontType *type,
2556 int *fontNum) {
2557 SysFontInfo *fi;
2558 GString *path;
2559
2560 path = NULL;
2561 lockGlobalParams;
2562 if ((fi = sysFonts->find(fontName))) {
2563 path = fi->path->copy();
2564 *type = fi->type;
2565 *fontNum = fi->fontNum;
2566 }
2567 unlockGlobalParams;
2568 return path;
2569 }
2570
2571 GString *GlobalParams::findCCFontFile(GString *collection) {
2572 GString *path;
2573
2574 lockGlobalParams;
2575 if ((path = (GString *)ccFontFiles->lookup(collection))) {
2576 path = path->copy();
2577 }
2578 unlockGlobalParams;
2579 return path;
2580 }
2581
2582 int GlobalParams::getPSPaperWidth() {
2583 int w;
2584
2585 lockGlobalParams;
2586 w = psPaperWidth;
2587 unlockGlobalParams;
2588 return w;
2589 }
2590
2591 int GlobalParams::getPSPaperHeight() {
2592 int h;
2593
2594 lockGlobalParams;
2595 h = psPaperHeight;
2596 unlockGlobalParams;
2597 return h;
2598 }
2599
2600 void GlobalParams::getPSImageableArea(int *llx, int *lly, int *urx, int *ury) {
2601 lockGlobalParams;
2602 *llx = psImageableLLX;
2603 *lly = psImageableLLY;
2604 *urx = psImageableURX;
2605 *ury = psImageableURY;
2606 unlockGlobalParams;
2607 }
2608
2609 GBool GlobalParams::getPSCrop() {
2610 GBool f;
2611
2612 lockGlobalParams;
2613 f = psCrop;
2614 unlockGlobalParams;
2615 return f;
2616 }
2617
2618 GBool GlobalParams::getPSUseCropBoxAsPage() {
2619 GBool f;
2620
2621 lockGlobalParams;
2622 f = psUseCropBoxAsPage;
2623 unlockGlobalParams;
2624 return f;
2625 }
2626
2627 GBool GlobalParams::getPSExpandSmaller() {
2628 GBool f;
2629
2630 lockGlobalParams;
2631 f = psExpandSmaller;
2632 unlockGlobalParams;
2633 return f;
2634 }
2635
2636 GBool GlobalParams::getPSShrinkLarger() {
2637 GBool f;
2638
2639 lockGlobalParams;
2640 f = psShrinkLarger;
2641 unlockGlobalParams;
2642 return f;
2643 }
2644
2645 GBool GlobalParams::getPSCenter() {
2646 GBool f;
2647
2648 lockGlobalParams;
2649 f = psCenter;
2650 unlockGlobalParams;
2651 return f;
2652 }
2653
2654 GBool GlobalParams::getPSDuplex() {
2655 GBool d;
2656
2657 lockGlobalParams;
2658 d = psDuplex;
2659 unlockGlobalParams;
2660 return d;
2661 }
2662
2663 PSLevel GlobalParams::getPSLevel() {
2664 PSLevel level;
2665
2666 lockGlobalParams;
2667 level = psLevel;
2668 unlockGlobalParams;
2669 return level;
2670 }
2671
2672 GString *GlobalParams::getPSResidentFont(GString *fontName) {
2673 GString *psName;
2674
2675 lockGlobalParams;
2676 if ((psName = (GString *)psResidentFonts->lookup(fontName))) {
2677 psName = psName->copy();
2678 }
2679 unlockGlobalParams;
2680 return psName;
2681 }
2682
2683 GList *GlobalParams::getPSResidentFonts() {
2684 GList *names;
2685 GHashIter *iter;
2686 GString *name;
2687 GString *psName;
2688
2689 names = new GList();
2690 lockGlobalParams;
2691 psResidentFonts->startIter(&iter);
2692 while (psResidentFonts->getNext(&iter, &name, (void **)&psName)) {
2693 names->append(psName->copy());
2694 }
2695 unlockGlobalParams;
2696 return names;
2697 }
2698
2699 PSFontParam16 *GlobalParams::getPSResidentFont16(GString *fontName,
2700 int wMode) {
2701 PSFontParam16 *p;
2702 int i;
2703
2704 lockGlobalParams;
2705 p = NULL;
2706 for (i = 0; i < psResidentFonts16->getLength(); ++i) {
2707 p = (PSFontParam16 *)psResidentFonts16->get(i);
2708 if (!(p->name->cmp(fontName)) && p->wMode == wMode) {
2709 break;
2710 }
2711 p = NULL;
2712 }
2713 unlockGlobalParams;
2714 return p;
2715 }
2716
2717 PSFontParam16 *GlobalParams::getPSResidentFontCC(GString *collection,
2718 int wMode) {
2719 PSFontParam16 *p;
2720 int i;
2721
2722 lockGlobalParams;
2723 p = NULL;
2724 for (i = 0; i < psResidentFontsCC->getLength(); ++i) {
2725 p = (PSFontParam16 *)psResidentFontsCC->get(i);
2726 if (!(p->name->cmp(collection)) && p->wMode == wMode) {
2727 break;
2728 }
2729 p = NULL;
2730 }
2731 unlockGlobalParams;
2732 return p;
2733 }
2734
2735 GBool GlobalParams::getPSEmbedType1() {
2736 GBool e;
2737
2738 lockGlobalParams;
2739 e = psEmbedType1;
2740 unlockGlobalParams;
2741 return e;
2742 }
2743
2744 GBool GlobalParams::getPSEmbedTrueType() {
2745 GBool e;
2746
2747 lockGlobalParams;
2748 e = psEmbedTrueType;
2749 unlockGlobalParams;
2750 return e;
2751 }
2752
2753 GBool GlobalParams::getPSEmbedCIDPostScript() {
2754 GBool e;
2755
2756 lockGlobalParams;
2757 e = psEmbedCIDPostScript;
2758 unlockGlobalParams;
2759 return e;
2760 }
2761
2762 GBool GlobalParams::getPSEmbedCIDTrueType() {
2763 GBool e;
2764
2765 lockGlobalParams;
2766 e = psEmbedCIDTrueType;
2767 unlockGlobalParams;
2768 return e;
2769 }
2770
2771 GBool GlobalParams::getPSFontPassthrough() {
2772 GBool e;
2773
2774 lockGlobalParams;
2775 e = psFontPassthrough;
2776 unlockGlobalParams;
2777 return e;
2778 }
2779
2780 GBool GlobalParams::getPSPreload() {
2781 GBool preload;
2782
2783 lockGlobalParams;
2784 preload = psPreload;
2785 unlockGlobalParams;
2786 return preload;
2787 }
2788
2789 GBool GlobalParams::getPSOPI() {
2790 GBool opi;
2791
2792 lockGlobalParams;
2793 opi = psOPI;
2794 unlockGlobalParams;
2795 return opi;
2796 }
2797
2798 GBool GlobalParams::getPSASCIIHex() {
2799 GBool ah;
2800
2801 lockGlobalParams;
2802 ah = psASCIIHex;
2803 unlockGlobalParams;
2804 return ah;
2805 }
2806
2807 GBool GlobalParams::getPSLZW() {
2808 GBool ah;
2809
2810 lockGlobalParams;
2811 ah = psLZW;
2812 unlockGlobalParams;
2813 return ah;
2814 }
2815
2816 GBool GlobalParams::getPSUncompressPreloadedImages() {
2817 GBool ah;
2818
2819 lockGlobalParams;
2820 ah = psUncompressPreloadedImages;
2821 unlockGlobalParams;
2822 return ah;
2823 }
2824
2825 double GlobalParams::getPSMinLineWidth() {
2826 double w;
2827
2828 lockGlobalParams;
2829 w = psMinLineWidth;
2830 unlockGlobalParams;
2831 return w;
2832 }
2833
2834 double GlobalParams::getPSRasterResolution() {
2835 double res;
2836
2837 lockGlobalParams;
2838 res = psRasterResolution;
2839 unlockGlobalParams;
2840 return res;
2841 }
2842
2843 GBool GlobalParams::getPSRasterMono() {
2844 GBool mono;
2845
2846 lockGlobalParams;
2847 mono = psRasterMono;
2848 unlockGlobalParams;
2849 return mono;
2850 }
2851
2852 int GlobalParams::getPSRasterSliceSize() {
2853 int slice;
2854
2855 lockGlobalParams;
2856 slice = psRasterSliceSize;
2857 unlockGlobalParams;
2858 return slice;
2859 }
2860
2861 GBool GlobalParams::getPSAlwaysRasterize() {
2862 GBool rast;
2863
2864 lockGlobalParams;
2865 rast = psAlwaysRasterize;
2866 unlockGlobalParams;
2867 return rast;
2868 }
2869
2870 GBool GlobalParams::getPSNeverRasterize() {
2871 GBool rast;
2872
2873 lockGlobalParams;
2874 rast = psNeverRasterize;
2875 unlockGlobalParams;
2876 return rast;
2877 }
2878
2879 GString *GlobalParams::getTextEncodingName() {
2880 GString *s;
2881
2882 lockGlobalParams;
2883 s = textEncoding->copy();
2884 unlockGlobalParams;
2885 return s;
2886 }
2887
2888 GList *GlobalParams::getAvailableTextEncodings() {
2889 GList *list; // [GString]
2890 GHashIter *iter;
2891 GString *key;
2892 void *val;
2893
2894 list = new GList();
2895 lockGlobalParams;
2896 residentUnicodeMaps->startIter(&iter);
2897 while (residentUnicodeMaps->getNext(&iter, &key, &val)) {
2898 list->append(key->copy());
2899 }
2900 unicodeMaps->startIter(&iter);
2901 while (unicodeMaps->getNext(&iter, &key, &val)) {
2902 list->append(key->copy());
2903 }
2904 unlockGlobalParams;
2905 return list;
2906 }
2907
2908 EndOfLineKind GlobalParams::getTextEOL() {
2909 EndOfLineKind eol;
2910
2911 lockGlobalParams;
2912 eol = textEOL;
2913 unlockGlobalParams;
2914 return eol;
2915 }
2916
2917 GBool GlobalParams::getTextPageBreaks() {
2918 GBool pageBreaks;
2919
2920 lockGlobalParams;
2921 pageBreaks = textPageBreaks;
2922 unlockGlobalParams;
2923 return pageBreaks;
2924 }
2925
2926 GBool GlobalParams::getTextKeepTinyChars() {
2927 GBool tiny;
2928
2929 lockGlobalParams;
2930 tiny = textKeepTinyChars;
2931 unlockGlobalParams;
2932 return tiny;
2933 }
2934
2935 GString *GlobalParams::getInitialZoom() {
2936 GString *s;
2937
2938 lockGlobalParams;
2939 s = initialZoom->copy();
2940 unlockGlobalParams;
2941 return s;
2942 }
2943
2944 int GlobalParams::getDefaultFitZoom() {
2945 int z;
2946
2947 lockGlobalParams;
2948 z = defaultFitZoom;
2949 unlockGlobalParams;
2950 return z;
2951 }
2952
2953 GString *GlobalParams::getInitialDisplayMode() {
2954 GString *s;
2955
2956 lockGlobalParams;
2957 s = initialDisplayMode->copy();
2958 unlockGlobalParams;
2959 return s;
2960 }
2961
2962 GBool GlobalParams::getInitialToolbarState() {
2963 GBool state;
2964
2965 lockGlobalParams;
2966 state = initialToolbarState;
2967 unlockGlobalParams;
2968 return state;
2969 }
2970
2971 GBool GlobalParams::getInitialSidebarState() {
2972 GBool state;
2973
2974 lockGlobalParams;
2975 state = initialSidebarState;
2976 unlockGlobalParams;
2977 return state;
2978 }
2979
2980 int GlobalParams::getInitialSidebarWidth() {
2981 int w;
2982
2983 lockGlobalParams;
2984 w = initialSidebarWidth;
2985 unlockGlobalParams;
2986 return w;
2987 }
2988
2989 GString *GlobalParams::getInitialSelectMode() {
2990 GString *s;
2991
2992 lockGlobalParams;
2993 s = initialSelectMode->copy();
2994 unlockGlobalParams;
2995 return s;
2996 }
2997
2998 int GlobalParams::getMaxTileWidth() {
2999 int w;
3000
3001 lockGlobalParams;
3002 w = maxTileWidth;
3003 unlockGlobalParams;
3004 return w;
3005 }
3006
3007 int GlobalParams::getMaxTileHeight() {
3008 int h;
3009
3010 lockGlobalParams;
3011 h = maxTileHeight;
3012 unlockGlobalParams;
3013 return h;
3014 }
3015
3016 int GlobalParams::getTileCacheSize() {
3017 int n;
3018
3019 lockGlobalParams;
3020 n = tileCacheSize;
3021 unlockGlobalParams;
3022 return n;
3023 }
3024
3025 int GlobalParams::getWorkerThreads() {
3026 int n;
3027
3028 lockGlobalParams;
3029 n = workerThreads;
3030 unlockGlobalParams;
3031 return n;
3032 }
3033
3034 GBool GlobalParams::getEnableFreeType() {
3035 GBool f;
3036
3037 lockGlobalParams;
3038 f = enableFreeType;
3039 unlockGlobalParams;
3040 return f;
3041 }
3042
3043 GBool GlobalParams::getDisableFreeTypeHinting() {
3044 GBool f;
3045
3046 lockGlobalParams;
3047 f = disableFreeTypeHinting;
3048 unlockGlobalParams;
3049 return f;
3050 }
3051
3052
3053 GBool GlobalParams::getAntialias() {
3054 GBool f;
3055
3056 lockGlobalParams;
3057 f = antialias;
3058 unlockGlobalParams;
3059 return f;
3060 }
3061
3062 GBool GlobalParams::getVectorAntialias() {
3063 GBool f;
3064
3065 lockGlobalParams;
3066 f = vectorAntialias;
3067 unlockGlobalParams;
3068 return f;
3069 }
3070
3071 GBool GlobalParams::getImageMaskAntialias() {
3072 GBool f;
3073
3074 lockGlobalParams;
3075 f = imageMaskAntialias;
3076 unlockGlobalParams;
3077 return f;
3078 }
3079
3080 GBool GlobalParams::getAntialiasPrinting() {
3081 GBool f;
3082
3083 lockGlobalParams;
3084 f = antialiasPrinting;
3085 unlockGlobalParams;
3086 return f;
3087 }
3088
3089 StrokeAdjustMode GlobalParams::getStrokeAdjust() {
3090 StrokeAdjustMode mode;
3091
3092 lockGlobalParams;
3093 mode = strokeAdjust;
3094 unlockGlobalParams;
3095 return mode;
3096 }
3097
3098 ScreenType GlobalParams::getScreenType() {
3099 ScreenType t;
3100
3101 lockGlobalParams;
3102 t = screenType;
3103 unlockGlobalParams;
3104 return t;
3105 }
3106
3107 int GlobalParams::getScreenSize() {
3108 int size;
3109
3110 lockGlobalParams;
3111 size = screenSize;
3112 unlockGlobalParams;
3113 return size;
3114 }
3115
3116 int GlobalParams::getScreenDotRadius() {
3117 int r;
3118
3119 lockGlobalParams;
3120 r = screenDotRadius;
3121 unlockGlobalParams;
3122 return r;
3123 }
3124
3125 double GlobalParams::getScreenGamma() {
3126 double gamma;
3127
3128 lockGlobalParams;
3129 gamma = screenGamma;
3130 unlockGlobalParams;
3131 return gamma;
3132 }
3133
3134 double GlobalParams::getScreenBlackThreshold() {
3135 double thresh;
3136
3137 lockGlobalParams;
3138 thresh = screenBlackThreshold;
3139 unlockGlobalParams;
3140 return thresh;
3141 }
3142
3143 double GlobalParams::getScreenWhiteThreshold() {
3144 double thresh;
3145
3146 lockGlobalParams;
3147 thresh = screenWhiteThreshold;
3148 unlockGlobalParams;
3149 return thresh;
3150 }
3151
3152 double GlobalParams::getMinLineWidth() {
3153 double w;
3154
3155 lockGlobalParams;
3156 w = minLineWidth;
3157 unlockGlobalParams;
3158 return w;
3159 }
3160
3161 GBool GlobalParams::getEnablePathSimplification() {
3162 GBool en;
3163
3164 lockGlobalParams;
3165 en = enablePathSimplification;
3166 unlockGlobalParams;
3167 return en;
3168 }
3169
3170 GBool GlobalParams::getDrawAnnotations() {
3171 GBool draw;
3172
3173 lockGlobalParams;
3174 draw = drawAnnotations;
3175 unlockGlobalParams;
3176 return draw;
3177 }
3178
3179 GBool GlobalParams::getDrawFormFields() {
3180 GBool draw;
3181
3182 lockGlobalParams;
3183 draw = drawFormFields;
3184 unlockGlobalParams;
3185 return draw;
3186 }
3187
3188 GBool GlobalParams::getEnableXFA() {
3189 GBool xfa;
3190
3191 lockGlobalParams;
3192 xfa = enableXFA;
3193 unlockGlobalParams;
3194 return xfa;
3195 }
3196
3197
3198
3199 GString *GlobalParams::getPaperColor() {
3200 GString *s;
3201
3202 lockGlobalParams;
3203 s = paperColor->copy();
3204 unlockGlobalParams;
3205 return s;
3206 }
3207
3208 GString *GlobalParams::getMatteColor() {
3209 GString *s;
3210
3211 lockGlobalParams;
3212 s = matteColor->copy();
3213 unlockGlobalParams;
3214 return s;
3215 }
3216
3217 GString *GlobalParams::getFullScreenMatteColor() {
3218 GString *s;
3219
3220 lockGlobalParams;
3221 s = fullScreenMatteColor->copy();
3222 unlockGlobalParams;
3223 return s;
3224 }
3225
3226 GString *GlobalParams::getSelectionColor() {
3227 GString *s;
3228
3229 lockGlobalParams;
3230 s = selectionColor->copy();
3231 unlockGlobalParams;
3232 return s;
3233 }
3234
3235 GBool GlobalParams::getReverseVideoInvertImages() {
3236 GBool invert;
3237
3238 lockGlobalParams;
3239 invert = reverseVideoInvertImages;
3240 unlockGlobalParams;
3241 return invert;
3242 }
3243
3244 GString *GlobalParams::getDefaultPrinter() {
3245 GString *s;
3246
3247 lockGlobalParams;
3248 s = defaultPrinter ? defaultPrinter->copy() : (GString *)NULL;
3249 unlockGlobalParams;
3250 return s;
3251 }
3252
3253 GBool GlobalParams::getMapNumericCharNames() {
3254 GBool map;
3255
3256 lockGlobalParams;
3257 map = mapNumericCharNames;
3258 unlockGlobalParams;
3259 return map;
3260 }
3261
3262 GBool GlobalParams::getMapUnknownCharNames() {
3263 GBool map;
3264
3265 lockGlobalParams;
3266 map = mapUnknownCharNames;
3267 unlockGlobalParams;
3268 return map;
3269 }
3270
3271 GBool GlobalParams::getMapExtTrueTypeFontsViaUnicode() {
3272 GBool map;
3273
3274 lockGlobalParams;
3275 map = mapExtTrueTypeFontsViaUnicode;
3276 unlockGlobalParams;
3277 return map;
3278 }
3279
3280 GBool GlobalParams::getUseTrueTypeUnicodeMapping() {
3281 GBool use;
3282
3283 lockGlobalParams;
3284 use = useTrueTypeUnicodeMapping;
3285 unlockGlobalParams;
3286 return use;
3287 }
3288
3289 GBool GlobalParams::isDroppedFont(const char *fontName) {
3290 GBool isDropped;
3291
3292 lockGlobalParams;
3293 isDropped = droppedFonts->lookupInt(fontName) != 0;
3294 unlockGlobalParams;
3295 return isDropped;
3296 }
3297
3298 GList *GlobalParams::getKeyBinding(int code, int mods, int context) {
3299 KeyBinding *binding;
3300 GList *cmds;
3301 int modMask;
3302 int i, j;
3303
3304 lockGlobalParams;
3305 cmds = NULL;
3306 // for ASCII chars, ignore the shift modifier
3307 modMask = (code >= 0x21 && code <= 0xff) ? ~xpdfKeyModShift : ~0;
3308 for (i = 0; i < keyBindings->getLength(); ++i) {
3309 binding = (KeyBinding *)keyBindings->get(i);
3310 if (binding->code == code &&
3311 (binding->mods & modMask) == (mods & modMask) &&
3312 (~binding->context | context) == ~0) {
3313 cmds = new GList();
3314 for (j = 0; j < binding->cmds->getLength(); ++j) {
3315 cmds->append(((GString *)binding->cmds->get(j))->copy());
3316 }
3317 break;
3318 }
3319 }
3320 unlockGlobalParams;
3321 return cmds;
3322 }
3323
3324 GList *GlobalParams::getAllKeyBindings() {
3325 return keyBindings;
3326 }
3327
3328 int GlobalParams::getNumPopupMenuCmds() {
3329 int n;
3330
3331 lockGlobalParams;
3332 n = popupMenuCmds->getLength();
3333 unlockGlobalParams;
3334 return n;
3335 }
3336
3337 PopupMenuCmd *GlobalParams::getPopupMenuCmd(int idx) {
3338 PopupMenuCmd *cmd;
3339
3340 lockGlobalParams;
3341 if (idx < popupMenuCmds->getLength()) {
3342 cmd = (PopupMenuCmd *)popupMenuCmds->get(idx);
3343 } else {
3344 cmd = NULL;
3345 }
3346 unlockGlobalParams;
3347 return cmd;
3348 }
3349
3350 GString *GlobalParams::getTabStateFile() {
3351 GString *s;
3352
3353 lockGlobalParams;
3354 s = tabStateFile->copy();
3355 unlockGlobalParams;
3356 return s;
3357 }
3358
3359 GBool GlobalParams::getSavePageNumbers() {
3360 GBool s;
3361
3362 lockGlobalParams;
3363 s = savePageNumbers;
3364 unlockGlobalParams;
3365 return s;
3366 }
3367
3368 GBool GlobalParams::getPrintCommands() {
3369 GBool p;
3370
3371 lockGlobalParams;
3372 p = printCommands;
3373 unlockGlobalParams;
3374 return p;
3375 }
3376
3377 GBool GlobalParams::getPrintStatusInfo() {
3378 GBool p;
3379
3380 lockGlobalParams;
3381 p = printStatusInfo;
3382 unlockGlobalParams;
3383 return p;
3384 }
3385
3386 GBool GlobalParams::getErrQuiet() {
3387 // no locking -- this function may get called from inside a locked
3388 // section
3389 return errQuiet;
3390 }
3391
3392 GString *GlobalParams::getDebugLogFile() {
3393 return debugLogFile;
3394 }
3395
3396 void GlobalParams::debugLogPrintf(const char *fmt, ...) {
3397 GString *path;
3398 FILE *f;
3399 GBool needClose;
3400 time_t t;
3401 struct tm tm;
3402 va_list args;
3403
3404 if (!(path = getDebugLogFile())) {
3405 return;
3406 }
3407 needClose = gFalse;
3408 if (!path->cmp("-")) {
3409 f = stdout;
3410 } else if (!path->cmp("+")) {
3411 f = stderr;
3412 } else {
3413 f = fopen(path->getCString(), "a");
3414 needClose = gTrue;
3415 }
3416 if (!f) {
3417 return;
3418 }
3419 t = time(NULL);
3420 #ifdef _WIN32
3421 localtime_s(&tm, &t);
3422 #else
3423 localtime_r(&t, &tm);
3424 #endif
3425 fprintf(f, "[%04d-%02d-%02d %02d:%02d:%02d] ",
3426 tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
3427 tm.tm_hour, tm.tm_min, tm.tm_sec);
3428 va_start(args, fmt);
3429 vfprintf(f, fmt, args);
3430 va_end(args);
3431 fflush(f);
3432 if (needClose) {
3433 fclose(f);
3434 }
3435 }
3436
3437 CharCodeToUnicode *GlobalParams::getCIDToUnicode(GString *collection) {
3438 GString *fileName;
3439 CharCodeToUnicode *ctu;
3440
3441 lockGlobalParams;
3442 if (!(ctu = cidToUnicodeCache->getCharCodeToUnicode(collection))) {
3443 if ((fileName = (GString *)cidToUnicodes->lookup(collection)) &&
3444 (ctu = CharCodeToUnicode::parseCIDToUnicode(fileName, collection))) {
3445 cidToUnicodeCache->add(ctu);
3446 }
3447 }
3448 unlockGlobalParams;
3449 return ctu;
3450 }
3451
3452 CharCodeToUnicode *GlobalParams::getUnicodeToUnicode(GString *fontName) {
3453 CharCodeToUnicode *ctu;
3454 GHashIter *iter;
3455 GString *fontPattern, *fileName;
3456
3457 lockGlobalParams;
3458 fileName = NULL;
3459 unicodeToUnicodes->startIter(&iter);
3460 while (unicodeToUnicodes->getNext(&iter, &fontPattern, (void **)&fileName)) {
3461 if (strstr(fontName->getCString(), fontPattern->getCString())) {
3462 unicodeToUnicodes->killIter(&iter);
3463 break;
3464 }
3465 fileName = NULL;
3466 }
3467 if (fileName) {
3468 if (!(ctu = unicodeToUnicodeCache->getCharCodeToUnicode(fileName))) {
3469 if ((ctu = CharCodeToUnicode::parseUnicodeToUnicode(fileName))) {
3470 unicodeToUnicodeCache->add(ctu);
3471 }
3472 }
3473 } else {
3474 ctu = NULL;
3475 }
3476 unlockGlobalParams;
3477 return ctu;
3478 }
3479
3480 UnicodeMap *GlobalParams::getUnicodeMap(GString *encodingName) {
3481 return getUnicodeMap2(encodingName);
3482 }
3483
3484 UnicodeMap *GlobalParams::getUnicodeMap2(GString *encodingName) {
3485 UnicodeMap *map;
3486
3487 if (!(map = getResidentUnicodeMap(encodingName))) {
3488 lockUnicodeMapCache;
3489 map = unicodeMapCache->getUnicodeMap(encodingName);
3490 unlockUnicodeMapCache;
3491 }
3492 return map;
3493 }
3494
3495 CMap *GlobalParams::getCMap(GString *collection, GString *cMapName) {
3496 CMap *cMap;
3497
3498 lockCMapCache;
3499 cMap = cMapCache->getCMap(collection, cMapName);
3500 unlockCMapCache;
3501 return cMap;
3502 }
3503
3504 UnicodeMap *GlobalParams::getTextEncoding() {
3505 return getUnicodeMap2(textEncoding);
3506 }
3507
3508 //------------------------------------------------------------------------
3509 // functions to set parameters
3510 //------------------------------------------------------------------------
3511
3512 void GlobalParams::addUnicodeRemapping(Unicode in, Unicode *out, int len) {
3513 unicodeRemapping->addRemapping(in, out, len);
3514 }
3515
3516 void GlobalParams::addFontFile(GString *fontName, GString *path) {
3517 lockGlobalParams;
3518 fontFiles->add(fontName, path);
3519 unlockGlobalParams;
3520 }
3521
3522 GBool GlobalParams::setPSPaperSize(char *size) {
3523 lockGlobalParams;
3524 if (!strcmp(size, "match")) {
3525 psPaperWidth = psPaperHeight = -1;
3526 } else if (!strcmp(size, "letter")) {
3527 psPaperWidth = 612;
3528 psPaperHeight = 792;
3529 } else if (!strcmp(size, "legal")) {
3530 psPaperWidth = 612;
3531 psPaperHeight = 1008;
3532 } else if (!strcmp(size, "A4")) {
3533 psPaperWidth = 595;
3534 psPaperHeight = 842;
3535 } else if (!strcmp(size, "A3")) {
3536 psPaperWidth = 842;
3537 psPaperHeight = 1190;
3538 } else {
3539 unlockGlobalParams;
3540 return gFalse;
3541 }
3542 psImageableLLX = psImageableLLY = 0;
3543 psImageableURX = psPaperWidth;
3544 psImageableURY = psPaperHeight;
3545 unlockGlobalParams;
3546 return gTrue;
3547 }
3548
3549 void GlobalParams::setPSPaperWidth(int width) {
3550 lockGlobalParams;
3551 psPaperWidth = width;
3552 psImageableLLX = 0;
3553 psImageableURX = psPaperWidth;
3554 unlockGlobalParams;
3555 }
3556
3557 void GlobalParams::setPSPaperHeight(int height) {
3558 lockGlobalParams;
3559 psPaperHeight = height;
3560 psImageableLLY = 0;
3561 psImageableURY = psPaperHeight;
3562 unlockGlobalParams;
3563 }
3564
3565 void GlobalParams::setPSImageableArea(int llx, int lly, int urx, int ury) {
3566 lockGlobalParams;
3567 psImageableLLX = llx;
3568 psImageableLLY = lly;
3569 psImageableURX = urx;
3570 psImageableURY = ury;
3571 unlockGlobalParams;
3572 }
3573
3574 void GlobalParams::setPSCrop(GBool crop) {
3575 lockGlobalParams;
3576 psCrop = crop;
3577 unlockGlobalParams;
3578 }
3579
3580 void GlobalParams::setPSUseCropBoxAsPage(GBool crop) {
3581 lockGlobalParams;
3582 psUseCropBoxAsPage = crop;
3583 unlockGlobalParams;
3584 }
3585
3586 void GlobalParams::setPSExpandSmaller(GBool expand) {
3587 lockGlobalParams;
3588 psExpandSmaller = expand;
3589 unlockGlobalParams;
3590 }
3591
3592 void GlobalParams::setPSShrinkLarger(GBool shrink) {
3593 lockGlobalParams;
3594 psShrinkLarger = shrink;
3595 unlockGlobalParams;
3596 }
3597
3598 void GlobalParams::setPSCenter(GBool center) {
3599 lockGlobalParams;
3600 psCenter = center;
3601 unlockGlobalParams;
3602 }
3603
3604 void GlobalParams::setPSDuplex(GBool duplex) {
3605 lockGlobalParams;
3606 psDuplex = duplex;
3607 unlockGlobalParams;
3608 }
3609
3610 void GlobalParams::setPSLevel(PSLevel level) {
3611 lockGlobalParams;
3612 psLevel = level;
3613 unlockGlobalParams;
3614 }
3615
3616 void GlobalParams::setPSEmbedType1(GBool embed) {
3617 lockGlobalParams;
3618 psEmbedType1 = embed;
3619 unlockGlobalParams;
3620 }
3621
3622 void GlobalParams::setPSEmbedTrueType(GBool embed) {
3623 lockGlobalParams;
3624 psEmbedTrueType = embed;
3625 unlockGlobalParams;
3626 }
3627
3628 void GlobalParams::setPSEmbedCIDPostScript(GBool embed) {
3629 lockGlobalParams;
3630 psEmbedCIDPostScript = embed;
3631 unlockGlobalParams;
3632 }
3633
3634 void GlobalParams::setPSEmbedCIDTrueType(GBool embed) {
3635 lockGlobalParams;
3636 psEmbedCIDTrueType = embed;
3637 unlockGlobalParams;
3638 }
3639
3640 void GlobalParams::setPSFontPassthrough(GBool passthrough) {
3641 lockGlobalParams;
3642 psFontPassthrough = passthrough;
3643 unlockGlobalParams;
3644 }
3645
3646 void GlobalParams::setPSPreload(GBool preload) {
3647 lockGlobalParams;
3648 psPreload = preload;
3649 unlockGlobalParams;
3650 }
3651
3652 void GlobalParams::setPSOPI(GBool opi) {
3653 lockGlobalParams;
3654 psOPI = opi;
3655 unlockGlobalParams;
3656 }
3657
3658 void GlobalParams::setPSASCIIHex(GBool hex) {
3659 lockGlobalParams;
3660 psASCIIHex = hex;
3661 unlockGlobalParams;
3662 }
3663
3664 void GlobalParams::setTextEncoding(const char *encodingName) {
3665 lockGlobalParams;
3666 delete textEncoding;
3667 textEncoding = new GString(encodingName);
3668 unlockGlobalParams;
3669 }
3670
3671 GBool GlobalParams::setTextEOL(char *s) {
3672 lockGlobalParams;
3673 if (!strcmp(s, "unix")) {
3674 textEOL = eolUnix;
3675 } else if (!strcmp(s, "dos")) {
3676 textEOL = eolDOS;
3677 } else if (!strcmp(s, "mac")) {
3678 textEOL = eolMac;
3679 } else {
3680 unlockGlobalParams;
3681 return gFalse;
3682 }
3683 unlockGlobalParams;
3684 return gTrue;
3685 }
3686
3687 void GlobalParams::setTextPageBreaks(GBool pageBreaks) {
3688 lockGlobalParams;
3689 textPageBreaks = pageBreaks;
3690 unlockGlobalParams;
3691 }
3692
3693 void GlobalParams::setTextKeepTinyChars(GBool keep) {
3694 lockGlobalParams;
3695 textKeepTinyChars = keep;
3696 unlockGlobalParams;
3697 }
3698
3699 void GlobalParams::setInitialZoom(char *s) {
3700 lockGlobalParams;
3701 delete initialZoom;
3702 initialZoom = new GString(s);
3703 unlockGlobalParams;
3704 }
3705
3706 GBool GlobalParams::setEnableFreeType(char *s) {
3707 GBool ok;
3708
3709 lockGlobalParams;
3710 ok = parseYesNo2(s, &enableFreeType);
3711 unlockGlobalParams;
3712 return ok;
3713 }
3714
3715
3716 GBool GlobalParams::setAntialias(char *s) {
3717 GBool ok;
3718
3719 lockGlobalParams;
3720 ok = parseYesNo2(s, &antialias);
3721 unlockGlobalParams;
3722 return ok;
3723 }
3724
3725 GBool GlobalParams::setVectorAntialias(char *s) {
3726 GBool ok;
3727
3728 lockGlobalParams;
3729 ok = parseYesNo2(s, &vectorAntialias);
3730 unlockGlobalParams;
3731 return ok;
3732 }
3733
3734 void GlobalParams::setScreenType(ScreenType t) {
3735 lockGlobalParams;
3736 screenType = t;
3737 unlockGlobalParams;
3738 }
3739
3740 void GlobalParams::setScreenSize(int size) {
3741 lockGlobalParams;
3742 screenSize = size;
3743 unlockGlobalParams;
3744 }
3745
3746 void GlobalParams::setScreenDotRadius(int r) {
3747 lockGlobalParams;
3748 screenDotRadius = r;
3749 unlockGlobalParams;
3750 }
3751
3752 void GlobalParams::setScreenGamma(double gamma) {
3753 lockGlobalParams;
3754 screenGamma = gamma;
3755 unlockGlobalParams;
3756 }
3757
3758 void GlobalParams::setScreenBlackThreshold(double thresh) {
3759 lockGlobalParams;
3760 screenBlackThreshold = thresh;
3761 unlockGlobalParams;
3762 }
3763
3764 void GlobalParams::setScreenWhiteThreshold(double thresh) {
3765 lockGlobalParams;
3766 screenWhiteThreshold = thresh;
3767 unlockGlobalParams;
3768 }
3769
3770 void GlobalParams::setDrawFormFields(GBool draw) {
3771 lockGlobalParams;
3772 drawFormFields = draw;
3773 unlockGlobalParams;
3774 }
3775
3776 void GlobalParams::setOverprintPreview(GBool preview) {
3777 lockGlobalParams;
3778 overprintPreview = preview;
3779 unlockGlobalParams;
3780 }
3781
3782
3783
3784 void GlobalParams::setMapNumericCharNames(GBool map) {
3785 lockGlobalParams;
3786 mapNumericCharNames = map;
3787 unlockGlobalParams;
3788 }
3789
3790 void GlobalParams::setMapUnknownCharNames(GBool map) {
3791 lockGlobalParams;
3792 mapUnknownCharNames = map;
3793 unlockGlobalParams;
3794 }
3795
3796 void GlobalParams::setMapExtTrueTypeFontsViaUnicode(GBool map) {
3797 lockGlobalParams;
3798 mapExtTrueTypeFontsViaUnicode = map;
3799 unlockGlobalParams;
3800 }
3801
3802 void GlobalParams::setTabStateFile(char *tabStateFileA) {
3803 lockGlobalParams;
3804 delete tabStateFile;
3805 tabStateFile = new GString(tabStateFileA);
3806 unlockGlobalParams;
3807 }
3808
3809 void GlobalParams::setPrintCommands(GBool printCommandsA) {
3810 lockGlobalParams;
3811 printCommands = printCommandsA;
3812 unlockGlobalParams;
3813 }
3814
3815 void GlobalParams::setPrintStatusInfo(GBool printStatusInfoA) {
3816 lockGlobalParams;
3817 printStatusInfo = printStatusInfoA;
3818 unlockGlobalParams;
3819 }
3820
3821 void GlobalParams::setErrQuiet(GBool errQuietA) {
3822 lockGlobalParams;
3823 errQuiet = errQuietA;
3824 unlockGlobalParams;
3825 }
3826
3827 #ifdef _WIN32
3828 void GlobalParams::setWin32ErrorInfo(const char *func, DWORD code) {
3829 XpdfWin32ErrorInfo *errorInfo;
3830
3831 if (tlsWin32ErrorInfo == TLS_OUT_OF_INDEXES) {
3832 return;
3833 }
3834 errorInfo = (XpdfWin32ErrorInfo *)TlsGetValue(tlsWin32ErrorInfo);
3835 if (!errorInfo) {
3836 errorInfo = new XpdfWin32ErrorInfo();
3837 TlsSetValue(tlsWin32ErrorInfo, errorInfo);
3838 }
3839 errorInfo->func = func;
3840 errorInfo->code = code;
3841 }
3842
3843 XpdfWin32ErrorInfo *GlobalParams::getWin32ErrorInfo() {
3844 XpdfWin32ErrorInfo *errorInfo;
3845
3846 if (tlsWin32ErrorInfo == TLS_OUT_OF_INDEXES) {
3847 return NULL;
3848 }
3849 errorInfo = (XpdfWin32ErrorInfo *)TlsGetValue(tlsWin32ErrorInfo);
3850 if (!errorInfo) {
3851 errorInfo = new XpdfWin32ErrorInfo();
3852 TlsSetValue(tlsWin32ErrorInfo, errorInfo);
3853 errorInfo->func = NULL;
3854 errorInfo->code = 0;
3855 }
3856 return errorInfo;
3857 }
3858 #endif