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

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

PDF plugin: Poppler library updated to version 0.10.0

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