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

Last change on this file since 461 was 461, checked in by Silvan Scherrer, 11 years ago

poppler update to 0.14.2

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