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

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

PDF plugin: Poppler library updated to version 0.12.3

File size: 43.4 KB
Line 
1//========================================================================
2//
3// GlobalParams.cc
4//
5// Copyright 2001-2003 Glyph & Cog, LLC
6//
7//========================================================================
8
9//========================================================================
10//
11// Modified under the Poppler project - http://poppler.freedesktop.org
12//
13// Copyright (C) 2005 Martin Kretzschmar <martink@gnome.org>
14// Copyright (C) 2005, 2006 Kristian HÞgsberg <krh@redhat.com>
15// Copyright (C) 2005, 2007-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  /*p = FcPatternBuild(NULL,
1096                    FC_FAMILY, FcTypeString, family,
1097                    FC_LANG, FcTypeString, lang,
1098                    NULL);
1099  if (slant != -1) FcPatternAddInteger(p, FC_SLANT, slant);
1100  if (weight != -1) FcPatternAddInteger(p, FC_WEIGHT, weight);
1101  if (width != -1) FcPatternAddInteger(p, FC_WIDTH, width);
1102  if (spacing != -1) FcPatternAddInteger(p, FC_SPACING, spacing);*/
1103
1104  p = FcPatternBuild(NULL,
1105                     FC_FAMILY, FcTypeString, family,
1106                     FC_SLANT, FcTypeInteger, slant, 
1107                     FC_WEIGHT, FcTypeInteger, weight,
1108                     FC_WIDTH, FcTypeInteger, width, 
1109                     FC_SPACING, FcTypeInteger, spacing,
1110                     FC_LANG, FcTypeString, lang,
1111                     NULL);
1112 
1113  if (deleteFamily)
1114    delete[] family;
1115  return p;
1116}
1117#endif
1118
1119/* if you can't or don't want to use Fontconfig, you need to implement
1120   this function for your platform. For Windows, it's in GlobalParamsWin.cc
1121*/
1122#ifndef _MSC_VER
1123DisplayFontParam *GlobalParams::getDisplayFont(GfxFont *font) {
1124  DisplayFontParam *dfp;
1125  FcPattern *p=0;
1126
1127  GooString *fontName = font->getName();
1128  if (!fontName) return NULL;
1129 
1130  lockGlobalParams;
1131  dfp = font->dfp;
1132  if (!dfp)
1133  {
1134    FcChar8* s;
1135    char * ext;
1136    FcResult res;
1137    FcFontSet *set;
1138    int i;
1139    p = buildFcPattern(font);
1140
1141    if (!p)
1142      goto fin;
1143    FcConfigSubstitute(FCcfg, p, FcMatchPattern);
1144    FcDefaultSubstitute(p);
1145    set = FcFontSort(FCcfg, p, FcFalse, NULL, &res);
1146    if (!set)
1147      goto fin;
1148    for (i = 0; i < set->nfont; ++i)
1149    {
1150      res = FcPatternGetString(set->fonts[i], FC_FILE, 0, &s);
1151      if (res != FcResultMatch || !s)
1152        continue;
1153      ext = strrchr((char*)s,'.');
1154      if (!ext)
1155        continue;
1156      if (!strncasecmp(ext,".ttf",4) || !strncasecmp(ext, ".ttc", 4))
1157      {
1158        dfp = new DisplayFontParam(fontName->copy(), displayFontTT); 
1159        dfp->tt.fileName = new GooString((char*)s);
1160        FcPatternGetInteger(set->fonts[i], FC_INDEX, 0, &(dfp->tt.faceIndex));
1161      }
1162      else if (!strncasecmp(ext,".pfa",4) || !strncasecmp(ext,".pfb",4)) 
1163      {
1164        dfp = new DisplayFontParam(fontName->copy(), displayFontT1); 
1165        dfp->t1.fileName = new GooString((char*)s);
1166      }
1167      else
1168        continue;
1169      font->dfp = dfp;
1170      break;
1171    }
1172    FcFontSetDestroy(set);
1173  }
1174fin:
1175  if (p)
1176    FcPatternDestroy(p);
1177
1178  unlockGlobalParams;
1179  return dfp;
1180}
1181#endif
1182
1183GBool GlobalParams::getPSExpandSmaller() {
1184  GBool f;
1185
1186  lockGlobalParams;
1187  f = psExpandSmaller;
1188  unlockGlobalParams;
1189  return f;
1190}
1191
1192GBool GlobalParams::getPSShrinkLarger() {
1193  GBool f;
1194
1195  lockGlobalParams;
1196  f = psShrinkLarger;
1197  unlockGlobalParams;
1198  return f;
1199}
1200
1201GBool GlobalParams::getPSCenter() {
1202  GBool f;
1203
1204  lockGlobalParams;
1205  f = psCenter;
1206  unlockGlobalParams;
1207  return f;
1208}
1209
1210PSLevel GlobalParams::getPSLevel() {
1211  PSLevel level;
1212
1213  lockGlobalParams;
1214  level = psLevel;
1215  unlockGlobalParams;
1216  return level;
1217}
1218
1219PSFontParam *GlobalParams::getPSFont(GooString *fontName) {
1220  PSFontParam *p;
1221
1222  lockGlobalParams;
1223  p = (PSFontParam *)psFonts->lookup(fontName);
1224  unlockGlobalParams;
1225  return p;
1226}
1227
1228PSFontParam *GlobalParams::getPSFont16(GooString *fontName,
1229                                       GooString *collection, int wMode) {
1230  PSFontParam *p;
1231  int i;
1232
1233  lockGlobalParams;
1234  p = NULL;
1235  if (fontName) {
1236    for (i = 0; i < psNamedFonts16->getLength(); ++i) {
1237      p = (PSFontParam *)psNamedFonts16->get(i);
1238      if (!p->pdfFontName->cmp(fontName) &&
1239          p->wMode == wMode) {
1240        break;
1241      }
1242      p = NULL;
1243    }
1244  }
1245  if (!p && collection) {
1246    for (i = 0; i < psFonts16->getLength(); ++i) {
1247      p = (PSFontParam *)psFonts16->get(i);
1248      if (!p->pdfFontName->cmp(collection) &&
1249          p->wMode == wMode) {
1250        break;
1251      }
1252      p = NULL;
1253    }
1254  }
1255  unlockGlobalParams;
1256  return p;
1257}
1258
1259GBool GlobalParams::getPSEmbedType1() {
1260  GBool e;
1261
1262  lockGlobalParams;
1263  e = psEmbedType1;
1264  unlockGlobalParams;
1265  return e;
1266}
1267
1268GBool GlobalParams::getPSEmbedTrueType() {
1269  GBool e;
1270
1271  lockGlobalParams;
1272  e = psEmbedTrueType;
1273  unlockGlobalParams;
1274  return e;
1275}
1276
1277GBool GlobalParams::getPSEmbedCIDPostScript() {
1278  GBool e;
1279
1280  lockGlobalParams;
1281  e = psEmbedCIDPostScript;
1282  unlockGlobalParams;
1283  return e;
1284}
1285
1286GBool GlobalParams::getPSEmbedCIDTrueType() {
1287  GBool e;
1288
1289  lockGlobalParams;
1290  e = psEmbedCIDTrueType;
1291  unlockGlobalParams;
1292  return e;
1293}
1294
1295GBool GlobalParams::getPSSubstFonts() {
1296  GBool e;
1297
1298  lockGlobalParams;
1299  e = psSubstFonts;
1300  unlockGlobalParams;
1301  return e;
1302}
1303
1304GBool GlobalParams::getPSPreload() {
1305  GBool preload;
1306
1307  lockGlobalParams;
1308  preload = psPreload;
1309  unlockGlobalParams;
1310  return preload;
1311}
1312
1313GBool GlobalParams::getPSOPI() {
1314  GBool opi;
1315
1316  lockGlobalParams;
1317  opi = psOPI;
1318  unlockGlobalParams;
1319  return opi;
1320}
1321
1322GBool GlobalParams::getPSASCIIHex() {
1323  GBool ah;
1324
1325  lockGlobalParams;
1326  ah = psASCIIHex;
1327  unlockGlobalParams;
1328  return ah;
1329}
1330
1331GooString *GlobalParams::getTextEncodingName() {
1332  GooString *s;
1333
1334  lockGlobalParams;
1335  s = textEncoding->copy();
1336  unlockGlobalParams;
1337  return s;
1338}
1339
1340EndOfLineKind GlobalParams::getTextEOL() {
1341  EndOfLineKind eol;
1342
1343  lockGlobalParams;
1344  eol = textEOL;
1345  unlockGlobalParams;
1346  return eol;
1347}
1348
1349GBool GlobalParams::getTextPageBreaks() {
1350  GBool pageBreaks;
1351
1352  lockGlobalParams;
1353  pageBreaks = textPageBreaks;
1354  unlockGlobalParams;
1355  return pageBreaks;
1356}
1357
1358GBool GlobalParams::getTextKeepTinyChars() {
1359  GBool tiny;
1360
1361  lockGlobalParams;
1362  tiny = textKeepTinyChars;
1363  unlockGlobalParams;
1364  return tiny;
1365}
1366
1367GooString *GlobalParams::findFontFile(GooString *fontName, char **exts) {
1368  GooString *dir, *fileName;
1369  char **ext;
1370  FILE *f;
1371  int i;
1372
1373  lockGlobalParams;
1374  for (i = 0; i < fontDirs->getLength(); ++i) {
1375    dir = (GooString *)fontDirs->get(i);
1376    for (ext = exts; *ext; ++ext) {
1377      fileName = appendToPath(dir->copy(), fontName->getCString());
1378      fileName->append(*ext);
1379      if ((f = fopen(fileName->getCString(), "rb"))) {
1380        fclose(f);
1381        unlockGlobalParams;
1382        return fileName;
1383      }
1384      delete fileName;
1385    }
1386  }
1387  unlockGlobalParams;
1388  return NULL;
1389}
1390
1391GBool GlobalParams::getEnableFreeType() {
1392  GBool f;
1393
1394  lockGlobalParams;
1395  f = enableFreeType;
1396  unlockGlobalParams;
1397  return f;
1398}
1399
1400
1401GBool GlobalParams::getAntialias() {
1402  GBool f;
1403
1404  lockGlobalParams;
1405  f = antialias;
1406  unlockGlobalParams;
1407  return f;
1408}
1409
1410GBool GlobalParams::getVectorAntialias() {
1411  GBool f;
1412
1413  lockGlobalParams;
1414  f = vectorAntialias;
1415  unlockGlobalParams;
1416  return f;
1417}
1418
1419GBool GlobalParams::getStrokeAdjust() {
1420  GBool f;
1421
1422  lockGlobalParams;
1423  f = strokeAdjust;
1424  unlockGlobalParams;
1425  return f;
1426}
1427
1428ScreenType GlobalParams::getScreenType() {
1429  ScreenType t;
1430
1431  lockGlobalParams;
1432  t = screenType;
1433  unlockGlobalParams;
1434  return t;
1435}
1436
1437int GlobalParams::getScreenSize() {
1438  int size;
1439
1440  lockGlobalParams;
1441  size = screenSize;
1442  unlockGlobalParams;
1443  return size;
1444}
1445
1446int GlobalParams::getScreenDotRadius() {
1447  int r;
1448
1449  lockGlobalParams;
1450  r = screenDotRadius;
1451  unlockGlobalParams;
1452  return r;
1453}
1454
1455double GlobalParams::getScreenGamma() {
1456  double gamma;
1457
1458  lockGlobalParams;
1459  gamma = screenGamma;
1460  unlockGlobalParams;
1461  return gamma;
1462}
1463
1464double GlobalParams::getScreenBlackThreshold() {
1465  double thresh;
1466
1467  lockGlobalParams;
1468  thresh = screenBlackThreshold;
1469  unlockGlobalParams;
1470  return thresh;
1471}
1472
1473double GlobalParams::getScreenWhiteThreshold() {
1474  double thresh;
1475
1476  lockGlobalParams;
1477  thresh = screenWhiteThreshold;
1478  unlockGlobalParams;
1479  return thresh;
1480}
1481
1482GBool GlobalParams::getMapNumericCharNames() {
1483  GBool map;
1484
1485  lockGlobalParams;
1486  map = mapNumericCharNames;
1487  unlockGlobalParams;
1488  return map;
1489}
1490
1491GBool GlobalParams::getMapUnknownCharNames() {
1492  GBool map;
1493
1494  lockGlobalParams;
1495  map = mapUnknownCharNames;
1496  unlockGlobalParams;
1497  return map;
1498}
1499
1500GBool GlobalParams::getPrintCommands() {
1501  GBool p;
1502
1503  lockGlobalParams;
1504  p = printCommands;
1505  unlockGlobalParams;
1506  return p;
1507}
1508
1509GBool GlobalParams::getProfileCommands() {
1510  GBool p;
1511
1512  lockGlobalParams;
1513  p = profileCommands;
1514  unlockGlobalParams;
1515  return p;
1516}
1517
1518GBool GlobalParams::getErrQuiet() {
1519  // no locking -- this function may get called from inside a locked
1520  // section
1521  return errQuiet;
1522}
1523
1524CharCodeToUnicode *GlobalParams::getCIDToUnicode(GooString *collection) {
1525  GooString *fileName;
1526  CharCodeToUnicode *ctu;
1527
1528  lockGlobalParams;
1529  if (!(ctu = cidToUnicodeCache->getCharCodeToUnicode(collection))) {
1530    if ((fileName = (GooString *)cidToUnicodes->lookup(collection)) &&
1531        (ctu = CharCodeToUnicode::parseCIDToUnicode(fileName, collection))) {
1532      cidToUnicodeCache->add(ctu);
1533    }
1534  }
1535  unlockGlobalParams;
1536  return ctu;
1537}
1538
1539CharCodeToUnicode *GlobalParams::getUnicodeToUnicode(GooString *fontName) {
1540  lockGlobalParams;
1541  GooHashIter *iter;
1542  unicodeToUnicodes->startIter(&iter);
1543  GooString *fileName = NULL;
1544  GooString *fontPattern;
1545  void *val;
1546  while (!fileName && unicodeToUnicodes->getNext(&iter, &fontPattern, &val)) {
1547    if (strstr(fontName->getCString(), fontPattern->getCString())) {
1548      unicodeToUnicodes->killIter(&iter);
1549      fileName = (GooString*)val;
1550    }
1551  }
1552  CharCodeToUnicode *ctu = NULL;
1553  if (fileName) {
1554    ctu = unicodeToUnicodeCache->getCharCodeToUnicode(fileName);
1555    if (!ctu) {
1556      ctu = CharCodeToUnicode::parseUnicodeToUnicode(fileName);
1557      if (ctu)
1558         unicodeToUnicodeCache->add(ctu);
1559    }
1560  }
1561  unlockGlobalParams;
1562  return ctu;
1563}
1564
1565UnicodeMap *GlobalParams::getUnicodeMap(GooString *encodingName) {
1566  return getUnicodeMap2(encodingName);
1567}
1568
1569UnicodeMap *GlobalParams::getUnicodeMap2(GooString *encodingName) {
1570  UnicodeMap *map;
1571
1572  if (!(map = getResidentUnicodeMap(encodingName))) {
1573    lockUnicodeMapCache;
1574    map = unicodeMapCache->getUnicodeMap(encodingName);
1575    unlockUnicodeMapCache;
1576  }
1577  return map;
1578}
1579
1580CMap *GlobalParams::getCMap(GooString *collection, GooString *cMapName, Stream *stream) {
1581  CMap *cMap;
1582
1583  lockCMapCache;
1584  cMap = cMapCache->getCMap(collection, cMapName, stream);
1585  unlockCMapCache;
1586  return cMap;
1587}
1588
1589UnicodeMap *GlobalParams::getTextEncoding() {
1590  return getUnicodeMap2(textEncoding);
1591}
1592
1593GooList *GlobalParams::getEncodingNames()
1594{
1595  GooList *result = new GooList;
1596  GooHashIter *iter;
1597  GooString *key;
1598  void *val;
1599  residentUnicodeMaps->startIter(&iter);
1600  while (residentUnicodeMaps->getNext(&iter, &key, &val)) {
1601    result->append(key);
1602  }
1603  residentUnicodeMaps->killIter(&iter);
1604  unicodeMaps->startIter(&iter);
1605  while (unicodeMaps->getNext(&iter, &key, &val)) {
1606    result->append(key);
1607  }
1608  unicodeMaps->killIter(&iter);
1609  return result;
1610}
1611
1612//------------------------------------------------------------------------
1613// functions to set parameters
1614//------------------------------------------------------------------------
1615
1616void GlobalParams::setPSExpandSmaller(GBool expand) {
1617  lockGlobalParams;
1618  psExpandSmaller = expand;
1619  unlockGlobalParams;
1620}
1621
1622void GlobalParams::setPSShrinkLarger(GBool shrink) {
1623  lockGlobalParams;
1624  psShrinkLarger = shrink;
1625  unlockGlobalParams;
1626}
1627
1628void GlobalParams::setPSCenter(GBool center) {
1629  lockGlobalParams;
1630  psCenter = center;
1631  unlockGlobalParams;
1632}
1633
1634void GlobalParams::setPSLevel(PSLevel level) {
1635  lockGlobalParams;
1636  psLevel = level;
1637  unlockGlobalParams;
1638}
1639
1640void GlobalParams::setPSEmbedType1(GBool embed) {
1641  lockGlobalParams;
1642  psEmbedType1 = embed;
1643  unlockGlobalParams;
1644}
1645
1646void GlobalParams::setPSEmbedTrueType(GBool embed) {
1647  lockGlobalParams;
1648  psEmbedTrueType = embed;
1649  unlockGlobalParams;
1650}
1651
1652void GlobalParams::setPSEmbedCIDPostScript(GBool embed) {
1653  lockGlobalParams;
1654  psEmbedCIDPostScript = embed;
1655  unlockGlobalParams;
1656}
1657
1658void GlobalParams::setPSEmbedCIDTrueType(GBool embed) {
1659  lockGlobalParams;
1660  psEmbedCIDTrueType = embed;
1661  unlockGlobalParams;
1662}
1663
1664void GlobalParams::setPSSubstFonts(GBool substFonts) {
1665  lockGlobalParams;
1666  psSubstFonts = substFonts;
1667  unlockGlobalParams;
1668}
1669
1670void GlobalParams::setPSPreload(GBool preload) {
1671  lockGlobalParams;
1672  psPreload = preload;
1673  unlockGlobalParams;
1674}
1675
1676void GlobalParams::setPSOPI(GBool opi) {
1677  lockGlobalParams;
1678  psOPI = opi;
1679  unlockGlobalParams;
1680}
1681
1682void GlobalParams::setPSASCIIHex(GBool hex) {
1683  lockGlobalParams;
1684  psASCIIHex = hex;
1685  unlockGlobalParams;
1686}
1687
1688void GlobalParams::setTextEncoding(char *encodingName) {
1689  lockGlobalParams;
1690  delete textEncoding;
1691  textEncoding = new GooString(encodingName);
1692  unlockGlobalParams;
1693}
1694
1695GBool GlobalParams::setTextEOL(char *s) {
1696  lockGlobalParams;
1697  if (!strcmp(s, "unix")) {
1698    textEOL = eolUnix;
1699  } else if (!strcmp(s, "dos")) {
1700    textEOL = eolDOS;
1701  } else if (!strcmp(s, "mac")) {
1702    textEOL = eolMac;
1703  } else {
1704    unlockGlobalParams;
1705    return gFalse;
1706  }
1707  unlockGlobalParams;
1708  return gTrue;
1709}
1710
1711void GlobalParams::setTextPageBreaks(GBool pageBreaks) {
1712  lockGlobalParams;
1713  textPageBreaks = pageBreaks;
1714  unlockGlobalParams;
1715}
1716
1717void GlobalParams::setTextKeepTinyChars(GBool keep) {
1718  lockGlobalParams;
1719  textKeepTinyChars = keep;
1720  unlockGlobalParams;
1721}
1722
1723GBool GlobalParams::setEnableFreeType(char *s) {
1724  GBool ok;
1725
1726  lockGlobalParams;
1727  ok = parseYesNo2(s, &enableFreeType);
1728  unlockGlobalParams;
1729  return ok;
1730}
1731
1732
1733GBool GlobalParams::setAntialias(char *s) {
1734  GBool ok;
1735
1736  lockGlobalParams;
1737  ok = parseYesNo2(s, &antialias);
1738  unlockGlobalParams;
1739  return ok;
1740}
1741
1742GBool GlobalParams::setVectorAntialias(char *s) {
1743  GBool ok;
1744
1745  lockGlobalParams;
1746  ok = parseYesNo2(s, &vectorAntialias);
1747  unlockGlobalParams;
1748  return ok;
1749}
1750
1751void GlobalParams::setStrokeAdjust(GBool adjust)
1752{
1753  lockGlobalParams;
1754  strokeAdjust = adjust;
1755  unlockGlobalParams;
1756}
1757
1758void GlobalParams::setScreenType(ScreenType st)
1759{
1760  lockGlobalParams;
1761  screenType = st;
1762  unlockGlobalParams;
1763}
1764
1765void GlobalParams::setScreenSize(int size)
1766{
1767  lockGlobalParams;
1768  screenSize = size;
1769  unlockGlobalParams;
1770}
1771
1772void GlobalParams::setScreenDotRadius(int radius)
1773{
1774  lockGlobalParams;
1775  screenDotRadius = radius;
1776  unlockGlobalParams;
1777}
1778
1779void GlobalParams::setScreenGamma(double gamma)
1780{
1781  lockGlobalParams;
1782  screenGamma = gamma;
1783  unlockGlobalParams;
1784}
1785
1786void GlobalParams::setScreenBlackThreshold(double blackThreshold)
1787{
1788  lockGlobalParams;
1789  screenBlackThreshold = blackThreshold;
1790  unlockGlobalParams;
1791}
1792
1793void GlobalParams::setScreenWhiteThreshold(double whiteThreshold)
1794{
1795  lockGlobalParams;
1796  screenWhiteThreshold = whiteThreshold;
1797  unlockGlobalParams;
1798}
1799
1800void GlobalParams::setMapNumericCharNames(GBool map) {
1801  lockGlobalParams;
1802  mapNumericCharNames = map;
1803  unlockGlobalParams;
1804}
1805
1806void GlobalParams::setMapUnknownCharNames(GBool map) {
1807  lockGlobalParams;
1808  mapUnknownCharNames = map;
1809  unlockGlobalParams;
1810}
1811
1812void GlobalParams::setPrintCommands(GBool printCommandsA) {
1813  lockGlobalParams;
1814  printCommands = printCommandsA;
1815  unlockGlobalParams;
1816}
1817
1818void GlobalParams::setProfileCommands(GBool profileCommandsA) {
1819  lockGlobalParams;
1820  profileCommands = profileCommandsA;
1821  unlockGlobalParams;
1822}
1823
1824void GlobalParams::setErrQuiet(GBool errQuietA) {
1825  lockGlobalParams;
1826  errQuiet = errQuietA;
1827  unlockGlobalParams;
1828}
1829
1830void GlobalParams::addSecurityHandler(XpdfSecurityHandler *handler) {
1831#ifdef ENABLE_PLUGINS
1832  lockGlobalParams;
1833  securityHandlers->append(handler);
1834  unlockGlobalParams;
1835#endif
1836}
1837
1838XpdfSecurityHandler *GlobalParams::getSecurityHandler(char *name) {
1839#ifdef ENABLE_PLUGINS
1840  XpdfSecurityHandler *hdlr;
1841  int i;
1842
1843  lockGlobalParams;
1844  for (i = 0; i < securityHandlers->getLength(); ++i) {
1845    hdlr = (XpdfSecurityHandler *)securityHandlers->get(i);
1846    if (!strcasecmp(hdlr->name, name)) {
1847      unlockGlobalParams;
1848      return hdlr;
1849    }
1850  }
1851  unlockGlobalParams;
1852
1853  if (!loadPlugin("security", name)) {
1854    return NULL;
1855  }
1856  deleteGooList(keyBindings, KeyBinding);
1857
1858  lockGlobalParams;
1859  for (i = 0; i < securityHandlers->getLength(); ++i) {
1860    hdlr = (XpdfSecurityHandler *)securityHandlers->get(i);
1861    if (!strcmp(hdlr->name, name)) {
1862      unlockGlobalParams;
1863      return hdlr;
1864    }
1865  }
1866  unlockGlobalParams;
1867#else
1868  (void)name;
1869#endif
1870
1871  return NULL;
1872}
1873
1874#ifdef ENABLE_PLUGINS
1875//------------------------------------------------------------------------
1876// plugins
1877//------------------------------------------------------------------------
1878
1879GBool GlobalParams::loadPlugin(char *type, char *name) {
1880  Plugin *plugin;
1881
1882  if (!(plugin = Plugin::load(type, name))) {
1883    return gFalse;
1884  }
1885  lockGlobalParams;
1886  plugins->append(plugin);
1887  unlockGlobalParams;
1888  return gTrue;
1889}
1890
1891#endif // ENABLE_PLUGINS
Note: See TracBrowser for help on using the repository browser.