File xpdf-poppler-autohinting-as-option.patch of Package xpdf-poppler

Overview Repositories Revisions Requests Users Attributes Meta

File xpdf-poppler-autohinting-as-option.patch of Package xpdf-poppler

Index: GlobalParamsGUI.cc
===================================================================
--- /dev/null
+++ GlobalParamsGUI.cc
@@ -0,0 +1,3242 @@
+//========================================================================
+//
+// GlobalParamsGUI.cc
+//
+// Copyright 2001-2003 Glyph & Cog, LLC
+//
+//========================================================================
+
+#include "config.h"
+
+#ifdef USE_GCC_PRAGMAS
+#pragma implementation
+#endif
+
+#include <string.h>
+#include <stdio.h>
+#include <ctype.h>
+#ifdef ENABLE_PLUGINS
+#  ifndef WIN32
+#    include <dlfcn.h>
+#  endif
+#endif
+#ifdef WIN32
+#  include <shlobj.h>
+#endif
+#if HAVE_PAPER_H
+#include <paper.h>
+#endif
+#include <fontconfig/fontconfig.h>
+#include "goo/gmem.h"
+#include "goo/GooString.h"
+#include "goo/GooList.h"
+#include "goo/GooHash.h"
+#include "goo/gfile.h"
+#include "Error.h"
+#include "NameToCharCode.h"
+#include "CharCodeToUnicode.h"
+#include "UnicodeMap.h"
+#include "CMap.h"
+#include "FontEncodingTables.h"
+#include <langinfo.h>
+#include <locale.h>
+#ifdef ENABLE_PLUGINS
+#  include "XpdfPluginAPI.h"
+#endif
+#include "GlobalParamsGUI.h"
+#include "GfxFont.h"
+
+#ifdef WIN32
+#  define strcasecmp stricmp
+#endif
+
+#if MULTITHREADED
+#  define lockGlobalParamsGUI            gLockMutex(&mutex)
+#  define lockUnicodeMapCache         gLockMutex(&unicodeMapCacheMutex)
+#  define lockCMapCache               gLockMutex(&cMapCacheMutex)
+#  define unlockGlobalParamsGUI          gUnlockMutex(&mutex)
+#  define unlockUnicodeMapCache       gUnlockMutex(&unicodeMapCacheMutex)
+#  define unlockCMapCache             gUnlockMutex(&cMapCacheMutex)
+#else
+#  define lockGlobalParamsGUI
+#  define lockUnicodeMapCache
+#  define lockCMapCache
+#  define unlockGlobalParamsGUI
+#  define unlockUnicodeMapCache
+#  define unlockCMapCache
+#endif
+
+#ifndef FC_WEIGHT_BOOK
+#define FC_WEIGHT_BOOK 75
+#endif
+
+#include "NameToUnicodeTable.h"
+#include "UnicodeMapTables.h"
+#include "UTF8.h"
+
+#ifdef ENABLE_PLUGINS
+#  ifdef WIN32
+extern XpdfPluginVecTable xpdfPluginVecTable;
+#  endif
+#endif
+
+//------------------------------------------------------------------------
+
+#define cidToUnicodeCacheSize     4
+#define unicodeToUnicodeCacheSize 4
+
+//------------------------------------------------------------------------
+
+static struct {
+  char *name;
+  char *t1FileName;
+  char *ttFileName;
+} displayFontTab[] = {
+  {"Courier",               "n022003l.pfb", "cour.ttf"},
+  {"Courier-Bold",          "n022004l.pfb", "courbd.ttf"},
+  {"Courier-BoldOblique",   "n022024l.pfb", "courbi.ttf"},
+  {"Courier-Oblique",       "n022023l.pfb", "couri.ttf"},
+  {"Helvetica",             "n019003l.pfb", "arial.ttf"},
+  {"Helvetica-Bold",        "n019004l.pfb", "arialbd.ttf"},
+  {"Helvetica-BoldOblique", "n019024l.pfb", "arialbi.ttf"},
+  {"Helvetica-Oblique",     "n019023l.pfb", "ariali.ttf"},
+  {"Symbol",                "s050000l.pfb", NULL},
+  {"Times-Bold",            "n021004l.pfb", "timesbd.ttf"},
+  {"Times-BoldItalic",      "n021024l.pfb", "timesbi.ttf"},
+  {"Times-Italic",          "n021023l.pfb", "timesi.ttf"},
+  {"Times-Roman",           "n021003l.pfb", "times.ttf"},
+  {"ZapfDingbats",          "d050000l.pfb", NULL},
+  {NULL}
+};
+
+#ifdef WIN32
+static char *displayFontDirs[] = {
+  "c:/windows/fonts",
+  "c:/winnt/fonts",
+  NULL
+};
+#else
+static char *displayFontDirs[] = {
+  "/usr/share/ghostscript/fonts",
+  "/usr/local/share/ghostscript/fonts",
+  "/usr/share/fonts/default/Type1",
+  "/usr/share/fonts/default/ghostscript",
+  "/usr/share/fonts/type1/gsfonts",
+  NULL
+};
+#endif
+
+//------------------------------------------------------------------------
+
+GlobalParamsGUI *globalParamsGUI = NULL;
+
+//------------------------------------------------------------------------
+// DisplayFontParam
+//------------------------------------------------------------------------
+
+DisplayFontParam::DisplayFontParam(GooString *nameA,
+				   DisplayFontParamKind kindA) {
+  name = nameA;
+  kind = kindA;
+  switch (kind) {
+  case displayFontT1:
+    t1.fileName = NULL;
+    break;
+  case displayFontTT:
+    tt.fileName = NULL;
+    break;
+  }
+}
+
+DisplayFontParam::~DisplayFontParam() {
+  delete name;
+  switch (kind) {
+  case displayFontT1:
+    if (t1.fileName) {
+      delete t1.fileName;
+    }
+    break;
+  case displayFontTT:
+    if (tt.fileName) {
+      delete tt.fileName;
+    }
+    break;
+  }
+}
+
+#ifdef WIN32
+
+//------------------------------------------------------------------------
+// WinFontInfo
+//------------------------------------------------------------------------
+
+class WinFontInfo: public DisplayFontParam {
+public:
+
+  GBool bold, italic;
+
+  static WinFontInfo *make(GooString *nameA, GBool boldA, GBool italicA,
+			   HKEY regKey, char *winFontDir);
+  WinFontInfo(GooString *nameA, GBool boldA, GBool italicA,
+	      GooString *fileNameA);
+  virtual ~WinFontInfo();
+  GBool equals(WinFontInfo *fi);
+};
+
+WinFontInfo *WinFontInfo::make(GooString *nameA, GBool boldA, GBool italicA,
+			       HKEY regKey, char *winFontDir) {
+  GooString *regName;
+  GooString *fileNameA;
+  char buf[MAX_PATH];
+  DWORD n;
+  char c;
+  int i;
+
+  //----- find the font file
+  fileNameA = NULL;
+  regName = nameA->copy();
+  if (boldA) {
+    regName->append(" Bold");
+  }
+  if (italicA) {
+    regName->append(" Italic");
+  }
+  regName->append(" (TrueType)");
+  n = sizeof(buf);
+  if (RegQueryValueEx(regKey, regName->getCString(), NULL, NULL,
+		      (LPBYTE)buf, &n) == ERROR_SUCCESS) {
+    fileNameA = new GooString(winFontDir);
+    fileNameA->append('\\')->append(buf);
+  }
+  delete regName;
+  if (!fileNameA) {
+    delete nameA;
+    return NULL;
+  }
+
+  //----- normalize the font name
+  i = 0;
+  while (i < nameA->getLength()) {
+    c = nameA->getChar(i);
+    if (c == ' ' || c == ',' || c == '-') {
+      nameA->del(i);
+    } else {
+      ++i;
+    }
+  }
+
+  return new WinFontInfo(nameA, boldA, italicA, fileNameA);
+}
+
+WinFontInfo::WinFontInfo(GooString *nameA, GBool boldA, GBool italicA,
+			 GooString *fileNameA):
+  DisplayFontParam(nameA, displayFontTT)
+{
+  bold = boldA;
+  italic = italicA;
+  tt.fileName = fileNameA;
+}
+
+WinFontInfo::~WinFontInfo() {
+}
+
+GBool WinFontInfo::equals(WinFontInfo *fi) {
+  return !name->cmp(fi->name) && bold == fi->bold && italic == fi->italic;
+}
+
+//------------------------------------------------------------------------
+// WinFontList
+//------------------------------------------------------------------------
+
+class WinFontList {
+public:
+
+  WinFontList(char *winFontDirA);
+  ~WinFontList();
+  WinFontInfo *find(GooString *font);
+
+private:
+
+  void add(WinFontInfo *fi);
+  static int CALLBACK enumFunc1(CONST LOGFONT *font,
+				CONST TEXTMETRIC *metrics,
+				DWORD type, LPARAM data);
+  static int CALLBACK enumFunc2(CONST LOGFONT *font,
+				CONST TEXTMETRIC *metrics,
+				DWORD type, LPARAM data);
+
+  GooList *fonts;			// [WinFontInfo]
+  HDC dc;			// (only used during enumeration)
+  HKEY regKey;			// (only used during enumeration)
+  char *winFontDir;		// (only used during enumeration)
+};
+
+WinFontList::WinFontList(char *winFontDirA) {
+  OSVERSIONINFO version;
+  char *path;
+
+  fonts = new GooList();
+  dc = GetDC(NULL);
+  winFontDir = winFontDirA;
+  version.dwOSVersionInfoSize = sizeof(version);
+  GetVersionEx(&version);
+  if (version.dwPlatformId == VER_PLATFORM_WIN32_NT) {
+    path = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts\\";
+  } else {
+    path = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Fonts\\";
+  }
+  if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, path, 0,
+		   KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS,
+		   &regKey) == ERROR_SUCCESS) {
+    EnumFonts(dc, NULL, &WinFontList::enumFunc1, (LPARAM)this);
+    RegCloseKey(regKey);
+  }
+  ReleaseDC(NULL, dc);
+}
+
+WinFontList::~WinFontList() {
+  deleteGooList(fonts, WinFontInfo);
+}
+
+void WinFontList::add(WinFontInfo *fi) {
+  int i;
+
+  for (i = 0; i < fonts->getLength(); ++i) {
+    if (((WinFontInfo *)fonts->get(i))->equals(fi)) {
+      delete fi;
+      return;
+    }
+  }
+  fonts->append(fi);
+}
+
+WinFontInfo *WinFontList::find(GooString *font) {
+  GooString *name;
+  GBool bold, italic;
+  WinFontInfo *fi;
+  char c;
+  int n, i;
+
+  name = font->copy();
+
+  // remove space, comma, dash chars
+  i = 0;
+  while (i < name->getLength()) {
+    c = name->getChar(i);
+    if (c == ' ' || c == ',' || c == '-') {
+      name->del(i);
+    } else {
+      ++i;
+    }
+  }
+  n = name->getLength();
+
+  // remove trailing "MT" (Foo-MT, Foo-BoldMT, etc.)
+  if (!strcmp(name->getCString() + n - 2, "MT")) {
+    name->del(n - 2, 2);
+    n -= 2;
+  }
+
+  // look for "Italic"
+  if (!strcmp(name->getCString() + n - 6, "Italic")) {
+    name->del(n - 6, 6);
+    italic = gTrue;
+    n -= 6;
+  } else {
+    italic = gFalse;
+  }
+
+  // look for "Bold"
+  if (!strcmp(name->getCString() + n - 4, "Bold")) {
+    name->del(n - 4, 4);
+    bold = gTrue;
+    n -= 4;
+  } else {
+    bold = gFalse;
+  }
+
+  // remove trailing "MT" (FooMT-Bold, etc.)
+  if (!strcmp(name->getCString() + n - 2, "MT")) {
+    name->del(n - 2, 2);
+    n -= 2;
+  }
+
+  // remove trailing "PS"
+  if (!strcmp(name->getCString() + n - 2, "PS")) {
+    name->del(n - 2, 2);
+    n -= 2;
+  }
+
+  // search for the font
+  fi = NULL;
+  for (i = 0; i < fonts->getLength(); ++i) {
+    fi = (WinFontInfo *)fonts->get(i);
+    if (!fi->name->cmp(name) && fi->bold == bold && fi->italic == italic) {
+      break;
+    }
+    fi = NULL;
+  }
+
+  delete name;
+  return fi;
+}
+
+int CALLBACK WinFontList::enumFunc1(CONST LOGFONT *font,
+				    CONST TEXTMETRIC *metrics,
+				    DWORD type, LPARAM data) {
+  WinFontList *fl = (WinFontList *)data;
+
+  EnumFonts(fl->dc, font->lfFaceName, &WinFontList::enumFunc2, (LPARAM)fl);
+  return 1;
+}
+
+int CALLBACK WinFontList::enumFunc2(CONST LOGFONT *font,
+				    CONST TEXTMETRIC *metrics,
+				    DWORD type, LPARAM data) {
+  WinFontList *fl = (WinFontList *)data;
+  WinFontInfo *fi;
+
+  if (type & TRUETYPE_FONTTYPE) {
+    if ((fi = WinFontInfo::make(new GooString(font->lfFaceName),
+				font->lfWeight >= 600,
+				font->lfItalic ? gTrue : gFalse,
+				fl->regKey, fl->winFontDir))) {
+      fl->add(fi);
+    }
+  }
+  return 1;
+}
+
+#endif // WIN32
+
+//------------------------------------------------------------------------
+// PSFontParam
+//------------------------------------------------------------------------
+
+PSFontParam::PSFontParam(GooString *pdfFontNameA, int wModeA,
+			 GooString *psFontNameA, GooString *encodingA) {
+  pdfFontName = pdfFontNameA;
+  wMode = wModeA;
+  psFontName = psFontNameA;
+  encoding = encodingA;
+}
+
+PSFontParam::~PSFontParam() {
+  delete pdfFontName;
+  delete psFontName;
+  if (encoding) {
+    delete encoding;
+  }
+}
+
+//------------------------------------------------------------------------
+// KeyBinding
+//------------------------------------------------------------------------
+
+KeyBinding::KeyBinding(int codeA, int modsA, int contextA, char *cmd0) {
+  code = codeA;
+  mods = modsA;
+  context = contextA;
+  cmds = new GooList();
+  cmds->append(new GooString(cmd0));
+}
+
+KeyBinding::KeyBinding(int codeA, int modsA, int contextA,
+		       char *cmd0, char *cmd1) {
+  code = codeA;
+  mods = modsA;
+  context = contextA;
+  cmds = new GooList();
+  cmds->append(new GooString(cmd0));
+  cmds->append(new GooString(cmd1));
+}
+
+KeyBinding::KeyBinding(int codeA, int modsA, int contextA, GooList *cmdsA) {
+  code = codeA;
+  mods = modsA;
+  context = contextA;
+  cmds = cmdsA;
+}
+
+KeyBinding::~KeyBinding() {
+  deleteGooList(cmds, GooString);
+}
+
+#ifdef ENABLE_PLUGINS
+//------------------------------------------------------------------------
+// Plugin
+//------------------------------------------------------------------------
+
+class Plugin {
+public:
+
+  static Plugin *load(char *type, char *name);
+  ~Plugin();
+
+private:
+
+#ifdef WIN32
+  Plugin(HMODULE libA);
+  HMODULE lib;
+#else
+  Plugin(void *dlA);
+  void *dl;
+#endif
+};
+
+Plugin *Plugin::load(char *type, char *name) {
+  GooString *path;
+  Plugin *plugin;
+  XpdfPluginVecTable *vt;
+  XpdfBool (*xpdfInitPlugin)(void);
+#ifdef WIN32
+  HMODULE libA;
+#else
+  void *dlA;
+#endif
+
+  path = globalParamsGUI->getBaseDir();
+  appendToPath(path, "plugins");
+  appendToPath(path, type);
+  appendToPath(path, name);
+
+#ifdef WIN32
+  path->append(".dll");
+  if (!(libA = LoadLibrary(path->getCString()))) {
+    error(-1, "Failed to load plugin '%s'",
+	  path->getCString());
+    goto err1;
+  }
+  if (!(vt = (XpdfPluginVecTable *)
+	         GetProcAddress(libA, "xpdfPluginVecTable"))) {
+    error(-1, "Failed to find xpdfPluginVecTable in plugin '%s'",
+	  path->getCString());
+    goto err2;
+  }
+#else
+  //~ need to deal with other extensions here
+  path->append(".so");
+  if (!(dlA = dlopen(path->getCString(), RTLD_NOW))) {
+    error(-1, "Failed to load plugin '%s': %s",
+	  path->getCString(), dlerror());
+    goto err1;
+  }
+  if (!(vt = (XpdfPluginVecTable *)dlsym(dlA, "xpdfPluginVecTable"))) {
+    error(-1, "Failed to find xpdfPluginVecTable in plugin '%s'",
+	  path->getCString());
+    goto err2;
+  }
+#endif
+
+  if (vt->version != xpdfPluginVecTable.version) {
+    error(-1, "Plugin '%s' is wrong version", path->getCString());
+    goto err2;
+  }
+  memcpy(vt, &xpdfPluginVecTable, sizeof(xpdfPluginVecTable));
+
+#ifdef WIN32
+  if (!(xpdfInitPlugin = (XpdfBool (*)(void))
+	                     GetProcAddress(libA, "xpdfInitPlugin"))) {
+    error(-1, "Failed to find xpdfInitPlugin in plugin '%s'",
+	  path->getCString());
+    goto err2;
+  }
+#else
+  if (!(xpdfInitPlugin = (XpdfBool (*)(void))dlsym(dlA, "xpdfInitPlugin"))) {
+    error(-1, "Failed to find xpdfInitPlugin in plugin '%s'",
+	  path->getCString());
+    goto err2;
+  }
+#endif
+
+  if (!(*xpdfInitPlugin)()) {
+    error(-1, "Initialization of plugin '%s' failed",
+	  path->getCString());
+    goto err2;
+  }
+
+#ifdef WIN32
+  plugin = new Plugin(libA);
+#else
+  plugin = new Plugin(dlA);
+#endif
+
+  delete path;
+  return plugin;
+
+ err2:
+#ifdef WIN32
+  FreeLibrary(libA);
+#else
+  dlclose(dlA);
+#endif
+ err1:
+  delete path;
+  return NULL;
+}
+
+#ifdef WIN32
+Plugin::Plugin(HMODULE libA) {
+  lib = libA;
+}
+#else
+Plugin::Plugin(void *dlA) {
+  dl = dlA;
+}
+#endif
+
+Plugin::~Plugin() {
+  void (*xpdfFreePlugin)(void);
+
+#ifdef WIN32
+  if ((xpdfFreePlugin = (void (*)(void))
+                            GetProcAddress(lib, "xpdfFreePlugin"))) {
+    (*xpdfFreePlugin)();
+  }
+  FreeLibrary(lib);
+#else
+  if ((xpdfFreePlugin = (void (*)(void))dlsym(dl, "xpdfFreePlugin"))) {
+    (*xpdfFreePlugin)();
+  }
+  dlclose(dl);
+#endif
+}
+
+#endif // ENABLE_PLUGINS
+
+//------------------------------------------------------------------------
+// parsing
+//------------------------------------------------------------------------
+
+GlobalParamsGUI::GlobalParamsGUI(char *cfgFileName) {
+  UnicodeMap *map;
+  GooString *fileName;
+  FILE *f;
+  int i;
+  
+  FcInit();
+  FCcfg = FcConfigGetCurrent();
+
+#if MULTITHREADED
+  gInitMutex(&mutex);
+  gInitMutex(&unicodeMapCacheMutex);
+  gInitMutex(&cMapCacheMutex);
+#endif
+
+  // scan the encoding in reverse because we want the lowest-numbered
+  // index for each char name ('space' is encoded twice)
+  macRomanReverseMap = new NameToCharCode();
+  for (i = 255; i >= 0; --i) {
+    if (macRomanEncoding[i]) {
+      macRomanReverseMap->add(macRomanEncoding[i], (CharCode)i);
+    }
+  }
+
+#ifdef WIN32
+  // baseDir will be set by a call to setBaseDir
+  baseDir = new GooString();
+#else
+  baseDir = appendToPath(getHomeDir(), ".xpdf");
+#endif
+  nameToUnicode = new NameToCharCode();
+  cidToUnicodes = new GooHash(gTrue);
+  unicodeToUnicodes = new GooHash(gTrue);
+  residentUnicodeMaps = new GooHash();
+  unicodeMaps = new GooHash(gTrue);
+  cMapDirs = new GooHash(gTrue);
+  toUnicodeDirs = new GooList();
+  displayFonts = new GooHash();
+  displayCIDFonts = new GooHash();
+  displayNamedCIDFonts = new GooHash();
+#if HAVE_PAPER_H
+  char *paperName;
+  const struct paper *paperType;
+  paperinit();
+  if ((paperName = systempapername())) {
+    paperType = paperinfo(paperName);
+    psPaperWidth = (int)paperpswidth(paperType);
+    psPaperHeight = (int)paperpsheight(paperType);
+  } else {
+    error(-1, "No paper information available - using defaults");
+    psPaperWidth = defPaperWidth;
+    psPaperHeight = defPaperHeight;
+  }
+  paperdone();
+#else
+  psPaperWidth = defPaperWidth;
+  psPaperHeight = defPaperHeight;
+#endif
+  psImageableLLX = psImageableLLY = 0;
+  psImageableURX = psPaperWidth;
+  psImageableURY = psPaperHeight;
+  psCrop = gTrue;
+  psExpandSmaller = gFalse;
+  psShrinkLarger = gTrue;
+  psCenter = gTrue;
+  psDuplex = gFalse;
+  psLevel = psLevel2;
+  psFile = NULL;
+  psFonts = new GooHash();
+  psNamedFonts16 = new GooList();
+  psFonts16 = new GooList();
+  psEmbedType1 = gTrue;
+  psEmbedTrueType = gTrue;
+  psEmbedCIDPostScript = gTrue;
+  psEmbedCIDTrueType = gTrue;
+  psPreload = gFalse;
+  psOPI = gFalse;
+  psASCIIHex = gFalse;
+  setlocale(LC_ALL,"");
+  setlocale(LC_NUMERIC,"POSIX");
+  if (strcmp("UTF-8",nl_langinfo(CODESET)))
+         textEncoding = new GooString("Latin1");
+  else
+         textEncoding = new GooString("UTF-8");
+#if defined(WIN32)
+  textEOL = eolDOS;
+#elif defined(MACOS)
+  textEOL = eolMac;
+#else
+  textEOL = eolUnix;
+#endif
+  textPageBreaks = gTrue;
+  textKeepTinyChars = gFalse;
+  fontDirs = new GooList();
+  initialZoom = new GooString("125");
+  continuousView = gFalse;
+  enableT1lib = gTrue;
+  enableFreeType = gTrue;
+  enableFreeTypeHinting = gFalse;
+  antialias = gTrue;
+  vectorAntialias = gTrue;
+  strokeAdjust = gTrue;
+  screenType = screenUnset;
+  screenSize = -1;
+  screenDotRadius = -1;
+  screenGamma = 1.0;
+  screenBlackThreshold = 0.0;
+  screenWhiteThreshold = 1.0;
+  urlCommand = NULL;
+  movieCommand = NULL;
+  mapNumericCharNames = gTrue;
+  mapUnknownCharNames = gFalse;
+  createDefaultKeyBindings();
+  printCommands = gFalse;
+  profileCommands = gFalse;
+  errQuiet = gFalse;
+
+  cidToUnicodeCache = new CharCodeToUnicodeCache(cidToUnicodeCacheSize);
+  unicodeToUnicodeCache =
+      new CharCodeToUnicodeCache(unicodeToUnicodeCacheSize);
+  unicodeMapCache = new UnicodeMapCache();
+  cMapCache = new CMapCache();
+
+#ifdef WIN32
+  winFontList = NULL;
+#endif
+
+#ifdef ENABLE_PLUGINS
+  plugins = new GooList();
+  securityHandlers = new GooList();
+#endif
+
+  // set up the initial nameToUnicode table
+  for (i = 0; nameToUnicodeTab[i].name; ++i) {
+    nameToUnicode->add(nameToUnicodeTab[i].name, nameToUnicodeTab[i].u);
+  }
+
+  // set up the residentUnicodeMaps table
+  map = new UnicodeMap("Latin1", gFalse,
+		       latin1UnicodeMapRanges, latin1UnicodeMapLen);
+  residentUnicodeMaps->add(map->getEncodingName(), map);
+  map = new UnicodeMap("ASCII7", gFalse,
+		       ascii7UnicodeMapRanges, ascii7UnicodeMapLen);
+  residentUnicodeMaps->add(map->getEncodingName(), map);
+  map = new UnicodeMap("Symbol", gFalse,
+		       symbolUnicodeMapRanges, symbolUnicodeMapLen);
+  residentUnicodeMaps->add(map->getEncodingName(), map);
+  map = new UnicodeMap("ZapfDingbats", gFalse, zapfDingbatsUnicodeMapRanges,
+		       zapfDingbatsUnicodeMapLen);
+  residentUnicodeMaps->add(map->getEncodingName(), map);
+  map = new UnicodeMap("UTF-8", gTrue, &mapUTF8);
+  residentUnicodeMaps->add(map->getEncodingName(), map);
+  map = new UnicodeMap("UCS-2", gTrue, &mapUCS2);
+  residentUnicodeMaps->add(map->getEncodingName(), map);
+
+  // look for a user config file, then a system-wide config file
+  f = NULL;
+  fileName = NULL;
+  if (cfgFileName && cfgFileName[0]) {
+    fileName = new GooString(cfgFileName);
+    if (!(f = fopen(fileName->getCString(), "r"))) {
+      delete fileName;
+    }
+  }
+  if (!f) {
+    fileName = appendToPath(getHomeDir(), xpdfUserConfigFile);
+    if (!(f = fopen(fileName->getCString(), "r"))) {
+      delete fileName;
+    }
+  }
+  if (!f) {
+#if defined(WIN32) && !defined(__CYGWIN32__)
+    char buf[512];
+    i = GetModuleFileName(NULL, buf, sizeof(buf));
+    if (i <= 0 || i >= sizeof(buf)) {
+      // error or path too long for buffer - just use the current dir
+      buf[0] = '\0';
+    }
+    fileName = grabPath(buf);
+    appendToPath(fileName, xpdfSysConfigFile);
+#else
+    fileName = new GooString(xpdfSysConfigFile);
+#endif
+    if (!(f = fopen(fileName->getCString(), "r"))) {
+      delete fileName;
+    }
+  }
+  if (f) {
+    parseFile(fileName, f);
+    delete fileName;
+    fclose(f);
+  }
+}
+
+void GlobalParamsGUI::createDefaultKeyBindings() {
+  keyBindings = new GooList();
+
+  //----- mouse buttons
+  keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress1, xpdfKeyModNone,
+				     xpdfKeyContextAny, "startSelection"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeMouseRelease1, xpdfKeyModNone,
+				     xpdfKeyContextAny, "endSelection",
+				     "followLinkNoSel"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress2, xpdfKeyModNone,
+				     xpdfKeyContextAny, "startPan"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeMouseRelease2, xpdfKeyModNone,
+				     xpdfKeyContextAny, "endPan"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress3, xpdfKeyModNone,
+				     xpdfKeyContextAny, "postPopupMenu"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress4, xpdfKeyModNone,
+				     xpdfKeyContextAny,
+				     "scrollUpPrevPage(16)"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress5, xpdfKeyModNone,
+				     xpdfKeyContextAny,
+				     "scrollDownNextPage(16)"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress6, xpdfKeyModNone,
+				     xpdfKeyContextAny, "scrollLeft(16)"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress7, xpdfKeyModNone,
+				     xpdfKeyContextAny, "scrollRight(16)"));
+
+  //----- keys
+  keyBindings->append(new KeyBinding(xpdfKeyCodeHome, xpdfKeyModCtrl,
+				     xpdfKeyContextAny, "gotoPage(1)"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeHome, xpdfKeyModNone,
+				     xpdfKeyContextAny, "scrollToTopLeft"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeEnd, xpdfKeyModCtrl,
+				     xpdfKeyContextAny, "gotoLastPage"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeEnd, xpdfKeyModNone,
+				     xpdfKeyContextAny,
+				     "scrollToBottomRight"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodePgUp, xpdfKeyModNone,
+				     xpdfKeyContextAny, "pageUp"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeBackspace, xpdfKeyModNone,
+				     xpdfKeyContextAny, "pageUp"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeDelete, xpdfKeyModNone,
+				     xpdfKeyContextAny, "pageUp"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodePgDn, xpdfKeyModNone,
+				     xpdfKeyContextAny, "pageDown"));
+  keyBindings->append(new KeyBinding(' ', xpdfKeyModNone,
+				     xpdfKeyContextAny, "pageDown"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeLeft, xpdfKeyModNone,
+				     xpdfKeyContextAny, "scrollLeft(16)"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeRight, xpdfKeyModNone,
+				     xpdfKeyContextAny, "scrollRight(16)"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeUp, xpdfKeyModNone,
+				     xpdfKeyContextAny, "scrollUp(16)"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeDown, xpdfKeyModNone,
+				     xpdfKeyContextAny, "scrollDown(16)"));
+  keyBindings->append(new KeyBinding('o', xpdfKeyModNone,
+				     xpdfKeyContextAny, "open"));
+  keyBindings->append(new KeyBinding('O', xpdfKeyModNone,
+				     xpdfKeyContextAny, "open"));
+  keyBindings->append(new KeyBinding('r', xpdfKeyModNone,
+				     xpdfKeyContextAny, "reload"));
+  keyBindings->append(new KeyBinding('R', xpdfKeyModNone,
+				     xpdfKeyContextAny, "reload"));
+  keyBindings->append(new KeyBinding('f', xpdfKeyModNone,
+				     xpdfKeyContextAny, "find"));
+  keyBindings->append(new KeyBinding('F', xpdfKeyModNone,
+				     xpdfKeyContextAny, "find"));
+  keyBindings->append(new KeyBinding('f', xpdfKeyModCtrl,
+				     xpdfKeyContextAny, "find"));
+  keyBindings->append(new KeyBinding('g', xpdfKeyModCtrl,
+				     xpdfKeyContextAny, "findNext"));
+  keyBindings->append(new KeyBinding('p', xpdfKeyModCtrl,
+				     xpdfKeyContextAny, "print"));
+  keyBindings->append(new KeyBinding('n', xpdfKeyModNone,
+				     xpdfKeyContextScrLockOff, "nextPage"));
+  keyBindings->append(new KeyBinding('N', xpdfKeyModNone,
+				     xpdfKeyContextScrLockOff, "nextPage"));
+  keyBindings->append(new KeyBinding('n', xpdfKeyModNone,
+				     xpdfKeyContextScrLockOn,
+				     "nextPageNoScroll"));
+  keyBindings->append(new KeyBinding('N', xpdfKeyModNone,
+				     xpdfKeyContextScrLockOn,
+				     "nextPageNoScroll"));
+  keyBindings->append(new KeyBinding('p', xpdfKeyModNone,
+				     xpdfKeyContextScrLockOff, "prevPage"));
+  keyBindings->append(new KeyBinding('P', xpdfKeyModNone,
+				     xpdfKeyContextScrLockOff, "prevPage"));
+  keyBindings->append(new KeyBinding('p', xpdfKeyModNone,
+				     xpdfKeyContextScrLockOn,
+				     "prevPageNoScroll"));
+  keyBindings->append(new KeyBinding('P', xpdfKeyModNone,
+				     xpdfKeyContextScrLockOn,
+				     "prevPageNoScroll"));
+  keyBindings->append(new KeyBinding('v', xpdfKeyModNone,
+				     xpdfKeyContextAny, "goForward"));
+  keyBindings->append(new KeyBinding('b', xpdfKeyModNone,
+				     xpdfKeyContextAny, "goBackward"));
+  keyBindings->append(new KeyBinding('g', xpdfKeyModNone,
+				     xpdfKeyContextAny, "focusToPageNum"));
+  keyBindings->append(new KeyBinding('0', xpdfKeyModNone,
+				     xpdfKeyContextAny, "zoomPercent(125)"));
+  keyBindings->append(new KeyBinding('+', xpdfKeyModNone,
+				     xpdfKeyContextAny, "zoomIn"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeAdd, xpdfKeyModNone,
+				     xpdfKeyContextAny, "zoomIn"));
+  keyBindings->append(new KeyBinding('-', xpdfKeyModNone,
+				     xpdfKeyContextAny, "zoomOut"));
+  keyBindings->append(new KeyBinding(xpdfKeyCodeSubtract, xpdfKeyModNone,
+				     xpdfKeyContextAny, "zoomOut"));
+  keyBindings->append(new KeyBinding('z', xpdfKeyModNone,
+				     xpdfKeyContextAny, "zoomFitPage"));
+  keyBindings->append(new KeyBinding('w', xpdfKeyModNone,
+				     xpdfKeyContextAny, "zoomFitWidth"));
+  keyBindings->append(new KeyBinding('f', xpdfKeyModAlt,
+				     xpdfKeyContextAny,
+				     "toggleFullScreenMode"));
+  keyBindings->append(new KeyBinding('l', xpdfKeyModCtrl,
+				     xpdfKeyContextAny, "redraw"));
+  keyBindings->append(new KeyBinding('w', xpdfKeyModCtrl,
+				     xpdfKeyContextAny, "closeWindow"));
+  keyBindings->append(new KeyBinding('?', xpdfKeyModNone,
+				     xpdfKeyContextAny, "about"));
+  keyBindings->append(new KeyBinding('q', xpdfKeyModNone,
+				     xpdfKeyContextAny, "quit"));
+  keyBindings->append(new KeyBinding('Q', xpdfKeyModNone,
+				     xpdfKeyContextAny, "quit"));
+}
+
+void GlobalParamsGUI::parseFile(GooString *fileName, FILE *f) {
+  int line;
+  char buf[512];
+
+  line = 1;
+  while (getLine(buf, sizeof(buf) - 1, f)) {
+    parseLine(buf, fileName, line);
+    ++line;
+  }
+}
+
+void GlobalParamsGUI::parseLine(char *buf, GooString *fileName, int line) {
+  GooList *tokens;
+  GooString *cmd, *incFile;
+  char *p1, *p2;
+  FILE *f2;
+
+  // break the line into tokens
+  tokens = new GooList();
+  p1 = buf;
+  while (*p1) {
+    for (; *p1 && isspace(*p1); ++p1) ;
+    if (!*p1) {
+      break;
+    }
+    if (*p1 == '"' || *p1 == '\'') {
+      for (p2 = p1 + 1; *p2 && *p2 != *p1; ++p2) ;
+      ++p1;
+    } else {
+      for (p2 = p1 + 1; *p2 && !isspace(*p2); ++p2) ;
+    }
+    tokens->append(new GooString(p1, p2 - p1));
+    p1 = *p2 ? p2 + 1 : p2;
+  }
+
+  // parse the line
+  if (tokens->getLength() > 0 &&
+      ((GooString *)tokens->get(0))->getChar(0) != '#') {
+    cmd = (GooString *)tokens->get(0);
+    if (!cmd->cmp("include")) {
+      if (tokens->getLength() == 2) {
+	incFile = (GooString *)tokens->get(1);
+	if ((f2 = fopen(incFile->getCString(), "r"))) {
+	  parseFile(incFile, f2);
+	  fclose(f2);
+	} else {
+	  error(-1, "Couldn't find included config file: '%s' (%s:%d)",
+		incFile->getCString(), fileName->getCString(), line);
+	}
+      } else {
+	error(-1, "Bad 'include' config file command (%s:%d)",
+	      fileName->getCString(), line);
+      }
+    } else if (!cmd->cmp("nameToUnicode")) {
+      parseNameToUnicode(tokens, fileName, line);
+    } else if (!cmd->cmp("cidToUnicode")) {
+      parseCIDToUnicode(tokens, fileName, line);
+    } else if (!cmd->cmp("unicodeToUnicode")) {
+      parseUnicodeToUnicode(tokens, fileName, line);
+    } else if (!cmd->cmp("unicodeMap")) {
+      parseUnicodeMap(tokens, fileName, line);
+    } else if (!cmd->cmp("cMapDir")) {
+      parseCMapDir(tokens, fileName, line);
+    } else if (!cmd->cmp("toUnicodeDir")) {
+      parseToUnicodeDir(tokens, fileName, line);
+    } else if (!cmd->cmp("displayFontT1")) {
+      parseDisplayFont(tokens, displayFonts, displayFontT1, fileName, line);
+    } else if (!cmd->cmp("displayFontTT")) {
+      parseDisplayFont(tokens, displayFonts, displayFontTT, fileName, line);
+    } else if (!cmd->cmp("displayNamedCIDFontT1")) {
+      parseDisplayFont(tokens, displayNamedCIDFonts,
+		       displayFontT1, fileName, line);
+    } else if (!cmd->cmp("displayCIDFontT1")) {
+      parseDisplayFont(tokens, displayCIDFonts,
+		       displayFontT1, fileName, line);
+    } else if (!cmd->cmp("displayNamedCIDFontTT")) {
+      parseDisplayFont(tokens, displayNamedCIDFonts,
+		       displayFontTT, fileName, line);
+    } else if (!cmd->cmp("displayCIDFontTT")) {
+      parseDisplayFont(tokens, displayCIDFonts,
+		       displayFontTT, fileName, line);
+    } else if (!cmd->cmp("psFile")) {
+      parsePSFile(tokens, fileName, line);
+    } else if (!cmd->cmp("psFont")) {
+      parsePSFont(tokens, fileName, line);
+    } else if (!cmd->cmp("psNamedFont16")) {
+      parsePSFont16("psNamedFont16", psNamedFonts16,
+		    tokens, fileName, line);
+    } else if (!cmd->cmp("psFont16")) {
+      parsePSFont16("psFont16", psFonts16, tokens, fileName, line);
+    } else if (!cmd->cmp("psPaperSize")) {
+      parsePSPaperSize(tokens, fileName, line);
+    } else if (!cmd->cmp("psImageableArea")) {
+      parsePSImageableArea(tokens, fileName, line);
+    } else if (!cmd->cmp("psCrop")) {
+      parseYesNo("psCrop", &psCrop, tokens, fileName, line);
+    } else if (!cmd->cmp("psExpandSmaller")) {
+      parseYesNo("psExpandSmaller", &psExpandSmaller,
+		 tokens, fileName, line);
+    } else if (!cmd->cmp("psShrinkLarger")) {
+      parseYesNo("psShrinkLarger", &psShrinkLarger, tokens, fileName, line);
+    } else if (!cmd->cmp("psCenter")) {
+      parseYesNo("psCenter", &psCenter, tokens, fileName, line);
+    } else if (!cmd->cmp("psDuplex")) {
+      parseYesNo("psDuplex", &psDuplex, tokens, fileName, line);
+    } else if (!cmd->cmp("psLevel")) {
+      parsePSLevel(tokens, fileName, line);
+    } else if (!cmd->cmp("psEmbedType1Fonts")) {
+      parseYesNo("psEmbedType1", &psEmbedType1, tokens, fileName, line);
+    } else if (!cmd->cmp("psEmbedTrueTypeFonts")) {
+      parseYesNo("psEmbedTrueType", &psEmbedTrueType,
+		 tokens, fileName, line);
+    } else if (!cmd->cmp("psEmbedCIDPostScriptFonts")) {
+      parseYesNo("psEmbedCIDPostScript", &psEmbedCIDPostScript,
+		 tokens, fileName, line);
+    } else if (!cmd->cmp("psEmbedCIDTrueTypeFonts")) {
+      parseYesNo("psEmbedCIDTrueType", &psEmbedCIDTrueType,
+		 tokens, fileName, line);
+    } else if (!cmd->cmp("psPreload")) {
+      parseYesNo("psPreload", &psPreload, tokens, fileName, line);
+    } else if (!cmd->cmp("psOPI")) {
+      parseYesNo("psOPI", &psOPI, tokens, fileName, line);
+    } else if (!cmd->cmp("psASCIIHex")) {
+      parseYesNo("psASCIIHex", &psASCIIHex, tokens, fileName, line);
+    } else if (!cmd->cmp("textEncoding")) {
+      parseTextEncoding(tokens, fileName, line);
+    } else if (!cmd->cmp("textEOL")) {
+      parseTextEOL(tokens, fileName, line);
+    } else if (!cmd->cmp("textPageBreaks")) {
+      parseYesNo("textPageBreaks", &textPageBreaks,
+		 tokens, fileName, line);
+    } else if (!cmd->cmp("textKeepTinyChars")) {
+      parseYesNo("textKeepTinyChars", &textKeepTinyChars,
+		 tokens, fileName, line);
+    } else if (!cmd->cmp("fontDir")) {
+      parseFontDir(tokens, fileName, line);
+    } else if (!cmd->cmp("initialZoom")) {
+      parseInitialZoom(tokens, fileName, line);
+    } else if (!cmd->cmp("continuousView")) {
+      parseYesNo("continuousView", &continuousView, tokens, fileName, line);
+    } else if (!cmd->cmp("enableT1lib")) {
+      parseYesNo("enableT1lib", &enableT1lib, tokens, fileName, line);
+    } else if (!cmd->cmp("enableFreeType")) {
+      parseYesNo("enableFreeType", &enableFreeType, tokens, fileName, line);
+    } else if (!cmd->cmp("antialias")) {
+      parseYesNo("antialias", &antialias, tokens, fileName, line);
+    } else if (!cmd->cmp("vectorAntialias")) {
+      parseYesNo("vectorAntialias", &vectorAntialias,
+		 tokens, fileName, line);
+    } else if (!cmd->cmp("strokeAdjust")) {
+      parseYesNo("strokeAdjust", &strokeAdjust, tokens, fileName, line);
+    } else if (!cmd->cmp("screenType")) {
+      parseScreenType(tokens, fileName, line);
+    } else if (!cmd->cmp("screenSize")) {
+      parseInteger("screenSize", &screenSize, tokens, fileName, line);
+    } else if (!cmd->cmp("screenDotRadius")) {
+      parseInteger("screenDotRadius", &screenDotRadius,
+		   tokens, fileName, line);
+    } else if (!cmd->cmp("screenGamma")) {
+      parseFloat("screenGamma", &screenGamma,
+		 tokens, fileName, line);
+    } else if (!cmd->cmp("screenBlackThreshold")) {
+      parseFloat("screenBlackThreshold", &screenBlackThreshold,
+		 tokens, fileName, line);
+    } else if (!cmd->cmp("screenWhiteThreshold")) {
+      parseFloat("screenWhiteThreshold", &screenWhiteThreshold,
+		 tokens, fileName, line);
+    } else if (!cmd->cmp("urlCommand")) {
+      parseCommand("urlCommand", &urlCommand, tokens, fileName, line);
+    } else if (!cmd->cmp("movieCommand")) {
+      parseCommand("movieCommand", &movieCommand, tokens, fileName, line);
+    } else if (!cmd->cmp("mapNumericCharNames")) {
+      parseYesNo("mapNumericCharNames", &mapNumericCharNames,
+		 tokens, fileName, line);
+    } else if (!cmd->cmp("mapUnknownCharNames")) {
+      parseYesNo("mapUnknownCharNames", &mapUnknownCharNames,
+		 tokens, fileName, line);
+    } else if (!cmd->cmp("bind")) {
+      parseBind(tokens, fileName, line);
+    } else if (!cmd->cmp("unbind")) {
+      parseUnbind(tokens, fileName, line);
+    } else if (!cmd->cmp("printCommands")) {
+      parseYesNo("printCommands", &printCommands, tokens, fileName, line);
+    } else if (!cmd->cmp("errQuiet")) {
+      parseYesNo("errQuiet", &errQuiet, tokens, fileName, line);
+    } else {
+      error(-1, "Unknown config file command '%s' (%s:%d)",
+	    cmd->getCString(), fileName->getCString(), line);
+      if (!cmd->cmp("displayFontX") ||
+	  !cmd->cmp("displayNamedCIDFontX") ||
+	  !cmd->cmp("displayCIDFontX")) {
+	error(-1, "-- Xpdf no longer supports X fonts");
+      } else if (!cmd->cmp("t1libControl") || !cmd->cmp("freetypeControl")) {
+	error(-1, "-- The t1libControl and freetypeControl options have been replaced");
+	error(-1, "   by the enableT1lib, enableFreeType, and antialias options");
+      } else if (!cmd->cmp("fontpath") || !cmd->cmp("fontmap")) {
+	error(-1, "-- the config file format has changed since Xpdf 0.9x");
+      }
+    }
+  }
+
+  deleteGooList(tokens, GooString);
+}
+
+void GlobalParamsGUI::parseNameToUnicode(GooList *tokens, GooString *fileName,
+					 int line) {
+  GooString *name;
+  char *tok1, *tok2;
+  FILE *f;
+  char buf[256];
+  int line2;
+  Unicode u;
+
+  if (tokens->getLength() != 2) {
+    error(-1, "Bad 'nameToUnicode' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  name = (GooString *)tokens->get(1);
+  if (!(f = fopen(name->getCString(), "r"))) {
+    error(-1, "Couldn't open 'nameToUnicode' file '%s'",
+	  name->getCString());
+    return;
+  }
+  line2 = 1;
+  while (getLine(buf, sizeof(buf), f)) {
+    tok1 = strtok(buf, " \t\r\n");
+    tok2 = strtok(NULL, " \t\r\n");
+    if (tok1 && tok2) {
+      sscanf(tok1, "%x", &u);
+      nameToUnicode->add(tok2, u);
+    } else {
+      error(-1, "Bad line in 'nameToUnicode' file (%s:%d)",
+	    name->getCString(), line2);
+    }
+    ++line2;
+  }
+  fclose(f);
+}
+
+void GlobalParamsGUI::parseNameToUnicode(GooString *name) {
+  char *tok1, *tok2;
+  FILE *f;
+  char buf[256];
+  int line;
+  Unicode u;
+
+  if (!(f = fopen(name->getCString(), "r"))) {
+    error(-1, "Couldn't open 'nameToUnicode' file '%s'",
+	  name->getCString());
+    return;
+  }
+  line = 1;
+  while (getLine(buf, sizeof(buf), f)) {
+    tok1 = strtok(buf, " \t\r\n");
+    tok2 = strtok(NULL, " \t\r\n");
+    if (tok1 && tok2) {
+      sscanf(tok1, "%x", &u);
+      nameToUnicode->add(tok2, u);
+    } else {
+      error(-1, "Bad line in 'nameToUnicode' file (%s:%d)",
+	    name->getCString(), line);
+    }
+    ++line;
+  }
+  fclose(f);
+}
+
+void GlobalParamsGUI::parseCIDToUnicode(GooList *tokens, GooString *fileName,
+				     int line) {
+  GooString *collection, *name, *old;
+
+  if (tokens->getLength() != 3) {
+    error(-1, "Bad 'cidToUnicode' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  collection = (GooString *)tokens->get(1);
+  name = (GooString *)tokens->get(2);
+  if ((old = (GooString *)cidToUnicodes->remove(collection))) {
+    delete old;
+  }
+  cidToUnicodes->add(collection->copy(), name->copy());
+}
+
+void GlobalParamsGUI::parseUnicodeToUnicode(GooList *tokens, GooString *fileName,
+					 int line) {
+  GooString *font, *file, *old;
+
+  if (tokens->getLength() != 3) {
+    error(-1, "Bad 'unicodeToUnicode' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  font = (GooString *)tokens->get(1);
+  file = (GooString *)tokens->get(2);
+  if ((old = (GooString *)unicodeToUnicodes->remove(font))) {
+    delete old;
+  }
+  unicodeToUnicodes->add(font->copy(), file->copy());
+}
+
+void GlobalParamsGUI::parseUnicodeMap(GooList *tokens, GooString *fileName,
+				   int line) {
+  GooString *encodingName, *name, *old;
+
+  if (tokens->getLength() != 3) {
+    error(-1, "Bad 'unicodeMap' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  encodingName = (GooString *)tokens->get(1);
+  name = (GooString *)tokens->get(2);
+  if ((old = (GooString *)unicodeMaps->remove(encodingName))) {
+    delete old;
+  }
+  unicodeMaps->add(encodingName->copy(), name->copy());
+}
+
+void GlobalParamsGUI::parseCMapDir(GooList *tokens, GooString *fileName, int line) {
+  GooString *collection, *dir;
+  GooList *list;
+
+  if (tokens->getLength() != 3) {
+    error(-1, "Bad 'cMapDir' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  collection = (GooString *)tokens->get(1);
+  dir = (GooString *)tokens->get(2);
+  if (!(list = (GooList *)cMapDirs->lookup(collection))) {
+    list = new GooList();
+    cMapDirs->add(collection->copy(), list);
+  }
+  list->append(dir->copy());
+}
+
+void GlobalParamsGUI::parseToUnicodeDir(GooList *tokens, GooString *fileName,
+				     int line) {
+  if (tokens->getLength() != 2) {
+    error(-1, "Bad 'toUnicodeDir' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  toUnicodeDirs->append(((GooString *)tokens->get(1))->copy());
+}
+
+void GlobalParamsGUI::parseDisplayFont(GooList *tokens, GooHash *fontHash,
+				    DisplayFontParamKind kind,
+				    GooString *fileName, int line) {
+  DisplayFontParam *param, *old;
+
+  if (tokens->getLength() < 2) {
+    goto err1;
+  }
+  param = new DisplayFontParam(((GooString *)tokens->get(1))->copy(), kind);
+  
+  switch (kind) {
+  case displayFontT1:
+    if (tokens->getLength() != 3) {
+      goto err2;
+    }
+    param->t1.fileName = ((GooString *)tokens->get(2))->copy();
+    break;
+  case displayFontTT:
+    if (tokens->getLength() != 3) {
+      goto err2;
+    }
+    param->tt.fileName = ((GooString *)tokens->get(2))->copy();
+    break;
+  }
+
+  if ((old = (DisplayFontParam *)fontHash->remove(param->name))) {
+    delete old;
+  }
+  fontHash->add(param->name, param);
+  return;
+
+ err2:
+  delete param;
+ err1:
+  error(-1, "Bad 'display*Font*' config file command (%s:%d)",
+	fileName->getCString(), line);
+}
+
+void GlobalParamsGUI::parsePSPaperSize(GooList *tokens, GooString *fileName,
+				    int line) {
+  GooString *tok;
+
+  if (tokens->getLength() == 2) {
+    tok = (GooString *)tokens->get(1);
+    if (!setPSPaperSize(tok->getCString())) {
+      error(-1, "Bad 'psPaperSize' config file command (%s:%d)",
+	    fileName->getCString(), line);
+    }
+  } else if (tokens->getLength() == 3) {
+    tok = (GooString *)tokens->get(1);
+    psPaperWidth = atoi(tok->getCString());
+    tok = (GooString *)tokens->get(2);
+    psPaperHeight = atoi(tok->getCString());
+    psImageableLLX = psImageableLLY = 0;
+    psImageableURX = psPaperWidth;
+    psImageableURY = psPaperHeight;
+  } else {
+    error(-1, "Bad 'psPaperSize' config file command (%s:%d)",
+	  fileName->getCString(), line);
+  }
+}
+
+void GlobalParamsGUI::parsePSImageableArea(GooList *tokens, GooString *fileName,
+					int line) {
+  if (tokens->getLength() != 5) {
+    error(-1, "Bad 'psImageableArea' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  psImageableLLX = atoi(((GooString *)tokens->get(1))->getCString());
+  psImageableLLY = atoi(((GooString *)tokens->get(2))->getCString());
+  psImageableURX = atoi(((GooString *)tokens->get(3))->getCString());
+  psImageableURY = atoi(((GooString *)tokens->get(4))->getCString());
+}
+
+void GlobalParamsGUI::parsePSLevel(GooList *tokens, GooString *fileName, int line) {
+  GooString *tok;
+
+  if (tokens->getLength() != 2) {
+    error(-1, "Bad 'psLevel' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  tok = (GooString *)tokens->get(1);
+  if (!tok->cmp("level1")) {
+    psLevel = psLevel1;
+  } else if (!tok->cmp("level1sep")) {
+    psLevel = psLevel1Sep;
+  } else if (!tok->cmp("level2")) {
+    psLevel = psLevel2;
+  } else if (!tok->cmp("level2sep")) {
+    psLevel = psLevel2Sep;
+  } else if (!tok->cmp("level3")) {
+    psLevel = psLevel3;
+  } else if (!tok->cmp("level3Sep")) {
+    psLevel = psLevel3Sep;
+  } else {
+    error(-1, "Bad 'psLevel' config file command (%s:%d)",
+	  fileName->getCString(), line);
+  }
+}
+
+void GlobalParamsGUI::parsePSFile(GooList *tokens, GooString *fileName, int line) {
+  if (tokens->getLength() != 2) {
+    error(-1, "Bad 'psFile' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  if (psFile) {
+    delete psFile;
+  }
+  psFile = ((GooString *)tokens->get(1))->copy();
+}
+
+void GlobalParamsGUI::parsePSFont(GooList *tokens, GooString *fileName, int line) {
+  PSFontParam *param;
+
+  if (tokens->getLength() != 3) {
+    error(-1, "Bad 'psFont' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  param = new PSFontParam(((GooString *)tokens->get(1))->copy(), 0,
+			  ((GooString *)tokens->get(2))->copy(), NULL);
+  psFonts->add(param->pdfFontName, param);
+}
+
+void GlobalParamsGUI::parsePSFont16(char *cmdName, GooList *fontList,
+				 GooList *tokens, GooString *fileName, int line) {
+  PSFontParam *param;
+  int wMode;
+  GooString *tok;
+
+  if (tokens->getLength() != 5) {
+    error(-1, "Bad '%s' config file command (%s:%d)",
+	  cmdName, fileName->getCString(), line);
+    return;
+  }
+  tok = (GooString *)tokens->get(2);
+  if (!tok->cmp("H")) {
+    wMode = 0;
+  } else if (!tok->cmp("V")) {
+    wMode = 1;
+  } else {
+    error(-1, "Bad '%s' config file command (%s:%d)",
+	  cmdName, fileName->getCString(), line);
+    return;
+  }
+  param = new PSFontParam(((GooString *)tokens->get(1))->copy(),
+			  wMode,
+			  ((GooString *)tokens->get(3))->copy(),
+			  ((GooString *)tokens->get(4))->copy());
+  fontList->append(param);
+}
+
+void GlobalParamsGUI::parseTextEncoding(GooList *tokens, GooString *fileName,
+				     int line) {
+  if (tokens->getLength() != 2) {
+    error(-1, "Bad 'textEncoding' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  delete textEncoding;
+  textEncoding = ((GooString *)tokens->get(1))->copy();
+}
+
+void GlobalParamsGUI::parseTextEOL(GooList *tokens, GooString *fileName, int line) {
+  GooString *tok;
+
+  if (tokens->getLength() != 2) {
+    error(-1, "Bad 'textEOL' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  tok = (GooString *)tokens->get(1);
+  if (!tok->cmp("unix")) {
+    textEOL = eolUnix;
+  } else if (!tok->cmp("dos")) {
+    textEOL = eolDOS;
+  } else if (!tok->cmp("mac")) {
+    textEOL = eolMac;
+  } else {
+    error(-1, "Bad 'textEOL' config file command (%s:%d)",
+	  fileName->getCString(), line);
+  }
+}
+
+void GlobalParamsGUI::parseFontDir(GooList *tokens, GooString *fileName, int line) {
+  if (tokens->getLength() != 2) {
+    error(-1, "Bad 'fontDir' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  fontDirs->append(((GooString *)tokens->get(1))->copy());
+}
+
+void GlobalParamsGUI::parseInitialZoom(GooList *tokens,
+				    GooString *fileName, int line) {
+  if (tokens->getLength() != 2) {
+    error(-1, "Bad 'initialZoom' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  delete initialZoom;
+  initialZoom = ((GooString *)tokens->get(1))->copy();
+}
+
+void GlobalParamsGUI::parseScreenType(GooList *tokens, GooString *fileName,
+				   int line) {
+  GooString *tok;
+
+  if (tokens->getLength() != 2) {
+    error(-1, "Bad 'screenType' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  tok = (GooString *)tokens->get(1);
+  if (!tok->cmp("dispersed")) {
+    screenType = screenDispersed;
+  } else if (!tok->cmp("clustered")) {
+    screenType = screenClustered;
+  } else if (!tok->cmp("stochasticClustered")) {
+    screenType = screenStochasticClustered;
+  } else {
+    error(-1, "Bad 'screenType' config file command (%s:%d)",
+	  fileName->getCString(), line);
+  }
+}
+
+void GlobalParamsGUI::parseBind(GooList *tokens, GooString *fileName, int line) {
+  KeyBinding *binding;
+  GooList *cmds;
+  int code, mods, context, i;
+
+  if (tokens->getLength() < 4) {
+    error(-1, "Bad 'bind' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  if (!parseKey((GooString *)tokens->get(1), (GooString *)tokens->get(2),
+		&code, &mods, &context,
+		"bind", tokens, fileName, line)) {
+    return;
+  }
+  for (i = 0; i < keyBindings->getLength(); ++i) {
+    binding = (KeyBinding *)keyBindings->get(i);
+    if (binding->code == code &&
+	binding->mods == mods &&
+	binding->context == context) {
+      delete (KeyBinding *)keyBindings->del(i);
+      break;
+    }
+  }
+  cmds = new GooList();
+  for (i = 3; i < tokens->getLength(); ++i) {
+    cmds->append(((GooString *)tokens->get(i))->copy());
+  }
+  keyBindings->append(new KeyBinding(code, mods, context, cmds));
+}
+
+void GlobalParamsGUI::parseUnbind(GooList *tokens, GooString *fileName, int line) {
+  KeyBinding *binding;
+  int code, mods, context, i;
+
+  if (tokens->getLength() != 3) {
+    error(-1, "Bad 'unbind' config file command (%s:%d)",
+	  fileName->getCString(), line);
+    return;
+  }
+  if (!parseKey((GooString *)tokens->get(1), (GooString *)tokens->get(2),
+		&code, &mods, &context,
+		"unbind", tokens, fileName, line)) {
+    return;
+  }
+  for (i = 0; i < keyBindings->getLength(); ++i) {
+    binding = (KeyBinding *)keyBindings->get(i);
+    if (binding->code == code &&
+	binding->mods == mods &&
+	binding->context == context) {
+      delete (KeyBinding *)keyBindings->del(i);
+      break;
+    }
+  }
+}
+
+GBool GlobalParamsGUI::parseKey(GooString *modKeyStr, GooString *contextStr,
+			     int *code, int *mods, int *context,
+			     char *cmdName,
+			     GooList *tokens, GooString *fileName, int line) {
+  char *p0;
+
+  *mods = xpdfKeyModNone;
+  p0 = modKeyStr->getCString();
+  while (1) {
+    if (!strncmp(p0, "shift-", 6)) {
+      *mods |= xpdfKeyModShift;
+      p0 += 6;
+    } else if (!strncmp(p0, "ctrl-", 5)) {
+      *mods |= xpdfKeyModCtrl;
+      p0 += 5;
+    } else if (!strncmp(p0, "alt-", 4)) {
+      *mods |= xpdfKeyModAlt;
+      p0 += 4;
+    } else {
+      break;
+    }
+  }
+
+  if (!strcmp(p0, "space")) {
+    *code = ' ';
+  } else if (!strcmp(p0, "tab")) {
+    *code = xpdfKeyCodeTab;
+  } else if (!strcmp(p0, "return")) {
+    *code = xpdfKeyCodeReturn;
+  } else if (!strcmp(p0, "enter")) {
+    *code = xpdfKeyCodeEnter;
+  } else if (!strcmp(p0, "backspace")) {
+    *code = xpdfKeyCodeBackspace;
+  } else if (!strcmp(p0, "insert")) {
+    *code = xpdfKeyCodeInsert;
+  } else if (!strcmp(p0, "delete")) {
+    *code = xpdfKeyCodeDelete;
+  } else if (!strcmp(p0, "home")) {
+    *code = xpdfKeyCodeHome;
+  } else if (!strcmp(p0, "end")) {
+    *code = xpdfKeyCodeEnd;
+  } else if (!strcmp(p0, "pgup")) {
+    *code = xpdfKeyCodePgUp;
+  } else if (!strcmp(p0, "pgdn")) {
+    *code = xpdfKeyCodePgDn;
+  } else if (!strcmp(p0, "left")) {
+    *code = xpdfKeyCodeLeft;
+  } else if (!strcmp(p0, "right")) {
+    *code = xpdfKeyCodeRight;
+  } else if (!strcmp(p0, "up")) {
+    *code = xpdfKeyCodeUp;
+  } else if (!strcmp(p0, "down")) {
+    *code = xpdfKeyCodeDown;
+  } else if (p0[0] == 'f' && p0[1] >= '1' && p0[1] <= '9' && !p0[2]) {
+    *code = xpdfKeyCodeF1 + (p0[1] - '1');
+  } else if (p0[0] == 'f' &&
+	     ((p0[1] >= '1' && p0[1] <= '2' && p0[2] >= '0' && p0[2] <= '9') ||
+	      (p0[1] == '3' && p0[2] >= '0' && p0[2] <= '5')) &&
+	     !p0[3]) {
+    *code = xpdfKeyCodeF1 + 10 * (p0[1] - '0') + (p0[2] - '0') - 1;
+  } else if (!strncmp(p0, "mousePress", 10) &&
+	     p0[10] >= '1' && p0[10] <= '7' && !p0[11]) {
+    *code = xpdfKeyCodeMousePress1 + (p0[10] - '1');
+  } else if (!strncmp(p0, "mouseRelease", 12) &&
+	     p0[12] >= '1' && p0[12] <= '7' && !p0[13]) {
+    *code = xpdfKeyCodeMouseRelease1 + (p0[12] - '1');
+  } else if (*p0 >= 0x20 && *p0 <= 0x7e && !p0[1]) {
+    *code = (int)*p0;
+  } else {
+    error(-1, "Bad key/modifier in '%s' config file command (%s:%d)",
+	  cmdName, fileName->getCString(), line);
+    return gFalse;
+  }
+
+  p0 = contextStr->getCString();
+  if (!strcmp(p0, "any")) {
+    *context = xpdfKeyContextAny;
+  } else {
+    *context = xpdfKeyContextAny;
+    while (1) {
+      if (!strncmp(p0, "fullScreen", 10)) {
+	*context |= xpdfKeyContextFullScreen;
+	p0 += 10;
+      } else if (!strncmp(p0, "window", 6)) {
+	*context |= xpdfKeyContextWindow;
+	p0 += 6;
+      } else if (!strncmp(p0, "continuous", 10)) {
+	*context |= xpdfKeyContextContinuous;
+	p0 += 10;
+      } else if (!strncmp(p0, "singlePage", 10)) {
+	*context |= xpdfKeyContextSinglePage;
+	p0 += 10;
+      } else if (!strncmp(p0, "overLink", 8)) {
+	*context |= xpdfKeyContextOverLink;
+	p0 += 8;
+      } else if (!strncmp(p0, "offLink", 7)) {
+	*context |= xpdfKeyContextOffLink;
+	p0 += 7;
+      } else if (!strncmp(p0, "outline", 7)) {
+	*context |= xpdfKeyContextOutline;
+	p0 += 7;
+      } else if (!strncmp(p0, "mainWin", 7)) {
+	*context |= xpdfKeyContextMainWin;
+	p0 += 7;
+      } else if (!strncmp(p0, "scrLockOn", 9)) {
+	*context |= xpdfKeyContextScrLockOn;
+	p0 += 9;
+      } else if (!strncmp(p0, "scrLockOff", 10)) {
+	*context |= xpdfKeyContextScrLockOff;
+	p0 += 10;
+      } else {
+	error(-1, "Bad context in '%s' config file command (%s:%d)",
+	      cmdName, fileName->getCString(), line);
+	return gFalse;
+      }
+      if (!*p0) {
+	break;
+      }
+      if (*p0 != ',') {
+	error(-1, "Bad context in '%s' config file command (%s:%d)",
+	      cmdName, fileName->getCString(), line);
+	return gFalse;
+      }
+      ++p0;
+    }
+  }
+
+  return gTrue;
+}
+
+void GlobalParamsGUI::parseCommand(char *cmdName, GooString **val,
+				GooList *tokens, GooString *fileName, int line) {
+  if (tokens->getLength() != 2) {
+    error(-1, "Bad '%s' config file command (%s:%d)",
+	  cmdName, fileName->getCString(), line);
+    return;
+  }
+  if (*val) {
+    delete *val;
+  }
+  *val = ((GooString *)tokens->get(1))->copy();
+}
+
+void GlobalParamsGUI::parseYesNo(char *cmdName, GBool *flag,
+			      GooList *tokens, GooString *fileName, int line) {
+  GooString *tok;
+
+  if (tokens->getLength() != 2) {
+    error(-1, "Bad '%s' config file command (%s:%d)",
+	  cmdName, fileName->getCString(), line);
+    return;
+  }
+  tok = (GooString *)tokens->get(1);
+  if (!parseYesNo2(tok->getCString(), flag)) {
+    error(-1, "Bad '%s' config file command (%s:%d)",
+	  cmdName, fileName->getCString(), line);
+  }
+}
+
+GBool GlobalParamsGUI::parseYesNo2(char *token, GBool *flag) {
+  if (!strcmp(token, "yes")) {
+    *flag = gTrue;
+  } else if (!strcmp(token, "no")) {
+    *flag = gFalse;
+  } else {
+    return gFalse;
+  }
+  return gTrue;
+}
+
+void GlobalParamsGUI::parseInteger(char *cmdName, int *val,
+				GooList *tokens, GooString *fileName, int line) {
+  GooString *tok;
+  int i;
+
+  if (tokens->getLength() != 2) {
+    error(-1, "Bad '%s' config file command (%s:%d)",
+	  cmdName, fileName->getCString(), line);
+    return;
+  }
+  tok = (GooString *)tokens->get(1);
+  if (tok->getLength() == 0) {
+    error(-1, "Bad '%s' config file command (%s:%d)",
+	  cmdName, fileName->getCString(), line);
+    return;
+  }
+  if (tok->getChar(0) == '-') {
+    i = 1;
+  } else {
+    i = 0;
+  }
+  for (; i < tok->getLength(); ++i) {
+    if (tok->getChar(i) < '0' || tok->getChar(i) > '9') {
+      error(-1, "Bad '%s' config file command (%s:%d)",
+	    cmdName, fileName->getCString(), line);
+      return;
+    }
+  }
+  *val = atoi(tok->getCString());
+}
+
+void GlobalParamsGUI::parseFloat(char *cmdName, double *val,
+			      GooList *tokens, GooString *fileName, int line) {
+  GooString *tok;
+  int i;
+
+  if (tokens->getLength() != 2) {
+    error(-1, "Bad '%s' config file command (%s:%d)",
+	  cmdName, fileName->getCString(), line);
+    return;
+  }
+  tok = (GooString *)tokens->get(1);
+  if (tok->getLength() == 0) {
+    error(-1, "Bad '%s' config file command (%s:%d)",
+	  cmdName, fileName->getCString(), line);
+    return;
+  }
+  if (tok->getChar(0) == '-') {
+    i = 1;
+  } else {
+    i = 0;
+  }
+  for (; i < tok->getLength(); ++i) {
+    if (!((tok->getChar(i) >= '0' && tok->getChar(i) <= '9') ||
+	  tok->getChar(i) == '.')) {
+      error(-1, "Bad '%s' config file command (%s:%d)",
+	    cmdName, fileName->getCString(), line);
+      return;
+    }
+  }
+  *val = atof(tok->getCString());
+}
+
+void GlobalParamsGUI::addCIDToUnicode(GooString *collection,
+				   GooString *fileName) {
+  GooString *old;
+
+  if ((old = (GooString *)cidToUnicodes->remove(collection))) {
+    delete old;
+  }
+  cidToUnicodes->add(collection->copy(), fileName->copy());
+}
+
+void GlobalParamsGUI::addUnicodeMap(GooString *encodingName, GooString *fileName)
+{
+  GooString *old;
+
+  if ((old = (GooString *)unicodeMaps->remove(encodingName))) {
+    delete old;
+  }
+  unicodeMaps->add(encodingName->copy(), fileName->copy());
+}
+
+void GlobalParamsGUI::addCMapDir(GooString *collection, GooString *dir) {
+  GooList *list;
+
+  if (!(list = (GooList *)cMapDirs->lookup(collection))) {
+    list = new GooList();
+    cMapDirs->add(collection->copy(), list);
+  }
+  list->append(dir->copy());
+}
+
+GlobalParamsGUI::~GlobalParamsGUI() {
+  GooHashIter *iter;
+  GooString *key;
+  GooList *list;
+
+  delete macRomanReverseMap;
+
+  delete baseDir;
+  delete nameToUnicode;
+  deleteGooHash(cidToUnicodes, GooString);
+  deleteGooHash(unicodeToUnicodes, GooString);
+  deleteGooHash(residentUnicodeMaps, UnicodeMap);
+  deleteGooHash(unicodeMaps, GooString);
+  deleteGooList(toUnicodeDirs, GooString);
+  deleteGooHash(displayFonts, DisplayFontParam);
+  deleteGooHash(displayCIDFonts, DisplayFontParam);
+  deleteGooHash(displayNamedCIDFonts, DisplayFontParam);
+#ifdef WIN32
+  if (winFontList) {
+    delete winFontList;
+  }
+#endif
+  if (psFile) {
+    delete psFile;
+  }
+  deleteGooHash(psFonts, PSFontParam);
+  deleteGooList(psNamedFonts16, PSFontParam);
+  deleteGooList(psFonts16, PSFontParam);
+  delete textEncoding;
+  deleteGooList(fontDirs, GooString);
+
+  cMapDirs->startIter(&iter);
+  while (cMapDirs->getNext(&iter, &key, (void **)&list)) {
+    deleteGooList(list, GooString);
+  }
+  delete cMapDirs;
+
+  delete cidToUnicodeCache;
+  delete unicodeToUnicodeCache;
+  delete unicodeMapCache;
+  delete cMapCache;
+
+#ifdef ENABLE_PLUGINS
+  delete securityHandlers;
+  deleteGooList(plugins, Plugin);
+#endif
+
+#if MULTITHREADED
+  gDestroyMutex(&mutex);
+  gDestroyMutex(&unicodeMapCacheMutex);
+  gDestroyMutex(&cMapCacheMutex);
+#endif
+}
+
+//------------------------------------------------------------------------
+
+void GlobalParamsGUI::setBaseDir(char *dir) {
+  delete baseDir;
+  baseDir = new GooString(dir);
+}
+
+void GlobalParamsGUI::setupBaseFonts(char *dir) {
+  GooString *fontName;
+  GooString *fileName;
+#ifdef WIN32
+  HMODULE shell32Lib;
+  BOOL (__stdcall *SHGetSpecialFolderPathFunc)(HWND hwndOwner,
+					       LPTSTR lpszPath,
+					       int nFolder,
+					       BOOL fCreate);
+  char winFontDir[MAX_PATH];
+#endif
+  FILE *f;
+  DisplayFontParamKind kind;
+  DisplayFontParam *dfp;
+  int i, j;
+
+#ifdef WIN32
+  // SHGetSpecialFolderPath isn't available in older versions of
+  // shell32.dll (Win95 and WinNT4), so do a dynamic load
+  winFontDir[0] = '\0';
+  if ((shell32Lib = LoadLibrary("shell32.dll"))) {
+    if ((SHGetSpecialFolderPathFunc = 
+	 (BOOL (__stdcall *)(HWND hwndOwner, LPTSTR lpszPath,
+			     int nFolder, BOOL fCreate))
+	 GetProcAddress(shell32Lib, "SHGetSpecialFolderPathA"))) {
+      if (!(*SHGetSpecialFolderPathFunc)(NULL, winFontDir,
+					 CSIDL_FONTS, FALSE)) {
+	winFontDir[0] = '\0';
+      }
+    }
+  }
+#endif
+  for (i = 0; displayFontTab[i].name; ++i) {
+    fontName = new GooString(displayFontTab[i].name);
+    if (getDisplayFont(fontName)) {
+      delete fontName;
+      continue;
+    }
+    fileName = NULL;
+    kind = displayFontT1; // make gcc happy
+    if (dir) {
+      fileName = appendToPath(new GooString(dir), displayFontTab[i].t1FileName);
+      kind = displayFontT1;
+      if ((f = fopen(fileName->getCString(), "rb"))) {
+	fclose(f);
+      } else {
+	delete fileName;
+	fileName = NULL;
+      }
+    }
+#ifdef WIN32
+    if (!fileName && winFontDir[0] && displayFontTab[i].ttFileName) {
+      fileName = appendToPath(new GooString(winFontDir),
+			      displayFontTab[i].ttFileName);
+      kind = displayFontTT;
+      if ((f = fopen(fileName->getCString(), "rb"))) {
+	fclose(f);
+      } else {
+	delete fileName;
+	fileName = NULL;
+      }
+    }
+    // SHGetSpecialFolderPath(CSIDL_FONTS) doesn't work on Win 2k Server
+    // or Win2003 Server, or with older versions of shell32.dll, so check
+    // the "standard" directories
+    if (displayFontTab[i].ttFileName) {
+      for (j = 0; !fileName && displayFontDirs[j]; ++j) {
+	fileName = appendToPath(new GooString(displayFontDirs[j]),
+				displayFontTab[i].ttFileName);
+	kind = displayFontTT;
+	if ((f = fopen(fileName->getCString(), "rb"))) {
+	  fclose(f);
+	} else {
+	  delete fileName;
+	  fileName = NULL;
+	}
+      }
+    }
+#else
+    for (j = 0; !fileName && displayFontDirs[j]; ++j) {
+      fileName = appendToPath(new GooString(displayFontDirs[j]),
+			      displayFontTab[i].t1FileName);
+      kind = displayFontT1;
+      if ((f = fopen(fileName->getCString(), "rb"))) {
+	fclose(f);
+      } else {
+	delete fileName;
+	fileName = NULL;
+      }
+    }
+#endif
+    if (!fileName) {
+      error(-1, "No display font for '%s'", displayFontTab[i].name);
+      delete fontName;
+      continue;
+    }
+    dfp = new DisplayFontParam(fontName, kind);
+    dfp->t1.fileName = fileName;
+    globalParamsGUI->addDisplayFont(dfp);
+  }
+
+#ifdef WIN32
+  if (winFontDir[0]) {
+    winFontList = new WinFontList(winFontDir);
+  }
+#endif
+}
+
+//------------------------------------------------------------------------
+// accessors
+//------------------------------------------------------------------------
+
+CharCode GlobalParamsGUI::getMacRomanCharCode(char *charName) {
+  // no need to lock - macRomanReverseMap is constant
+  return macRomanReverseMap->lookup(charName);
+}
+
+GooString *GlobalParamsGUI::getBaseDir() {
+  GooString *s;
+
+  lockGlobalParamsGUI;
+  s = baseDir->copy();
+  unlockGlobalParamsGUI;
+  return s;
+}
+
+Unicode GlobalParamsGUI::mapNameToUnicode(char *charName) {
+  // no need to lock - nameToUnicode is constant
+  return nameToUnicode->lookup(charName);
+}
+
+UnicodeMap *GlobalParamsGUI::getResidentUnicodeMap(GooString *encodingName) {
+  UnicodeMap *map;
+
+  lockGlobalParamsGUI;
+  map = (UnicodeMap *)residentUnicodeMaps->lookup(encodingName);
+  unlockGlobalParamsGUI;
+  if (map) {
+    map->incRefCnt();
+  }
+  return map;
+}
+
+FILE *GlobalParamsGUI::getUnicodeMapFile(GooString *encodingName) {
+  GooString *fileName;
+  FILE *f;
+
+  lockGlobalParamsGUI;
+  if ((fileName = (GooString *)unicodeMaps->lookup(encodingName))) {
+    f = fopen(fileName->getCString(), "r");
+  } else {
+    f = NULL;
+  }
+  unlockGlobalParamsGUI;
+  return f;
+}
+
+FILE *GlobalParamsGUI::findCMapFile(GooString *collection, GooString *cMapName) {
+  GooList *list;
+  GooString *dir;
+  GooString *fileName;
+  FILE *f;
+  int i;
+
+  lockGlobalParamsGUI;
+  if (!(list = (GooList *)cMapDirs->lookup(collection))) {
+    unlockGlobalParamsGUI;
+    return NULL;
+  }
+  for (i = 0; i < list->getLength(); ++i) {
+    dir = (GooString *)list->get(i);
+    fileName = appendToPath(dir->copy(), cMapName->getCString());
+    f = fopen(fileName->getCString(), "r");
+    delete fileName;
+    if (f) {
+      unlockGlobalParamsGUI;
+      return f;
+    }
+  }
+  unlockGlobalParamsGUI;
+  return NULL;
+}
+
+FILE *GlobalParamsGUI::findToUnicodeFile(GooString *name) {
+  GooString *dir, *fileName;
+  FILE *f;
+  int i;
+
+  lockGlobalParamsGUI;
+  for (i = 0; i < toUnicodeDirs->getLength(); ++i) {
+    dir = (GooString *)toUnicodeDirs->get(i);
+    fileName = appendToPath(dir->copy(), name->getCString());
+    f = fopen(fileName->getCString(), "r");
+    delete fileName;
+    if (f) {
+      unlockGlobalParamsGUI;
+      return f;
+    }
+  }
+  unlockGlobalParamsGUI;
+  return NULL;
+}
+
+GBool findModifier(const char *name, const char *modifier, const char **start)
+{
+  const char *match;
+
+  if (name == NULL)
+    return gFalse;
+
+  match = strstr(name, modifier);
+  if (match) {
+    if (*start == NULL || match < *start)
+      *start = match;
+    return gTrue;
+  }
+  else {
+    return gFalse;
+  }
+}
+
+static FcPattern *buildFcPattern(GfxFont *font)
+{
+  int weight = FC_WEIGHT_NORMAL,
+      slant = FC_SLANT_ROMAN,
+      width = FC_WIDTH_NORMAL,
+      spacing = FC_PROPORTIONAL;
+  bool deleteFamily = false;
+  char *family, *name, *lang, *modifiers;
+  const char *start;
+  FcPattern *p;
+
+  // this is all heuristics will be overwritten if font had proper info
+  name = font->getName()->getCString();
+  
+  modifiers = strchr (name, ',');
+  if (modifiers == NULL)
+    modifiers = strchr (name, '-');
+  
+  // remove the - from the names, for some reason, Fontconfig does not
+  // understand "MS-Mincho" but does with "MS Mincho"
+  int len = strlen(name);
+  for (int i = 0; i < len; i++)
+    name[i] = (name[i] == '-' ? ' ' : name[i]);
+
+  start = NULL;
+  findModifier(modifiers, "Regular", &start);
+  findModifier(modifiers, "Roman", &start);
+  
+  if (findModifier(modifiers, "Oblique", &start))
+    slant = FC_SLANT_OBLIQUE;
+  if (findModifier(modifiers, "Italic", &start))
+    slant = FC_SLANT_ITALIC;
+  if (findModifier(modifiers, "Bold", &start))
+    weight = FC_WEIGHT_BOLD;
+  if (findModifier(modifiers, "Light", &start))
+    weight = FC_WEIGHT_LIGHT;
+  if (findModifier(modifiers, "Condensed", &start))
+    width = FC_WIDTH_CONDENSED;
+  
+  if (start) {
+    // There have been "modifiers" in the name, crop them to obtain
+    // the family name
+    family = new char[len+1];
+    strcpy(family, name);
+    int pos = (modifiers - name);
+    family[pos] = '\0';
+    deleteFamily = true;
+  }
+  else {
+    family = name;
+  }
+  
+  // use font flags
+  if (font->isFixedWidth())
+    spacing = FC_MONO;
+  if (font->isBold())
+    weight = FC_WEIGHT_BOLD;
+  if (font->isItalic())
+    slant = FC_SLANT_ITALIC;
+  
+  // if the FontDescriptor specified a family name use it
+  if (font->getFamily()) {
+    if (deleteFamily) {
+      delete[] family;
+      deleteFamily = false;
+    }
+    family = font->getFamily()->getCString();
+  }
+  
+  // if the FontDescriptor specified a weight use it
+  switch (font -> getWeight())
+  {
+    case GfxFont::W100: weight = FC_WEIGHT_EXTRALIGHT; break; 
+    case GfxFont::W200: weight = FC_WEIGHT_LIGHT; break; 
+    case GfxFont::W300: weight = FC_WEIGHT_BOOK; break; 
+    case GfxFont::W400: weight = FC_WEIGHT_NORMAL; break; 
+    case GfxFont::W500: weight = FC_WEIGHT_MEDIUM; break; 
+    case GfxFont::W600: weight = FC_WEIGHT_DEMIBOLD; break; 
+    case GfxFont::W700: weight = FC_WEIGHT_BOLD; break; 
+    case GfxFont::W800: weight = FC_WEIGHT_EXTRABOLD; break; 
+    case GfxFont::W900: weight = FC_WEIGHT_BLACK; break; 
+    default: break; 
+  }
+  
+  // if the FontDescriptor specified a width use it
+  switch (font -> getStretch())
+  {
+    case GfxFont::UltraCondensed: width = FC_WIDTH_ULTRACONDENSED; break; 
+    case GfxFont::ExtraCondensed: width = FC_WIDTH_EXTRACONDENSED; break; 
+    case GfxFont::Condensed: width = FC_WIDTH_CONDENSED; break; 
+    case GfxFont::SemiCondensed: width = FC_WIDTH_SEMICONDENSED; break; 
+    case GfxFont::Normal: width = FC_WIDTH_NORMAL; break; 
+    case GfxFont::SemiExpanded: width = FC_WIDTH_SEMIEXPANDED; break; 
+    case GfxFont::Expanded: width = FC_WIDTH_EXPANDED; break; 
+    case GfxFont::ExtraExpanded: width = FC_WIDTH_EXTRAEXPANDED; break; 
+    case GfxFont::UltraExpanded: width = FC_WIDTH_ULTRAEXPANDED; break; 
+    default: break; 
+  }
+  
+  // find the language we want the font to support
+  if (font->isCIDFont())
+  {
+    GooString *collection = ((GfxCIDFont *)font)->getCollection();
+    if (collection)
+    {
+      if (strcmp(collection->getCString(), "Adobe-GB1") == 0)
+        lang = "zh-cn"; // Simplified Chinese
+      else if (strcmp(collection->getCString(), "Adobe-CNS1") == 0)
+        lang = "zh-tw"; // Traditional Chinese
+      else if (strcmp(collection->getCString(), "Adobe-Japan1") == 0)
+        lang = "ja"; // Japanese
+      else if (strcmp(collection->getCString(), "Adobe-Japan2") == 0)
+        lang = "ja"; // Japanese
+      else if (strcmp(collection->getCString(), "Adobe-Korea1") == 0)
+        lang = "ko"; // Korean
+      else if (strcmp(collection->getCString(), "Adobe-UCS") == 0)
+        lang = "xx";
+      else if (strcmp(collection->getCString(), "Adobe-Identity") == 0)
+        lang = "xx";
+      else
+      {
+        error(-1, "Unknown CID font collection, please report to poppler bugzilla.");
+        lang = "xx";
+      }
+    }
+    else lang = "xx";
+  }
+  else lang = "xx";
+  
+  p = FcPatternBuild(NULL,
+                    FC_FAMILY, FcTypeString, family,
+                    FC_SLANT, FcTypeInteger, slant, 
+                    FC_WEIGHT, FcTypeInteger, weight,
+                    FC_WIDTH, FcTypeInteger, width, 
+                    FC_SPACING, FcTypeInteger, spacing,
+                    FC_LANG, FcTypeString, lang,
+                    NULL);
+  if (deleteFamily)
+    delete[] family;
+  return p;
+}
+
+DisplayFontParam *GlobalParamsGUI::getDisplayFont(GfxFont *font) {
+  DisplayFontParam *dfp;
+  FcPattern *p=0;
+
+  GooString *fontName = font->getName();
+  if (!fontName) return NULL;
+  
+  lockGlobalParamsGUI;
+  dfp = font->dfp;
+  if (!dfp)
+  {
+    FcChar8* s;
+    char * ext;
+    FcResult res;
+    FcFontSet *set;
+    int i;
+    p = buildFcPattern(font);
+
+    if (!p)
+      goto fin;
+    FcConfigSubstitute(FCcfg, p, FcMatchPattern);
+    FcDefaultSubstitute(p);
+    set = FcFontSort(FCcfg, p, FcFalse, NULL, &res);
+    if (!set)
+      goto fin;
+    for (i = 0; i < set->nfont; ++i)
+    {
+      res = FcPatternGetString(set->fonts[i], FC_FILE, 0, &s);
+      if (res != FcResultMatch || !s)
+        continue;
+      ext = strrchr((char*)s,'.');
+      if (!ext)
+        continue;
+      if (!strncasecmp(ext,".ttf",4) || !strncasecmp(ext, ".ttc", 4))
+      {
+        dfp = new DisplayFontParam(fontName->copy(), displayFontTT);  
+        dfp->tt.fileName = new GooString((char*)s);
+        FcPatternGetInteger(set->fonts[i], FC_INDEX, 0, &(dfp->tt.faceIndex));
+      }
+      else if (!strncasecmp(ext,".pfa",4) || !strncasecmp(ext,".pfb",4)) 
+      {
+        dfp = new DisplayFontParam(fontName->copy(), displayFontT1);  
+        dfp->t1.fileName = new GooString((char*)s);
+      }
+      else
+        continue;
+      font->dfp = dfp;
+      break;
+    }
+    FcFontSetDestroy(set);
+  }
+fin:
+  if (p)
+    FcPatternDestroy(p);
+
+  unlockGlobalParamsGUI;
+  return dfp;
+}
+
+DisplayFontParam *GlobalParamsGUI::getDisplayFont(GooString *fontName) {
+  DisplayFontParam *dfp;
+
+  lockGlobalParamsGUI;
+  dfp = (DisplayFontParam *)displayFonts->lookup(fontName);
+#ifdef WIN32
+  if (!dfp && winFontList) {
+    dfp = winFontList->find(fontName);
+  }
+#endif
+  unlockGlobalParamsGUI;
+  return dfp;
+}
+
+DisplayFontParam *GlobalParamsGUI::getDisplayCIDFont(GooString *fontName,
+						  GooString *collection) {
+  DisplayFontParam *dfp;
+
+  lockGlobalParamsGUI;
+  if (!fontName ||
+      !(dfp = (DisplayFontParam *)displayNamedCIDFonts->lookup(fontName))) {
+    dfp = (DisplayFontParam *)displayCIDFonts->lookup(collection);
+  }
+  unlockGlobalParamsGUI;
+  return dfp;
+}
+
+GooString *GlobalParamsGUI::getPSFile() {
+  GooString *s;
+
+  lockGlobalParamsGUI;
+  s = psFile ? psFile->copy() : (GooString *)NULL;
+  unlockGlobalParamsGUI;
+  return s;
+}
+
+int GlobalParamsGUI::getPSPaperWidth() {
+  int w;
+
+  lockGlobalParamsGUI;
+  w = psPaperWidth;
+  unlockGlobalParamsGUI;
+  return w;
+}
+
+int GlobalParamsGUI::getPSPaperHeight() {
+  int h;
+
+  lockGlobalParamsGUI;
+  h = psPaperHeight;
+  unlockGlobalParamsGUI;
+  return h;
+}
+
+void GlobalParamsGUI::getPSImageableArea(int *llx, int *lly, int *urx, int *ury) {
+  lockGlobalParamsGUI;
+  *llx = psImageableLLX;
+  *lly = psImageableLLY;
+  *urx = psImageableURX;
+  *ury = psImageableURY;
+  unlockGlobalParamsGUI;
+}
+
+GBool GlobalParamsGUI::getPSCrop() {
+  GBool f;
+
+  lockGlobalParamsGUI;
+  f = psCrop;
+  unlockGlobalParamsGUI;
+  return f;
+}
+
+GBool GlobalParamsGUI::getPSExpandSmaller() {
+  GBool f;
+
+  lockGlobalParamsGUI;
+  f = psExpandSmaller;
+  unlockGlobalParamsGUI;
+  return f;
+}
+
+GBool GlobalParamsGUI::getPSShrinkLarger() {
+  GBool f;
+
+  lockGlobalParamsGUI;
+  f = psShrinkLarger;
+  unlockGlobalParamsGUI;
+  return f;
+}
+
+GBool GlobalParamsGUI::getPSCenter() {
+  GBool f;
+
+  lockGlobalParamsGUI;
+  f = psCenter;
+  unlockGlobalParamsGUI;
+  return f;
+}
+
+GBool GlobalParamsGUI::getPSDuplex() {
+  GBool d;
+
+  lockGlobalParamsGUI;
+  d = psDuplex;
+  unlockGlobalParamsGUI;
+  return d;
+}
+
+PSLevel GlobalParamsGUI::getPSLevel() {
+  PSLevel level;
+
+  lockGlobalParamsGUI;
+  level = psLevel;
+  unlockGlobalParamsGUI;
+  return level;
+}
+
+PSFontParam *GlobalParamsGUI::getPSFont(GooString *fontName) {
+  PSFontParam *p;
+
+  lockGlobalParamsGUI;
+  p = (PSFontParam *)psFonts->lookup(fontName);
+  unlockGlobalParamsGUI;
+  return p;
+}
+
+PSFontParam *GlobalParamsGUI::getPSFont16(GooString *fontName,
+				       GooString *collection, int wMode) {
+  PSFontParam *p;
+  int i;
+
+  lockGlobalParamsGUI;
+  p = NULL;
+  if (fontName) {
+    for (i = 0; i < psNamedFonts16->getLength(); ++i) {
+      p = (PSFontParam *)psNamedFonts16->get(i);
+      if (!p->pdfFontName->cmp(fontName) &&
+	  p->wMode == wMode) {
+	break;
+      }
+      p = NULL;
+    }
+  }
+  if (!p && collection) {
+    for (i = 0; i < psFonts16->getLength(); ++i) {
+      p = (PSFontParam *)psFonts16->get(i);
+      if (!p->pdfFontName->cmp(collection) &&
+	  p->wMode == wMode) {
+	break;
+      }
+      p = NULL;
+    }
+  }
+  unlockGlobalParamsGUI;
+  return p;
+}
+
+GBool GlobalParamsGUI::getPSEmbedType1() {
+  GBool e;
+
+  lockGlobalParamsGUI;
+  e = psEmbedType1;
+  unlockGlobalParamsGUI;
+  return e;
+}
+
+GBool GlobalParamsGUI::getPSEmbedTrueType() {
+  GBool e;
+
+  lockGlobalParamsGUI;
+  e = psEmbedTrueType;
+  unlockGlobalParamsGUI;
+  return e;
+}
+
+GBool GlobalParamsGUI::getPSEmbedCIDPostScript() {
+  GBool e;
+
+  lockGlobalParamsGUI;
+  e = psEmbedCIDPostScript;
+  unlockGlobalParamsGUI;
+  return e;
+}
+
+GBool GlobalParamsGUI::getPSEmbedCIDTrueType() {
+  GBool e;
+
+  lockGlobalParamsGUI;
+  e = psEmbedCIDTrueType;
+  unlockGlobalParamsGUI;
+  return e;
+}
+
+GBool GlobalParamsGUI::getPSPreload() {
+  GBool preload;
+
+  lockGlobalParamsGUI;
+  preload = psPreload;
+  unlockGlobalParamsGUI;
+  return preload;
+}
+
+GBool GlobalParamsGUI::getPSOPI() {
+  GBool opi;
+
+  lockGlobalParamsGUI;
+  opi = psOPI;
+  unlockGlobalParamsGUI;
+  return opi;
+}
+
+GBool GlobalParamsGUI::getPSASCIIHex() {
+  GBool ah;
+
+  lockGlobalParamsGUI;
+  ah = psASCIIHex;
+  unlockGlobalParamsGUI;
+  return ah;
+}
+
+GooString *GlobalParamsGUI::getTextEncodingName() {
+  GooString *s;
+
+  lockGlobalParamsGUI;
+  s = textEncoding->copy();
+  unlockGlobalParamsGUI;
+  return s;
+}
+
+EndOfLineKind GlobalParamsGUI::getTextEOL() {
+  EndOfLineKind eol;
+
+  lockGlobalParamsGUI;
+  eol = textEOL;
+  unlockGlobalParamsGUI;
+  return eol;
+}
+
+GBool GlobalParamsGUI::getTextPageBreaks() {
+  GBool pageBreaks;
+
+  lockGlobalParamsGUI;
+  pageBreaks = textPageBreaks;
+  unlockGlobalParamsGUI;
+  return pageBreaks;
+}
+
+GBool GlobalParamsGUI::getTextKeepTinyChars() {
+  GBool tiny;
+
+  lockGlobalParamsGUI;
+  tiny = textKeepTinyChars;
+  unlockGlobalParamsGUI;
+  return tiny;
+}
+
+GooString *GlobalParamsGUI::findFontFile(GooString *fontName, char **exts) {
+  GooString *dir, *fileName;
+  char **ext;
+  FILE *f;
+  int i;
+
+  lockGlobalParamsGUI;
+  for (i = 0; i < fontDirs->getLength(); ++i) {
+    dir = (GooString *)fontDirs->get(i);
+    for (ext = exts; *ext; ++ext) {
+      fileName = appendToPath(dir->copy(), fontName->getCString());
+      fileName->append(*ext);
+      if ((f = fopen(fileName->getCString(), "rb"))) {
+	fclose(f);
+	unlockGlobalParamsGUI;
+	return fileName;
+      }
+      delete fileName;
+    }
+  }
+  unlockGlobalParamsGUI;
+  return NULL;
+}
+
+GooString *GlobalParamsGUI::getInitialZoom() {
+  GooString *s;
+
+  lockGlobalParamsGUI;
+  s = initialZoom->copy();
+  unlockGlobalParamsGUI;
+  return s;
+}
+
+GBool GlobalParamsGUI::getContinuousView() {
+  GBool f;
+
+  lockGlobalParamsGUI;
+  f = continuousView;
+  unlockGlobalParamsGUI;
+  return f;
+}
+
+GBool GlobalParamsGUI::getEnableT1lib() {
+  GBool f;
+
+  lockGlobalParamsGUI;
+  f = enableT1lib;
+  unlockGlobalParamsGUI;
+  return f;
+}
+
+GBool GlobalParamsGUI::getEnableFreeType() {
+  GBool f;
+
+  lockGlobalParamsGUI;
+  f = enableFreeType;
+  unlockGlobalParamsGUI;
+  return f;
+}
+
+GBool GlobalParamsGUI::getEnableFreeTypeHinting() {
+  GBool f;
+
+  lockGlobalParamsGUI;
+  f = enableFreeTypeHinting;
+  unlockGlobalParamsGUI;
+  return f;
+}
+
+GBool GlobalParamsGUI::getAntialias() {
+  GBool f;
+
+  lockGlobalParamsGUI;
+  f = antialias;
+  unlockGlobalParamsGUI;
+  return f;
+}
+
+GBool GlobalParamsGUI::getVectorAntialias() {
+  GBool f;
+
+  lockGlobalParamsGUI;
+  f = vectorAntialias;
+  unlockGlobalParamsGUI;
+  return f;
+}
+
+GBool GlobalParamsGUI::getStrokeAdjust() {
+  GBool f;
+
+  lockGlobalParamsGUI;
+  f = strokeAdjust;
+  unlockGlobalParamsGUI;
+  return f;
+}
+
+ScreenType GlobalParamsGUI::getScreenType() {
+  ScreenType t;
+
+  lockGlobalParamsGUI;
+  t = screenType;
+  unlockGlobalParamsGUI;
+  return t;
+}
+
+int GlobalParamsGUI::getScreenSize() {
+  int size;
+
+  lockGlobalParamsGUI;
+  size = screenSize;
+  unlockGlobalParamsGUI;
+  return size;
+}
+
+int GlobalParamsGUI::getScreenDotRadius() {
+  int r;
+
+  lockGlobalParamsGUI;
+  r = screenDotRadius;
+  unlockGlobalParamsGUI;
+  return r;
+}
+
+double GlobalParamsGUI::getScreenGamma() {
+  double gamma;
+
+  lockGlobalParamsGUI;
+  gamma = screenGamma;
+  unlockGlobalParamsGUI;
+  return gamma;
+}
+
+double GlobalParamsGUI::getScreenBlackThreshold() {
+  double thresh;
+
+  lockGlobalParamsGUI;
+  thresh = screenBlackThreshold;
+  unlockGlobalParamsGUI;
+  return thresh;
+}
+
+double GlobalParamsGUI::getScreenWhiteThreshold() {
+  double thresh;
+
+  lockGlobalParamsGUI;
+  thresh = screenWhiteThreshold;
+  unlockGlobalParamsGUI;
+  return thresh;
+}
+
+GBool GlobalParamsGUI::getMapNumericCharNames() {
+  GBool map;
+
+  lockGlobalParamsGUI;
+  map = mapNumericCharNames;
+  unlockGlobalParamsGUI;
+  return map;
+}
+
+GBool GlobalParamsGUI::getMapUnknownCharNames() {
+  GBool map;
+
+  lockGlobalParamsGUI;
+  map = mapUnknownCharNames;
+  unlockGlobalParamsGUI;
+  return map;
+}
+
+GooList *GlobalParamsGUI::getKeyBinding(int code, int mods, int context) {
+  KeyBinding *binding;
+  GooList *cmds;
+  int modMask;
+  int i, j;
+
+  lockGlobalParamsGUI;
+  cmds = NULL;
+  // for ASCII chars, ignore the shift modifier
+  modMask = code <= 0xff ? ~xpdfKeyModShift : ~0;
+  for (i = 0; i < keyBindings->getLength(); ++i) {
+    binding = (KeyBinding *)keyBindings->get(i);
+    if (binding->code == code &&
+	(binding->mods & modMask) == (mods & modMask) &&
+	(~binding->context | context) == ~0) {
+      cmds = new GooList();
+      for (j = 0; j < binding->cmds->getLength(); ++j) {
+	cmds->append(((GooString *)binding->cmds->get(j))->copy());
+      }
+      break;
+    }
+  }
+  unlockGlobalParamsGUI;
+  return cmds;
+}
+
+GBool GlobalParamsGUI::getPrintCommands() {
+  GBool p;
+
+  lockGlobalParamsGUI;
+  p = printCommands;
+  unlockGlobalParamsGUI;
+  return p;
+}
+
+GBool GlobalParamsGUI::getProfileCommands() {
+  GBool p;
+
+  lockGlobalParamsGUI;
+  p = profileCommands;
+  unlockGlobalParamsGUI;
+  return p;
+}
+
+GBool GlobalParamsGUI::getErrQuiet() {
+  // no locking -- this function may get called from inside a locked
+  // section
+  return errQuiet;
+}
+
+CharCodeToUnicode *GlobalParamsGUI::getCIDToUnicode(GooString *collection) {
+  GooString *fileName;
+  CharCodeToUnicode *ctu;
+
+  lockGlobalParamsGUI;
+  if (!(ctu = cidToUnicodeCache->getCharCodeToUnicode(collection))) {
+    if ((fileName = (GooString *)cidToUnicodes->lookup(collection)) &&
+	(ctu = CharCodeToUnicode::parseCIDToUnicode(fileName, collection))) {
+      cidToUnicodeCache->add(ctu);
+    }
+  }
+  unlockGlobalParamsGUI;
+  return ctu;
+}
+
+CharCodeToUnicode *GlobalParamsGUI::getUnicodeToUnicode(GooString *fontName) {
+  CharCodeToUnicode *ctu;
+  GooHashIter *iter;
+  GooString *fontPattern, *fileName;
+
+  lockGlobalParamsGUI;
+  fileName = NULL;
+  unicodeToUnicodes->startIter(&iter);
+  while (unicodeToUnicodes->getNext(&iter, &fontPattern, (void **)&fileName)) {
+    if (strstr(fontName->getCString(), fontPattern->getCString())) {
+      unicodeToUnicodes->killIter(&iter);
+      break;
+    }
+    fileName = NULL;
+  }
+  if (fileName) {
+    if (!(ctu = unicodeToUnicodeCache->getCharCodeToUnicode(fileName))) {
+      if ((ctu = CharCodeToUnicode::parseUnicodeToUnicode(fileName))) {
+	unicodeToUnicodeCache->add(ctu);
+      }
+    }
+  } else {
+    ctu = NULL;
+  }
+  unlockGlobalParamsGUI;
+  return ctu;
+}
+
+UnicodeMap *GlobalParamsGUI::getUnicodeMap(GooString *encodingName) {
+  return getUnicodeMap2(encodingName);
+}
+
+UnicodeMap *GlobalParamsGUI::getUnicodeMap2(GooString *encodingName) {
+  UnicodeMap *map;
+
+  if (!(map = getResidentUnicodeMap(encodingName))) {
+    lockUnicodeMapCache;
+    map = unicodeMapCache->getUnicodeMap(encodingName);
+    unlockUnicodeMapCache;
+  }
+  return map;
+}
+
+CMap *GlobalParamsGUI::getCMap(GooString *collection, GooString *cMapName) {
+  CMap *cMap;
+
+  lockCMapCache;
+  cMap = cMapCache->getCMap(collection, cMapName);
+  unlockCMapCache;
+  return cMap;
+}
+
+UnicodeMap *GlobalParamsGUI::getTextEncoding() {
+  return getUnicodeMap2(textEncoding);
+}
+
+//------------------------------------------------------------------------
+// functions to set parameters
+//------------------------------------------------------------------------
+
+void GlobalParamsGUI::addDisplayFont(DisplayFontParam *param) {
+  DisplayFontParam *old;
+
+  lockGlobalParamsGUI;
+  if ((old = (DisplayFontParam *)displayFonts->remove(param->name))) {
+    delete old;
+  }
+  displayFonts->add(param->name, param);
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPSFile(char *file) {
+  lockGlobalParamsGUI;
+  if (psFile) {
+    delete psFile;
+  }
+  psFile = new GooString(file);
+  unlockGlobalParamsGUI;
+}
+
+GBool GlobalParamsGUI::setPSPaperSize(char *size) {
+  lockGlobalParamsGUI;
+  if (!strcmp(size, "match")) {
+    psPaperWidth = psPaperHeight = -1;
+  } else if (!strcmp(size, "letter")) {
+    psPaperWidth = 612;
+    psPaperHeight = 792;
+  } else if (!strcmp(size, "legal")) {
+    psPaperWidth = 612;
+    psPaperHeight = 1008;
+  } else if (!strcmp(size, "A4")) {
+    psPaperWidth = 595;
+    psPaperHeight = 842;
+  } else if (!strcmp(size, "A3")) {
+    psPaperWidth = 842;
+    psPaperHeight = 1190;
+  } else {
+    unlockGlobalParamsGUI;
+    return gFalse;
+  }
+  psImageableLLX = psImageableLLY = 0;
+  psImageableURX = psPaperWidth;
+  psImageableURY = psPaperHeight;
+  unlockGlobalParamsGUI;
+  return gTrue;
+}
+
+void GlobalParamsGUI::setPSPaperWidth(int width) {
+  lockGlobalParamsGUI;
+  psPaperWidth = width;
+  psImageableLLX = 0;
+  psImageableURX = psPaperWidth;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPSPaperHeight(int height) {
+  lockGlobalParamsGUI;
+  psPaperHeight = height;
+  psImageableLLY = 0;
+  psImageableURY = psPaperHeight;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPSImageableArea(int llx, int lly, int urx, int ury) {
+  lockGlobalParamsGUI;
+  psImageableLLX = llx;
+  psImageableLLY = lly;
+  psImageableURX = urx;
+  psImageableURY = ury;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPSCrop(GBool crop) {
+  lockGlobalParamsGUI;
+  psCrop = crop;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPSExpandSmaller(GBool expand) {
+  lockGlobalParamsGUI;
+  psExpandSmaller = expand;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPSShrinkLarger(GBool shrink) {
+  lockGlobalParamsGUI;
+  psShrinkLarger = shrink;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPSCenter(GBool center) {
+  lockGlobalParamsGUI;
+  psCenter = center;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPSDuplex(GBool duplex) {
+  lockGlobalParamsGUI;
+  psDuplex = duplex;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPSLevel(PSLevel level) {
+  lockGlobalParamsGUI;
+  psLevel = level;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPSEmbedType1(GBool embed) {
+  lockGlobalParamsGUI;
+  psEmbedType1 = embed;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPSEmbedTrueType(GBool embed) {
+  lockGlobalParamsGUI;
+  psEmbedTrueType = embed;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPSEmbedCIDPostScript(GBool embed) {
+  lockGlobalParamsGUI;
+  psEmbedCIDPostScript = embed;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPSEmbedCIDTrueType(GBool embed) {
+  lockGlobalParamsGUI;
+  psEmbedCIDTrueType = embed;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPSPreload(GBool preload) {
+  lockGlobalParamsGUI;
+  psPreload = preload;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPSOPI(GBool opi) {
+  lockGlobalParamsGUI;
+  psOPI = opi;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPSASCIIHex(GBool hex) {
+  lockGlobalParamsGUI;
+  psASCIIHex = hex;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setTextEncoding(char *encodingName) {
+  lockGlobalParamsGUI;
+  delete textEncoding;
+  textEncoding = new GooString(encodingName);
+  unlockGlobalParamsGUI;
+}
+
+GBool GlobalParamsGUI::setTextEOL(char *s) {
+  lockGlobalParamsGUI;
+  if (!strcmp(s, "unix")) {
+    textEOL = eolUnix;
+  } else if (!strcmp(s, "dos")) {
+    textEOL = eolDOS;
+  } else if (!strcmp(s, "mac")) {
+    textEOL = eolMac;
+  } else {
+    unlockGlobalParamsGUI;
+    return gFalse;
+  }
+  unlockGlobalParamsGUI;
+  return gTrue;
+}
+
+void GlobalParamsGUI::setTextPageBreaks(GBool pageBreaks) {
+  lockGlobalParamsGUI;
+  textPageBreaks = pageBreaks;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setTextKeepTinyChars(GBool keep) {
+  lockGlobalParamsGUI;
+  textKeepTinyChars = keep;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setInitialZoom(char *s) {
+  lockGlobalParamsGUI;
+  delete initialZoom;
+  initialZoom = new GooString(s);
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setContinuousView(GBool cont) {
+  lockGlobalParamsGUI;
+  continuousView = cont;
+  unlockGlobalParamsGUI;
+}
+
+GBool GlobalParamsGUI::setEnableT1lib(char *s) {
+  GBool ok;
+
+  lockGlobalParamsGUI;
+  ok = parseYesNo2(s, &enableT1lib);
+  unlockGlobalParamsGUI;
+  return ok;
+}
+
+GBool GlobalParamsGUI::setEnableFreeType(char *s) {
+  GBool ok;
+
+  lockGlobalParamsGUI;
+  ok = parseYesNo2(s, &enableFreeType);
+  unlockGlobalParamsGUI;
+  return ok;
+}
+
+GBool GlobalParamsGUI::setEnableFreeTypeHinting(char *s) {
+  GBool ok;
+  
+  lockGlobalParamsGUI;
+  ok = parseYesNo2(s, &enableFreeTypeHinting);
+  unlockGlobalParamsGUI;
+  return ok;
+}
+
+GBool GlobalParamsGUI::setAntialias(char *s) {
+  GBool ok;
+
+  lockGlobalParamsGUI;
+  ok = parseYesNo2(s, &antialias);
+  unlockGlobalParamsGUI;
+  return ok;
+}
+
+GBool GlobalParamsGUI::setVectorAntialias(char *s) {
+  GBool ok;
+
+  lockGlobalParamsGUI;
+  ok = parseYesNo2(s, &vectorAntialias);
+  unlockGlobalParamsGUI;
+  return ok;
+}
+
+void GlobalParamsGUI::setStrokeAdjust(GBool adjust)
+{
+  lockGlobalParamsGUI;
+  strokeAdjust = adjust;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setScreenType(ScreenType st)
+{
+  lockGlobalParamsGUI;
+  screenType = st;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setScreenSize(int size)
+{
+  lockGlobalParamsGUI;
+  screenSize = size;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setScreenDotRadius(int radius)
+{
+  lockGlobalParamsGUI;
+  screenDotRadius = radius;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setScreenGamma(double gamma)
+{
+  lockGlobalParamsGUI;
+  screenGamma = gamma;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setScreenBlackThreshold(double blackThreshold)
+{
+  lockGlobalParamsGUI;
+  screenBlackThreshold = blackThreshold;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setScreenWhiteThreshold(double whiteThreshold)
+{
+  lockGlobalParamsGUI;
+  screenWhiteThreshold = whiteThreshold;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setMapNumericCharNames(GBool map) {
+  lockGlobalParamsGUI;
+  mapNumericCharNames = map;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setMapUnknownCharNames(GBool map) {
+  lockGlobalParamsGUI;
+  mapUnknownCharNames = map;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setPrintCommands(GBool printCommandsA) {
+  lockGlobalParamsGUI;
+  printCommands = printCommandsA;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setProfileCommands(GBool profileCommandsA) {
+  lockGlobalParamsGUI;
+  profileCommands = profileCommandsA;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::setErrQuiet(GBool errQuietA) {
+  lockGlobalParamsGUI;
+  errQuiet = errQuietA;
+  unlockGlobalParamsGUI;
+}
+
+void GlobalParamsGUI::addSecurityHandler(XpdfSecurityHandler *handler) {
+#ifdef ENABLE_PLUGINS
+  lockGlobalParamsGUI;
+  securityHandlers->append(handler);
+  unlockGlobalParamsGUI;
+#endif
+}
+
+XpdfSecurityHandler *GlobalParamsGUI::getSecurityHandler(char *name) {
+#ifdef ENABLE_PLUGINS
+  XpdfSecurityHandler *hdlr;
+  int i;
+
+  lockGlobalParamsGUI;
+  for (i = 0; i < securityHandlers->getLength(); ++i) {
+    hdlr = (XpdfSecurityHandler *)securityHandlers->get(i);
+    if (!strcasecmp(hdlr->name, name)) {
+      unlockGlobalParamsGUI;
+      return hdlr;
+    }
+  }
+  unlockGlobalParamsGUI;
+
+  if (!loadPlugin("security", name)) {
+    return NULL;
+  }
+  deleteGooList(keyBindings, KeyBinding);
+
+  lockGlobalParamsGUI;
+  for (i = 0; i < securityHandlers->getLength(); ++i) {
+    hdlr = (XpdfSecurityHandler *)securityHandlers->get(i);
+    if (!strcmp(hdlr->name, name)) {
+      unlockGlobalParamsGUI;
+      return hdlr;
+    }
+  }
+  unlockGlobalParamsGUI;
+#else
+  (void)name;
+#endif
+
+  return NULL;
+}
+
+#ifdef ENABLE_PLUGINS
+//------------------------------------------------------------------------
+// plugins
+//------------------------------------------------------------------------
+
+GBool GlobalParamsGUI::loadPlugin(char *type, char *name) {
+  Plugin *plugin;
+
+  if (!(plugin = Plugin::load(type, name))) {
+    return gFalse;
+  }
+  lockGlobalParamsGUI;
+  plugins->append(plugin);
+  unlockGlobalParamsGUI;
+  return gTrue;
+}
+
+#endif // ENABLE_PLUGINS
Index: GlobalParamsGUI.h
===================================================================
--- /dev/null
+++ GlobalParamsGUI.h
@@ -0,0 +1,482 @@
+//========================================================================
+//
+// GlobalParamsGUI.h
+//
+// Copyright 2001-2003 Glyph & Cog, LLC
+//
+//========================================================================
+
+#ifndef GLOBALPARAMSGUI_H
+#define GLOBALPARAMSGUI_H
+
+#ifdef USE_GCC_PRAGMAS
+#pragma interface
+#endif
+
+#include "config.h"
+#include <stdio.h>
+#include <fontconfig/fontconfig.h>
+#include <GlobalParams.h>
+#include "goo/gtypes.h"
+#include "CharTypes.h"
+
+#if MULTITHREADED
+#include "goo/GooMutex.h"
+#endif
+
+class GooString;
+class GooList;
+class GooHash;
+class NameToCharCode;
+class CharCodeToUnicode;
+class CharCodeToUnicodeCache;
+class UnicodeMap;
+class UnicodeMapCache;
+class CMap;
+class CMapCache;
+struct XpdfSecurityHandler;
+class GlobalParamsGUI;
+class GfxFont;
+#ifdef WIN32
+class WinFontList;
+#endif
+
+//------------------------------------------------------------------------
+
+// The global parameters object.
+extern GlobalParamsGUI *globalParamsGUI;
+
+//------------------------------------------------------------------------
+
+/*enum DisplayFontParamKind {
+  displayFontT1,
+  displayFontTT
+};
+
+struct DisplayFontParamT1 {
+  GooString *fileName;
+};
+
+struct DisplayFontParamTT {
+  GooString *fileName;
+  int faceIndex;
+};
+
+class DisplayFontParam {
+public:
+
+  GooString *name;		// font name for 8-bit fonts and named
+				//   CID fonts; collection name for
+				//   generic CID fonts
+  DisplayFontParamKind kind;
+  union {
+    DisplayFontParamT1 t1;
+    DisplayFontParamTT tt;
+  };
+
+  DisplayFontParam(GooString *nameA, DisplayFontParamKind kindA);
+  virtual ~DisplayFontParam();
+};
+
+//------------------------------------------------------------------------
+
+class PSFontParam {
+public:
+
+  GooString *pdfFontName;		// PDF font name for 8-bit fonts and
+				//   named 16-bit fonts; char collection
+				//   name for generic 16-bit fonts
+  int wMode;			// writing mode (0=horiz, 1=vert) for
+				//   16-bit fonts
+  GooString *psFontName;		// PostScript font name
+  GooString *encoding;		// encoding, for 16-bit fonts only
+
+  PSFontParam(GooString *pdfFontNameA, int wModeA,
+	      GooString *psFontNameA, GooString *encodingA);
+  ~PSFontParam();
+};*/
+
+//------------------------------------------------------------------------
+
+/*enum PSLevel {
+  psLevel1,
+  psLevel1Sep,
+  psLevel2,
+  psLevel2Sep,
+  psLevel3,
+  psLevel3Sep
+};*/
+
+//------------------------------------------------------------------------
+
+/*enum EndOfLineKind {
+  eolUnix,			// LF
+  eolDOS,			// CR+LF
+  eolMac			// CR
+};*/
+
+//------------------------------------------------------------------------
+
+/*enum ScreenType {
+  screenUnset,
+  screenDispersed,
+  screenClustered,
+  screenStochasticClustered
+};*/
+
+//------------------------------------------------------------------------
+
+class KeyBinding {
+public:
+
+  int code;			// 0x20 .. 0xfe = ASCII,
+				//   >=0x10000 = special keys, mouse buttons,
+				//   etc. (xpdfKeyCode* symbols)
+  int mods;			// modifiers (xpdfKeyMod* symbols, or-ed
+				//   together)
+  int context;			// context (xpdfKeyContext* symbols, or-ed
+				//   together)
+  GooList *cmds;			// list of commands [GooString]
+
+  KeyBinding(int codeA, int modsA, int contextA, char *cmd0);
+  KeyBinding(int codeA, int modsA, int contextA, char *cmd0, char *cmd1);
+  KeyBinding(int codeA, int modsA, int contextA, GooList *cmdsA);
+  ~KeyBinding();
+};
+
+#define xpdfKeyCodeTab            0x1000
+#define xpdfKeyCodeReturn         0x1001
+#define xpdfKeyCodeEnter          0x1002
+#define xpdfKeyCodeBackspace      0x1003
+#define xpdfKeyCodeInsert         0x1004
+#define xpdfKeyCodeDelete         0x1005
+#define xpdfKeyCodeHome           0x1006
+#define xpdfKeyCodeEnd            0x1007
+#define xpdfKeyCodePgUp           0x1008
+#define xpdfKeyCodePgDn           0x1009
+#define xpdfKeyCodeLeft           0x100a
+#define xpdfKeyCodeRight          0x100b
+#define xpdfKeyCodeUp             0x100c
+#define xpdfKeyCodeDown           0x100d
+#define xpdfKeyCodeF1             0x1100
+#define xpdfKeyCodeF35            0x1122
+#define xpdfKeyCodeAdd            0x1200
+#define xpdfKeyCodeSubtract       0x1201
+#define xpdfKeyCodeMousePress1    0x2001
+#define xpdfKeyCodeMousePress2    0x2002
+#define xpdfKeyCodeMousePress3    0x2003
+#define xpdfKeyCodeMousePress4    0x2004
+#define xpdfKeyCodeMousePress5    0x2005
+#define xpdfKeyCodeMousePress6    0x2006
+#define xpdfKeyCodeMousePress7    0x2007
+#define xpdfKeyCodeMouseRelease1  0x2101
+#define xpdfKeyCodeMouseRelease2  0x2102
+#define xpdfKeyCodeMouseRelease3  0x2103
+#define xpdfKeyCodeMouseRelease4  0x2104
+#define xpdfKeyCodeMouseRelease5  0x2105
+#define xpdfKeyCodeMouseRelease6  0x2106
+#define xpdfKeyCodeMouseRelease7  0x2107
+#define xpdfKeyModNone            0
+#define xpdfKeyModShift           (1 << 0)
+#define xpdfKeyModCtrl            (1 << 1)
+#define xpdfKeyModAlt             (1 << 2)
+#define xpdfKeyContextAny         0
+#define xpdfKeyContextFullScreen  (1 << 0)
+#define xpdfKeyContextWindow      (2 << 0)
+#define xpdfKeyContextContinuous  (1 << 2)
+#define xpdfKeyContextSinglePage  (2 << 2)
+#define xpdfKeyContextOverLink    (1 << 4)
+#define xpdfKeyContextOffLink     (2 << 4)
+#define xpdfKeyContextOutline     (1 << 6)
+#define xpdfKeyContextMainWin     (2 << 6)
+#define xpdfKeyContextScrLockOn   (1 << 8)
+#define xpdfKeyContextScrLockOff  (2 << 8)
+
+//------------------------------------------------------------------------
+
+class GlobalParamsGUI {
+public:
+
+  // Initialize the global parameters by attempting to read a config
+  // file.
+  GlobalParamsGUI(char *cfgFileName = NULL);
+
+  ~GlobalParamsGUI();
+
+  void setBaseDir(char *dir);
+  void setupBaseFonts(char *dir);
+
+  void parseLine(char *buf, GooString *fileName, int line);
+
+  //----- accessors
+
+  CharCode getMacRomanCharCode(char *charName);
+
+  GooString *getBaseDir();
+  Unicode mapNameToUnicode(char *charName);
+  UnicodeMap *getResidentUnicodeMap(GooString *encodingName);
+  FILE *getUnicodeMapFile(GooString *encodingName);
+  FILE *findCMapFile(GooString *collection, GooString *cMapName);
+  FILE *findToUnicodeFile(GooString *name);
+  DisplayFontParam *getDisplayFont(GfxFont *font);
+  DisplayFontParam *getDisplayFont(GooString *fontName);
+  DisplayFontParam *getDisplayCIDFont(GooString *fontName, GooString *collection);
+  GooString *getPSFile();
+  int getPSPaperWidth();
+  int getPSPaperHeight();
+  void getPSImageableArea(int *llx, int *lly, int *urx, int *ury);
+  GBool getPSDuplex();
+  GBool getPSCrop();
+  GBool getPSExpandSmaller();
+  GBool getPSShrinkLarger();
+  GBool getPSCenter();
+  PSLevel getPSLevel();
+  PSFontParam *getPSFont(GooString *fontName);
+  PSFontParam *getPSFont16(GooString *fontName, GooString *collection, int wMode);
+  GBool getPSEmbedType1();
+  GBool getPSEmbedTrueType();
+  GBool getPSEmbedCIDPostScript();
+  GBool getPSEmbedCIDTrueType();
+  GBool getPSPreload();
+  GBool getPSOPI();
+  GBool getPSASCIIHex();
+  GooString *getTextEncodingName();
+  EndOfLineKind getTextEOL();
+  GBool getTextPageBreaks();
+  GBool getTextKeepTinyChars();
+  GooString *findFontFile(GooString *fontName, char **exts);
+  GooString *getInitialZoom();
+  GBool getContinuousView();
+  GBool getEnableT1lib();
+  GBool getEnableFreeType();
+  GBool getEnableFreeTypeHinting();
+  GBool getAntialias();
+  GBool getVectorAntialias();
+  GBool getStrokeAdjust();
+  ScreenType getScreenType();
+  int getScreenSize();
+  int getScreenDotRadius();
+  double getScreenGamma();
+  double getScreenBlackThreshold();
+  double getScreenWhiteThreshold();
+  GooString *getURLCommand() { return urlCommand; }
+  GooString *getMovieCommand() { return movieCommand; }
+  GBool getMapNumericCharNames();
+  GBool getMapUnknownCharNames();
+  GooList *getKeyBinding(int code, int mods, int context);
+  GBool getPrintCommands();
+  GBool getProfileCommands();
+  GBool getErrQuiet();
+
+  CharCodeToUnicode *getCIDToUnicode(GooString *collection);
+  CharCodeToUnicode *getUnicodeToUnicode(GooString *fontName);
+  UnicodeMap *getUnicodeMap(GooString *encodingName);
+  CMap *getCMap(GooString *collection, GooString *cMapName);
+  UnicodeMap *getTextEncoding();
+#ifdef ENABLE_PLUGINS
+  GBool loadPlugin(char *type, char *name);
+#endif
+
+  //----- functions to set parameters
+  void addDisplayFont(DisplayFontParam *param);
+  void setPSFile(char *file);
+  GBool setPSPaperSize(char *size);
+  void setPSPaperWidth(int width);
+  void setPSPaperHeight(int height);
+  void setPSImageableArea(int llx, int lly, int urx, int ury);
+  void setPSDuplex(GBool duplex);
+  void setPSCrop(GBool crop);
+  void setPSExpandSmaller(GBool expand);
+  void setPSShrinkLarger(GBool shrink);
+  void setPSCenter(GBool center);
+  void setPSLevel(PSLevel level);
+  void setPSEmbedType1(GBool embed);
+  void setPSEmbedTrueType(GBool embed);
+  void setPSEmbedCIDPostScript(GBool embed);
+  void setPSEmbedCIDTrueType(GBool embed);
+  void setPSPreload(GBool preload);
+  void setPSOPI(GBool opi);
+  void setPSASCIIHex(GBool hex);
+  void setTextEncoding(char *encodingName);
+  GBool setTextEOL(char *s);
+  void setTextPageBreaks(GBool pageBreaks);
+  void setTextKeepTinyChars(GBool keep);
+  void setInitialZoom(char *s);
+  void setContinuousView(GBool cont);
+  GBool setEnableT1lib(char *s);
+  GBool setEnableFreeType(char *s);
+  GBool setEnableFreeTypeHinting(char *s);
+  GBool setAntialias(char *s);
+  GBool setVectorAntialias(char *s);
+  void setStrokeAdjust(GBool strokeAdjust);
+  void setScreenType(ScreenType st);
+  void setScreenSize(int size);
+  void setScreenDotRadius(int radius);
+  void setScreenGamma(double gamma);
+  void setScreenBlackThreshold(double blackThreshold);
+  void setScreenWhiteThreshold(double whiteThreshold);
+  void setMapNumericCharNames(GBool map);
+  void setMapUnknownCharNames(GBool map);
+  void setPrintCommands(GBool printCommandsA);
+  void setProfileCommands(GBool profileCommandsA);
+  void setErrQuiet(GBool errQuietA);
+
+  //----- security handlers
+
+  void addSecurityHandler(XpdfSecurityHandler *handler);
+  XpdfSecurityHandler *getSecurityHandler(char *name);
+
+  GBool parseYesNo2(char *token, GBool *flag);
+private:
+
+  void createDefaultKeyBindings();
+  void parseFile(GooString *fileName, FILE *f);
+  void parseNameToUnicode(GooList *tokens, GooString *fileName, int line);
+  void parseNameToUnicode(GooString *name);
+  void parseCIDToUnicode(GooList *tokens, GooString *fileName, int line);
+  void parseUnicodeToUnicode(GooList *tokens, GooString *fileName, int line);
+  void parseUnicodeMap(GooList *tokens, GooString *fileName, int line);
+  void parseCMapDir(GooList *tokens, GooString *fileName, int line);
+  void parseToUnicodeDir(GooList *tokens, GooString *fileName, int line);
+  void parseDisplayFont(GooList *tokens, GooHash *fontHash,
+			DisplayFontParamKind kind,
+			GooString *fileName, int line);
+  void parsePSFile(GooList *tokens, GooString *fileName, int line);
+  void parsePSPaperSize(GooList *tokens, GooString *fileName, int line);
+  void parsePSImageableArea(GooList *tokens, GooString *fileName, int line);
+  void parsePSLevel(GooList *tokens, GooString *fileName, int line);
+  void parsePSFont(GooList *tokens, GooString *fileName, int line);
+  void parsePSFont16(char *cmdName, GooList *fontList,
+		     GooList *tokens, GooString *fileName, int line);
+  void parseTextEncoding(GooList *tokens, GooString *fileName, int line);
+  void parseTextEOL(GooList *tokens, GooString *fileName, int line);
+  void parseFontDir(GooList *tokens, GooString *fileName, int line);
+  void parseInitialZoom(GooList *tokens, GooString *fileName, int line);
+  void parseScreenType(GooList *tokens, GooString *fileName, int line);
+  void parseBind(GooList *tokens, GooString *fileName, int line);
+  void parseUnbind(GooList *tokens, GooString *fileName, int line);
+  GBool parseKey(GooString *modKeyStr, GooString *contextStr,
+		 int *code, int *mods, int *context,
+		 char *cmdName,
+		 GooList *tokens, GooString *fileName, int line);
+  void parseCommand(char *cmdName, GooString **val,
+		    GooList *tokens, GooString *fileName, int line);
+  void parseYesNo(char *cmdName, GBool *flag,
+		  GooList *tokens, GooString *fileName, int line);
+  void parseInteger(char *cmdName, int *val,
+		    GooList *tokens, GooString *fileName, int line);
+  void parseFloat(char *cmdName, double *val,
+		  GooList *tokens, GooString *fileName, int line);
+  UnicodeMap *getUnicodeMap2(GooString *encodingName);
+
+  void addCIDToUnicode(GooString *collection, GooString *fileName);
+  void addUnicodeMap(GooString *encodingName, GooString *fileName);
+  void addCMapDir(GooString *collection, GooString *dir);
+
+  //----- static tables
+
+  NameToCharCode *		// mapping from char name to
+    macRomanReverseMap;		//   MacRomanEncoding index
+
+  //----- user-modifiable settings
+
+  GooString *baseDir;		// base directory - for plugins, etc.
+  NameToCharCode *		// mapping from char name to Unicode
+    nameToUnicode;
+  GooHash *cidToUnicodes;		// files for mappings from char collections
+				//   to Unicode, indexed by collection name
+				//   [GooString]
+  GooHash *unicodeToUnicodes;	// files for Unicode-to-Unicode mappings,
+				//   indexed by font name pattern [GooString]
+  GooHash *residentUnicodeMaps;	// mappings from Unicode to char codes,
+				//   indexed by encoding name [UnicodeMap]
+  GooHash *unicodeMaps;		// files for mappings from Unicode to char
+				//   codes, indexed by encoding name [GooString]
+  GooHash *cMapDirs;		// list of CMap dirs, indexed by collection
+				//   name [GooList[GooString]]
+  GooList *toUnicodeDirs;		// list of ToUnicode CMap dirs [GooString]
+  GooHash *displayFonts;		// display font info, indexed by font name
+				//   [DisplayFontParam]
+#ifdef WIN32
+  WinFontList *winFontList;	// system TrueType fonts
+#endif
+  GooHash *displayCIDFonts;	// display CID font info, indexed by
+				//   collection [DisplayFontParam]
+  GooHash *displayNamedCIDFonts;	// display CID font info, indexed by
+				//   font name [DisplayFontParam]
+  GooString *psFile;		// PostScript file or command (for xpdf)
+  int psPaperWidth;		// paper size, in PostScript points, for
+  int psPaperHeight;		//   PostScript output
+  int psImageableLLX,		// imageable area, in PostScript points,
+      psImageableLLY,		//   for PostScript output
+      psImageableURX,
+      psImageableURY;
+  GBool psCrop;			// crop PS output to CropBox
+  GBool psExpandSmaller;	// expand smaller pages to fill paper
+  GBool psShrinkLarger;		// shrink larger pages to fit paper
+  GBool psCenter;		// center pages on the paper
+  GBool psDuplex;		// enable duplexing in PostScript?
+  PSLevel psLevel;		// PostScript level to generate
+  GooHash *psFonts;		// PostScript font info, indexed by PDF
+				//   font name [PSFontParam]
+  GooList *psNamedFonts16;	// named 16-bit fonts [PSFontParam]
+  GooList *psFonts16;		// generic 16-bit fonts [PSFontParam]
+  GBool psEmbedType1;		// embed Type 1 fonts?
+  GBool psEmbedTrueType;	// embed TrueType fonts?
+  GBool psEmbedCIDPostScript;	// embed CID PostScript fonts?
+  GBool psEmbedCIDTrueType;	// embed CID TrueType fonts?
+  GBool psPreload;		// preload PostScript images and forms into
+				//   memory
+  GBool psOPI;			// generate PostScript OPI comments?
+  GBool psASCIIHex;		// use ASCIIHex instead of ASCII85?
+  GooString *textEncoding;	// encoding (unicodeMap) to use for text
+				//   output
+  EndOfLineKind textEOL;	// type of EOL marker to use for text
+				//   output
+  GBool textPageBreaks;		// insert end-of-page markers?
+  GBool textKeepTinyChars;	// keep all characters in text output
+  GooList *fontDirs;		// list of font dirs [GooString]
+  GooString *initialZoom;		// initial zoom level
+  GBool continuousView;		// continuous view mode
+  GBool enableT1lib;		// t1lib enable flag
+  GBool enableFreeType;		// FreeType enable flag
+  GBool enableFreeTypeHinting;  // FreeType hinting enable flag
+  GBool antialias;		// anti-aliasing enable flag
+  GBool vectorAntialias;	// vector anti-aliasing enable flag
+  GBool strokeAdjust;		// stroke adjustment enable flag
+  ScreenType screenType;	// halftone screen type
+  int screenSize;		// screen matrix size
+  int screenDotRadius;		// screen dot radius
+  double screenGamma;		// screen gamma correction
+  double screenBlackThreshold;	// screen black clamping threshold
+  double screenWhiteThreshold;	// screen white clamping threshold
+  GooString *urlCommand;		// command executed for URL links
+  GooString *movieCommand;	// command executed for movie annotations
+  GBool mapNumericCharNames;	// map numeric char names (from font subsets)?
+  GBool mapUnknownCharNames;	// map unknown char names?
+  GooList *keyBindings;		// key & mouse button bindings [KeyBinding]
+  GBool printCommands;		// print the drawing commands
+  GBool profileCommands;	// profile the drawing commands
+  GBool errQuiet;		// suppress error messages?
+
+  CharCodeToUnicodeCache *cidToUnicodeCache;
+  CharCodeToUnicodeCache *unicodeToUnicodeCache;
+  UnicodeMapCache *unicodeMapCache;
+  CMapCache *cMapCache;
+  
+  FcConfig *FCcfg;
+
+#ifdef ENABLE_PLUGINS
+  GooList *plugins;		// list of plugins [Plugin]
+  GooList *securityHandlers;	// list of loaded security handlers
+				//   [XpdfSecurityHandler]
+#endif
+
+#if MULTITHREADED
+  GooMutex mutex;
+  GooMutex unicodeMapCacheMutex;
+  GooMutex cMapCacheMutex;
+#endif
+};
+
+#endif
Index: Makefile
===================================================================
--- Makefile.orig
+++ Makefile
@@ -4,7 +4,7 @@ INCLUDES=$(POPPLERBASE) $(POPPLERBASE)/g
 
 CPPFLAGS+= $(INCLUDES) -DHAVE_DIRENT_H
 
-xpdf: CoreOutputDev.o GlobalParams.o ImageOutputDev.o PDFCore.o XPDFApp.o XPDFCore.o XPDFTree.o XPDFViewer.o parseargs.o xpdf.o 
+xpdf: CoreOutputDev.o GlobalParamsGUI.o ImageOutputDev.o PDFCore.o XPDFApp.o XPDFCore.o XPDFTree.o XPDFViewer.o parseargs.o xpdf.o 
 	$(CXX) $(CXXFLAGS) $(LDFLAGS) -o xpdf *.o $(LIBS)
 
 clean:
Index: PDFCore.cc
===================================================================
--- PDFCore.cc.orig
+++ PDFCore.cc
@@ -19,7 +19,7 @@
 #include <endian.h> 
 #include "GooString.h"
 #include "GooList.h"
-#include "GlobalParams.h"
+#include "GlobalParamsGUI.h"
 #include "Splash.h"
 #include "SplashBitmap.h"
 #include "SplashPattern.h"
@@ -88,7 +88,7 @@ PDFCore::PDFCore(SplashColorMode colorMo
   int i;
 
   doc = NULL;
-  continuousMode = globalParams->getContinuousView();
+  continuousMode = globalParamsGUI->getContinuousView();
   drawAreaWidth = drawAreaHeight = 0;
   maxPageW = totalDocH = 0;
   pageY = NULL;
Index: XPDFCore.cc
===================================================================
--- XPDFCore.cc.orig
+++ XPDFCore.cc
@@ -19,7 +19,7 @@
 #include "GooString.h"
 #include "GooList.h"
 #include "Error.h"
-#include "GlobalParams.h"
+#include "GlobalParamsGUI.h"
 #include "PDFDoc.h"
 #include "Link.h"
 #include "FileSpec.h"
@@ -114,7 +114,7 @@ XPDFCore::XPDFCore(Widget shellA, Widget
   if (fullScreen) {
     zoom = zoomPage;
   } else {
-    initialZoom = globalParams->getInitialZoom();
+    initialZoom = globalParamsGUI->getInitialZoom();
     if (!initialZoom->cmp("page")) {
       zoom = zoomPage;
     } else if (!initialZoom->cmp("width")) {
@@ -435,7 +435,7 @@ Boolean XPDFCore::convertSelectionCbk(Wi
     if (!(array = (Atom *)XtMalloc(sizeof(Atom)))) {
       return False;
     }
-    if (strcmp("UTF-8",globalParams->getTextEncodingName()->getCString()))
+    if (strcmp("UTF-8",globalParamsGUI->getTextEncodingName()->getCString()))
 	    array[0] = XA_STRING;
     else
 	    array[0] = utf8str;
@@ -571,7 +571,7 @@ void XPDFCore::doAction(LinkAction *acti
 
   // URI action
   case actionURI:
-    if (!(cmd = globalParams->getURLCommand())) {
+    if (!(cmd = globalParamsGUI->getURLCommand())) {
       error(-1, "No urlCommand defined in config file");
       break;
     }
@@ -608,7 +608,7 @@ void XPDFCore::doAction(LinkAction *acti
 
   // Movie action
   case actionMovie:
-    if (!(cmd = globalParams->getMovieCommand())) {
+    if (!(cmd = globalParamsGUI->getMovieCommand())) {
       error(-1, "No movieCommand defined in config file");
       break;
     }
Index: XPDFViewer.cc
===================================================================
--- XPDFViewer.cc.orig
+++ XPDFViewer.cc
@@ -30,7 +30,7 @@
 #include "GooString.h"
 #include "GooList.h"
 #include "Error.h"
-#include "GlobalParams.h"
+#include "GlobalParamsGUI.h"
 #include "PDFDoc.h"
 #include "Link.h"
 #include "ErrorCodes.h"
@@ -583,7 +583,7 @@ void XPDFViewer::keyPressCbk(void *data,
     return;
   }
 
-  if ((cmds = globalParams->getKeyBinding(keyCode,
+  if ((cmds = globalParamsGUI->getKeyBinding(keyCode,
 					  viewer->getModifiers(modifiers),
 					  viewer->getContext(modifiers)))) {
     for (i = 0; i < cmds->getLength(); ++i) {
@@ -615,7 +615,7 @@ void XPDFViewer::mouseCbk(void *data, XE
     return;
   }
 
-  if ((cmds = globalParams->getKeyBinding(keyCode,
+  if ((cmds = globalParamsGUI->getKeyBinding(keyCode,
 					  viewer->getModifiers(
 						      event->xkey.state),
 					  viewer->getContext(
@@ -2668,11 +2668,11 @@ void XPDFViewer::setupOutline() {
     // create the new labels
     items = core->getDoc()->getOutline()->getItems();
     if (items && items->getLength() > 0) {
-      if (strcmp("UTF-8",globalParams->getTextEncodingName()->getCString()))
+      if (strcmp("UTF-8",globalParamsGUI->getTextEncodingName()->getCString()))
              enc = new GooString("Latin1");
       else
              enc = new GooString("UTF-8");
-      uMap = globalParams->getUnicodeMap(enc);
+      uMap = globalParamsGUI->getUnicodeMap(enc);
       delete enc;
       setupOutlineItems(items, NULL, uMap);
       uMap->decRefCnt();
@@ -3329,7 +3329,7 @@ void XPDFViewer::initPrintDialog() {
   XtSetValues(printDialog, args, n);
 
   //----- initial values
-  if ((psFileName = globalParams->getPSFile())) {
+  if ((psFileName = globalParamsGUI->getPSFile())) {
     if (psFileName->getChar(0) == '|') {
       XmTextFieldSetString(printCmdText,
 			   psFileName->getCString() + 1);
@@ -3347,7 +3347,7 @@ void XPDFViewer::setupPrintDialog() {
   char *p;
 
   doc = core->getDoc();
-  psFileName = globalParams->getPSFile();
+  psFileName = globalParamsGUI->getPSFile();
   if (!psFileName || psFileName->getChar(0) == '|') {
     pdfFileName = doc->getFileName();
     p = pdfFileName->getCString() + pdfFileName->getLength() - 4;
@@ -3453,7 +3453,7 @@ void XPDFViewer::printPrintCbk(Widget wi
 			  firstPage, lastPage, psModePS);
   if (psOut->isOk()) {
     doc->displayPages(psOut, firstPage, lastPage, 72, 72,
-		      0, gTrue, globalParams->getPSCrop(), gTrue);
+		      0, gTrue, globalParamsGUI->getPSCrop(), gTrue);
   }
   delete psOut;
   delete psFileName;
Index: xpdf.cc
===================================================================
--- xpdf.cc.orig
+++ xpdf.cc
@@ -12,7 +12,8 @@
 #include "parseargs.h"
 #include "gfile.h"
 #include "gmem.h"
-#include "GlobalParams.h"
+#include "GlobalParamsGUI.h"
+#include <GlobalParams.h>
 #include "Object.h"
 #include "XPDFApp.h"
 #include "config.h"
@@ -26,6 +27,7 @@ static char enableT1libStr[16] = "";
 static char enableFreeTypeStr[16] = "";
 static char antialiasStr[16] = "";
 static char vectorAntialiasStr[16] = "";
+static char autohintingStr[16] = "no";
 static char psFileArg[256];
 static char paperSize[15] = "";
 static int paperWidth = 0;
@@ -78,6 +80,8 @@ static ArgDesc argDesc[] = {
    "enable font anti-aliasing: yes, no"},
   {"-aaVector",   argString,      vectorAntialiasStr, sizeof(vectorAntialiasStr),
    "enable vector anti-aliasing: yes, no"},
+  {"-ah",         argString,      autohintingStr, sizeof(autohintingStr),
+   "enable font auto-hinting: yes, no (default no)"},
   {"-ps",         argString,      psFileArg,      sizeof(psFileArg),
    "default PostScript file name or command"},
   {"-paper",      argString,      paperSize,      sizeof(paperSize),
@@ -153,63 +157,71 @@ int main(int argc, char *argv[]) {
     goto done0;
   }
 
+  // poppler's globalParams
+  globalParams = new GlobalParams;
+
   // read config file
-  globalParams = new GlobalParams(cfgFileName);
-  globalParams->setupBaseFonts(NULL);
+  globalParamsGUI = new GlobalParamsGUI(cfgFileName);
+  globalParamsGUI->setupBaseFonts(NULL);
   if (contView) {
-    globalParams->setContinuousView(contView);
+    globalParamsGUI->setContinuousView(contView);
   }
   if (psFileArg[0]) {
-    globalParams->setPSFile(psFileArg);
+    globalParamsGUI->setPSFile(psFileArg);
   }
   if (paperSize[0]) {
-    if (!globalParams->setPSPaperSize(paperSize)) {
+    if (!globalParamsGUI->setPSPaperSize(paperSize)) {
       fprintf(stderr, "Invalid paper size\n");
     }
   } else {
     if (paperWidth) {
-      globalParams->setPSPaperWidth(paperWidth);
+      globalParamsGUI->setPSPaperWidth(paperWidth);
     }
     if (paperHeight) {
-      globalParams->setPSPaperHeight(paperHeight);
+      globalParamsGUI->setPSPaperHeight(paperHeight);
     }
   }
   if (level1) {
-    globalParams->setPSLevel(psLevel1);
+    globalParamsGUI->setPSLevel(psLevel1);
   }
   if (textEncName[0]) {
-    globalParams->setTextEncoding(textEncName);
+    globalParamsGUI->setTextEncoding(textEncName);
   }
   if (textEOL[0]) {
-    if (!globalParams->setTextEOL(textEOL)) {
+    if (!globalParamsGUI->setTextEOL(textEOL)) {
       fprintf(stderr, "Bad '-eol' value on command line\n");
     }
   }
   if (enableT1libStr[0]) {
-    if (!globalParams->setEnableT1lib(enableT1libStr)) {
+    if (!globalParamsGUI->setEnableT1lib(enableT1libStr)) {
       fprintf(stderr, "Bad '-t1lib' value on command line\n");
     }
   }
   if (enableFreeTypeStr[0]) {
-    if (!globalParams->setEnableFreeType(enableFreeTypeStr)) {
+    if (!globalParamsGUI->setEnableFreeType(enableFreeTypeStr)) {
       fprintf(stderr, "Bad '-freetype' value on command line\n");
     }
   }
   if (antialiasStr[0]) {
-    if (!globalParams->setAntialias(antialiasStr)) {
+    if (!globalParamsGUI->setAntialias(antialiasStr)) {
       fprintf(stderr, "Bad '-aa' value on command line\n");
     }
   }
   if (vectorAntialiasStr[0]) {
-    if (!globalParams->setVectorAntialias(vectorAntialiasStr)) {
+    if (!globalParamsGUI->setVectorAntialias(vectorAntialiasStr)) {
       fprintf(stderr, "Bad '-aaVector' value on command line\n");
     }
   }
+  if (autohintingStr[0]) {
+    if (!globalParamsGUI->setEnableFreeTypeHinting(autohintingStr)) {
+      fprintf(stderr, "Bad '-ah' value on command line\n");
+    }
+  }
   if (printCommands) {
-    globalParams->setPrintCommands(printCommands);
+    globalParamsGUI->setPrintCommands(printCommands);
   }
   if (quiet) {
-    globalParams->setErrQuiet(quiet);
+    globalParamsGUI->setErrQuiet(quiet);
   }
 
   // create the XPDFApp object
@@ -218,7 +230,7 @@ int main(int argc, char *argv[]) {
   // the initialZoom parameter can be set in either the config file or
   // as an X resource (or command line arg)
   if (app->getInitialZoom()) {
-    globalParams->setInitialZoom(app->getInitialZoom()->getCString());
+    globalParamsGUI->setInitialZoom(app->getInitialZoom()->getCString());
   }
 
   // check command line
@@ -333,6 +345,7 @@ int main(int argc, char *argv[]) {
   }
  done1:
   delete app;
+  delete globalParamsGUI;
   delete globalParams;
 
   // check for memory leaks
Index: CoreOutputDev.cc
===================================================================
--- CoreOutputDev.cc.orig
+++ CoreOutputDev.cc
@@ -15,6 +15,7 @@
 #include "Object.h"
 #include "TextOutputDev.h"
 #include "CoreOutputDev.h"
+#include "GlobalParamsGUI.h"
 
 //------------------------------------------------------------------------
 // CoreOutputDev
@@ -30,6 +31,8 @@ CoreOutputDev::CoreOutputDev(SplashColor
   incrementalUpdate = incrementalUpdateA;
   redrawCbk = redrawCbkA;
   redrawCbkData = redrawCbkDataA;
+
+  setFreeTypeHinting(globalParamsGUI->getEnableFreeTypeHinting());
 }
 
 CoreOutputDev::~CoreOutputDev() {

Places

File xpdf-poppler-autohinting-as-option.patch of Package xpdf-poppler

Places