Ignore:
Timestamp:
Jun 30, 2008, 10:13:07 AM (13 years ago)
Author:
Eugene Romanenko
Message:

PDF plugin: poppler library updated to version 0.8.3

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/poppler/mypoppler/poppler/GlobalParams.cc

    r134 r250  
    2424#  include <shlobj.h>
    2525#endif
    26 #include <fontconfig/fontconfig.h>
    2726#include "goo/gmem.h"
    2827#include "goo/GooString.h"
     
    4342#include "GfxFont.h"
    4443
     44#ifdef WIN32
     45#  define strcasecmp stricmp
     46#endif
     47
    4548#if MULTITHREADED
    4649#  define lockGlobalParams            gLockMutex(&mutex)
     
    116119}
    117120
     121#ifdef WIN32
     122
     123//------------------------------------------------------------------------
     124// WinFontInfo
     125//------------------------------------------------------------------------
     126
     127class WinFontInfo: public DisplayFontParam {
     128public:
     129
     130  GBool bold, italic;
     131
     132  static WinFontInfo *make(GooString *nameA, GBool boldA, GBool italicA,
     133                           HKEY regKey, char *winFontDir);
     134  WinFontInfo(GooString *nameA, GBool boldA, GBool italicA,
     135              GooString *fileNameA);
     136  virtual ~WinFontInfo();
     137  GBool equals(WinFontInfo *fi);
     138};
     139
     140WinFontInfo *WinFontInfo::make(GooString *nameA, GBool boldA, GBool italicA,
     141                               HKEY regKey, char *winFontDir) {
     142  GooString *regName;
     143  GooString *fileNameA;
     144  char buf[MAX_PATH];
     145  DWORD n;
     146  char c;
     147  int i;
     148
     149  //----- find the font file
     150  fileNameA = NULL;
     151  regName = nameA->copy();
     152  if (boldA) {
     153    regName->append(" Bold");
     154  }
     155  if (italicA) {
     156    regName->append(" Italic");
     157  }
     158  regName->append(" (TrueType)");
     159  n = sizeof(buf);
     160  if (RegQueryValueEx(regKey, regName->getCString(), NULL, NULL,
     161                      (LPBYTE)buf, &n) == ERROR_SUCCESS) {
     162    fileNameA = new GooString(winFontDir);
     163    fileNameA->append('\\')->append(buf);
     164  }
     165  delete regName;
     166  if (!fileNameA) {
     167    delete nameA;
     168    return NULL;
     169  }
     170
     171  //----- normalize the font name
     172  i = 0;
     173  while (i < nameA->getLength()) {
     174    c = nameA->getChar(i);
     175    if (c == ' ' || c == ',' || c == '-') {
     176      nameA->del(i);
     177    } else {
     178      ++i;
     179    }
     180  }
     181
     182  return new WinFontInfo(nameA, boldA, italicA, fileNameA);
     183}
     184
     185WinFontInfo::WinFontInfo(GooString *nameA, GBool boldA, GBool italicA,
     186                         GooString *fileNameA):
     187  DisplayFontParam(nameA, displayFontTT)
     188{
     189  bold = boldA;
     190  italic = italicA;
     191  tt.fileName = fileNameA;
     192}
     193
     194WinFontInfo::~WinFontInfo() {
     195}
     196
     197GBool WinFontInfo::equals(WinFontInfo *fi) {
     198  return !name->cmp(fi->name) && bold == fi->bold && italic == fi->italic;
     199}
     200
     201//------------------------------------------------------------------------
     202// WinFontList
     203//------------------------------------------------------------------------
     204
     205class WinFontList {
     206public:
     207
     208  WinFontList(char *winFontDirA);
     209  ~WinFontList();
     210  WinFontInfo *find(GooString *font);
     211
     212private:
     213
     214  void add(WinFontInfo *fi);
     215  static int CALLBACK enumFunc1(CONST LOGFONT *font,
     216                                CONST TEXTMETRIC *metrics,
     217                                DWORD type, LPARAM data);
     218  static int CALLBACK enumFunc2(CONST LOGFONT *font,
     219                                CONST TEXTMETRIC *metrics,
     220                                DWORD type, LPARAM data);
     221
     222  GooList *fonts;                       // [WinFontInfo]
     223  HDC dc;                       // (only used during enumeration)
     224  HKEY regKey;                  // (only used during enumeration)
     225  char *winFontDir;             // (only used during enumeration)
     226};
     227
     228WinFontList::WinFontList(char *winFontDirA) {
     229  OSVERSIONINFO version;
     230  char *path;
     231
     232  fonts = new GooList();
     233  dc = GetDC(NULL);
     234  winFontDir = winFontDirA;
     235  version.dwOSVersionInfoSize = sizeof(version);
     236  GetVersionEx(&version);
     237  if (version.dwPlatformId == VER_PLATFORM_WIN32_NT) {
     238    path = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts\\";
     239  } else {
     240    path = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Fonts\\";
     241  }
     242  if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, path, 0,
     243                   KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS,
     244                   &regKey) == ERROR_SUCCESS) {
     245    EnumFonts(dc, NULL, &WinFontList::enumFunc1, (LPARAM)this);
     246    RegCloseKey(regKey);
     247  }
     248  ReleaseDC(NULL, dc);
     249}
     250
     251WinFontList::~WinFontList() {
     252  deleteGooList(fonts, WinFontInfo);
     253}
     254
     255void WinFontList::add(WinFontInfo *fi) {
     256  int i;
     257
     258  for (i = 0; i < fonts->getLength(); ++i) {
     259    if (((WinFontInfo *)fonts->get(i))->equals(fi)) {
     260      delete fi;
     261      return;
     262    }
     263  }
     264  fonts->append(fi);
     265}
     266
     267WinFontInfo *WinFontList::find(GooString *font) {
     268  GooString *name;
     269  GBool bold, italic;
     270  WinFontInfo *fi;
     271  char c;
     272  int n, i;
     273
     274  name = font->copy();
     275
     276  // remove space, comma, dash chars
     277  i = 0;
     278  while (i < name->getLength()) {
     279    c = name->getChar(i);
     280    if (c == ' ' || c == ',' || c == '-') {
     281      name->del(i);
     282    } else {
     283      ++i;
     284    }
     285  }
     286  n = name->getLength();
     287
     288  // remove trailing "MT" (Foo-MT, Foo-BoldMT, etc.)
     289  if (!strcmp(name->getCString() + n - 2, "MT")) {
     290    name->del(n - 2, 2);
     291    n -= 2;
     292  }
     293
     294  // look for "Italic"
     295  if (!strcmp(name->getCString() + n - 6, "Italic")) {
     296    name->del(n - 6, 6);
     297    italic = gTrue;
     298    n -= 6;
     299  } else {
     300    italic = gFalse;
     301  }
     302
     303  // look for "Bold"
     304  if (!strcmp(name->getCString() + n - 4, "Bold")) {
     305    name->del(n - 4, 4);
     306    bold = gTrue;
     307    n -= 4;
     308  } else {
     309    bold = gFalse;
     310  }
     311
     312  // remove trailing "MT" (FooMT-Bold, etc.)
     313  if (!strcmp(name->getCString() + n - 2, "MT")) {
     314    name->del(n - 2, 2);
     315    n -= 2;
     316  }
     317
     318  // remove trailing "PS"
     319  if (!strcmp(name->getCString() + n - 2, "PS")) {
     320    name->del(n - 2, 2);
     321    n -= 2;
     322  }
     323
     324  // search for the font
     325  fi = NULL;
     326  for (i = 0; i < fonts->getLength(); ++i) {
     327    fi = (WinFontInfo *)fonts->get(i);
     328    if (!fi->name->cmp(name) && fi->bold == bold && fi->italic == italic) {
     329      break;
     330    }
     331    fi = NULL;
     332  }
     333
     334  delete name;
     335  return fi;
     336}
     337
     338int CALLBACK WinFontList::enumFunc1(CONST LOGFONT *font,
     339                                    CONST TEXTMETRIC *metrics,
     340                                    DWORD type, LPARAM data) {
     341  WinFontList *fl = (WinFontList *)data;
     342
     343  EnumFonts(fl->dc, font->lfFaceName, &WinFontList::enumFunc2, (LPARAM)fl);
     344  return 1;
     345}
     346
     347int CALLBACK WinFontList::enumFunc2(CONST LOGFONT *font,
     348                                    CONST TEXTMETRIC *metrics,
     349                                    DWORD type, LPARAM data) {
     350  WinFontList *fl = (WinFontList *)data;
     351  WinFontInfo *fi;
     352
     353  if (type & TRUETYPE_FONTTYPE) {
     354    if ((fi = WinFontInfo::make(new GooString(font->lfFaceName),
     355                                font->lfWeight >= 600,
     356                                font->lfItalic ? gTrue : gFalse,
     357                                fl->regKey, fl->winFontDir))) {
     358      fl->add(fi);
     359    }
     360  }
     361  return 1;
     362}
     363
     364#endif // WIN32
     365
    118366//------------------------------------------------------------------------
    119367// PSFontParam
     
    282530//------------------------------------------------------------------------
    283531
    284 GlobalParams::GlobalParams(char *cfgFileName) {
     532GlobalParams::GlobalParams() {
    285533  UnicodeMap *map;
    286   GooString *fileName;
    287   FILE *f;
    288534  int i;
    289  
     535
     536#ifndef _MSC_VER 
    290537  FcInit();
    291538  FCcfg = FcConfigGetCurrent();
     539#endif
    292540
    293541#if MULTITHREADED
     
    322570  toUnicodeDirs = new GooList();
    323571  displayFonts = new GooHash();
    324   psPaperWidth = -1;
    325   psPaperHeight = -1;
    326   psImageableLLX = psImageableLLY = 0;
    327   psImageableURX = psPaperWidth;
    328   psImageableURY = psPaperHeight;
    329   psCrop = gTrue;
    330572  psExpandSmaller = gFalse;
    331573  psShrinkLarger = gTrue;
    332574  psCenter = gTrue;
    333   psDuplex = gFalse;
    334575  psLevel = psLevel2;
    335   psFile = NULL;
    336576  psFonts = new GooHash();
    337577  psNamedFonts16 = new GooList();
     
    341581  psEmbedCIDPostScript = gTrue;
    342582  psEmbedCIDTrueType = gTrue;
     583  psPreload = gFalse;
    343584  psOPI = gFalse;
    344585  psASCIIHex = gFalse;
     
    354595  textKeepTinyChars = gFalse;
    355596  fontDirs = new GooList();
    356   initialZoom = new GooString("125");
    357   continuousView = gFalse;
    358   enableT1lib = gTrue;
    359597  enableFreeType = gTrue;
    360598  antialias = gTrue;
    361   urlCommand = NULL;
    362   movieCommand = NULL;
     599  vectorAntialias = gTrue;
     600  strokeAdjust = gTrue;
     601  screenType = screenUnset;
     602  screenSize = -1;
     603  screenDotRadius = -1;
     604  screenGamma = 1.0;
     605  screenBlackThreshold = 0.0;
     606  screenWhiteThreshold = 1.0;
    363607  mapNumericCharNames = gTrue;
     608  mapUnknownCharNames = gFalse;
    364609  printCommands = gFalse;
    365610  profileCommands = gFalse;
     
    371616  unicodeMapCache = new UnicodeMapCache();
    372617  cMapCache = new CMapCache();
     618
     619#ifdef WIN32
     620  winFontList = NULL;
     621#endif
    373622
    374623#ifdef ENABLE_PLUGINS
     
    400649  residentUnicodeMaps->add(map->getEncodingName(), map);
    401650
    402   // look for a user config file, then a system-wide config file
    403   f = NULL;
    404   fileName = NULL;
    405   if (cfgFileName && cfgFileName[0]) {
    406     fileName = new GooString(cfgFileName);
    407     if (!(f = fopen(fileName->getCString(), "r"))) {
    408       delete fileName;
    409     }
    410   }
    411   if (!f) {
    412     fileName = appendToPath(getHomeDir(), xpdfUserConfigFile);
    413     if (!(f = fopen(fileName->getCString(), "r"))) {
    414       delete fileName;
    415     }
    416   }
    417   if (!f) {
    418 #if defined(WIN32) && !defined(__CYGWIN32__)
    419     char buf[512];
    420     i = GetModuleFileName(NULL, buf, sizeof(buf));
    421     if (i <= 0 || i >= sizeof(buf)) {
    422       // error or path too long for buffer - just use the current dir
    423       buf[0] = '\0';
    424     }
    425     fileName = grabPath(buf);
    426     appendToPath(fileName, xpdfSysConfigFile);
    427 #else
    428     fileName = new GooString(xpdfSysConfigFile);
    429 #endif
    430     if (!(f = fopen(fileName->getCString(), "r"))) {
    431       delete fileName;
    432     }
    433   }
    434   if (f) {
    435     parseFile(fileName, f);
    436     delete fileName;
    437     fclose(f);
    438   }
    439 
    440651  scanEncodingDirs();
    441 }
    442 
    443 void GlobalParams::parseFile(GooString *fileName, FILE *f) {
    444   int line;
    445   GooList *tokens;
    446   GooString *cmd, *incFile;
    447   char *p1, *p2;
    448   char buf[512];
    449   FILE *f2;
    450 
    451   line = 1;
    452   while (getLine(buf, sizeof(buf) - 1, f)) {
    453 
    454     // break the line into tokens
    455     tokens = new GooList();
    456     p1 = buf;
    457     while (*p1) {
    458       for (; *p1 && isspace(*p1); ++p1) ;
    459       if (!*p1) {
    460         break;
    461       }
    462       if (*p1 == '"' || *p1 == '\'') {
    463         for (p2 = p1 + 1; *p2 && *p2 != *p1; ++p2) ;
    464         ++p1;
    465       } else {
    466         for (p2 = p1 + 1; *p2 && !isspace(*p2); ++p2) ;
    467       }
    468       tokens->append(new GooString(p1, p2 - p1));
    469       p1 = *p2 ? p2 + 1 : p2;
    470     }
    471 
    472     if (tokens->getLength() > 0 &&
    473         ((GooString *)tokens->get(0))->getChar(0) != '#') {
    474       cmd = (GooString *)tokens->get(0);
    475       if (!cmd->cmp("include")) {
    476         if (tokens->getLength() == 2) {
    477           incFile = (GooString *)tokens->get(1);
    478           if ((f2 = fopen(incFile->getCString(), "r"))) {
    479             parseFile(incFile, f2);
    480             fclose(f2);
    481           } else {
    482             error(-1, "Couldn't find included config file: '%s' (%s:%d)",
    483                   incFile->getCString(), fileName->getCString(), line);
    484           }
    485         } else {
    486           error(-1, "Bad 'include' config file command (%s:%d)",
    487                 fileName->getCString(), line);
    488         }
    489       } else if (!cmd->cmp("nameToUnicode")) {
    490         if (tokens->getLength() != 2)
    491           error(-1, "Bad 'nameToUnicode' config file command (%s:%d)",
    492                 fileName->getCString(), line);
    493         else
    494           parseNameToUnicode((GooString *) tokens->get(1));
    495       } else if (!cmd->cmp("cidToUnicode")) {
    496         parseCIDToUnicode(tokens, fileName, line);
    497       } else if (!cmd->cmp("unicodeToUnicode")) {
    498         parseUnicodeToUnicode(tokens, fileName, line);
    499       } else if (!cmd->cmp("unicodeMap")) {
    500         parseUnicodeMap(tokens, fileName, line);
    501       } else if (!cmd->cmp("cMapDir")) {
    502         parseCMapDir(tokens, fileName, line);
    503       } else if (!cmd->cmp("toUnicodeDir")) {
    504         parseToUnicodeDir(tokens, fileName, line);
    505       } else if (!cmd->cmp("displayFontT1")) {
    506         // deprecated
    507       } else if (!cmd->cmp("displayFontTT")) {
    508         // deprecated
    509       } else if (!cmd->cmp("displayNamedCIDFontT1")) {
    510         // deprecated
    511       } else if (!cmd->cmp("displayCIDFontT1")) {
    512         // deprecated
    513       } else if (!cmd->cmp("displayNamedCIDFontTT")) {
    514         // deprecated
    515       } else if (!cmd->cmp("displayCIDFontTT")) {
    516         // deprecated
    517       } else if (!cmd->cmp("psFile")) {
    518         parsePSFile(tokens, fileName, line);
    519       } else if (!cmd->cmp("psFont")) {
    520         parsePSFont(tokens, fileName, line);
    521       } else if (!cmd->cmp("psNamedFont16")) {
    522         parsePSFont16("psNamedFont16", psNamedFonts16,
    523                       tokens, fileName, line);
    524       } else if (!cmd->cmp("psFont16")) {
    525         parsePSFont16("psFont16", psFonts16, tokens, fileName, line);
    526       } else if (!cmd->cmp("psPaperSize")) {
    527         parsePSPaperSize(tokens, fileName, line);
    528       } else if (!cmd->cmp("psImageableArea")) {
    529         parsePSImageableArea(tokens, fileName, line);
    530       } else if (!cmd->cmp("psCrop")) {
    531         parseYesNo("psCrop", &psCrop, tokens, fileName, line);
    532       } else if (!cmd->cmp("psExpandSmaller")) {
    533         parseYesNo("psExpandSmaller", &psExpandSmaller,
    534                    tokens, fileName, line);
    535       } else if (!cmd->cmp("psShrinkLarger")) {
    536         parseYesNo("psShrinkLarger", &psShrinkLarger, tokens, fileName, line);
    537       } else if (!cmd->cmp("psCenter")) {
    538         parseYesNo("psCenter", &psCenter, tokens, fileName, line);
    539       } else if (!cmd->cmp("psDuplex")) {
    540         parseYesNo("psDuplex", &psDuplex, tokens, fileName, line);
    541       } else if (!cmd->cmp("psLevel")) {
    542         parsePSLevel(tokens, fileName, line);
    543       } else if (!cmd->cmp("psEmbedType1Fonts")) {
    544         parseYesNo("psEmbedType1", &psEmbedType1, tokens, fileName, line);
    545       } else if (!cmd->cmp("psEmbedTrueTypeFonts")) {
    546         parseYesNo("psEmbedTrueType", &psEmbedTrueType,
    547                    tokens, fileName, line);
    548       } else if (!cmd->cmp("psEmbedCIDPostScriptFonts")) {
    549         parseYesNo("psEmbedCIDPostScript", &psEmbedCIDPostScript,
    550                    tokens, fileName, line);
    551       } else if (!cmd->cmp("psEmbedCIDTrueTypeFonts")) {
    552         parseYesNo("psEmbedCIDTrueType", &psEmbedCIDTrueType,
    553                    tokens, fileName, line);
    554       } else if (!cmd->cmp("psOPI")) {
    555         parseYesNo("psOPI", &psOPI, tokens, fileName, line);
    556       } else if (!cmd->cmp("psASCIIHex")) {
    557         parseYesNo("psASCIIHex", &psASCIIHex, tokens, fileName, line);
    558       } else if (!cmd->cmp("textEncoding")) {
    559         parseTextEncoding(tokens, fileName, line);
    560       } else if (!cmd->cmp("textEOL")) {
    561         parseTextEOL(tokens, fileName, line);
    562       } else if (!cmd->cmp("textPageBreaks")) {
    563         parseYesNo("textPageBreaks", &textPageBreaks,
    564                    tokens, fileName, line);
    565       } else if (!cmd->cmp("textKeepTinyChars")) {
    566         parseYesNo("textKeepTinyChars", &textKeepTinyChars,
    567                    tokens, fileName, line);
    568       } else if (!cmd->cmp("fontDir")) {
    569         parseFontDir(tokens, fileName, line);
    570       } else if (!cmd->cmp("initialZoom")) {
    571         parseInitialZoom(tokens, fileName, line);
    572       } else if (!cmd->cmp("continuousView")) {
    573         parseYesNo("continuousView", &continuousView, tokens, fileName, line);
    574       } else if (!cmd->cmp("enableT1lib")) {
    575         parseYesNo("enableT1lib", &enableT1lib, tokens, fileName, line);
    576       } else if (!cmd->cmp("enableFreeType")) {
    577         parseYesNo("enableFreeType", &enableFreeType, tokens, fileName, line);
    578       } else if (!cmd->cmp("antialias")) {
    579         parseYesNo("antialias", &antialias, tokens, fileName, line);
    580       } else if (!cmd->cmp("urlCommand")) {
    581         parseCommand("urlCommand", &urlCommand, tokens, fileName, line);
    582       } else if (!cmd->cmp("movieCommand")) {
    583         parseCommand("movieCommand", &movieCommand, tokens, fileName, line);
    584       } else if (!cmd->cmp("mapNumericCharNames")) {
    585         parseYesNo("mapNumericCharNames", &mapNumericCharNames,
    586                    tokens, fileName, line);
    587       } else if (!cmd->cmp("printCommands")) {
    588         parseYesNo("printCommands", &printCommands, tokens, fileName, line);
    589       } else if (!cmd->cmp("errQuiet")) {
    590         parseYesNo("errQuiet", &errQuiet, tokens, fileName, line);
    591       } else {
    592         error(-1, "Unknown config file command '%s' (%s:%d)",
    593               cmd->getCString(), fileName->getCString(), line);
    594         if (!cmd->cmp("displayFontX") ||
    595             !cmd->cmp("displayNamedCIDFontX") ||
    596             !cmd->cmp("displayCIDFontX")) {
    597           error(-1, "-- Xpdf no longer supports X fonts");
    598         } else if (!cmd->cmp("t1libControl") || !cmd->cmp("freetypeControl")) {
    599           error(-1, "-- The t1libControl and freetypeControl options have been replaced");
    600           error(-1, "   by the enableT1lib, enableFreeType, and antialias options");
    601         } else if (!cmd->cmp("fontpath") || !cmd->cmp("fontmap")) {
    602           error(-1, "-- the config file format has changed since Xpdf 0.9x");
    603         }
    604       }
    605     }
    606 
    607     deleteGooList(tokens, GooString);
    608     ++line;
    609   }
    610652}
    611653
     
    614656  GDirEntry *entry;
    615657
    616   dir = new GDir(POPPLER_DATADIR "/nameToUnicode", gFalse);
     658  dir = new GDir(POPPLER_DATADIR "/nameToUnicode", gTrue);
    617659  while (entry = dir->getNextEntry(), entry != NULL) {
    618     parseNameToUnicode(entry->getFullPath());
     660    if (!entry->isDir()) {
     661      parseNameToUnicode(entry->getFullPath());
     662    }
    619663    delete entry;
    620664  }
     
    682726}
    683727
    684 void GlobalParams::parseCIDToUnicode(GooList *tokens, GooString *fileName,
    685                                      int line) {
    686   if (tokens->getLength() != 3) {
    687     error(-1, "Bad 'cidToUnicode' config file command (%s:%d)",
    688           fileName->getCString(), line);
    689     return;
    690   }
    691   addCIDToUnicode((GooString *)tokens->get(1), (GooString *)tokens->get(2));
    692 }
    693 
    694 void GlobalParams::parseUnicodeToUnicode(GooList *tokens, GooString *fileName,
    695                                          int line) {
    696   GooString *font, *file, *old;
    697 
    698   if (tokens->getLength() != 3) {
    699     error(-1, "Bad 'unicodeToUnicode' config file command (%s:%d)",
    700           fileName->getCString(), line);
    701     return;
    702   }
    703   font = (GooString *)tokens->get(1);
    704   file = (GooString *)tokens->get(2);
    705   if ((old = (GooString *)unicodeToUnicodes->remove(font))) {
    706     delete old;
    707   }
    708   unicodeToUnicodes->add(font->copy(), file->copy());
    709 }
    710 
    711728void GlobalParams::addUnicodeMap(GooString *encodingName, GooString *fileName)
    712729{
     
    719736}
    720737
    721 void GlobalParams::parseUnicodeMap(GooList *tokens, GooString *fileName,
    722                                    int line) {
    723 
    724   if (tokens->getLength() != 3) {
    725     error(-1, "Bad 'unicodeMap' config file command (%s:%d)",
    726           fileName->getCString(), line);
    727     return;
    728   }
    729   addUnicodeMap((GooString *)tokens->get(1), (GooString *)tokens->get(2));
    730 }
    731 
    732738void GlobalParams::addCMapDir(GooString *collection, GooString *dir) {
    733739  GooList *list;
     
    738744  }
    739745  list->append(dir->copy());
    740 }
    741 
    742 void GlobalParams::parseCMapDir(GooList *tokens, GooString *fileName, int line) {
    743   if (tokens->getLength() != 3) {
    744     error(-1, "Bad 'cMapDir' config file command (%s:%d)",
    745           fileName->getCString(), line);
    746     return;
    747   }
    748   addCMapDir((GooString *)tokens->get(1), (GooString *)tokens->get(2));
    749 }
    750 
    751 void GlobalParams::parseToUnicodeDir(GooList *tokens, GooString *fileName,
    752                                      int line) {
    753   if (tokens->getLength() != 2) {
    754     error(-1, "Bad 'toUnicodeDir' config file command (%s:%d)",
    755           fileName->getCString(), line);
    756     return;
    757   }
    758   toUnicodeDirs->append(((GooString *)tokens->get(1))->copy());
    759 }
    760 
    761 void GlobalParams::parsePSPaperSize(GooList *tokens, GooString *fileName,
    762                                     int line) {
    763   GooString *tok;
    764 
    765   if (tokens->getLength() == 2) {
    766     tok = (GooString *)tokens->get(1);
    767     if (!setPSPaperSize(tok->getCString())) {
    768       error(-1, "Bad 'psPaperSize' config file command (%s:%d)",
    769             fileName->getCString(), line);
    770     }
    771   } else if (tokens->getLength() == 3) {
    772     tok = (GooString *)tokens->get(1);
    773     psPaperWidth = atoi(tok->getCString());
    774     tok = (GooString *)tokens->get(2);
    775     psPaperHeight = atoi(tok->getCString());
    776     psImageableLLX = psImageableLLY = 0;
    777     psImageableURX = psPaperWidth;
    778     psImageableURY = psPaperHeight;
    779   } else {
    780     error(-1, "Bad 'psPaperSize' config file command (%s:%d)",
    781           fileName->getCString(), line);
    782   }
    783 }
    784 
    785 void GlobalParams::parsePSImageableArea(GooList *tokens, GooString *fileName,
    786                                         int line) {
    787   if (tokens->getLength() != 5) {
    788     error(-1, "Bad 'psImageableArea' config file command (%s:%d)",
    789           fileName->getCString(), line);
    790     return;
    791   }
    792   psImageableLLX = atoi(((GooString *)tokens->get(1))->getCString());
    793   psImageableLLY = atoi(((GooString *)tokens->get(2))->getCString());
    794   psImageableURX = atoi(((GooString *)tokens->get(3))->getCString());
    795   psImageableURY = atoi(((GooString *)tokens->get(4))->getCString());
    796 }
    797 
    798 void GlobalParams::parsePSLevel(GooList *tokens, GooString *fileName, int line) {
    799   GooString *tok;
    800 
    801   if (tokens->getLength() != 2) {
    802     error(-1, "Bad 'psLevel' config file command (%s:%d)",
    803           fileName->getCString(), line);
    804     return;
    805   }
    806   tok = (GooString *)tokens->get(1);
    807   if (!tok->cmp("level1")) {
    808     psLevel = psLevel1;
    809   } else if (!tok->cmp("level1sep")) {
    810     psLevel = psLevel1Sep;
    811   } else if (!tok->cmp("level2")) {
    812     psLevel = psLevel2;
    813   } else if (!tok->cmp("level2sep")) {
    814     psLevel = psLevel2Sep;
    815   } else if (!tok->cmp("level3")) {
    816     psLevel = psLevel3;
    817   } else if (!tok->cmp("level3Sep")) {
    818     psLevel = psLevel3Sep;
    819   } else {
    820     error(-1, "Bad 'psLevel' config file command (%s:%d)",
    821           fileName->getCString(), line);
    822   }
    823 }
    824 
    825 void GlobalParams::parsePSFile(GooList *tokens, GooString *fileName, int line) {
    826   if (tokens->getLength() != 2) {
    827     error(-1, "Bad 'psFile' config file command (%s:%d)",
    828           fileName->getCString(), line);
    829     return;
    830   }
    831   if (psFile) {
    832     delete psFile;
    833   }
    834   psFile = ((GooString *)tokens->get(1))->copy();
    835 }
    836 
    837 void GlobalParams::parsePSFont(GooList *tokens, GooString *fileName, int line) {
    838   PSFontParam *param;
    839 
    840   if (tokens->getLength() != 3) {
    841     error(-1, "Bad 'psFont' config file command (%s:%d)",
    842           fileName->getCString(), line);
    843     return;
    844   }
    845   param = new PSFontParam(((GooString *)tokens->get(1))->copy(), 0,
    846                           ((GooString *)tokens->get(2))->copy(), NULL);
    847   psFonts->add(param->pdfFontName, param);
    848 }
    849 
    850 void GlobalParams::parsePSFont16(char *cmdName, GooList *fontList,
    851                                  GooList *tokens, GooString *fileName, int line) {
    852   PSFontParam *param;
    853   int wMode;
    854   GooString *tok;
    855 
    856   if (tokens->getLength() != 5) {
    857     error(-1, "Bad '%s' config file command (%s:%d)",
    858           cmdName, fileName->getCString(), line);
    859     return;
    860   }
    861   tok = (GooString *)tokens->get(2);
    862   if (!tok->cmp("H")) {
    863     wMode = 0;
    864   } else if (!tok->cmp("V")) {
    865     wMode = 1;
    866   } else {
    867     error(-1, "Bad '%s' config file command (%s:%d)",
    868           cmdName, fileName->getCString(), line);
    869     return;
    870   }
    871   param = new PSFontParam(((GooString *)tokens->get(1))->copy(),
    872                           wMode,
    873                           ((GooString *)tokens->get(3))->copy(),
    874                           ((GooString *)tokens->get(4))->copy());
    875   fontList->append(param);
    876 }
    877 
    878 void GlobalParams::parseTextEncoding(GooList *tokens, GooString *fileName,
    879                                      int line) {
    880   if (tokens->getLength() != 2) {
    881     error(-1, "Bad 'textEncoding' config file command (%s:%d)",
    882           fileName->getCString(), line);
    883     return;
    884   }
    885   delete textEncoding;
    886   textEncoding = ((GooString *)tokens->get(1))->copy();
    887 }
    888 
    889 void GlobalParams::parseTextEOL(GooList *tokens, GooString *fileName, int line) {
    890   GooString *tok;
    891 
    892   if (tokens->getLength() != 2) {
    893     error(-1, "Bad 'textEOL' config file command (%s:%d)",
    894           fileName->getCString(), line);
    895     return;
    896   }
    897   tok = (GooString *)tokens->get(1);
    898   if (!tok->cmp("unix")) {
    899     textEOL = eolUnix;
    900   } else if (!tok->cmp("dos")) {
    901     textEOL = eolDOS;
    902   } else if (!tok->cmp("mac")) {
    903     textEOL = eolMac;
    904   } else {
    905     error(-1, "Bad 'textEOL' config file command (%s:%d)",
    906           fileName->getCString(), line);
    907   }
    908 }
    909 
    910 void GlobalParams::parseFontDir(GooList *tokens, GooString *fileName, int line) {
    911   if (tokens->getLength() != 2) {
    912     error(-1, "Bad 'fontDir' config file command (%s:%d)",
    913           fileName->getCString(), line);
    914     return;
    915   }
    916   fontDirs->append(((GooString *)tokens->get(1))->copy());
    917 }
    918 
    919 void GlobalParams::parseInitialZoom(GooList *tokens,
    920                                     GooString *fileName, int line) {
    921   if (tokens->getLength() != 2) {
    922     error(-1, "Bad 'initialZoom' config file command (%s:%d)",
    923           fileName->getCString(), line);
    924     return;
    925   }
    926   delete initialZoom;
    927   initialZoom = ((GooString *)tokens->get(1))->copy();
    928 }
    929 
    930 void GlobalParams::parseCommand(char *cmdName, GooString **val,
    931                                 GooList *tokens, GooString *fileName, int line) {
    932   if (tokens->getLength() != 2) {
    933     error(-1, "Bad '%s' config file command (%s:%d)",
    934           cmdName, fileName->getCString(), line);
    935     return;
    936   }
    937   if (*val) {
    938     delete *val;
    939   }
    940   *val = ((GooString *)tokens->get(1))->copy();
    941 }
    942 
    943 void GlobalParams::parseYesNo(char *cmdName, GBool *flag,
    944                               GooList *tokens, GooString *fileName, int line) {
    945   GooString *tok;
    946 
    947   if (tokens->getLength() != 2) {
    948     error(-1, "Bad '%s' config file command (%s:%d)",
    949           cmdName, fileName->getCString(), line);
    950     return;
    951   }
    952   tok = (GooString *)tokens->get(1);
    953   if (!parseYesNo2(tok->getCString(), flag)) {
    954     error(-1, "Bad '%s' config file command (%s:%d)",
    955           cmdName, fileName->getCString(), line);
    956   }
    957746}
    958747
     
    969758
    970759GlobalParams::~GlobalParams() {
    971   GooHashIter *iter;
    972   GooString *key;
    973   GooList *list;
    974 
    975760  freeBuiltinFontTables();
    976761
     
    985770  deleteGooList(toUnicodeDirs, GooString);
    986771  deleteGooHash(displayFonts, DisplayFontParam);
    987   if (psFile) {
    988     delete psFile;
    989   }
     772#ifdef WIN32
     773  delete winFontList;
     774#endif
    990775  deleteGooHash(psFonts, PSFontParam);
    991776  deleteGooList(psNamedFonts16, PSFontParam);
     
    993778  delete textEncoding;
    994779  deleteGooList(fontDirs, GooString);
    995   delete initialZoom;
    996   if (urlCommand) {
    997     delete urlCommand;
    998   }
    999   if (movieCommand) {
    1000     delete movieCommand;
    1001   }
    1002 
     780
     781  GooHashIter *iter;
     782  GooString *key;
    1003783  cMapDirs->startIter(&iter);
    1004   while (cMapDirs->getNext(&iter, &key, (void **)&list)) {
     784  void *val;
     785  while (cMapDirs->getNext(&iter, &key, &val)) {
     786    GooList* list = (GooList*)val;
    1005787    deleteGooList(list, GooString);
    1006788  }
     
    1144926}
    1145927
     928#ifndef _MSC_VER
    1146929static FcPattern *buildFcPattern(GfxFont *font)
    1147930{
    1148   int weight = FC_WEIGHT_NORMAL,
    1149       slant = FC_SLANT_ROMAN,
    1150       width = FC_WIDTH_NORMAL,
    1151       spacing = FC_PROPORTIONAL;
     931  int weight = -1,
     932      slant = -1,
     933      width = -1,
     934      spacing = -1;
    1152935  bool deleteFamily = false;
    1153936  char *family, *name, *lang, *modifiers;
     
    12731056  else lang = "xx";
    12741057 
     1058  /*p = FcPatternBuild(NULL,
     1059                    FC_FAMILY, FcTypeString, family,
     1060                    FC_LANG, FcTypeString, lang,
     1061                    NULL);
     1062  if (slant != -1) FcPatternAddInteger(p, FC_SLANT, slant);
     1063  if (weight != -1) FcPatternAddInteger(p, FC_WEIGHT, weight);
     1064  if (width != -1) FcPatternAddInteger(p, FC_WIDTH, width);
     1065  if (spacing != -1) FcPatternAddInteger(p, FC_SPACING, spacing);*/
     1066 
    12751067  p = FcPatternBuild(NULL,
    12761068                    FC_FAMILY, FcTypeString, family,
     
    12811073                    FC_LANG, FcTypeString, lang,
    12821074                    NULL);
     1075 
    12831076  if (deleteFamily)
    12841077    delete[] family;
    12851078  return p;
    12861079}
    1287 
     1080#endif
     1081
     1082/* if you can't or don't want to use Fontconfig, you need to implement
     1083   this function for your platform. For Windows, it's in GlobalParamsWin.cc
     1084*/
     1085#ifndef _MSC_VER
    12881086DisplayFontParam *GlobalParams::getDisplayFont(GfxFont *font) {
    12891087  DisplayFontParam *dfp;
     
    12941092 
    12951093  lockGlobalParams;
    1296   dfp = (DisplayFontParam *)displayFonts->lookup(fontName);
     1094  dfp = font->dfp;
    12971095  if (!dfp)
    12981096  {
     
    13321130      else
    13331131        continue;
    1334       displayFonts->add(dfp->name,dfp);
     1132      font->dfp = dfp;
    13351133      break;
    13361134    }
     
    13441142  return dfp;
    13451143}
    1346 
    1347 GooString *GlobalParams::getPSFile() {
    1348   GooString *s;
    1349 
    1350   lockGlobalParams;
    1351   s = psFile ? psFile->copy() : (GooString *)NULL;
    1352   unlockGlobalParams;
    1353   return s;
    1354 }
    1355 
    1356 int GlobalParams::getPSPaperWidth() {
    1357   int w;
    1358 
    1359   lockGlobalParams;
    1360   w = psPaperWidth;
    1361   unlockGlobalParams;
    1362   return w;
    1363 }
    1364 
    1365 int GlobalParams::getPSPaperHeight() {
    1366   int h;
    1367 
    1368   lockGlobalParams;
    1369   h = psPaperHeight;
    1370   unlockGlobalParams;
    1371   return h;
    1372 }
    1373 
    1374 void GlobalParams::getPSImageableArea(int *llx, int *lly, int *urx, int *ury) {
    1375   lockGlobalParams;
    1376   *llx = psImageableLLX;
    1377   *lly = psImageableLLY;
    1378   *urx = psImageableURX;
    1379   *ury = psImageableURY;
    1380   unlockGlobalParams;
    1381 }
    1382 
    1383 GBool GlobalParams::getPSCrop() {
    1384   GBool f;
    1385 
    1386   lockGlobalParams;
    1387   f = psCrop;
    1388   unlockGlobalParams;
    1389   return f;
    1390 }
     1144#endif
    13911145
    13921146GBool GlobalParams::getPSExpandSmaller() {
     
    14151169  unlockGlobalParams;
    14161170  return f;
    1417 }
    1418 
    1419 GBool GlobalParams::getPSDuplex() {
    1420   GBool d;
    1421 
    1422   lockGlobalParams;
    1423   d = psDuplex;
    1424   unlockGlobalParams;
    1425   return d;
    14261171}
    14271172
     
    15091254  unlockGlobalParams;
    15101255  return e;
     1256}
     1257
     1258GBool GlobalParams::getPSPreload() {
     1259  GBool preload;
     1260
     1261  lockGlobalParams;
     1262  preload = psPreload;
     1263  unlockGlobalParams;
     1264  return preload;
    15111265}
    15121266
     
    15891343}
    15901344
    1591 GooString *GlobalParams::getInitialZoom() {
    1592   GooString *s;
    1593 
    1594   lockGlobalParams;
    1595   s = initialZoom->copy();
    1596   unlockGlobalParams;
    1597   return s;
    1598 }
    1599 
    1600 GBool GlobalParams::getContinuousView() {
    1601   GBool f;
    1602 
    1603   lockGlobalParams;
    1604   f = continuousView;
    1605   unlockGlobalParams;
    1606   return f;
    1607 }
    1608 
    1609 GBool GlobalParams::getEnableT1lib() {
    1610   GBool f;
    1611 
    1612   lockGlobalParams;
    1613   f = enableT1lib;
    1614   unlockGlobalParams;
    1615   return f;
    1616 }
    1617 
    16181345GBool GlobalParams::getEnableFreeType() {
    16191346  GBool f;
     
    16351362}
    16361363
     1364GBool GlobalParams::getVectorAntialias() {
     1365  GBool f;
     1366
     1367  lockGlobalParams;
     1368  f = vectorAntialias;
     1369  unlockGlobalParams;
     1370  return f;
     1371}
     1372
     1373GBool GlobalParams::getStrokeAdjust() {
     1374  GBool f;
     1375
     1376  lockGlobalParams;
     1377  f = strokeAdjust;
     1378  unlockGlobalParams;
     1379  return f;
     1380}
     1381
     1382ScreenType GlobalParams::getScreenType() {
     1383  ScreenType t;
     1384
     1385  lockGlobalParams;
     1386  t = screenType;
     1387  unlockGlobalParams;
     1388  return t;
     1389}
     1390
     1391int GlobalParams::getScreenSize() {
     1392  int size;
     1393
     1394  lockGlobalParams;
     1395  size = screenSize;
     1396  unlockGlobalParams;
     1397  return size;
     1398}
     1399
     1400int GlobalParams::getScreenDotRadius() {
     1401  int r;
     1402
     1403  lockGlobalParams;
     1404  r = screenDotRadius;
     1405  unlockGlobalParams;
     1406  return r;
     1407}
     1408
     1409double GlobalParams::getScreenGamma() {
     1410  double gamma;
     1411
     1412  lockGlobalParams;
     1413  gamma = screenGamma;
     1414  unlockGlobalParams;
     1415  return gamma;
     1416}
     1417
     1418double GlobalParams::getScreenBlackThreshold() {
     1419  double thresh;
     1420
     1421  lockGlobalParams;
     1422  thresh = screenBlackThreshold;
     1423  unlockGlobalParams;
     1424  return thresh;
     1425}
     1426
     1427double GlobalParams::getScreenWhiteThreshold() {
     1428  double thresh;
     1429
     1430  lockGlobalParams;
     1431  thresh = screenWhiteThreshold;
     1432  unlockGlobalParams;
     1433  return thresh;
     1434}
     1435
    16371436GBool GlobalParams::getMapNumericCharNames() {
    16381437  GBool map;
     
    16441443}
    16451444
     1445GBool GlobalParams::getMapUnknownCharNames() {
     1446  GBool map;
     1447
     1448  lockGlobalParams;
     1449  map = mapUnknownCharNames;
     1450  unlockGlobalParams;
     1451  return map;
     1452}
     1453
    16461454GBool GlobalParams::getPrintCommands() {
    16471455  GBool p;
     
    16631471
    16641472GBool GlobalParams::getErrQuiet() {
    1665   GBool q;
    1666 
    1667   lockGlobalParams;
    1668   q = errQuiet;
    1669   unlockGlobalParams;
    1670   return q;
     1473  // no locking -- this function may get called from inside a locked
     1474  // section
     1475  return errQuiet;
    16711476}
    16721477
     
    16871492
    16881493CharCodeToUnicode *GlobalParams::getUnicodeToUnicode(GooString *fontName) {
    1689   CharCodeToUnicode *ctu;
     1494  lockGlobalParams;
    16901495  GooHashIter *iter;
    1691   GooString *fontPattern, *fileName;
    1692 
    1693   lockGlobalParams;
    1694   fileName = NULL;
    16951496  unicodeToUnicodes->startIter(&iter);
    1696   while (unicodeToUnicodes->getNext(&iter, &fontPattern, (void **)&fileName)) {
     1497  GooString *fileName = NULL;
     1498  GooString *fontPattern;
     1499  void *val;
     1500  while (!fileName && unicodeToUnicodes->getNext(&iter, &fontPattern, &val)) {
    16971501    if (strstr(fontName->getCString(), fontPattern->getCString())) {
    16981502      unicodeToUnicodes->killIter(&iter);
    1699       break;
    1700     }
    1701     fileName = NULL;
    1702   }
     1503      fileName = (GooString*)val;
     1504    }
     1505  }
     1506  CharCodeToUnicode *ctu = NULL;
    17031507  if (fileName) {
    1704     if (!(ctu = unicodeToUnicodeCache->getCharCodeToUnicode(fileName))) {
    1705       if ((ctu = CharCodeToUnicode::parseUnicodeToUnicode(fileName))) {
    1706         unicodeToUnicodeCache->add(ctu);
    1707       }
    1708     }
    1709   } else {
    1710     ctu = NULL;
     1508    ctu = unicodeToUnicodeCache->getCharCodeToUnicode(fileName);
     1509    if (!ctu) {
     1510      ctu = CharCodeToUnicode::parseUnicodeToUnicode(fileName);
     1511      if (ctu)
     1512         unicodeToUnicodeCache->add(ctu);
     1513    }
    17111514  }
    17121515  unlockGlobalParams;
     
    17461549//------------------------------------------------------------------------
    17471550
    1748 void GlobalParams::setPSFile(char *file) {
    1749   lockGlobalParams;
    1750   if (psFile) {
    1751     delete psFile;
    1752   }
    1753   psFile = new GooString(file);
    1754   unlockGlobalParams;
    1755 }
    1756 
    1757 GBool GlobalParams::setPSPaperSize(char *size) {
    1758   lockGlobalParams;
    1759   if (!strcmp(size, "match")) {
    1760     psPaperWidth = psPaperHeight = -1;
    1761   } else if (!strcmp(size, "letter")) {
    1762     psPaperWidth = 612;
    1763     psPaperHeight = 792;
    1764   } else if (!strcmp(size, "legal")) {
    1765     psPaperWidth = 612;
    1766     psPaperHeight = 1008;
    1767   } else if (!strcmp(size, "A4")) {
    1768     psPaperWidth = 595;
    1769     psPaperHeight = 842;
    1770   } else if (!strcmp(size, "A3")) {
    1771     psPaperWidth = 842;
    1772     psPaperHeight = 1190;
    1773   } else {
    1774     unlockGlobalParams;
    1775     return gFalse;
    1776   }
    1777   psImageableLLX = psImageableLLY = 0;
    1778   psImageableURX = psPaperWidth;
    1779   psImageableURY = psPaperHeight;
    1780   unlockGlobalParams;
    1781   return gTrue;
    1782 }
    1783 
    1784 void GlobalParams::setPSPaperWidth(int width) {
    1785   lockGlobalParams;
    1786   psPaperWidth = width;
    1787   psImageableLLX = 0;
    1788   psImageableURX = psPaperWidth;
    1789   unlockGlobalParams;
    1790 }
    1791 
    1792 void GlobalParams::setPSPaperHeight(int height) {
    1793   lockGlobalParams;
    1794   psPaperHeight = height;
    1795   psImageableLLY = 0;
    1796   psImageableURY = psPaperHeight;
    1797   unlockGlobalParams;
    1798 }
    1799 
    1800 void GlobalParams::setPSImageableArea(int llx, int lly, int urx, int ury) {
    1801   lockGlobalParams;
    1802   psImageableLLX = llx;
    1803   psImageableLLY = lly;
    1804   psImageableURX = urx;
    1805   psImageableURY = ury;
    1806   unlockGlobalParams;
    1807 }
    1808 
    1809 void GlobalParams::setPSCrop(GBool crop) {
    1810   lockGlobalParams;
    1811   psCrop = crop;
    1812   unlockGlobalParams;
    1813 }
    1814 
    18151551void GlobalParams::setPSExpandSmaller(GBool expand) {
    18161552  lockGlobalParams;
     
    18311567}
    18321568
    1833 void GlobalParams::setPSDuplex(GBool duplex) {
    1834   lockGlobalParams;
    1835   psDuplex = duplex;
    1836   unlockGlobalParams;
    1837 }
    1838 
    18391569void GlobalParams::setPSLevel(PSLevel level) {
    18401570  lockGlobalParams;
     
    18641594  lockGlobalParams;
    18651595  psEmbedCIDTrueType = embed;
     1596  unlockGlobalParams;
     1597}
     1598
     1599void GlobalParams::setPSPreload(GBool preload) {
     1600  lockGlobalParams;
     1601  psPreload = preload;
    18661602  unlockGlobalParams;
    18671603}
     
    19141650}
    19151651
    1916 void GlobalParams::setInitialZoom(char *s) {
    1917   lockGlobalParams;
    1918   delete initialZoom;
    1919   initialZoom = new GooString(s);
    1920   unlockGlobalParams;
    1921 }
    1922 
    1923 void GlobalParams::setContinuousView(GBool cont) {
    1924   lockGlobalParams;
    1925   continuousView = cont;
    1926   unlockGlobalParams;
    1927 }
    1928 
    1929 GBool GlobalParams::setEnableT1lib(char *s) {
    1930   GBool ok;
    1931 
    1932   lockGlobalParams;
    1933   ok = parseYesNo2(s, &enableT1lib);
    1934   unlockGlobalParams;
    1935   return ok;
    1936 }
    1937 
    19381652GBool GlobalParams::setEnableFreeType(char *s) {
    19391653  GBool ok;
     
    19551669}
    19561670
     1671GBool GlobalParams::setVectorAntialias(char *s) {
     1672  GBool ok;
     1673
     1674  lockGlobalParams;
     1675  ok = parseYesNo2(s, &vectorAntialias);
     1676  unlockGlobalParams;
     1677  return ok;
     1678}
     1679
     1680void GlobalParams::setStrokeAdjust(GBool adjust)
     1681{
     1682  lockGlobalParams;
     1683  strokeAdjust = adjust;
     1684  unlockGlobalParams;
     1685}
     1686
     1687void GlobalParams::setScreenType(ScreenType st)
     1688{
     1689  lockGlobalParams;
     1690  screenType = st;
     1691  unlockGlobalParams;
     1692}
     1693
     1694void GlobalParams::setScreenSize(int size)
     1695{
     1696  lockGlobalParams;
     1697  screenSize = size;
     1698  unlockGlobalParams;
     1699}
     1700
     1701void GlobalParams::setScreenDotRadius(int radius)
     1702{
     1703  lockGlobalParams;
     1704  screenDotRadius = radius;
     1705  unlockGlobalParams;
     1706}
     1707
     1708void GlobalParams::setScreenGamma(double gamma)
     1709{
     1710  lockGlobalParams;
     1711  screenGamma = gamma;
     1712  unlockGlobalParams;
     1713}
     1714
     1715void GlobalParams::setScreenBlackThreshold(double blackThreshold)
     1716{
     1717  lockGlobalParams;
     1718  screenBlackThreshold = blackThreshold;
     1719  unlockGlobalParams;
     1720}
     1721
     1722void GlobalParams::setScreenWhiteThreshold(double whiteThreshold)
     1723{
     1724  lockGlobalParams;
     1725  screenWhiteThreshold = whiteThreshold;
     1726  unlockGlobalParams;
     1727}
     1728
    19571729void GlobalParams::setMapNumericCharNames(GBool map) {
    19581730  lockGlobalParams;
    19591731  mapNumericCharNames = map;
     1732  unlockGlobalParams;
     1733}
     1734
     1735void GlobalParams::setMapUnknownCharNames(GBool map) {
     1736  lockGlobalParams;
     1737  mapUnknownCharNames = map;
    19601738  unlockGlobalParams;
    19611739}
     
    19951773  for (i = 0; i < securityHandlers->getLength(); ++i) {
    19961774    hdlr = (XpdfSecurityHandler *)securityHandlers->get(i);
    1997     if (!stricmp(hdlr->name, name)) {
     1775    if (!strcasecmp(hdlr->name, name)) {
    19981776      unlockGlobalParams;
    19991777      return hdlr;
     
    20051783    return NULL;
    20061784  }
     1785  deleteGooList(keyBindings, KeyBinding);
    20071786
    20081787  lockGlobalParams;
     
    20151794  }
    20161795  unlockGlobalParams;
     1796#else
     1797  (void)name;
    20171798#endif
    20181799
Note: See TracChangeset for help on using the changeset viewer.