Server : Apache/2.4.41 (Ubuntu) System : Linux absol.cf 5.4.0-198-generic #218-Ubuntu SMP Fri Sep 27 20:18:53 UTC 2024 x86_64 User : www-data ( 33) PHP Version : 7.4.33 Disable Function : pcntl_alarm,pcntl_fork,pcntl_waitpid,pcntl_wait,pcntl_wifexited,pcntl_wifstopped,pcntl_wifsignaled,pcntl_wifcontinued,pcntl_wexitstatus,pcntl_wtermsig,pcntl_wstopsig,pcntl_signal,pcntl_signal_get_handler,pcntl_signal_dispatch,pcntl_get_last_error,pcntl_strerror,pcntl_sigprocmask,pcntl_sigwaitinfo,pcntl_sigtimedwait,pcntl_exec,pcntl_getpriority,pcntl_setpriority,pcntl_async_signals,pcntl_unshare, Directory : /usr/share/emscripten/tests/poppler/poppler/
Upload File :
Current File : //usr/share/emscripten/tests/poppler/poppler/GlobalParams.cc
//========================================================================
//
// GlobalParams.cc
//
// Copyright 2001-2003 Glyph & Cog, LLC
//
//========================================================================
//========================================================================
//
// Modified under the Poppler project - http://poppler.freedesktop.org
//
// Copyright (C) 2005 Martin Kretzschmar <martink@gnome.org>
// Copyright (C) 2005, 2006 Kristian Høgsberg <krh@redhat.com>
// Copyright (C) 2005, 2007-2010 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2005 Jonathan Blandford <jrb@redhat.com>
// Copyright (C) 2006, 2007 Jeff Muizelaar <jeff@infidigm.net>
// Copyright (C) 2006 Takashi Iwai <tiwai@suse.de>
// Copyright (C) 2006 Ed Catmur <ed@catmur.co.uk>
// Copyright (C) 2007 Krzysztof Kowalczyk <kkowalczyk@gmail.com>
// Copyright (C) 2007, 2009 Jonathan Kew <jonathan_kew@sil.org>
// Copyright (C) 2009 Petr Gajdos <pgajdos@novell.com>
// Copyright (C) 2009 William Bader <williambader@hotmail.com>
// Copyright (C) 2009 Kovid Goyal <kovid@kovidgoyal.net>
// Copyright (C) 2010 Hib Eris <hib@hiberis.nl>
// Copyright (C) 2010 Patrick Spendrin <ps_ml@gmx.de>
// Copyright (C) 2010 Jakub Wilk <ubanus@users.sf.net>
//
// To see a description of the changes please see the Changelog file that
// came with your tarball or type make ChangeLog if you are building from git
//
//========================================================================
#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>
# include <mbstring.h>
#endif
#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 "BuiltinFontTables.h"
#include "FontEncodingTables.h"
#ifdef ENABLE_PLUGINS
# include "XpdfPluginAPI.h"
#endif
#include "GlobalParams.h"
#include "GfxFont.h"
#ifdef _WIN32
# define strcasecmp stricmp
#else
# include <strings.h>
#endif
#if MULTITHREADED
# define lockGlobalParams gLockMutex(&mutex)
# define lockUnicodeMapCache gLockMutex(&unicodeMapCacheMutex)
# define lockCMapCache gLockMutex(&cMapCacheMutex)
# define unlockGlobalParams gUnlockMutex(&mutex)
# define unlockUnicodeMapCache gUnlockMutex(&unicodeMapCacheMutex)
# define unlockCMapCache gUnlockMutex(&cMapCacheMutex)
#else
# define lockGlobalParams
# define lockUnicodeMapCache
# define lockCMapCache
# define unlockGlobalParams
# 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
//------------------------------------------------------------------------
GlobalParams *globalParams = 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;
}
}
#if ENABLE_RELOCATABLE && defined(_WIN32)
/* search for data relative to where we are installed */
static HMODULE hmodule;
extern "C" {
BOOL WINAPI
DllMain (HINSTANCE hinstDLL,
DWORD fdwReason,
LPVOID lpvReserved)
{
switch (fdwReason)
{
case DLL_PROCESS_ATTACH:
hmodule = hinstDLL;
break;
}
return TRUE;
}
}
static char *
get_poppler_datadir (void)
{
static char retval[MAX_PATH];
static int beenhere = 0;
unsigned char *p;
if (beenhere)
return retval;
if (!GetModuleFileName (hmodule, (CHAR *) retval, sizeof(retval) - 20))
return POPPLER_DATADIR;
p = _mbsrchr ((unsigned char *) retval, '\\');
*p = '\0';
p = _mbsrchr ((unsigned char *) retval, '\\');
if (p) {
if (stricmp ((const char *) (p+1), "bin") == 0)
*p = '\0';
}
strcat (retval, "\\share\\poppler");
beenhere = 1;
return retval;
}
#undef POPPLER_DATADIR
#define POPPLER_DATADIR get_poppler_datadir ()
#endif
#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,
®Key) == 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;
}
}
#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 = globalParams->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
//------------------------------------------------------------------------
GlobalParams::GlobalParams(const char *customPopplerDataDir)
: popplerDataDir(customPopplerDataDir)
{
UnicodeMap *map;
int i;
#if MULTITHREADED
gInitMutex(&mutex);
gInitMutex(&unicodeMapCacheMutex);
gInitMutex(&cMapCacheMutex);
#endif
initBuiltinFontTables();
// 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();
psExpandSmaller = gFalse;
psShrinkLarger = gTrue;
psCenter = gTrue;
psLevel = psLevel2;
psFonts = new GooHash();
psNamedFonts16 = new GooList();
psFonts16 = new GooList();
psEmbedType1 = gTrue;
psEmbedTrueType = gTrue;
psEmbedCIDPostScript = gTrue;
psEmbedCIDTrueType = gTrue;
psSubstFonts = gTrue;
psPreload = gFalse;
psOPI = gFalse;
psASCIIHex = gFalse;
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();
enableFreeType = gTrue;
antialias = gTrue;
vectorAntialias = gTrue;
strokeAdjust = gTrue;
screenType = screenUnset;
screenSize = -1;
screenDotRadius = -1;
screenGamma = 1.0;
screenBlackThreshold = 0.0;
screenWhiteThreshold = 1.0;
mapNumericCharNames = gTrue;
mapUnknownCharNames = gFalse;
printCommands = gFalse;
profileCommands = gFalse;
errQuiet = gFalse;
cidToUnicodeCache = new CharCodeToUnicodeCache(cidToUnicodeCacheSize);
unicodeToUnicodeCache =
new CharCodeToUnicodeCache(unicodeToUnicodeCacheSize);
unicodeMapCache = new UnicodeMapCache();
cMapCache = new CMapCache();
#ifdef _WIN32
baseFontsInitialized = gFalse;
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);
scanEncodingDirs();
}
void GlobalParams::scanEncodingDirs() {
GDir *dir;
GDirEntry *entry;
const char *dataRoot = popplerDataDir ? popplerDataDir : POPPLER_DATADIR;
// allocate buffer large enough to append "/nameToUnicode"
size_t bufSize = strlen(dataRoot) + strlen("/nameToUnicode") + 1;
char *dataPathBuffer = new char[bufSize];
snprintf(dataPathBuffer, bufSize, "%s/nameToUnicode", dataRoot);
dir = new GDir(dataPathBuffer, gTrue);
while (entry = dir->getNextEntry(), entry != NULL) {
if (!entry->isDir()) {
parseNameToUnicode(entry->getFullPath());
}
delete entry;
}
delete dir;
snprintf(dataPathBuffer, bufSize, "%s/cidToUnicode", dataRoot);
dir = new GDir(dataPathBuffer, gFalse);
while (entry = dir->getNextEntry(), entry != NULL) {
addCIDToUnicode(entry->getName(), entry->getFullPath());
delete entry;
}
delete dir;
snprintf(dataPathBuffer, bufSize, "%s/unicodeMap", dataRoot);
dir = new GDir(dataPathBuffer, gFalse);
while (entry = dir->getNextEntry(), entry != NULL) {
addUnicodeMap(entry->getName(), entry->getFullPath());
delete entry;
}
delete dir;
snprintf(dataPathBuffer, bufSize, "%s/cMap", dataRoot);
dir = new GDir(dataPathBuffer, gFalse);
while (entry = dir->getNextEntry(), entry != NULL) {
addCMapDir(entry->getName(), entry->getFullPath());
toUnicodeDirs->append(entry->getFullPath()->copy());
delete entry;
}
delete dir;
delete[] dataPathBuffer;
}
void GlobalParams::parseNameToUnicode(GooString *name) {
char *tok1, *tok2;
FILE *f;
char buf[256];
int line;
Unicode u;
char *tokptr;
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_r(buf, " \t\r\n", &tokptr);
tok2 = strtok_r(NULL, " \t\r\n", &tokptr);
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 GlobalParams::addCIDToUnicode(GooString *collection,
GooString *fileName) {
GooString *old;
if ((old = (GooString *)cidToUnicodes->remove(collection))) {
delete old;
}
cidToUnicodes->add(collection->copy(), fileName->copy());
}
void GlobalParams::addUnicodeMap(GooString *encodingName, GooString *fileName)
{
GooString *old;
if ((old = (GooString *)unicodeMaps->remove(encodingName))) {
delete old;
}
unicodeMaps->add(encodingName->copy(), fileName->copy());
}
void GlobalParams::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());
}
GBool GlobalParams::parseYesNo2(char *token, GBool *flag) {
if (!strcmp(token, "yes")) {
*flag = gTrue;
} else if (!strcmp(token, "no")) {
*flag = gFalse;
} else {
return gFalse;
}
return gTrue;
}
GlobalParams::~GlobalParams() {
freeBuiltinFontTables();
delete macRomanReverseMap;
delete baseDir;
delete nameToUnicode;
deleteGooHash(cidToUnicodes, GooString);
deleteGooHash(unicodeToUnicodes, GooString);
deleteGooHash(residentUnicodeMaps, UnicodeMap);
deleteGooHash(unicodeMaps, GooString);
deleteGooList(toUnicodeDirs, GooString);
deleteGooHash(displayFonts, DisplayFontParam);
#ifdef _WIN32
delete winFontList;
#endif
deleteGooHash(psFonts, PSFontParam);
deleteGooList(psNamedFonts16, PSFontParam);
deleteGooList(psFonts16, PSFontParam);
delete textEncoding;
deleteGooList(fontDirs, GooString);
GooHashIter *iter;
GooString *key;
cMapDirs->startIter(&iter);
void *val;
while (cMapDirs->getNext(&iter, &key, &val)) {
GooList* list = (GooList*)val;
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 GlobalParams::setBaseDir(char *dir) {
delete baseDir;
baseDir = new GooString(dir);
}
//------------------------------------------------------------------------
// accessors
//------------------------------------------------------------------------
CharCode GlobalParams::getMacRomanCharCode(char *charName) {
// no need to lock - macRomanReverseMap is constant
return macRomanReverseMap->lookup(charName);
}
GooString *GlobalParams::getBaseDir() {
GooString *s;
lockGlobalParams;
s = baseDir->copy();
unlockGlobalParams;
return s;
}
Unicode GlobalParams::mapNameToUnicode(char *charName) {
// no need to lock - nameToUnicode is constant
return nameToUnicode->lookup(charName);
}
UnicodeMap *GlobalParams::getResidentUnicodeMap(GooString *encodingName) {
UnicodeMap *map;
lockGlobalParams;
map = (UnicodeMap *)residentUnicodeMaps->lookup(encodingName);
unlockGlobalParams;
if (map) {
map->incRefCnt();
}
return map;
}
FILE *GlobalParams::getUnicodeMapFile(GooString *encodingName) {
GooString *fileName;
FILE *f;
lockGlobalParams;
if ((fileName = (GooString *)unicodeMaps->lookup(encodingName))) {
f = fopen(fileName->getCString(), "r");
} else {
f = NULL;
}
unlockGlobalParams;
return f;
}
FILE *GlobalParams::findCMapFile(GooString *collection, GooString *cMapName) {
GooList *list;
GooString *dir;
GooString *fileName;
FILE *f;
int i;
lockGlobalParams;
if (!(list = (GooList *)cMapDirs->lookup(collection))) {
unlockGlobalParams;
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) {
unlockGlobalParams;
return f;
}
}
unlockGlobalParams;
return NULL;
}
FILE *GlobalParams::findToUnicodeFile(GooString *name) {
GooString *dir, *fileName;
FILE *f;
int i;
lockGlobalParams;
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) {
unlockGlobalParams;
return f;
}
}
unlockGlobalParams;
return NULL;
}
#if WITH_FONTCONFIGURATION_FONTCONFIG
static 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 = -1,
slant = -1,
width = -1,
spacing = -1;
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_LANG, FcTypeString, lang,
NULL);
if (slant != -1) FcPatternAddInteger(p, FC_SLANT, slant);
if (weight != -1) FcPatternAddInteger(p, FC_WEIGHT, weight);
if (width != -1) FcPatternAddInteger(p, FC_WIDTH, width);
if (spacing != -1) FcPatternAddInteger(p, FC_SPACING, spacing);
if (deleteFamily)
delete[] family;
return p;
}
#endif
/* if you can't or don't want to use Fontconfig, you need to implement
this function for your platform. For Windows, it's in GlobalParamsWin.cc
*/
#if WITH_FONTCONFIGURATION_FONTCONFIG
DisplayFontParam *GlobalParams::getDisplayFont(GfxFont *font) {
DisplayFontParam *dfp;
FcPattern *p=0;
GooString *fontName = font->getName();
if (!fontName) return NULL;
lockGlobalParams;
dfp = font->dfp;
if (!dfp)
{
FcChar8* s;
char * ext;
FcResult res;
FcFontSet *set;
int i;
p = buildFcPattern(font);
if (!p)
goto fin;
FcConfigSubstitute(NULL, p, FcMatchPattern);
FcDefaultSubstitute(p);
set = FcFontSort(NULL, 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);
unlockGlobalParams;
return dfp;
}
#endif
#if WITH_FONTCONFIGURATION_WIN32
#include "GlobalParamsWin.cc"
#endif
GBool GlobalParams::getPSExpandSmaller() {
GBool f;
lockGlobalParams;
f = psExpandSmaller;
unlockGlobalParams;
return f;
}
GBool GlobalParams::getPSShrinkLarger() {
GBool f;
lockGlobalParams;
f = psShrinkLarger;
unlockGlobalParams;
return f;
}
GBool GlobalParams::getPSCenter() {
GBool f;
lockGlobalParams;
f = psCenter;
unlockGlobalParams;
return f;
}
PSLevel GlobalParams::getPSLevel() {
PSLevel level;
lockGlobalParams;
level = psLevel;
unlockGlobalParams;
return level;
}
PSFontParam *GlobalParams::getPSFont(GooString *fontName) {
PSFontParam *p;
lockGlobalParams;
p = (PSFontParam *)psFonts->lookup(fontName);
unlockGlobalParams;
return p;
}
PSFontParam *GlobalParams::getPSFont16(GooString *fontName,
GooString *collection, int wMode) {
PSFontParam *p;
int i;
lockGlobalParams;
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;
}
}
unlockGlobalParams;
return p;
}
GBool GlobalParams::getPSEmbedType1() {
GBool e;
lockGlobalParams;
e = psEmbedType1;
unlockGlobalParams;
return e;
}
GBool GlobalParams::getPSEmbedTrueType() {
GBool e;
lockGlobalParams;
e = psEmbedTrueType;
unlockGlobalParams;
return e;
}
GBool GlobalParams::getPSEmbedCIDPostScript() {
GBool e;
lockGlobalParams;
e = psEmbedCIDPostScript;
unlockGlobalParams;
return e;
}
GBool GlobalParams::getPSEmbedCIDTrueType() {
GBool e;
lockGlobalParams;
e = psEmbedCIDTrueType;
unlockGlobalParams;
return e;
}
GBool GlobalParams::getPSSubstFonts() {
GBool e;
lockGlobalParams;
e = psSubstFonts;
unlockGlobalParams;
return e;
}
GBool GlobalParams::getPSPreload() {
GBool preload;
lockGlobalParams;
preload = psPreload;
unlockGlobalParams;
return preload;
}
GBool GlobalParams::getPSOPI() {
GBool opi;
lockGlobalParams;
opi = psOPI;
unlockGlobalParams;
return opi;
}
GBool GlobalParams::getPSASCIIHex() {
GBool ah;
lockGlobalParams;
ah = psASCIIHex;
unlockGlobalParams;
return ah;
}
GooString *GlobalParams::getTextEncodingName() {
GooString *s;
lockGlobalParams;
s = textEncoding->copy();
unlockGlobalParams;
return s;
}
EndOfLineKind GlobalParams::getTextEOL() {
EndOfLineKind eol;
lockGlobalParams;
eol = textEOL;
unlockGlobalParams;
return eol;
}
GBool GlobalParams::getTextPageBreaks() {
GBool pageBreaks;
lockGlobalParams;
pageBreaks = textPageBreaks;
unlockGlobalParams;
return pageBreaks;
}
GBool GlobalParams::getTextKeepTinyChars() {
GBool tiny;
lockGlobalParams;
tiny = textKeepTinyChars;
unlockGlobalParams;
return tiny;
}
GooString *GlobalParams::findFontFile(GooString *fontName, char **exts) {
GooString *dir, *fileName;
char **ext;
FILE *f;
int i;
lockGlobalParams;
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);
unlockGlobalParams;
return fileName;
}
delete fileName;
}
}
unlockGlobalParams;
return NULL;
}
GBool GlobalParams::getEnableFreeType() {
GBool f;
lockGlobalParams;
f = enableFreeType;
unlockGlobalParams;
return f;
}
GBool GlobalParams::getAntialias() {
GBool f;
lockGlobalParams;
f = antialias;
unlockGlobalParams;
return f;
}
GBool GlobalParams::getVectorAntialias() {
GBool f;
lockGlobalParams;
f = vectorAntialias;
unlockGlobalParams;
return f;
}
GBool GlobalParams::getStrokeAdjust() {
GBool f;
lockGlobalParams;
f = strokeAdjust;
unlockGlobalParams;
return f;
}
ScreenType GlobalParams::getScreenType() {
ScreenType t;
lockGlobalParams;
t = screenType;
unlockGlobalParams;
return t;
}
int GlobalParams::getScreenSize() {
int size;
lockGlobalParams;
size = screenSize;
unlockGlobalParams;
return size;
}
int GlobalParams::getScreenDotRadius() {
int r;
lockGlobalParams;
r = screenDotRadius;
unlockGlobalParams;
return r;
}
double GlobalParams::getScreenGamma() {
double gamma;
lockGlobalParams;
gamma = screenGamma;
unlockGlobalParams;
return gamma;
}
double GlobalParams::getScreenBlackThreshold() {
double thresh;
lockGlobalParams;
thresh = screenBlackThreshold;
unlockGlobalParams;
return thresh;
}
double GlobalParams::getScreenWhiteThreshold() {
double thresh;
lockGlobalParams;
thresh = screenWhiteThreshold;
unlockGlobalParams;
return thresh;
}
GBool GlobalParams::getMapNumericCharNames() {
GBool map;
lockGlobalParams;
map = mapNumericCharNames;
unlockGlobalParams;
return map;
}
GBool GlobalParams::getMapUnknownCharNames() {
GBool map;
lockGlobalParams;
map = mapUnknownCharNames;
unlockGlobalParams;
return map;
}
GBool GlobalParams::getPrintCommands() {
GBool p;
lockGlobalParams;
p = printCommands;
unlockGlobalParams;
return p;
}
GBool GlobalParams::getProfileCommands() {
GBool p;
lockGlobalParams;
p = profileCommands;
unlockGlobalParams;
return p;
}
GBool GlobalParams::getErrQuiet() {
// no locking -- this function may get called from inside a locked
// section
return errQuiet;
}
CharCodeToUnicode *GlobalParams::getCIDToUnicode(GooString *collection) {
GooString *fileName;
CharCodeToUnicode *ctu;
lockGlobalParams;
if (!(ctu = cidToUnicodeCache->getCharCodeToUnicode(collection))) {
if ((fileName = (GooString *)cidToUnicodes->lookup(collection)) &&
(ctu = CharCodeToUnicode::parseCIDToUnicode(fileName, collection))) {
cidToUnicodeCache->add(ctu);
}
}
unlockGlobalParams;
return ctu;
}
CharCodeToUnicode *GlobalParams::getUnicodeToUnicode(GooString *fontName) {
lockGlobalParams;
GooHashIter *iter;
unicodeToUnicodes->startIter(&iter);
GooString *fileName = NULL;
GooString *fontPattern;
void *val;
while (!fileName && unicodeToUnicodes->getNext(&iter, &fontPattern, &val)) {
if (strstr(fontName->getCString(), fontPattern->getCString())) {
unicodeToUnicodes->killIter(&iter);
fileName = (GooString*)val;
}
}
CharCodeToUnicode *ctu = NULL;
if (fileName) {
ctu = unicodeToUnicodeCache->getCharCodeToUnicode(fileName);
if (!ctu) {
ctu = CharCodeToUnicode::parseUnicodeToUnicode(fileName);
if (ctu)
unicodeToUnicodeCache->add(ctu);
}
}
unlockGlobalParams;
return ctu;
}
UnicodeMap *GlobalParams::getUnicodeMap(GooString *encodingName) {
return getUnicodeMap2(encodingName);
}
UnicodeMap *GlobalParams::getUnicodeMap2(GooString *encodingName) {
UnicodeMap *map;
if (!(map = getResidentUnicodeMap(encodingName))) {
lockUnicodeMapCache;
map = unicodeMapCache->getUnicodeMap(encodingName);
unlockUnicodeMapCache;
}
return map;
}
CMap *GlobalParams::getCMap(GooString *collection, GooString *cMapName, Stream *stream) {
CMap *cMap;
lockCMapCache;
cMap = cMapCache->getCMap(collection, cMapName, stream);
unlockCMapCache;
return cMap;
}
UnicodeMap *GlobalParams::getTextEncoding() {
return getUnicodeMap2(textEncoding);
}
GooList *GlobalParams::getEncodingNames()
{
GooList *result = new GooList;
GooHashIter *iter;
GooString *key;
void *val;
residentUnicodeMaps->startIter(&iter);
while (residentUnicodeMaps->getNext(&iter, &key, &val)) {
result->append(key);
}
residentUnicodeMaps->killIter(&iter);
unicodeMaps->startIter(&iter);
while (unicodeMaps->getNext(&iter, &key, &val)) {
result->append(key);
}
unicodeMaps->killIter(&iter);
return result;
}
//------------------------------------------------------------------------
// functions to set parameters
//------------------------------------------------------------------------
void GlobalParams::setPSExpandSmaller(GBool expand) {
lockGlobalParams;
psExpandSmaller = expand;
unlockGlobalParams;
}
void GlobalParams::setPSShrinkLarger(GBool shrink) {
lockGlobalParams;
psShrinkLarger = shrink;
unlockGlobalParams;
}
void GlobalParams::setPSCenter(GBool center) {
lockGlobalParams;
psCenter = center;
unlockGlobalParams;
}
void GlobalParams::setPSLevel(PSLevel level) {
lockGlobalParams;
psLevel = level;
unlockGlobalParams;
}
void GlobalParams::setPSEmbedType1(GBool embed) {
lockGlobalParams;
psEmbedType1 = embed;
unlockGlobalParams;
}
void GlobalParams::setPSEmbedTrueType(GBool embed) {
lockGlobalParams;
psEmbedTrueType = embed;
unlockGlobalParams;
}
void GlobalParams::setPSEmbedCIDPostScript(GBool embed) {
lockGlobalParams;
psEmbedCIDPostScript = embed;
unlockGlobalParams;
}
void GlobalParams::setPSEmbedCIDTrueType(GBool embed) {
lockGlobalParams;
psEmbedCIDTrueType = embed;
unlockGlobalParams;
}
void GlobalParams::setPSSubstFonts(GBool substFonts) {
lockGlobalParams;
psSubstFonts = substFonts;
unlockGlobalParams;
}
void GlobalParams::setPSPreload(GBool preload) {
lockGlobalParams;
psPreload = preload;
unlockGlobalParams;
}
void GlobalParams::setPSOPI(GBool opi) {
lockGlobalParams;
psOPI = opi;
unlockGlobalParams;
}
void GlobalParams::setPSASCIIHex(GBool hex) {
lockGlobalParams;
psASCIIHex = hex;
unlockGlobalParams;
}
void GlobalParams::setTextEncoding(char *encodingName) {
lockGlobalParams;
delete textEncoding;
textEncoding = new GooString(encodingName);
unlockGlobalParams;
}
GBool GlobalParams::setTextEOL(char *s) {
lockGlobalParams;
if (!strcmp(s, "unix")) {
textEOL = eolUnix;
} else if (!strcmp(s, "dos")) {
textEOL = eolDOS;
} else if (!strcmp(s, "mac")) {
textEOL = eolMac;
} else {
unlockGlobalParams;
return gFalse;
}
unlockGlobalParams;
return gTrue;
}
void GlobalParams::setTextPageBreaks(GBool pageBreaks) {
lockGlobalParams;
textPageBreaks = pageBreaks;
unlockGlobalParams;
}
void GlobalParams::setTextKeepTinyChars(GBool keep) {
lockGlobalParams;
textKeepTinyChars = keep;
unlockGlobalParams;
}
GBool GlobalParams::setEnableFreeType(char *s) {
GBool ok;
lockGlobalParams;
ok = parseYesNo2(s, &enableFreeType);
unlockGlobalParams;
return ok;
}
GBool GlobalParams::setAntialias(char *s) {
GBool ok;
lockGlobalParams;
ok = parseYesNo2(s, &antialias);
unlockGlobalParams;
return ok;
}
GBool GlobalParams::setVectorAntialias(char *s) {
GBool ok;
lockGlobalParams;
ok = parseYesNo2(s, &vectorAntialias);
unlockGlobalParams;
return ok;
}
void GlobalParams::setStrokeAdjust(GBool adjust)
{
lockGlobalParams;
strokeAdjust = adjust;
unlockGlobalParams;
}
void GlobalParams::setScreenType(ScreenType st)
{
lockGlobalParams;
screenType = st;
unlockGlobalParams;
}
void GlobalParams::setScreenSize(int size)
{
lockGlobalParams;
screenSize = size;
unlockGlobalParams;
}
void GlobalParams::setScreenDotRadius(int radius)
{
lockGlobalParams;
screenDotRadius = radius;
unlockGlobalParams;
}
void GlobalParams::setScreenGamma(double gamma)
{
lockGlobalParams;
screenGamma = gamma;
unlockGlobalParams;
}
void GlobalParams::setScreenBlackThreshold(double blackThreshold)
{
lockGlobalParams;
screenBlackThreshold = blackThreshold;
unlockGlobalParams;
}
void GlobalParams::setScreenWhiteThreshold(double whiteThreshold)
{
lockGlobalParams;
screenWhiteThreshold = whiteThreshold;
unlockGlobalParams;
}
void GlobalParams::setMapNumericCharNames(GBool map) {
lockGlobalParams;
mapNumericCharNames = map;
unlockGlobalParams;
}
void GlobalParams::setMapUnknownCharNames(GBool map) {
lockGlobalParams;
mapUnknownCharNames = map;
unlockGlobalParams;
}
void GlobalParams::setPrintCommands(GBool printCommandsA) {
lockGlobalParams;
printCommands = printCommandsA;
unlockGlobalParams;
}
void GlobalParams::setProfileCommands(GBool profileCommandsA) {
lockGlobalParams;
profileCommands = profileCommandsA;
unlockGlobalParams;
}
void GlobalParams::setErrQuiet(GBool errQuietA) {
lockGlobalParams;
errQuiet = errQuietA;
unlockGlobalParams;
}
void GlobalParams::addSecurityHandler(XpdfSecurityHandler *handler) {
#ifdef ENABLE_PLUGINS
lockGlobalParams;
securityHandlers->append(handler);
unlockGlobalParams;
#endif
}
XpdfSecurityHandler *GlobalParams::getSecurityHandler(char *name) {
#ifdef ENABLE_PLUGINS
XpdfSecurityHandler *hdlr;
int i;
lockGlobalParams;
for (i = 0; i < securityHandlers->getLength(); ++i) {
hdlr = (XpdfSecurityHandler *)securityHandlers->get(i);
if (!strcasecmp(hdlr->name, name)) {
unlockGlobalParams;
return hdlr;
}
}
unlockGlobalParams;
if (!loadPlugin("security", name)) {
return NULL;
}
deleteGooList(keyBindings, KeyBinding);
lockGlobalParams;
for (i = 0; i < securityHandlers->getLength(); ++i) {
hdlr = (XpdfSecurityHandler *)securityHandlers->get(i);
if (!strcmp(hdlr->name, name)) {
unlockGlobalParams;
return hdlr;
}
}
unlockGlobalParams;
#else
(void)name;
#endif
return NULL;
}
#ifdef ENABLE_PLUGINS
//------------------------------------------------------------------------
// plugins
//------------------------------------------------------------------------
GBool GlobalParams::loadPlugin(char *type, char *name) {
Plugin *plugin;
if (!(plugin = Plugin::load(type, name))) {
return gFalse;
}
lockGlobalParams;
plugins->append(plugin);
unlockGlobalParams;
return gTrue;
}
#endif // ENABLE_PLUGINS
Server : Apache/2.4.41 (Ubuntu)