//======================================================================== // // GlobalParams.cc // // Copyright 2001-2003 Glyph & Cog, LLC // //======================================================================== //======================================================================== // // Modified under the Poppler project - http://poppler.freedesktop.org // // Copyright (C) 2005 Martin Kretzschmar // Copyright (C) 2005, 2006 Kristian Høgsberg // Copyright (C) 2005, 2007-2010 Albert Astals Cid // Copyright (C) 2005 Jonathan Blandford // Copyright (C) 2006, 2007 Jeff Muizelaar // Copyright (C) 2006 Takashi Iwai // Copyright (C) 2006 Ed Catmur // Copyright (C) 2007 Krzysztof Kowalczyk // Copyright (C) 2007, 2009 Jonathan Kew // Copyright (C) 2009 Petr Gajdos // Copyright (C) 2009 William Bader // Copyright (C) 2009 Kovid Goyal // Copyright (C) 2010 Hib Eris // Copyright (C) 2010 Patrick Spendrin // Copyright (C) 2010 Jakub Wilk // // 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 #ifdef USE_GCC_PRAGMAS #pragma implementation #endif #include #include #include #ifdef ENABLE_PLUGINS # ifndef _WIN32 # include # endif #endif #ifdef _WIN32 # include # include #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 #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; } 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; } } #if WITH_FONTCONFIGURATION_FONTCONFIG 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