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

Last change on this file since 290 was 290, checked in by rbri, 12 years ago

PDF plugin: Poppler library updated to version 0.12.4

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