source: trunk/poppler/mypoppler/poppler/GlobalParams.cc @ 250

Last change on this file since 250 was 250, checked in by Eugene Romanenko, 13 years ago

PDF plugin: poppler library updated to version 0.8.3

File size: 41.0 KB
Line 
1//========================================================================
2//
3// GlobalParams.cc
4//
5// Copyright 2001-2003 Glyph & Cog, LLC
6//
7//========================================================================
8
9#include <config.h>
10
11#ifdef USE_GCC_PRAGMAS
12#pragma implementation
13#endif
14
15#include <string.h>
16#include <stdio.h>
17#include <ctype.h>
18#ifdef ENABLE_PLUGINS
19#  ifndef WIN32
20#    include <dlfcn.h>
21#  endif
22#endif
23#ifdef WIN32
24#  include <shlobj.h>
25#endif
26#include "goo/gmem.h"
27#include "goo/GooString.h"
28#include "goo/GooList.h"
29#include "goo/GooHash.h"
30#include "goo/gfile.h"
31#include "Error.h"
32#include "NameToCharCode.h"
33#include "CharCodeToUnicode.h"
34#include "UnicodeMap.h"
35#include "CMap.h"
36#include "BuiltinFontTables.h"
37#include "FontEncodingTables.h"
38#ifdef ENABLE_PLUGINS
39#  include "XpdfPluginAPI.h"
40#endif
41#include "GlobalParams.h"
42#include "GfxFont.h"
43
44#ifdef WIN32
45#  define strcasecmp stricmp
46#endif
47
48#if MULTITHREADED
49#  define lockGlobalParams            gLockMutex(&mutex)
50#  define lockUnicodeMapCache         gLockMutex(&unicodeMapCacheMutex)
51#  define lockCMapCache               gLockMutex(&cMapCacheMutex)
52#  define unlockGlobalParams          gUnlockMutex(&mutex)
53#  define unlockUnicodeMapCache       gUnlockMutex(&unicodeMapCacheMutex)
54#  define unlockCMapCache             gUnlockMutex(&cMapCacheMutex)
55#else
56#  define lockGlobalParams
57#  define lockUnicodeMapCache
58#  define lockCMapCache
59#  define unlockGlobalParams
60#  define unlockUnicodeMapCache
61#  define unlockCMapCache
62#endif
63
64#ifndef FC_WEIGHT_BOOK
65#define FC_WEIGHT_BOOK 75
66#endif
67
68#include "NameToUnicodeTable.h"
69#include "UnicodeMapTables.h"
70#include "UTF8.h"
71
72#ifdef ENABLE_PLUGINS
73#  ifdef WIN32
74extern XpdfPluginVecTable xpdfPluginVecTable;
75#  endif
76#endif
77
78//------------------------------------------------------------------------
79
80#define cidToUnicodeCacheSize     4
81#define unicodeToUnicodeCacheSize 4
82
83//------------------------------------------------------------------------
84
85GlobalParams *globalParams = NULL;
86
87//------------------------------------------------------------------------
88// DisplayFontParam
89//------------------------------------------------------------------------
90
91DisplayFontParam::DisplayFontParam(GooString *nameA,
92                                   DisplayFontParamKind kindA) {
93  name = nameA;
94  kind = kindA;
95  switch (kind) {
96  case displayFontT1:
97    t1.fileName = NULL;
98    break;
99  case displayFontTT:
100    tt.fileName = NULL;
101    break;
102  }
103}
104
105DisplayFontParam::~DisplayFontParam() {
106  delete name;
107  switch (kind) {
108  case displayFontT1:
109    if (t1.fileName) {
110      delete t1.fileName;
111    }
112    break;
113  case displayFontTT:
114    if (tt.fileName) {
115      delete tt.fileName;
116    }
117    break;
118  }
119}
120
121#ifdef WIN32
122
123//------------------------------------------------------------------------
124// WinFontInfo
125//------------------------------------------------------------------------
126
127class WinFontInfo: public DisplayFontParam {
128public:
129
130  GBool bold, italic;
131
132  static WinFontInfo *make(GooString *nameA, GBool boldA, GBool italicA,
133                           HKEY regKey, char *winFontDir);
134  WinFontInfo(GooString *nameA, GBool boldA, GBool italicA,
135              GooString *fileNameA);
136  virtual ~WinFontInfo();
137  GBool equals(WinFontInfo *fi);
138};
139
140WinFontInfo *WinFontInfo::make(GooString *nameA, GBool boldA, GBool italicA,
141                               HKEY regKey, char *winFontDir) {
142  GooString *regName;
143  GooString *fileNameA;
144  char buf[MAX_PATH];
145  DWORD n;
146  char c;
147  int i;
148
149  //----- find the font file
150  fileNameA = NULL;
151  regName = nameA->copy();
152  if (boldA) {
153    regName->append(" Bold");
154  }
155  if (italicA) {
156    regName->append(" Italic");
157  }
158  regName->append(" (TrueType)");
159  n = sizeof(buf);
160  if (RegQueryValueEx(regKey, regName->getCString(), NULL, NULL,
161                      (LPBYTE)buf, &n) == ERROR_SUCCESS) {
162    fileNameA = new GooString(winFontDir);
163    fileNameA->append('\\')->append(buf);
164  }
165  delete regName;
166  if (!fileNameA) {
167    delete nameA;
168    return NULL;
169  }
170
171  //----- normalize the font name
172  i = 0;
173  while (i < nameA->getLength()) {
174    c = nameA->getChar(i);
175    if (c == ' ' || c == ',' || c == '-') {
176      nameA->del(i);
177    } else {
178      ++i;
179    }
180  }
181
182  return new WinFontInfo(nameA, boldA, italicA, fileNameA);
183}
184
185WinFontInfo::WinFontInfo(GooString *nameA, GBool boldA, GBool italicA,
186                         GooString *fileNameA):
187  DisplayFontParam(nameA, displayFontTT)
188{
189  bold = boldA;
190  italic = italicA;
191  tt.fileName = fileNameA;
192}
193
194WinFontInfo::~WinFontInfo() {
195}
196
197GBool WinFontInfo::equals(WinFontInfo *fi) {
198  return !name->cmp(fi->name) && bold == fi->bold && italic == fi->italic;
199}
200
201//------------------------------------------------------------------------
202// WinFontList
203//------------------------------------------------------------------------
204
205class WinFontList {
206public:
207
208  WinFontList(char *winFontDirA);
209  ~WinFontList();
210  WinFontInfo *find(GooString *font);
211
212private:
213
214  void add(WinFontInfo *fi);
215  static int CALLBACK enumFunc1(CONST LOGFONT *font,
216                                CONST TEXTMETRIC *metrics,
217                                DWORD type, LPARAM data);
218  static int CALLBACK enumFunc2(CONST LOGFONT *font,
219                                CONST TEXTMETRIC *metrics,
220                                DWORD type, LPARAM data);
221
222  GooList *fonts;                       // [WinFontInfo]
223  HDC dc;                       // (only used during enumeration)
224  HKEY regKey;                  // (only used during enumeration)
225  char *winFontDir;             // (only used during enumeration)
226};
227
228WinFontList::WinFontList(char *winFontDirA) {
229  OSVERSIONINFO version;
230  char *path;
231
232  fonts = new GooList();
233  dc = GetDC(NULL);
234  winFontDir = winFontDirA;
235  version.dwOSVersionInfoSize = sizeof(version);
236  GetVersionEx(&version);
237  if (version.dwPlatformId == VER_PLATFORM_WIN32_NT) {
238    path = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts\\";
239  } else {
240    path = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Fonts\\";
241  }
242  if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, path, 0,
243                   KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS,
244                   &regKey) == ERROR_SUCCESS) {
245    EnumFonts(dc, NULL, &WinFontList::enumFunc1, (LPARAM)this);
246    RegCloseKey(regKey);
247  }
248  ReleaseDC(NULL, dc);
249}
250
251WinFontList::~WinFontList() {
252  deleteGooList(fonts, WinFontInfo);
253}
254
255void WinFontList::add(WinFontInfo *fi) {
256  int i;
257
258  for (i = 0; i < fonts->getLength(); ++i) {
259    if (((WinFontInfo *)fonts->get(i))->equals(fi)) {
260      delete fi;
261      return;
262    }
263  }
264  fonts->append(fi);
265}
266
267WinFontInfo *WinFontList::find(GooString *font) {
268  GooString *name;
269  GBool bold, italic;
270  WinFontInfo *fi;
271  char c;
272  int n, i;
273
274  name = font->copy();
275
276  // remove space, comma, dash chars
277  i = 0;
278  while (i < name->getLength()) {
279    c = name->getChar(i);
280    if (c == ' ' || c == ',' || c == '-') {
281      name->del(i);
282    } else {
283      ++i;
284    }
285  }
286  n = name->getLength();
287
288  // remove trailing "MT" (Foo-MT, Foo-BoldMT, etc.)
289  if (!strcmp(name->getCString() + n - 2, "MT")) {
290    name->del(n - 2, 2);
291    n -= 2;
292  }
293
294  // look for "Italic"
295  if (!strcmp(name->getCString() + n - 6, "Italic")) {
296    name->del(n - 6, 6);
297    italic = gTrue;
298    n -= 6;
299  } else {
300    italic = gFalse;
301  }
302
303  // look for "Bold"
304  if (!strcmp(name->getCString() + n - 4, "Bold")) {
305    name->del(n - 4, 4);
306    bold = gTrue;
307    n -= 4;
308  } else {
309    bold = gFalse;
310  }
311
312  // remove trailing "MT" (FooMT-Bold, etc.)
313  if (!strcmp(name->getCString() + n - 2, "MT")) {
314    name->del(n - 2, 2);
315    n -= 2;
316  }
317
318  // remove trailing "PS"
319  if (!strcmp(name->getCString() + n - 2, "PS")) {
320    name->del(n - 2, 2);
321    n -= 2;
322  }
323
324  // search for the font
325  fi = NULL;
326  for (i = 0; i < fonts->getLength(); ++i) {
327    fi = (WinFontInfo *)fonts->get(i);
328    if (!fi->name->cmp(name) && fi->bold == bold && fi->italic == italic) {
329      break;
330    }
331    fi = NULL;
332  }
333
334  delete name;
335  return fi;
336}
337
338int CALLBACK WinFontList::enumFunc1(CONST LOGFONT *font,
339                                    CONST TEXTMETRIC *metrics,
340                                    DWORD type, LPARAM data) {
341  WinFontList *fl = (WinFontList *)data;
342
343  EnumFonts(fl->dc, font->lfFaceName, &WinFontList::enumFunc2, (LPARAM)fl);
344  return 1;
345}
346
347int CALLBACK WinFontList::enumFunc2(CONST LOGFONT *font,
348                                    CONST TEXTMETRIC *metrics,
349                                    DWORD type, LPARAM data) {
350  WinFontList *fl = (WinFontList *)data;
351  WinFontInfo *fi;
352
353  if (type & TRUETYPE_FONTTYPE) {
354    if ((fi = WinFontInfo::make(new GooString(font->lfFaceName),
355                                font->lfWeight >= 600,
356                                font->lfItalic ? gTrue : gFalse,
357                                fl->regKey, fl->winFontDir))) {
358      fl->add(fi);
359    }
360  }
361  return 1;
362}
363
364#endif // WIN32
365
366//------------------------------------------------------------------------
367// PSFontParam
368//------------------------------------------------------------------------
369
370PSFontParam::PSFontParam(GooString *pdfFontNameA, int wModeA,
371                         GooString *psFontNameA, GooString *encodingA) {
372  pdfFontName = pdfFontNameA;
373  wMode = wModeA;
374  psFontName = psFontNameA;
375  encoding = encodingA;
376}
377
378PSFontParam::~PSFontParam() {
379  delete pdfFontName;
380  delete psFontName;
381  if (encoding) {
382    delete encoding;
383  }
384}
385
386#ifdef ENABLE_PLUGINS
387//------------------------------------------------------------------------
388// Plugin
389//------------------------------------------------------------------------
390
391class Plugin {
392public:
393
394  static Plugin *load(char *type, char *name);
395  ~Plugin();
396
397private:
398
399#ifdef WIN32
400  Plugin(HMODULE libA);
401  HMODULE lib;
402#else
403  Plugin(void *dlA);
404  void *dl;
405#endif
406};
407
408Plugin *Plugin::load(char *type, char *name) {
409  GooString *path;
410  Plugin *plugin;
411  XpdfPluginVecTable *vt;
412  XpdfBool (*xpdfInitPlugin)(void);
413#ifdef WIN32
414  HMODULE libA;
415#else
416  void *dlA;
417#endif
418
419  path = globalParams->getBaseDir();
420  appendToPath(path, "plugins");
421  appendToPath(path, type);
422  appendToPath(path, name);
423
424#ifdef WIN32
425  path->append(".dll");
426  if (!(libA = LoadLibrary(path->getCString()))) {
427    error(-1, "Failed to load plugin '%s'",
428          path->getCString());
429    goto err1;
430  }
431  if (!(vt = (XpdfPluginVecTable *)
432                 GetProcAddress(libA, "xpdfPluginVecTable"))) {
433    error(-1, "Failed to find xpdfPluginVecTable in plugin '%s'",
434          path->getCString());
435    goto err2;
436  }
437#else
438  //~ need to deal with other extensions here
439  path->append(".so");
440  if (!(dlA = dlopen(path->getCString(), RTLD_NOW))) {
441    error(-1, "Failed to load plugin '%s': %s",
442          path->getCString(), dlerror());
443    goto err1;
444  }
445  if (!(vt = (XpdfPluginVecTable *)dlsym(dlA, "xpdfPluginVecTable"))) {
446    error(-1, "Failed to find xpdfPluginVecTable in plugin '%s'",
447          path->getCString());
448    goto err2;
449  }
450#endif
451
452  if (vt->version != xpdfPluginVecTable.version) {
453    error(-1, "Plugin '%s' is wrong version", path->getCString());
454    goto err2;
455  }
456  memcpy(vt, &xpdfPluginVecTable, sizeof(xpdfPluginVecTable));
457
458#ifdef WIN32
459  if (!(xpdfInitPlugin = (XpdfBool (*)(void))
460                             GetProcAddress(libA, "xpdfInitPlugin"))) {
461    error(-1, "Failed to find xpdfInitPlugin in plugin '%s'",
462          path->getCString());
463    goto err2;
464  }
465#else
466  if (!(xpdfInitPlugin = (XpdfBool (*)(void))dlsym(dlA, "xpdfInitPlugin"))) {
467    error(-1, "Failed to find xpdfInitPlugin in plugin '%s'",
468          path->getCString());
469    goto err2;
470  }
471#endif
472
473  if (!(*xpdfInitPlugin)()) {
474    error(-1, "Initialization of plugin '%s' failed",
475          path->getCString());
476    goto err2;
477  }
478
479#ifdef WIN32
480  plugin = new Plugin(libA);
481#else
482  plugin = new Plugin(dlA);
483#endif
484
485  delete path;
486  return plugin;
487
488 err2:
489#ifdef WIN32
490  FreeLibrary(libA);
491#else
492  dlclose(dlA);
493#endif
494 err1:
495  delete path;
496  return NULL;
497}
498
499#ifdef WIN32
500Plugin::Plugin(HMODULE libA) {
501  lib = libA;
502}
503#else
504Plugin::Plugin(void *dlA) {
505  dl = dlA;
506}
507#endif
508
509Plugin::~Plugin() {
510  void (*xpdfFreePlugin)(void);
511
512#ifdef WIN32
513  if ((xpdfFreePlugin = (void (*)(void))
514                            GetProcAddress(lib, "xpdfFreePlugin"))) {
515    (*xpdfFreePlugin)();
516  }
517  FreeLibrary(lib);
518#else
519  if ((xpdfFreePlugin = (void (*)(void))dlsym(dl, "xpdfFreePlugin"))) {
520    (*xpdfFreePlugin)();
521  }
522  dlclose(dl);
523#endif
524}
525
526#endif // ENABLE_PLUGINS
527
528//------------------------------------------------------------------------
529// parsing
530//------------------------------------------------------------------------
531
532GlobalParams::GlobalParams() {
533  UnicodeMap *map;
534  int i;
535
536#ifndef _MSC_VER 
537  FcInit();
538  FCcfg = FcConfigGetCurrent();
539#endif
540
541#if MULTITHREADED
542  gInitMutex(&mutex);
543  gInitMutex(&unicodeMapCacheMutex);
544  gInitMutex(&cMapCacheMutex);
545#endif
546
547  initBuiltinFontTables();
548
549  // scan the encoding in reverse because we want the lowest-numbered
550  // index for each char name ('space' is encoded twice)
551  macRomanReverseMap = new NameToCharCode();
552  for (i = 255; i >= 0; --i) {
553    if (macRomanEncoding[i]) {
554      macRomanReverseMap->add(macRomanEncoding[i], (CharCode)i);
555    }
556  }
557
558#ifdef WIN32
559  // baseDir will be set by a call to setBaseDir
560  baseDir = new GooString();
561#else
562  baseDir = appendToPath(getHomeDir(), ".xpdf");
563#endif
564  nameToUnicode = new NameToCharCode();
565  cidToUnicodes = new GooHash(gTrue);
566  unicodeToUnicodes = new GooHash(gTrue);
567  residentUnicodeMaps = new GooHash();
568  unicodeMaps = new GooHash(gTrue);
569  cMapDirs = new GooHash(gTrue);
570  toUnicodeDirs = new GooList();
571  displayFonts = new GooHash();
572  psExpandSmaller = gFalse;
573  psShrinkLarger = gTrue;
574  psCenter = gTrue;
575  psLevel = psLevel2;
576  psFonts = new GooHash();
577  psNamedFonts16 = new GooList();
578  psFonts16 = new GooList();
579  psEmbedType1 = gTrue;
580  psEmbedTrueType = gTrue;
581  psEmbedCIDPostScript = gTrue;
582  psEmbedCIDTrueType = gTrue;
583  psPreload = gFalse;
584  psOPI = gFalse;
585  psASCIIHex = gFalse;
586  textEncoding = new GooString("UTF-8");
587#if defined(WIN32)
588  textEOL = eolDOS;
589#elif defined(MACOS)
590  textEOL = eolMac;
591#else
592  textEOL = eolUnix;
593#endif
594  textPageBreaks = gTrue;
595  textKeepTinyChars = gFalse;
596  fontDirs = new GooList();
597  enableFreeType = gTrue;
598  antialias = gTrue;
599  vectorAntialias = gTrue;
600  strokeAdjust = gTrue;
601  screenType = screenUnset;
602  screenSize = -1;
603  screenDotRadius = -1;
604  screenGamma = 1.0;
605  screenBlackThreshold = 0.0;
606  screenWhiteThreshold = 1.0;
607  mapNumericCharNames = gTrue;
608  mapUnknownCharNames = gFalse;
609  printCommands = gFalse;
610  profileCommands = gFalse;
611  errQuiet = gFalse;
612
613  cidToUnicodeCache = new CharCodeToUnicodeCache(cidToUnicodeCacheSize);
614  unicodeToUnicodeCache =
615      new CharCodeToUnicodeCache(unicodeToUnicodeCacheSize);
616  unicodeMapCache = new UnicodeMapCache();
617  cMapCache = new CMapCache();
618
619#ifdef WIN32
620  winFontList = NULL;
621#endif
622
623#ifdef ENABLE_PLUGINS
624  plugins = new GooList();
625  securityHandlers = new GooList();
626#endif
627
628  // set up the initial nameToUnicode table
629  for (i = 0; nameToUnicodeTab[i].name; ++i) {
630    nameToUnicode->add(nameToUnicodeTab[i].name, nameToUnicodeTab[i].u);
631  }
632
633  // set up the residentUnicodeMaps table
634  map = new UnicodeMap("Latin1", gFalse,
635                       latin1UnicodeMapRanges, latin1UnicodeMapLen);
636  residentUnicodeMaps->add(map->getEncodingName(), map);
637  map = new UnicodeMap("ASCII7", gFalse,
638                       ascii7UnicodeMapRanges, ascii7UnicodeMapLen);
639  residentUnicodeMaps->add(map->getEncodingName(), map);
640  map = new UnicodeMap("Symbol", gFalse,
641                       symbolUnicodeMapRanges, symbolUnicodeMapLen);
642  residentUnicodeMaps->add(map->getEncodingName(), map);
643  map = new UnicodeMap("ZapfDingbats", gFalse, zapfDingbatsUnicodeMapRanges,
644                       zapfDingbatsUnicodeMapLen);
645  residentUnicodeMaps->add(map->getEncodingName(), map);
646  map = new UnicodeMap("UTF-8", gTrue, &mapUTF8);
647  residentUnicodeMaps->add(map->getEncodingName(), map);
648  map = new UnicodeMap("UCS-2", gTrue, &mapUCS2);
649  residentUnicodeMaps->add(map->getEncodingName(), map);
650
651  scanEncodingDirs();
652}
653
654void GlobalParams::scanEncodingDirs() {
655  GDir *dir;
656  GDirEntry *entry;
657
658  dir = new GDir(POPPLER_DATADIR "/nameToUnicode", gTrue);
659  while (entry = dir->getNextEntry(), entry != NULL) {
660    if (!entry->isDir()) {
661      parseNameToUnicode(entry->getFullPath());
662    }
663    delete entry;
664  }
665  delete dir;
666
667  dir = new GDir(POPPLER_DATADIR "/cidToUnicode", gFalse);
668  while (entry = dir->getNextEntry(), entry != NULL) {
669    addCIDToUnicode(entry->getName(), entry->getFullPath());
670    delete entry;
671  }
672  delete dir;
673
674  dir = new GDir(POPPLER_DATADIR "/unicodeMap", gFalse);
675  while (entry = dir->getNextEntry(), entry != NULL) {
676    addUnicodeMap(entry->getName(), entry->getFullPath());
677    delete entry;
678  }
679  delete dir;
680
681  dir = new GDir(POPPLER_DATADIR "/cMap", gFalse);
682  while (entry = dir->getNextEntry(), entry != NULL) {
683    addCMapDir(entry->getName(), entry->getFullPath());
684    toUnicodeDirs->append(entry->getFullPath()->copy());
685    delete entry;
686  }
687  delete dir;
688}
689
690void GlobalParams::parseNameToUnicode(GooString *name) {
691  char *tok1, *tok2;
692  FILE *f;
693  char buf[256];
694  int line;
695  Unicode u;
696
697  if (!(f = fopen(name->getCString(), "r"))) {
698    error(-1, "Couldn't open 'nameToUnicode' file '%s'",
699          name->getCString());
700    return;
701  }
702  line = 1;
703  while (getLine(buf, sizeof(buf), f)) {
704    tok1 = strtok(buf, " \t\r\n");
705    tok2 = strtok(NULL, " \t\r\n");
706    if (tok1 && tok2) {
707      sscanf(tok1, "%x", &u);
708      nameToUnicode->add(tok2, u);
709    } else {
710      error(-1, "Bad line in 'nameToUnicode' file (%s:%d)",
711            name->getCString(), line);
712    }
713    ++line;
714  }
715  fclose(f);
716}
717
718void GlobalParams::addCIDToUnicode(GooString *collection,
719                                   GooString *fileName) {
720  GooString *old;
721
722  if ((old = (GooString *)cidToUnicodes->remove(collection))) {
723    delete old;
724  }
725  cidToUnicodes->add(collection->copy(), fileName->copy());
726}
727
728void GlobalParams::addUnicodeMap(GooString *encodingName, GooString *fileName)
729{
730  GooString *old;
731
732  if ((old = (GooString *)unicodeMaps->remove(encodingName))) {
733    delete old;
734  }
735  unicodeMaps->add(encodingName->copy(), fileName->copy());
736}
737
738void GlobalParams::addCMapDir(GooString *collection, GooString *dir) {
739  GooList *list;
740
741  if (!(list = (GooList *)cMapDirs->lookup(collection))) {
742    list = new GooList();
743    cMapDirs->add(collection->copy(), list);
744  }
745  list->append(dir->copy());
746}
747
748GBool GlobalParams::parseYesNo2(char *token, GBool *flag) {
749  if (!strcmp(token, "yes")) {
750    *flag = gTrue;
751  } else if (!strcmp(token, "no")) {
752    *flag = gFalse;
753  } else {
754    return gFalse;
755  }
756  return gTrue;
757}
758
759GlobalParams::~GlobalParams() {
760  freeBuiltinFontTables();
761
762  delete macRomanReverseMap;
763
764  delete baseDir;
765  delete nameToUnicode;
766  deleteGooHash(cidToUnicodes, GooString);
767  deleteGooHash(unicodeToUnicodes, GooString);
768  deleteGooHash(residentUnicodeMaps, UnicodeMap);
769  deleteGooHash(unicodeMaps, GooString);
770  deleteGooList(toUnicodeDirs, GooString);
771  deleteGooHash(displayFonts, DisplayFontParam);
772#ifdef WIN32
773  delete winFontList;
774#endif
775  deleteGooHash(psFonts, PSFontParam);
776  deleteGooList(psNamedFonts16, PSFontParam);
777  deleteGooList(psFonts16, PSFontParam);
778  delete textEncoding;
779  deleteGooList(fontDirs, GooString);
780
781  GooHashIter *iter;
782  GooString *key;
783  cMapDirs->startIter(&iter);
784  void *val;
785  while (cMapDirs->getNext(&iter, &key, &val)) {
786    GooList* list = (GooList*)val;
787    deleteGooList(list, GooString);
788  }
789  delete cMapDirs;
790
791  delete cidToUnicodeCache;
792  delete unicodeToUnicodeCache;
793  delete unicodeMapCache;
794  delete cMapCache;
795
796#ifdef ENABLE_PLUGINS
797  delete securityHandlers;
798  deleteGooList(plugins, Plugin);
799#endif
800
801#if MULTITHREADED
802  gDestroyMutex(&mutex);
803  gDestroyMutex(&unicodeMapCacheMutex);
804  gDestroyMutex(&cMapCacheMutex);
805#endif
806}
807
808//------------------------------------------------------------------------
809
810void GlobalParams::setBaseDir(char *dir) {
811  delete baseDir;
812  baseDir = new GooString(dir);
813}
814
815//------------------------------------------------------------------------
816// accessors
817//------------------------------------------------------------------------
818
819CharCode GlobalParams::getMacRomanCharCode(char *charName) {
820  // no need to lock - macRomanReverseMap is constant
821  return macRomanReverseMap->lookup(charName);
822}
823
824GooString *GlobalParams::getBaseDir() {
825  GooString *s;
826
827  lockGlobalParams;
828  s = baseDir->copy();
829  unlockGlobalParams;
830  return s;
831}
832
833Unicode GlobalParams::mapNameToUnicode(char *charName) {
834  // no need to lock - nameToUnicode is constant
835  return nameToUnicode->lookup(charName);
836}
837
838UnicodeMap *GlobalParams::getResidentUnicodeMap(GooString *encodingName) {
839  UnicodeMap *map;
840
841  lockGlobalParams;
842  map = (UnicodeMap *)residentUnicodeMaps->lookup(encodingName);
843  unlockGlobalParams;
844  if (map) {
845    map->incRefCnt();
846  }
847  return map;
848}
849
850FILE *GlobalParams::getUnicodeMapFile(GooString *encodingName) {
851  GooString *fileName;
852  FILE *f;
853
854  lockGlobalParams;
855  if ((fileName = (GooString *)unicodeMaps->lookup(encodingName))) {
856    f = fopen(fileName->getCString(), "r");
857  } else {
858    f = NULL;
859  }
860  unlockGlobalParams;
861  return f;
862}
863
864FILE *GlobalParams::findCMapFile(GooString *collection, GooString *cMapName) {
865  GooList *list;
866  GooString *dir;
867  GooString *fileName;
868  FILE *f;
869  int i;
870
871  lockGlobalParams;
872  if (!(list = (GooList *)cMapDirs->lookup(collection))) {
873    unlockGlobalParams;
874    return NULL;
875  }
876  for (i = 0; i < list->getLength(); ++i) {
877    dir = (GooString *)list->get(i);
878    fileName = appendToPath(dir->copy(), cMapName->getCString());
879    f = fopen(fileName->getCString(), "r");
880    delete fileName;
881    if (f) {
882      unlockGlobalParams;
883      return f;
884    }
885  }
886  unlockGlobalParams;
887  return NULL;
888}
889
890FILE *GlobalParams::findToUnicodeFile(GooString *name) {
891  GooString *dir, *fileName;
892  FILE *f;
893  int i;
894
895  lockGlobalParams;
896  for (i = 0; i < toUnicodeDirs->getLength(); ++i) {
897    dir = (GooString *)toUnicodeDirs->get(i);
898    fileName = appendToPath(dir->copy(), name->getCString());
899    f = fopen(fileName->getCString(), "r");
900    delete fileName;
901    if (f) {
902      unlockGlobalParams;
903      return f;
904    }
905  }
906  unlockGlobalParams;
907  return NULL;
908}
909
910GBool findModifier(const char *name, const char *modifier, const char **start)
911{
912  const char *match;
913
914  if (name == NULL)
915    return gFalse;
916
917  match = strstr(name, modifier);
918  if (match) {
919    if (*start == NULL || match < *start)
920      *start = match;
921    return gTrue;
922  }
923  else {
924    return gFalse;
925  }
926}
927
928#ifndef _MSC_VER
929static FcPattern *buildFcPattern(GfxFont *font)
930{
931  int weight = -1,
932      slant = -1,
933      width = -1,
934      spacing = -1;
935  bool deleteFamily = false;
936  char *family, *name, *lang, *modifiers;
937  const char *start;
938  FcPattern *p;
939
940  // this is all heuristics will be overwritten if font had proper info
941  name = font->getName()->getCString();
942 
943  modifiers = strchr (name, ',');
944  if (modifiers == NULL)
945    modifiers = strchr (name, '-');
946 
947  // remove the - from the names, for some reason, Fontconfig does not
948  // understand "MS-Mincho" but does with "MS Mincho"
949  int len = strlen(name);
950  for (int i = 0; i < len; i++)
951    name[i] = (name[i] == '-' ? ' ' : name[i]);
952
953  start = NULL;
954  findModifier(modifiers, "Regular", &start);
955  findModifier(modifiers, "Roman", &start);
956 
957  if (findModifier(modifiers, "Oblique", &start))
958    slant = FC_SLANT_OBLIQUE;
959  if (findModifier(modifiers, "Italic", &start))
960    slant = FC_SLANT_ITALIC;
961  if (findModifier(modifiers, "Bold", &start))
962    weight = FC_WEIGHT_BOLD;
963  if (findModifier(modifiers, "Light", &start))
964    weight = FC_WEIGHT_LIGHT;
965  if (findModifier(modifiers, "Condensed", &start))
966    width = FC_WIDTH_CONDENSED;
967 
968  if (start) {
969    // There have been "modifiers" in the name, crop them to obtain
970    // the family name
971    family = new char[len+1];
972    strcpy(family, name);
973    int pos = (modifiers - name);
974    family[pos] = '\0';
975    deleteFamily = true;
976  }
977  else {
978    family = name;
979  }
980 
981  // use font flags
982  if (font->isFixedWidth())
983    spacing = FC_MONO;
984  if (font->isBold())
985    weight = FC_WEIGHT_BOLD;
986  if (font->isItalic())
987    slant = FC_SLANT_ITALIC;
988 
989  // if the FontDescriptor specified a family name use it
990  if (font->getFamily()) {
991    if (deleteFamily) {
992      delete[] family;
993      deleteFamily = false;
994    }
995    family = font->getFamily()->getCString();
996  }
997 
998  // if the FontDescriptor specified a weight use it
999  switch (font -> getWeight())
1000  {
1001    case GfxFont::W100: weight = FC_WEIGHT_EXTRALIGHT; break; 
1002    case GfxFont::W200: weight = FC_WEIGHT_LIGHT; break; 
1003    case GfxFont::W300: weight = FC_WEIGHT_BOOK; break; 
1004    case GfxFont::W400: weight = FC_WEIGHT_NORMAL; break; 
1005    case GfxFont::W500: weight = FC_WEIGHT_MEDIUM; break; 
1006    case GfxFont::W600: weight = FC_WEIGHT_DEMIBOLD; break; 
1007    case GfxFont::W700: weight = FC_WEIGHT_BOLD; break; 
1008    case GfxFont::W800: weight = FC_WEIGHT_EXTRABOLD; break; 
1009    case GfxFont::W900: weight = FC_WEIGHT_BLACK; break; 
1010    default: break; 
1011  }
1012 
1013  // if the FontDescriptor specified a width use it
1014  switch (font -> getStretch())
1015  {
1016    case GfxFont::UltraCondensed: width = FC_WIDTH_ULTRACONDENSED; break; 
1017    case GfxFont::ExtraCondensed: width = FC_WIDTH_EXTRACONDENSED; break; 
1018    case GfxFont::Condensed: width = FC_WIDTH_CONDENSED; break; 
1019    case GfxFont::SemiCondensed: width = FC_WIDTH_SEMICONDENSED; break; 
1020    case GfxFont::Normal: width = FC_WIDTH_NORMAL; break; 
1021    case GfxFont::SemiExpanded: width = FC_WIDTH_SEMIEXPANDED; break; 
1022    case GfxFont::Expanded: width = FC_WIDTH_EXPANDED; break; 
1023    case GfxFont::ExtraExpanded: width = FC_WIDTH_EXTRAEXPANDED; break; 
1024    case GfxFont::UltraExpanded: width = FC_WIDTH_ULTRAEXPANDED; break; 
1025    default: break; 
1026  }
1027 
1028  // find the language we want the font to support
1029  if (font->isCIDFont())
1030  {
1031    GooString *collection = ((GfxCIDFont *)font)->getCollection();
1032    if (collection)
1033    {
1034      if (strcmp(collection->getCString(), "Adobe-GB1") == 0)
1035        lang = "zh-cn"; // Simplified Chinese
1036      else if (strcmp(collection->getCString(), "Adobe-CNS1") == 0)
1037        lang = "zh-tw"; // Traditional Chinese
1038      else if (strcmp(collection->getCString(), "Adobe-Japan1") == 0)
1039        lang = "ja"; // Japanese
1040      else if (strcmp(collection->getCString(), "Adobe-Japan2") == 0)
1041        lang = "ja"; // Japanese
1042      else if (strcmp(collection->getCString(), "Adobe-Korea1") == 0)
1043        lang = "ko"; // Korean
1044      else if (strcmp(collection->getCString(), "Adobe-UCS") == 0)
1045        lang = "xx";
1046      else if (strcmp(collection->getCString(), "Adobe-Identity") == 0)
1047        lang = "xx";
1048      else
1049      {
1050        error(-1, "Unknown CID font collection, please report to poppler bugzilla.");
1051        lang = "xx";
1052      }
1053    }
1054    else lang = "xx";
1055  }
1056  else lang = "xx";
1057 
1058  /*p = FcPatternBuild(NULL,
1059                    FC_FAMILY, FcTypeString, family,
1060                    FC_LANG, FcTypeString, lang,
1061                    NULL);
1062  if (slant != -1) FcPatternAddInteger(p, FC_SLANT, slant);
1063  if (weight != -1) FcPatternAddInteger(p, FC_WEIGHT, weight);
1064  if (width != -1) FcPatternAddInteger(p, FC_WIDTH, width);
1065  if (spacing != -1) FcPatternAddInteger(p, FC_SPACING, spacing);*/
1066 
1067  p = FcPatternBuild(NULL,
1068                    FC_FAMILY, FcTypeString, family,
1069                    FC_SLANT, FcTypeInteger, slant, 
1070                    FC_WEIGHT, FcTypeInteger, weight,
1071                    FC_WIDTH, FcTypeInteger, width, 
1072                    FC_SPACING, FcTypeInteger, spacing,
1073                    FC_LANG, FcTypeString, lang,
1074                    NULL);
1075 
1076  if (deleteFamily)
1077    delete[] family;
1078  return p;
1079}
1080#endif
1081
1082/* if you can't or don't want to use Fontconfig, you need to implement
1083   this function for your platform. For Windows, it's in GlobalParamsWin.cc
1084*/
1085#ifndef _MSC_VER
1086DisplayFontParam *GlobalParams::getDisplayFont(GfxFont *font) {
1087  DisplayFontParam *dfp;
1088  FcPattern *p=0;
1089
1090  GooString *fontName = font->getName();
1091  if (!fontName) return NULL;
1092 
1093  lockGlobalParams;
1094  dfp = font->dfp;
1095  if (!dfp)
1096  {
1097    FcChar8* s;
1098    char * ext;
1099    FcResult res;
1100    FcFontSet *set;
1101    int i;
1102    p = buildFcPattern(font);
1103
1104    if (!p)
1105      goto fin;
1106    FcConfigSubstitute(FCcfg, p, FcMatchPattern);
1107    FcDefaultSubstitute(p);
1108    set = FcFontSort(FCcfg, p, FcFalse, NULL, &res);
1109    if (!set)
1110      goto fin;
1111    for (i = 0; i < set->nfont; ++i)
1112    {
1113      res = FcPatternGetString(set->fonts[i], FC_FILE, 0, &s);
1114      if (res != FcResultMatch || !s)
1115        continue;
1116      ext = strrchr((char*)s,'.');
1117      if (!ext)
1118        continue;
1119      if (!strncasecmp(ext,".ttf",4) || !strncasecmp(ext, ".ttc", 4))
1120      {
1121        dfp = new DisplayFontParam(fontName->copy(), displayFontTT); 
1122        dfp->tt.fileName = new GooString((char*)s);
1123        FcPatternGetInteger(set->fonts[i], FC_INDEX, 0, &(dfp->tt.faceIndex));
1124      }
1125      else if (!strncasecmp(ext,".pfa",4) || !strncasecmp(ext,".pfb",4)) 
1126      {
1127        dfp = new DisplayFontParam(fontName->copy(), displayFontT1); 
1128        dfp->t1.fileName = new GooString((char*)s);
1129      }
1130      else
1131        continue;
1132      font->dfp = dfp;
1133      break;
1134    }
1135    FcFontSetDestroy(set);
1136  }
1137fin:
1138  if (p)
1139    FcPatternDestroy(p);
1140
1141  unlockGlobalParams;
1142  return dfp;
1143}
1144#endif
1145
1146GBool GlobalParams::getPSExpandSmaller() {
1147  GBool f;
1148
1149  lockGlobalParams;
1150  f = psExpandSmaller;
1151  unlockGlobalParams;
1152  return f;
1153}
1154
1155GBool GlobalParams::getPSShrinkLarger() {
1156  GBool f;
1157
1158  lockGlobalParams;
1159  f = psShrinkLarger;
1160  unlockGlobalParams;
1161  return f;
1162}
1163
1164GBool GlobalParams::getPSCenter() {
1165  GBool f;
1166
1167  lockGlobalParams;
1168  f = psCenter;
1169  unlockGlobalParams;
1170  return f;
1171}
1172
1173PSLevel GlobalParams::getPSLevel() {
1174  PSLevel level;
1175
1176  lockGlobalParams;
1177  level = psLevel;
1178  unlockGlobalParams;
1179  return level;
1180}
1181
1182PSFontParam *GlobalParams::getPSFont(GooString *fontName) {
1183  PSFontParam *p;
1184
1185  lockGlobalParams;
1186  p = (PSFontParam *)psFonts->lookup(fontName);
1187  unlockGlobalParams;
1188  return p;
1189}
1190
1191PSFontParam *GlobalParams::getPSFont16(GooString *fontName,
1192                                       GooString *collection, int wMode) {
1193  PSFontParam *p;
1194  int i;
1195
1196  lockGlobalParams;
1197  p = NULL;
1198  if (fontName) {
1199    for (i = 0; i < psNamedFonts16->getLength(); ++i) {
1200      p = (PSFontParam *)psNamedFonts16->get(i);
1201      if (!p->pdfFontName->cmp(fontName) &&
1202          p->wMode == wMode) {
1203        break;
1204      }
1205      p = NULL;
1206    }
1207  }
1208  if (!p && collection) {
1209    for (i = 0; i < psFonts16->getLength(); ++i) {
1210      p = (PSFontParam *)psFonts16->get(i);
1211      if (!p->pdfFontName->cmp(collection) &&
1212          p->wMode == wMode) {
1213        break;
1214      }
1215      p = NULL;
1216    }
1217  }
1218  unlockGlobalParams;
1219  return p;
1220}
1221
1222GBool GlobalParams::getPSEmbedType1() {
1223  GBool e;
1224
1225  lockGlobalParams;
1226  e = psEmbedType1;
1227  unlockGlobalParams;
1228  return e;
1229}
1230
1231GBool GlobalParams::getPSEmbedTrueType() {
1232  GBool e;
1233
1234  lockGlobalParams;
1235  e = psEmbedTrueType;
1236  unlockGlobalParams;
1237  return e;
1238}
1239
1240GBool GlobalParams::getPSEmbedCIDPostScript() {
1241  GBool e;
1242
1243  lockGlobalParams;
1244  e = psEmbedCIDPostScript;
1245  unlockGlobalParams;
1246  return e;
1247}
1248
1249GBool GlobalParams::getPSEmbedCIDTrueType() {
1250  GBool e;
1251
1252  lockGlobalParams;
1253  e = psEmbedCIDTrueType;
1254  unlockGlobalParams;
1255  return e;
1256}
1257
1258GBool GlobalParams::getPSPreload() {
1259  GBool preload;
1260
1261  lockGlobalParams;
1262  preload = psPreload;
1263  unlockGlobalParams;
1264  return preload;
1265}
1266
1267GBool GlobalParams::getPSOPI() {
1268  GBool opi;
1269
1270  lockGlobalParams;
1271  opi = psOPI;
1272  unlockGlobalParams;
1273  return opi;
1274}
1275
1276GBool GlobalParams::getPSASCIIHex() {
1277  GBool ah;
1278
1279  lockGlobalParams;
1280  ah = psASCIIHex;
1281  unlockGlobalParams;
1282  return ah;
1283}
1284
1285GooString *GlobalParams::getTextEncodingName() {
1286  GooString *s;
1287
1288  lockGlobalParams;
1289  s = textEncoding->copy();
1290  unlockGlobalParams;
1291  return s;
1292}
1293
1294EndOfLineKind GlobalParams::getTextEOL() {
1295  EndOfLineKind eol;
1296
1297  lockGlobalParams;
1298  eol = textEOL;
1299  unlockGlobalParams;
1300  return eol;
1301}
1302
1303GBool GlobalParams::getTextPageBreaks() {
1304  GBool pageBreaks;
1305
1306  lockGlobalParams;
1307  pageBreaks = textPageBreaks;
1308  unlockGlobalParams;
1309  return pageBreaks;
1310}
1311
1312GBool GlobalParams::getTextKeepTinyChars() {
1313  GBool tiny;
1314
1315  lockGlobalParams;
1316  tiny = textKeepTinyChars;
1317  unlockGlobalParams;
1318  return tiny;
1319}
1320
1321GooString *GlobalParams::findFontFile(GooString *fontName, char **exts) {
1322  GooString *dir, *fileName;
1323  char **ext;
1324  FILE *f;
1325  int i;
1326
1327  lockGlobalParams;
1328  for (i = 0; i < fontDirs->getLength(); ++i) {
1329    dir = (GooString *)fontDirs->get(i);
1330    for (ext = exts; *ext; ++ext) {
1331      fileName = appendToPath(dir->copy(), fontName->getCString());
1332      fileName->append(*ext);
1333      if ((f = fopen(fileName->getCString(), "rb"))) {
1334        fclose(f);
1335        unlockGlobalParams;
1336        return fileName;
1337      }
1338      delete fileName;
1339    }
1340  }
1341  unlockGlobalParams;
1342  return NULL;
1343}
1344
1345GBool GlobalParams::getEnableFreeType() {
1346  GBool f;
1347
1348  lockGlobalParams;
1349  f = enableFreeType;
1350  unlockGlobalParams;
1351  return f;
1352}
1353
1354
1355GBool GlobalParams::getAntialias() {
1356  GBool f;
1357
1358  lockGlobalParams;
1359  f = antialias;
1360  unlockGlobalParams;
1361  return f;
1362}
1363
1364GBool GlobalParams::getVectorAntialias() {
1365  GBool f;
1366
1367  lockGlobalParams;
1368  f = vectorAntialias;
1369  unlockGlobalParams;
1370  return f;
1371}
1372
1373GBool GlobalParams::getStrokeAdjust() {
1374  GBool f;
1375
1376  lockGlobalParams;
1377  f = strokeAdjust;
1378  unlockGlobalParams;
1379  return f;
1380}
1381
1382ScreenType GlobalParams::getScreenType() {
1383  ScreenType t;
1384
1385  lockGlobalParams;
1386  t = screenType;
1387  unlockGlobalParams;
1388  return t;
1389}
1390
1391int GlobalParams::getScreenSize() {
1392  int size;
1393
1394  lockGlobalParams;
1395  size = screenSize;
1396  unlockGlobalParams;
1397  return size;
1398}
1399
1400int GlobalParams::getScreenDotRadius() {
1401  int r;
1402
1403  lockGlobalParams;
1404  r = screenDotRadius;
1405  unlockGlobalParams;
1406  return r;
1407}
1408
1409double GlobalParams::getScreenGamma() {
1410  double gamma;
1411
1412  lockGlobalParams;
1413  gamma = screenGamma;
1414  unlockGlobalParams;
1415  return gamma;
1416}
1417
1418double GlobalParams::getScreenBlackThreshold() {
1419  double thresh;
1420
1421  lockGlobalParams;
1422  thresh = screenBlackThreshold;
1423  unlockGlobalParams;
1424  return thresh;
1425}
1426
1427double GlobalParams::getScreenWhiteThreshold() {
1428  double thresh;
1429
1430  lockGlobalParams;
1431  thresh = screenWhiteThreshold;
1432  unlockGlobalParams;
1433  return thresh;
1434}
1435
1436GBool GlobalParams::getMapNumericCharNames() {
1437  GBool map;
1438
1439  lockGlobalParams;
1440  map = mapNumericCharNames;
1441  unlockGlobalParams;
1442  return map;
1443}
1444
1445GBool GlobalParams::getMapUnknownCharNames() {
1446  GBool map;
1447
1448  lockGlobalParams;
1449  map = mapUnknownCharNames;
1450  unlockGlobalParams;
1451  return map;
1452}
1453
1454GBool GlobalParams::getPrintCommands() {
1455  GBool p;
1456
1457  lockGlobalParams;
1458  p = printCommands;
1459  unlockGlobalParams;
1460  return p;
1461}
1462
1463GBool GlobalParams::getProfileCommands() {
1464  GBool p;
1465
1466  lockGlobalParams;
1467  p = profileCommands;
1468  unlockGlobalParams;
1469  return p;
1470}
1471
1472GBool GlobalParams::getErrQuiet() {
1473  // no locking -- this function may get called from inside a locked
1474  // section
1475  return errQuiet;
1476}
1477
1478CharCodeToUnicode *GlobalParams::getCIDToUnicode(GooString *collection) {
1479  GooString *fileName;
1480  CharCodeToUnicode *ctu;
1481
1482  lockGlobalParams;
1483  if (!(ctu = cidToUnicodeCache->getCharCodeToUnicode(collection))) {
1484    if ((fileName = (GooString *)cidToUnicodes->lookup(collection)) &&
1485        (ctu = CharCodeToUnicode::parseCIDToUnicode(fileName, collection))) {
1486      cidToUnicodeCache->add(ctu);
1487    }
1488  }
1489  unlockGlobalParams;
1490  return ctu;
1491}
1492
1493CharCodeToUnicode *GlobalParams::getUnicodeToUnicode(GooString *fontName) {
1494  lockGlobalParams;
1495  GooHashIter *iter;
1496  unicodeToUnicodes->startIter(&iter);
1497  GooString *fileName = NULL;
1498  GooString *fontPattern;
1499  void *val;
1500  while (!fileName && unicodeToUnicodes->getNext(&iter, &fontPattern, &val)) {
1501    if (strstr(fontName->getCString(), fontPattern->getCString())) {
1502      unicodeToUnicodes->killIter(&iter);
1503      fileName = (GooString*)val;
1504    }
1505  }
1506  CharCodeToUnicode *ctu = NULL;
1507  if (fileName) {
1508    ctu = unicodeToUnicodeCache->getCharCodeToUnicode(fileName);
1509    if (!ctu) {
1510      ctu = CharCodeToUnicode::parseUnicodeToUnicode(fileName);
1511      if (ctu)
1512         unicodeToUnicodeCache->add(ctu);
1513    }
1514  }
1515  unlockGlobalParams;
1516  return ctu;
1517}
1518
1519UnicodeMap *GlobalParams::getUnicodeMap(GooString *encodingName) {
1520  return getUnicodeMap2(encodingName);
1521}
1522
1523UnicodeMap *GlobalParams::getUnicodeMap2(GooString *encodingName) {
1524  UnicodeMap *map;
1525
1526  if (!(map = getResidentUnicodeMap(encodingName))) {
1527    lockUnicodeMapCache;
1528    map = unicodeMapCache->getUnicodeMap(encodingName);
1529    unlockUnicodeMapCache;
1530  }
1531  return map;
1532}
1533
1534CMap *GlobalParams::getCMap(GooString *collection, GooString *cMapName) {
1535  CMap *cMap;
1536
1537  lockCMapCache;
1538  cMap = cMapCache->getCMap(collection, cMapName);
1539  unlockCMapCache;
1540  return cMap;
1541}
1542
1543UnicodeMap *GlobalParams::getTextEncoding() {
1544  return getUnicodeMap2(textEncoding);
1545}
1546
1547//------------------------------------------------------------------------
1548// functions to set parameters
1549//------------------------------------------------------------------------
1550
1551void GlobalParams::setPSExpandSmaller(GBool expand) {
1552  lockGlobalParams;
1553  psExpandSmaller = expand;
1554  unlockGlobalParams;
1555}
1556
1557void GlobalParams::setPSShrinkLarger(GBool shrink) {
1558  lockGlobalParams;
1559  psShrinkLarger = shrink;
1560  unlockGlobalParams;
1561}
1562
1563void GlobalParams::setPSCenter(GBool center) {
1564  lockGlobalParams;
1565  psCenter = center;
1566  unlockGlobalParams;
1567}
1568
1569void GlobalParams::setPSLevel(PSLevel level) {
1570  lockGlobalParams;
1571  psLevel = level;
1572  unlockGlobalParams;
1573}
1574
1575void GlobalParams::setPSEmbedType1(GBool embed) {
1576  lockGlobalParams;
1577  psEmbedType1 = embed;
1578  unlockGlobalParams;
1579}
1580
1581void GlobalParams::setPSEmbedTrueType(GBool embed) {
1582  lockGlobalParams;
1583  psEmbedTrueType = embed;
1584  unlockGlobalParams;
1585}
1586
1587void GlobalParams::setPSEmbedCIDPostScript(GBool embed) {
1588  lockGlobalParams;
1589  psEmbedCIDPostScript = embed;
1590  unlockGlobalParams;
1591}
1592
1593void GlobalParams::setPSEmbedCIDTrueType(GBool embed) {
1594  lockGlobalParams;
1595  psEmbedCIDTrueType = embed;
1596  unlockGlobalParams;
1597}
1598
1599void GlobalParams::setPSPreload(GBool preload) {
1600  lockGlobalParams;
1601  psPreload = preload;
1602  unlockGlobalParams;
1603}
1604
1605void GlobalParams::setPSOPI(GBool opi) {
1606  lockGlobalParams;
1607  psOPI = opi;
1608  unlockGlobalParams;
1609}
1610
1611void GlobalParams::setPSASCIIHex(GBool hex) {
1612  lockGlobalParams;
1613  psASCIIHex = hex;
1614  unlockGlobalParams;
1615}
1616
1617void GlobalParams::setTextEncoding(char *encodingName) {
1618  lockGlobalParams;
1619  delete textEncoding;
1620  textEncoding = new GooString(encodingName);
1621  unlockGlobalParams;
1622}
1623
1624GBool GlobalParams::setTextEOL(char *s) {
1625  lockGlobalParams;
1626  if (!strcmp(s, "unix")) {
1627    textEOL = eolUnix;
1628  } else if (!strcmp(s, "dos")) {
1629    textEOL = eolDOS;
1630  } else if (!strcmp(s, "mac")) {
1631    textEOL = eolMac;
1632  } else {
1633    unlockGlobalParams;
1634    return gFalse;
1635  }
1636  unlockGlobalParams;
1637  return gTrue;
1638}
1639
1640void GlobalParams::setTextPageBreaks(GBool pageBreaks) {
1641  lockGlobalParams;
1642  textPageBreaks = pageBreaks;
1643  unlockGlobalParams;
1644}
1645
1646void GlobalParams::setTextKeepTinyChars(GBool keep) {
1647  lockGlobalParams;
1648  textKeepTinyChars = keep;
1649  unlockGlobalParams;
1650}
1651
1652GBool GlobalParams::setEnableFreeType(char *s) {
1653  GBool ok;
1654
1655  lockGlobalParams;
1656  ok = parseYesNo2(s, &enableFreeType);
1657  unlockGlobalParams;
1658  return ok;
1659}
1660
1661
1662GBool GlobalParams::setAntialias(char *s) {
1663  GBool ok;
1664
1665  lockGlobalParams;
1666  ok = parseYesNo2(s, &antialias);
1667  unlockGlobalParams;
1668  return ok;
1669}
1670
1671GBool GlobalParams::setVectorAntialias(char *s) {
1672  GBool ok;
1673
1674  lockGlobalParams;
1675  ok = parseYesNo2(s, &vectorAntialias);
1676  unlockGlobalParams;
1677  return ok;
1678}
1679
1680void GlobalParams::setStrokeAdjust(GBool adjust)
1681{
1682  lockGlobalParams;
1683  strokeAdjust = adjust;
1684  unlockGlobalParams;
1685}
1686
1687void GlobalParams::setScreenType(ScreenType st)
1688{
1689  lockGlobalParams;
1690  screenType = st;
1691  unlockGlobalParams;
1692}
1693
1694void GlobalParams::setScreenSize(int size)
1695{
1696  lockGlobalParams;
1697  screenSize = size;
1698  unlockGlobalParams;
1699}
1700
1701void GlobalParams::setScreenDotRadius(int radius)
1702{
1703  lockGlobalParams;
1704  screenDotRadius = radius;
1705  unlockGlobalParams;
1706}
1707
1708void GlobalParams::setScreenGamma(double gamma)
1709{
1710  lockGlobalParams;
1711  screenGamma = gamma;
1712  unlockGlobalParams;
1713}
1714
1715void GlobalParams::setScreenBlackThreshold(double blackThreshold)
1716{
1717  lockGlobalParams;
1718  screenBlackThreshold = blackThreshold;
1719  unlockGlobalParams;
1720}
1721
1722void GlobalParams::setScreenWhiteThreshold(double whiteThreshold)
1723{
1724  lockGlobalParams;
1725  screenWhiteThreshold = whiteThreshold;
1726  unlockGlobalParams;
1727}
1728
1729void GlobalParams::setMapNumericCharNames(GBool map) {
1730  lockGlobalParams;
1731  mapNumericCharNames = map;
1732  unlockGlobalParams;
1733}
1734
1735void GlobalParams::setMapUnknownCharNames(GBool map) {
1736  lockGlobalParams;
1737  mapUnknownCharNames = map;
1738  unlockGlobalParams;
1739}
1740
1741void GlobalParams::setPrintCommands(GBool printCommandsA) {
1742  lockGlobalParams;
1743  printCommands = printCommandsA;
1744  unlockGlobalParams;
1745}
1746
1747void GlobalParams::setProfileCommands(GBool profileCommandsA) {
1748  lockGlobalParams;
1749  profileCommands = profileCommandsA;
1750  unlockGlobalParams;
1751}
1752
1753void GlobalParams::setErrQuiet(GBool errQuietA) {
1754  lockGlobalParams;
1755  errQuiet = errQuietA;
1756  unlockGlobalParams;
1757}
1758
1759void GlobalParams::addSecurityHandler(XpdfSecurityHandler *handler) {
1760#ifdef ENABLE_PLUGINS
1761  lockGlobalParams;
1762  securityHandlers->append(handler);
1763  unlockGlobalParams;
1764#endif
1765}
1766
1767XpdfSecurityHandler *GlobalParams::getSecurityHandler(char *name) {
1768#ifdef ENABLE_PLUGINS
1769  XpdfSecurityHandler *hdlr;
1770  int i;
1771
1772  lockGlobalParams;
1773  for (i = 0; i < securityHandlers->getLength(); ++i) {
1774    hdlr = (XpdfSecurityHandler *)securityHandlers->get(i);
1775    if (!strcasecmp(hdlr->name, name)) {
1776      unlockGlobalParams;
1777      return hdlr;
1778    }
1779  }
1780  unlockGlobalParams;
1781
1782  if (!loadPlugin("security", name)) {
1783    return NULL;
1784  }
1785  deleteGooList(keyBindings, KeyBinding);
1786
1787  lockGlobalParams;
1788  for (i = 0; i < securityHandlers->getLength(); ++i) {
1789    hdlr = (XpdfSecurityHandler *)securityHandlers->get(i);
1790    if (!strcmp(hdlr->name, name)) {
1791      unlockGlobalParams;
1792      return hdlr;
1793    }
1794  }
1795  unlockGlobalParams;
1796#else
1797  (void)name;
1798#endif
1799
1800  return NULL;
1801}
1802
1803#ifdef ENABLE_PLUGINS
1804//------------------------------------------------------------------------
1805// plugins
1806//------------------------------------------------------------------------
1807
1808GBool GlobalParams::loadPlugin(char *type, char *name) {
1809  Plugin *plugin;
1810
1811  if (!(plugin = Plugin::load(type, name))) {
1812    return gFalse;
1813  }
1814  lockGlobalParams;
1815  plugins->append(plugin);
1816  unlockGlobalParams;
1817  return gTrue;
1818}
1819
1820#endif // ENABLE_PLUGINS
Note: See TracBrowser for help on using the repository browser.