//======================================================================== // // GlobalParams.cc // // Copyright 2001-2003 Glyph & Cog, LLC // //======================================================================== #include #ifdef USE_GCC_PRAGMAS #pragma implementation #endif #include #include // KPDF: additional includes for Qt and Xft #include #include #include // -- gentoo compile fix (XFree 4.3.0, FC 2.2.3, FreeType 2.1.9) -- // on other distros these 2 lines should't harm #include #include FT_FREETYPE_H // -- ---------------------------------------------------------- -- #include #include #include #include #include #include #ifdef ENABLE_PLUGINS # ifndef WIN32 # include # endif #endif #ifdef WIN32 # include #endif #if HAVE_PAPER_H #include #endif #include "gmem.h" #include "GString.h" #include "GList.h" #include "GHash.h" #include "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 #include #include #ifdef WIN32 # define strcasecmp stricmp #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 #include "NameToUnicodeTable.h" #include "UnicodeMapTables.h" #include "UTF8.h" #ifdef ENABLE_PLUGINS # ifdef WIN32 extern XpdfPluginVecTable xpdfPluginVecTable; # endif #endif //------------------------------------------------------------------------ #define cidToUnicodeCacheSize 4 #define unicodeToUnicodeCacheSize 4 //------------------------------------------------------------------------ static struct { char *name; char *t1FileName; char *ttFileName; } displayFontTab[] = { {"Courier", "n022003l.pfb", "cour.ttf"}, {"Courier-Bold", "n022004l.pfb", "courbd.ttf"}, {"Courier-BoldOblique", "n022024l.pfb", "courbi.ttf"}, {"Courier-Oblique", "n022023l.pfb", "couri.ttf"}, {"Helvetica", "n019003l.pfb", "arial.ttf"}, {"Helvetica-Bold", "n019004l.pfb", "arialbd.ttf"}, {"Helvetica-BoldOblique", "n019024l.pfb", "arialbi.ttf"}, {"Helvetica-Oblique", "n019023l.pfb", "ariali.ttf"}, {"Symbol", "s050000l.pfb", NULL}, {"Times-Bold", "n021004l.pfb", "timesbd.ttf"}, {"Times-BoldItalic", "n021024l.pfb", "timesbi.ttf"}, {"Times-Italic", "n021023l.pfb", "timesi.ttf"}, {"Times-Roman", "n021003l.pfb", "times.ttf"}, {"ZapfDingbats", "d050000l.pfb", NULL}, {NULL, NULL, NULL} }; #ifdef WIN32 static char *displayFontDirs[] = { "c:/windows/fonts", "c:/winnt/fonts", NULL }; #else static char *displayFontDirs[] = { "/usr/share/ghostscript/fonts", "/usr/pkg/share/ghostscript/fonts", "/usr/local/share/ghostscript/fonts", "/usr/share/fonts/default/Type1", "/usr/X11R6/lib/X11/fonts/Type1", "/usr/share/fonts/default/ghostscript", "/usr/share/fonts/type1/gsfonts", "/usr/share/fonts/Type1", NULL }; #endif //------------------------------------------------------------------------ GlobalParams *globalParams = NULL; //------------------------------------------------------------------------ // DisplayFontParam //------------------------------------------------------------------------ DisplayFontParam::DisplayFontParam(GString *nameA, DisplayFontParamKind kindA) { name = nameA; kind = kindA; switch (kind) { case displayFontT1: t1.fileName = NULL; break; case displayFontTT: tt.fileName = NULL; break; } } DisplayFontParam::~DisplayFontParam() { delete name; switch (kind) { case displayFontT1: if (t1.fileName) { delete t1.fileName; } break; case displayFontTT: if (tt.fileName) { delete tt.fileName; } break; } } #ifdef WIN32 //------------------------------------------------------------------------ // WinFontInfo //------------------------------------------------------------------------ class WinFontInfo: public DisplayFontParam { public: GBool bold, italic; static WinFontInfo *make(GString *nameA, GBool boldA, GBool italicA, HKEY regKey, char *winFontDir); WinFontInfo(GString *nameA, GBool boldA, GBool italicA, GString *fileNameA); virtual ~WinFontInfo(); GBool equals(WinFontInfo *fi); }; WinFontInfo *WinFontInfo::make(GString *nameA, GBool boldA, GBool italicA, HKEY regKey, char *winFontDir) { GString *regName; GString *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 GString(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(GString *nameA, GBool boldA, GBool italicA, GString *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(GString *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); GList *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 GList(); 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() { deleteGList(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(GString *font) { GString *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 GString(font->lfFaceName), font->lfWeight >= 600, font->lfItalic ? gTrue : gFalse, fl->regKey, fl->winFontDir))) { fl->add(fi); } } return 1; } #endif // WIN32 //------------------------------------------------------------------------ // PSFontParam //------------------------------------------------------------------------ PSFontParam::PSFontParam(GString *pdfFontNameA, int wModeA, GString *psFontNameA, GString *encodingA) { pdfFontName = pdfFontNameA; wMode = wModeA; psFontName = psFontNameA; encoding = encodingA; } PSFontParam::~PSFontParam() { delete pdfFontName; delete psFontName; if (encoding) { delete encoding; } } //------------------------------------------------------------------------ // KeyBinding //------------------------------------------------------------------------ KeyBinding::KeyBinding(int codeA, int modsA, int contextA, char *cmd0) { code = codeA; mods = modsA; context = contextA; cmds = new GList(); cmds->append(new GString(cmd0)); } KeyBinding::KeyBinding(int codeA, int modsA, int contextA, char *cmd0, char *cmd1) { code = codeA; mods = modsA; context = contextA; cmds = new GList(); cmds->append(new GString(cmd0)); cmds->append(new GString(cmd1)); } KeyBinding::KeyBinding(int codeA, int modsA, int contextA, GList *cmdsA) { code = codeA; mods = modsA; context = contextA; cmds = cmdsA; } KeyBinding::~KeyBinding() { deleteGList(cmds, GString); } #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) { GString *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(char *cfgFileName) { UnicodeMap *map; GString *fileName; FILE *f; 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 GString(); #else baseDir = appendToPath(getHomeDir(), ".xpdf"); #endif nameToUnicode = new NameToCharCode(); cidToUnicodes = new GHash(gTrue); unicodeToUnicodes = new GHash(gTrue); residentUnicodeMaps = new GHash(); unicodeMaps = new GHash(gTrue); cMapDirs = new GHash(gTrue); toUnicodeDirs = new GList(); displayFonts = new GHash(); displayCIDFonts = new GHash(); displayNamedCIDFonts = new GHash(); #if HAVE_PAPER_H char *paperName; const struct paper *paperType; paperinit(); if ((paperName = systempapername())) { paperType = paperinfo(paperName); psPaperWidth = (int)paperpswidth(paperType); psPaperHeight = (int)paperpsheight(paperType); } else { error(-1, "No paper information available - using defaults"); psPaperWidth = defPaperWidth; psPaperHeight = defPaperHeight; } paperdone(); #else psPaperWidth = defPaperWidth; psPaperHeight = defPaperHeight; #endif psImageableLLX = psImageableLLY = 0; psImageableURX = psPaperWidth; psImageableURY = psPaperHeight; psCrop = gTrue; psExpandSmaller = gFalse; psShrinkLarger = gTrue; psCenter = gTrue; psDuplex = gFalse; psLevel = psLevel2; psFile = NULL; psFonts = new GHash(); psNamedFonts16 = new GList(); psFonts16 = new GList(); psEmbedType1 = gTrue; psEmbedTrueType = gTrue; psEmbedCIDPostScript = gTrue; psEmbedCIDTrueType = gTrue; psPreload = gFalse; psOPI = gFalse; psASCIIHex = gFalse; // KPDF: use always UTF-8 and TQString::fromUtf textEncoding = new GString("UTF-8"); #if defined(WIN32) textEOL = eolDOS; #elif defined(MACOS) textEOL = eolMac; #else textEOL = eolUnix; #endif textPageBreaks = gTrue; textKeepTinyChars = gFalse; fontDirs = new GList(); initialZoom = new GString("125"); continuousView = gFalse; enableT1lib = gTrue; enableFreeType = gTrue; antialias = gTrue; vectorAntialias = gTrue; strokeAdjust = gTrue; screenType = screenUnset; screenSize = -1; screenDotRadius = -1; screenGamma = 1.0; screenBlackThreshold = 0.0; screenWhiteThreshold = 1.0; urlCommand = NULL; movieCommand = NULL; mapNumericCharNames = gTrue; mapUnknownCharNames = gFalse; createDefaultKeyBindings(); printCommands = gFalse; errQuiet = gFalse; cidToUnicodeCache = new CharCodeToUnicodeCache(cidToUnicodeCacheSize); unicodeToUnicodeCache = new CharCodeToUnicodeCache(unicodeToUnicodeCacheSize); unicodeMapCache = new UnicodeMapCache(); cMapCache = new CMapCache(); #ifdef WIN32 winFontList = NULL; #endif #ifdef ENABLE_PLUGINS plugins = new GList(); securityHandlers = new GList(); #endif // set up the initial nameToUnicode table for (i = 0; nameToUnicodeTab[i].name; ++i) { nameToUnicode->add(nameToUnicodeTab[i].name, nameToUnicodeTab[i].u); } // set up the residentUnicodeMaps table map = new UnicodeMap("Latin1", gFalse, latin1UnicodeMapRanges, latin1UnicodeMapLen); residentUnicodeMaps->add(map->getEncodingName(), map); map = new UnicodeMap("ASCII7", gFalse, ascii7UnicodeMapRanges, ascii7UnicodeMapLen); residentUnicodeMaps->add(map->getEncodingName(), map); map = new UnicodeMap("Symbol", gFalse, symbolUnicodeMapRanges, symbolUnicodeMapLen); residentUnicodeMaps->add(map->getEncodingName(), map); map = new UnicodeMap("ZapfDingbats", gFalse, zapfDingbatsUnicodeMapRanges, zapfDingbatsUnicodeMapLen); residentUnicodeMaps->add(map->getEncodingName(), map); map = new UnicodeMap("UTF-8", gTrue, &mapUTF8); residentUnicodeMaps->add(map->getEncodingName(), map); map = new UnicodeMap("UCS-2", gTrue, &mapUCS2); residentUnicodeMaps->add(map->getEncodingName(), map); // look for a user config file, then a system-wide config file f = NULL; fileName = NULL; if (cfgFileName && cfgFileName[0]) { fileName = new GString(cfgFileName); if (!(f = fopen(fileName->getCString(), "r"))) { delete fileName; } } if (!f) { fileName = appendToPath(getHomeDir(), xpdfUserConfigFile); if (!(f = fopen(fileName->getCString(), "r"))) { delete fileName; } } if (!f) { #if defined(WIN32) && !defined(__CYGWIN32__) char buf[512]; i = GetModuleFileName(NULL, buf, sizeof(buf)); if (i <= 0 || i >= sizeof(buf)) { // error or path too long for buffer - just use the current dir buf[0] = '\0'; } fileName = grabPath(buf); appendToPath(fileName, xpdfSysConfigFile); #else fileName = new GString(xpdfSysConfigFile); #endif if (!(f = fopen(fileName->getCString(), "r"))) { delete fileName; } } if (f) { parseFile(fileName, f); delete fileName; fclose(f); } } void GlobalParams::createDefaultKeyBindings() { keyBindings = new GList(); //----- mouse buttons keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress1, xpdfKeyModNone, xpdfKeyContextAny, "startSelection")); keyBindings->append(new KeyBinding(xpdfKeyCodeMouseRelease1, xpdfKeyModNone, xpdfKeyContextAny, "endSelection", "followLinkNoSel")); keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress2, xpdfKeyModNone, xpdfKeyContextAny, "startPan")); keyBindings->append(new KeyBinding(xpdfKeyCodeMouseRelease2, xpdfKeyModNone, xpdfKeyContextAny, "endPan")); keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress3, xpdfKeyModNone, xpdfKeyContextAny, "postPopupMenu")); keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress4, xpdfKeyModNone, xpdfKeyContextAny, "scrollUpPrevPage(16)")); keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress5, xpdfKeyModNone, xpdfKeyContextAny, "scrollDownNextPage(16)")); keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress6, xpdfKeyModNone, xpdfKeyContextAny, "scrollLeft(16)")); keyBindings->append(new KeyBinding(xpdfKeyCodeMousePress7, xpdfKeyModNone, xpdfKeyContextAny, "scrollRight(16)")); //----- keys keyBindings->append(new KeyBinding(xpdfKeyCodeHome, xpdfKeyModCtrl, xpdfKeyContextAny, "gotoPage(1)")); keyBindings->append(new KeyBinding(xpdfKeyCodeHome, xpdfKeyModNone, xpdfKeyContextAny, "scrollToTopLeft")); keyBindings->append(new KeyBinding(xpdfKeyCodeEnd, xpdfKeyModCtrl, xpdfKeyContextAny, "gotoLastPage")); keyBindings->append(new KeyBinding(xpdfKeyCodeEnd, xpdfKeyModNone, xpdfKeyContextAny, "scrollToBottomRight")); keyBindings->append(new KeyBinding(xpdfKeyCodePgUp, xpdfKeyModNone, xpdfKeyContextAny, "pageUp")); keyBindings->append(new KeyBinding(xpdfKeyCodeBackspace, xpdfKeyModNone, xpdfKeyContextAny, "pageUp")); keyBindings->append(new KeyBinding(xpdfKeyCodeDelete, xpdfKeyModNone, xpdfKeyContextAny, "pageUp")); keyBindings->append(new KeyBinding(xpdfKeyCodePgDn, xpdfKeyModNone, xpdfKeyContextAny, "pageDown")); keyBindings->append(new KeyBinding(' ', xpdfKeyModNone, xpdfKeyContextAny, "pageDown")); keyBindings->append(new KeyBinding(xpdfKeyCodeLeft, xpdfKeyModNone, xpdfKeyContextAny, "scrollLeft(16)")); keyBindings->append(new KeyBinding(xpdfKeyCodeRight, xpdfKeyModNone, xpdfKeyContextAny, "scrollRight(16)")); keyBindings->append(new KeyBinding(xpdfKeyCodeUp, xpdfKeyModNone, xpdfKeyContextAny, "scrollUp(16)")); keyBindings->append(new KeyBinding(xpdfKeyCodeDown, xpdfKeyModNone, xpdfKeyContextAny, "scrollDown(16)")); keyBindings->append(new KeyBinding('o', xpdfKeyModNone, xpdfKeyContextAny, "open")); keyBindings->append(new KeyBinding('O', xpdfKeyModNone, xpdfKeyContextAny, "open")); keyBindings->append(new KeyBinding('r', xpdfKeyModNone, xpdfKeyContextAny, "reload")); keyBindings->append(new KeyBinding('R', xpdfKeyModNone, xpdfKeyContextAny, "reload")); keyBindings->append(new KeyBinding('f', xpdfKeyModNone, xpdfKeyContextAny, "find")); keyBindings->append(new KeyBinding('F', xpdfKeyModNone, xpdfKeyContextAny, "find")); keyBindings->append(new KeyBinding('f', xpdfKeyModCtrl, xpdfKeyContextAny, "find")); keyBindings->append(new KeyBinding('g', xpdfKeyModCtrl, xpdfKeyContextAny, "findNext")); keyBindings->append(new KeyBinding('p', xpdfKeyModCtrl, xpdfKeyContextAny, "print")); keyBindings->append(new KeyBinding('n', xpdfKeyModNone, xpdfKeyContextScrLockOff, "nextPage")); keyBindings->append(new KeyBinding('N', xpdfKeyModNone, xpdfKeyContextScrLockOff, "nextPage")); keyBindings->append(new KeyBinding('n', xpdfKeyModNone, xpdfKeyContextScrLockOn, "nextPageNoScroll")); keyBindings->append(new KeyBinding('N', xpdfKeyModNone, xpdfKeyContextScrLockOn, "nextPageNoScroll")); keyBindings->append(new KeyBinding('p', xpdfKeyModNone, xpdfKeyContextScrLockOff, "prevPage")); keyBindings->append(new KeyBinding('P', xpdfKeyModNone, xpdfKeyContextScrLockOff, "prevPage")); keyBindings->append(new KeyBinding('p', xpdfKeyModNone, xpdfKeyContextScrLockOn, "prevPageNoScroll")); keyBindings->append(new KeyBinding('P', xpdfKeyModNone, xpdfKeyContextScrLockOn, "prevPageNoScroll")); keyBindings->append(new KeyBinding('v', xpdfKeyModNone, xpdfKeyContextAny, "goForward")); keyBindings->append(new KeyBinding('b', xpdfKeyModNone, xpdfKeyContextAny, "goBackward")); keyBindings->append(new KeyBinding('g', xpdfKeyModNone, xpdfKeyContextAny, "focusToPageNum")); keyBindings->append(new KeyBinding('0', xpdfKeyModNone, xpdfKeyContextAny, "zoomPercent(125)")); keyBindings->append(new KeyBinding('+', xpdfKeyModNone, xpdfKeyContextAny, "zoomIn")); keyBindings->append(new KeyBinding('-', xpdfKeyModNone, xpdfKeyContextAny, "zoomOut")); keyBindings->append(new KeyBinding('z', xpdfKeyModNone, xpdfKeyContextAny, "zoomFitPage")); keyBindings->append(new KeyBinding('w', xpdfKeyModNone, xpdfKeyContextAny, "zoomFitWidth")); keyBindings->append(new KeyBinding('f', xpdfKeyModAlt, xpdfKeyContextAny, "toggleFullScreenMode")); keyBindings->append(new KeyBinding('l', xpdfKeyModCtrl, xpdfKeyContextAny, "redraw")); keyBindings->append(new KeyBinding('w', xpdfKeyModCtrl, xpdfKeyContextAny, "closeWindow")); keyBindings->append(new KeyBinding('?', xpdfKeyModNone, xpdfKeyContextAny, "about")); keyBindings->append(new KeyBinding('q', xpdfKeyModNone, xpdfKeyContextAny, "quit")); keyBindings->append(new KeyBinding('Q', xpdfKeyModNone, xpdfKeyContextAny, "quit")); } void GlobalParams::parseFile(GString *fileName, FILE *f) { int line; char buf[512]; line = 1; while (getLine(buf, sizeof(buf) - 1, f)) { parseLine(buf, fileName, line); ++line; } } void GlobalParams::parseLine(char *buf, GString *fileName, int line) { GList *tokens; GString *cmd, *incFile; char *p1, *p2; FILE *f2; // break the line into tokens tokens = new GList(); p1 = buf; while (*p1) { for (; *p1 && isspace(*p1); ++p1) ; if (!*p1) { break; } if (*p1 == '"' || *p1 == '\'') { for (p2 = p1 + 1; *p2 && *p2 != *p1; ++p2) ; ++p1; } else { for (p2 = p1 + 1; *p2 && !isspace(*p2); ++p2) ; } tokens->append(new GString(p1, p2 - p1)); p1 = *p2 ? p2 + 1 : p2; } // parse the line if (tokens->getLength() > 0 && ((GString *)tokens->get(0))->getChar(0) != '#') { cmd = (GString *)tokens->get(0); if (!cmd->cmp("include")) { if (tokens->getLength() == 2) { incFile = (GString *)tokens->get(1); if ((f2 = fopen(incFile->getCString(), "r"))) { parseFile(incFile, f2); fclose(f2); } else { error(-1, "Couldn't find included config file: '%s' (%s:%d)", incFile->getCString(), fileName->getCString(), line); } } else { error(-1, "Bad 'include' config file command (%s:%d)", fileName->getCString(), line); } } else if (!cmd->cmp("nameToUnicode")) { parseNameToUnicode(tokens, fileName, line); } else if (!cmd->cmp("cidToUnicode")) { parseCIDToUnicode(tokens, fileName, line); } else if (!cmd->cmp("unicodeToUnicode")) { parseUnicodeToUnicode(tokens, fileName, line); } else if (!cmd->cmp("unicodeMap")) { parseUnicodeMap(tokens, fileName, line); } else if (!cmd->cmp("cMapDir")) { parseCMapDir(tokens, fileName, line); } else if (!cmd->cmp("toUnicodeDir")) { parseToUnicodeDir(tokens, fileName, line); } else if (!cmd->cmp("displayFontT1")) { parseDisplayFont(tokens, displayFonts, displayFontT1, fileName, line); } else if (!cmd->cmp("displayFontTT")) { parseDisplayFont(tokens, displayFonts, displayFontTT, fileName, line); } else if (!cmd->cmp("displayNamedCIDFontT1")) { parseDisplayFont(tokens, displayNamedCIDFonts, displayFontT1, fileName, line); } else if (!cmd->cmp("displayCIDFontT1")) { parseDisplayFont(tokens, displayCIDFonts, displayFontT1, fileName, line); } else if (!cmd->cmp("displayNamedCIDFontTT")) { parseDisplayFont(tokens, displayNamedCIDFonts, displayFontTT, fileName, line); } else if (!cmd->cmp("displayCIDFontTT")) { parseDisplayFont(tokens, displayCIDFonts, displayFontTT, fileName, line); } else if (!cmd->cmp("psFile")) { parsePSFile(tokens, fileName, line); } else if (!cmd->cmp("psFont")) { parsePSFont(tokens, fileName, line); } else if (!cmd->cmp("psNamedFont16")) { parsePSFont16("psNamedFont16", psNamedFonts16, tokens, fileName, line); } else if (!cmd->cmp("psFont16")) { parsePSFont16("psFont16", psFonts16, tokens, fileName, line); } else if (!cmd->cmp("psPaperSize")) { parsePSPaperSize(tokens, fileName, line); } else if (!cmd->cmp("psImageableArea")) { parsePSImageableArea(tokens, fileName, line); } else if (!cmd->cmp("psCrop")) { parseYesNo("psCrop", &psCrop, tokens, fileName, line); } else if (!cmd->cmp("psExpandSmaller")) { parseYesNo("psExpandSmaller", &psExpandSmaller, tokens, fileName, line); } else if (!cmd->cmp("psShrinkLarger")) { parseYesNo("psShrinkLarger", &psShrinkLarger, tokens, fileName, line); } else if (!cmd->cmp("psCenter")) { parseYesNo("psCenter", &psCenter, tokens, fileName, line); } else if (!cmd->cmp("psDuplex")) { parseYesNo("psDuplex", &psDuplex, tokens, fileName, line); } else if (!cmd->cmp("psLevel")) { parsePSLevel(tokens, fileName, line); } else if (!cmd->cmp("psEmbedType1Fonts")) { parseYesNo("psEmbedType1", &psEmbedType1, tokens, fileName, line); } else if (!cmd->cmp("psEmbedTrueTypeFonts")) { parseYesNo("psEmbedTrueType", &psEmbedTrueType, tokens, fileName, line); } else if (!cmd->cmp("psEmbedCIDPostScriptFonts")) { parseYesNo("psEmbedCIDPostScript", &psEmbedCIDPostScript, tokens, fileName, line); } else if (!cmd->cmp("psEmbedCIDTrueTypeFonts")) { parseYesNo("psEmbedCIDTrueType", &psEmbedCIDTrueType, tokens, fileName, line); } else if (!cmd->cmp("psPreload")) { parseYesNo("psPreload", &psPreload, tokens, fileName, line); } else if (!cmd->cmp("psOPI")) { parseYesNo("psOPI", &psOPI, tokens, fileName, line); } else if (!cmd->cmp("psASCIIHex")) { parseYesNo("psASCIIHex", &psASCIIHex, tokens, fileName, line); } else if (!cmd->cmp("textEncoding")) { // Always use UTF-8 and allow TQString do the magic // parseTextEncoding(tokens, fileName, line); } else if (!cmd->cmp("textEOL")) { parseTextEOL(tokens, fileName, line); } else if (!cmd->cmp("textPageBreaks")) { parseYesNo("textPageBreaks", &textPageBreaks, tokens, fileName, line); } else if (!cmd->cmp("textKeepTinyChars")) { parseYesNo("textKeepTinyChars", &textKeepTinyChars, tokens, fileName, line); } else if (!cmd->cmp("fontDir")) { parseFontDir(tokens, fileName, line); } else if (!cmd->cmp("initialZoom")) { parseInitialZoom(tokens, fileName, line); } else if (!cmd->cmp("continuousView")) { parseYesNo("continuousView", &continuousView, tokens, fileName, line); } else if (!cmd->cmp("enableT1lib")) { parseYesNo("enableT1lib", &enableT1lib, tokens, fileName, line); } else if (!cmd->cmp("enableFreeType")) { parseYesNo("enableFreeType", &enableFreeType, tokens, fileName, line); } else if (!cmd->cmp("antialias")) { parseYesNo("antialias", &antialias, tokens, fileName, line); } else if (!cmd->cmp("vectorAntialias")) { parseYesNo("vectorAntialias", &vectorAntialias, tokens, fileName, line); } else if (!cmd->cmp("strokeAdjust")) { parseYesNo("strokeAdjust", &strokeAdjust, tokens, fileName, line); } else if (!cmd->cmp("screenType")) { parseScreenType(tokens, fileName, line); } else if (!cmd->cmp("screenSize")) { parseInteger("screenSize", &screenSize, tokens, fileName, line); } else if (!cmd->cmp("screenDotRadius")) { parseInteger("screenDotRadius", &screenDotRadius, tokens, fileName, line); } else if (!cmd->cmp("screenGamma")) { parseFloat("screenGamma", &screenGamma, tokens, fileName, line); } else if (!cmd->cmp("screenBlackThreshold")) { parseFloat("screenBlackThreshold", &screenBlackThreshold, tokens, fileName, line); } else if (!cmd->cmp("screenWhiteThreshold")) { parseFloat("screenWhiteThreshold", &screenWhiteThreshold, tokens, fileName, line); } else if (!cmd->cmp("urlCommand")) { parseCommand("urlCommand", &urlCommand, tokens, fileName, line); } else if (!cmd->cmp("movieCommand")) { parseCommand("movieCommand", &movieCommand, tokens, fileName, line); } else if (!cmd->cmp("mapNumericCharNames")) { parseYesNo("mapNumericCharNames", &mapNumericCharNames, tokens, fileName, line); } else if (!cmd->cmp("mapUnknownCharNames")) { parseYesNo("mapUnknownCharNames", &mapUnknownCharNames, tokens, fileName, line); } else if (!cmd->cmp("bind")) { parseBind(tokens, fileName, line); } else if (!cmd->cmp("unbind")) { parseUnbind(tokens, fileName, line); } else if (!cmd->cmp("printCommands")) { parseYesNo("printCommands", &printCommands, tokens, fileName, line); } else if (!cmd->cmp("errQuiet")) { parseYesNo("errQuiet", &errQuiet, tokens, fileName, line); } else { error(-1, "Unknown config file command '%s' (%s:%d)", cmd->getCString(), fileName->getCString(), line); if (!cmd->cmp("displayFontX") || !cmd->cmp("displayNamedCIDFontX") || !cmd->cmp("displayCIDFontX")) { error(-1, "-- Xpdf no longer supports X fonts"); } else if (!cmd->cmp("t1libControl") || !cmd->cmp("freetypeControl")) { error(-1, "-- The t1libControl and freetypeControl options have been replaced"); error(-1, " by the enableT1lib, enableFreeType, and antialias options"); } else if (!cmd->cmp("fontpath") || !cmd->cmp("fontmap")) { error(-1, "-- the config file format has changed since Xpdf 0.9x"); } } } deleteGList(tokens, GString); } void GlobalParams::parseNameToUnicode(GList *tokens, GString *fileName, int line) { GString *name; char *tok1, *tok2; FILE *f; char buf[256]; int line2; Unicode u; if (tokens->getLength() != 2) { error(-1, "Bad 'nameToUnicode' config file command (%s:%d)", fileName->getCString(), line); return; } name = (GString *)tokens->get(1); if (!(f = fopen(name->getCString(), "r"))) { error(-1, "Couldn't open 'nameToUnicode' file '%s'", name->getCString()); return; } line2 = 1; while (getLine(buf, sizeof(buf), f)) { tok1 = strtok(buf, " \t\r\n"); tok2 = strtok(NULL, " \t\r\n"); if (tok1 && tok2) { sscanf(tok1, "%x", &u); nameToUnicode->add(tok2, u); } else { error(-1, "Bad line in 'nameToUnicode' file (%s:%d)", name, line2); } ++line2; } fclose(f); } void GlobalParams::parseCIDToUnicode(GList *tokens, GString *fileName, int line) { GString *collection, *name, *old; if (tokens->getLength() != 3) { error(-1, "Bad 'cidToUnicode' config file command (%s:%d)", fileName->getCString(), line); return; } collection = (GString *)tokens->get(1); name = (GString *)tokens->get(2); if ((old = (GString *)cidToUnicodes->remove(collection))) { delete old; } cidToUnicodes->add(collection->copy(), name->copy()); } void GlobalParams::parseUnicodeToUnicode(GList *tokens, GString *fileName, int line) { GString *font, *file, *old; if (tokens->getLength() != 3) { error(-1, "Bad 'unicodeToUnicode' config file command (%s:%d)", fileName->getCString(), line); return; } font = (GString *)tokens->get(1); file = (GString *)tokens->get(2); if ((old = (GString *)unicodeToUnicodes->remove(font))) { delete old; } unicodeToUnicodes->add(font->copy(), file->copy()); } void GlobalParams::parseUnicodeMap(GList *tokens, GString *fileName, int line) { GString *encodingName, *name, *old; if (tokens->getLength() != 3) { error(-1, "Bad 'unicodeMap' config file command (%s:%d)", fileName->getCString(), line); return; } encodingName = (GString *)tokens->get(1); name = (GString *)tokens->get(2); if ((old = (GString *)unicodeMaps->remove(encodingName))) { delete old; } unicodeMaps->add(encodingName->copy(), name->copy()); } void GlobalParams::parseCMapDir(GList *tokens, GString *fileName, int line) { GString *collection, *dir; GList *list; if (tokens->getLength() != 3) { error(-1, "Bad 'cMapDir' config file command (%s:%d)", fileName->getCString(), line); return; } collection = (GString *)tokens->get(1); dir = (GString *)tokens->get(2); if (!(list = (GList *)cMapDirs->lookup(collection))) { list = new GList(); cMapDirs->add(collection->copy(), list); } list->append(dir->copy()); } void GlobalParams::parseToUnicodeDir(GList *tokens, GString *fileName, int line) { if (tokens->getLength() != 2) { error(-1, "Bad 'toUnicodeDir' config file command (%s:%d)", fileName->getCString(), line); return; } toUnicodeDirs->append(((GString *)tokens->get(1))->copy()); } void GlobalParams::parseDisplayFont(GList *tokens, GHash *fontHash, DisplayFontParamKind kind, GString *fileName, int line) { DisplayFontParam *param, *old; struct stat statbuf; if (tokens->getLength() < 2) { goto err1; } param = new DisplayFontParam(((GString *)tokens->get(1))->copy(), kind); switch (kind) { case displayFontT1: if (tokens->getLength() != 3) { goto err2; } param->t1.fileName = ((GString *)tokens->get(2))->copy(); if (stat((param->t1.fileName->getCString)(), &statbuf)) { delete param; // silently ignore non-existing files return; } break; case displayFontTT: if (tokens->getLength() < 3) { goto err2; } param->tt.fileName = ((GString *)tokens->get(2))->copy(); if (stat((param->tt.fileName->getCString)(), &statbuf)) { delete param; // silently ignore non-existing files return; } if (tokens->getLength() > 3) param->tt.faceIndex = atoi(((GString *)tokens->get(3))->getCString()); else param->tt.faceIndex = 0; break; } if ((old = (DisplayFontParam *)fontHash->remove(param->name))) { delete old; } fontHash->add(param->name, param); return; err2: delete param; err1: error(-1, "Bad 'display*Font*' config file command (%s:%d)", fileName->getCString(), line); } void GlobalParams::parsePSPaperSize(GList *tokens, GString *fileName, int line) { GString *tok; if (tokens->getLength() == 2) { tok = (GString *)tokens->get(1); if (!setPSPaperSize(tok->getCString())) { error(-1, "Bad 'psPaperSize' config file command (%s:%d)", fileName->getCString(), line); } } else if (tokens->getLength() == 3) { tok = (GString *)tokens->get(1); psPaperWidth = atoi(tok->getCString()); tok = (GString *)tokens->get(2); psPaperHeight = atoi(tok->getCString()); psImageableLLX = psImageableLLY = 0; psImageableURX = psPaperWidth; psImageableURY = psPaperHeight; } else { error(-1, "Bad 'psPaperSize' config file command (%s:%d)", fileName->getCString(), line); } } void GlobalParams::parsePSImageableArea(GList *tokens, GString *fileName, int line) { if (tokens->getLength() != 5) { error(-1, "Bad 'psImageableArea' config file command (%s:%d)", fileName->getCString(), line); return; } psImageableLLX = atoi(((GString *)tokens->get(1))->getCString()); psImageableLLY = atoi(((GString *)tokens->get(2))->getCString()); psImageableURX = atoi(((GString *)tokens->get(3))->getCString()); psImageableURY = atoi(((GString *)tokens->get(4))->getCString()); } void GlobalParams::parsePSLevel(GList *tokens, GString *fileName, int line) { GString *tok; if (tokens->getLength() != 2) { error(-1, "Bad 'psLevel' config file command (%s:%d)", fileName->getCString(), line); return; } tok = (GString *)tokens->get(1); if (!tok->cmp("level1")) { psLevel = psLevel1; } else if (!tok->cmp("level1sep")) { psLevel = psLevel1Sep; } else if (!tok->cmp("level2")) { psLevel = psLevel2; } else if (!tok->cmp("level2sep")) { psLevel = psLevel2Sep; } else if (!tok->cmp("level3")) { psLevel = psLevel3; } else if (!tok->cmp("level3Sep")) { psLevel = psLevel3Sep; } else { error(-1, "Bad 'psLevel' config file command (%s:%d)", fileName->getCString(), line); } } void GlobalParams::parsePSFile(GList *tokens, GString *fileName, int line) { if (tokens->getLength() != 2) { error(-1, "Bad 'psFile' config file command (%s:%d)", fileName->getCString(), line); return; } if (psFile) { delete psFile; } psFile = ((GString *)tokens->get(1))->copy(); } void GlobalParams::parsePSFont(GList *tokens, GString *fileName, int line) { PSFontParam *param; if (tokens->getLength() != 3) { error(-1, "Bad 'psFont' config file command (%s:%d)", fileName->getCString(), line); return; } param = new PSFontParam(((GString *)tokens->get(1))->copy(), 0, ((GString *)tokens->get(2))->copy(), NULL); psFonts->add(param->pdfFontName, param); } void GlobalParams::parsePSFont16(char *cmdName, GList *fontList, GList *tokens, GString *fileName, int line) { PSFontParam *param; int wMode; GString *tok; if (tokens->getLength() != 5) { error(-1, "Bad '%s' config file command (%s:%d)", cmdName, fileName->getCString(), line); return; } tok = (GString *)tokens->get(2); if (!tok->cmp("H")) { wMode = 0; } else if (!tok->cmp("V")) { wMode = 1; } else { error(-1, "Bad '%s' config file command (%s:%d)", cmdName, fileName->getCString(), line); return; } param = new PSFontParam(((GString *)tokens->get(1))->copy(), wMode, ((GString *)tokens->get(3))->copy(), ((GString *)tokens->get(4))->copy()); fontList->append(param); } void GlobalParams::parseTextEncoding(GList *tokens, GString *fileName, int line) { if (tokens->getLength() != 2) { error(-1, "Bad 'textEncoding' config file command (%s:%d)", fileName->getCString(), line); return; } delete textEncoding; textEncoding = ((GString *)tokens->get(1))->copy(); } void GlobalParams::parseTextEOL(GList *tokens, GString *fileName, int line) { GString *tok; if (tokens->getLength() != 2) { error(-1, "Bad 'textEOL' config file command (%s:%d)", fileName->getCString(), line); return; } tok = (GString *)tokens->get(1); if (!tok->cmp("unix")) { textEOL = eolUnix; } else if (!tok->cmp("dos")) { textEOL = eolDOS; } else if (!tok->cmp("mac")) { textEOL = eolMac; } else { error(-1, "Bad 'textEOL' config file command (%s:%d)", fileName->getCString(), line); } } void GlobalParams::parseFontDir(GList *tokens, GString *fileName, int line) { if (tokens->getLength() != 2) { error(-1, "Bad 'fontDir' config file command (%s:%d)", fileName->getCString(), line); return; } fontDirs->append(((GString *)tokens->get(1))->copy()); } void GlobalParams::parseInitialZoom(GList *tokens, GString *fileName, int line) { if (tokens->getLength() != 2) { error(-1, "Bad 'initialZoom' config file command (%s:%d)", fileName->getCString(), line); return; } delete initialZoom; initialZoom = ((GString *)tokens->get(1))->copy(); } void GlobalParams::parseScreenType(GList *tokens, GString *fileName, int line) { GString *tok; if (tokens->getLength() != 2) { error(-1, "Bad 'screenType' config file command (%s:%d)", fileName->getCString(), line); return; } tok = (GString *)tokens->get(1); if (!tok->cmp("dispersed")) { screenType = screenDispersed; } else if (!tok->cmp("clustered")) { screenType = screenClustered; } else if (!tok->cmp("stochasticClustered")) { screenType = screenStochasticClustered; } else { error(-1, "Bad 'screenType' config file command (%s:%d)", fileName->getCString(), line); } } void GlobalParams::parseBind(GList *tokens, GString *fileName, int line) { KeyBinding *binding; GList *cmds; int code, mods, context, i; if (tokens->getLength() < 4) { error(-1, "Bad 'bind' config file command (%s:%d)", fileName->getCString(), line); return; } if (!parseKey((GString *)tokens->get(1), (GString *)tokens->get(2), &code, &mods, &context, "bind", tokens, fileName, line)) { return; } for (i = 0; i < keyBindings->getLength(); ++i) { binding = (KeyBinding *)keyBindings->get(i); if (binding->code == code && binding->mods == mods && binding->context == context) { delete (KeyBinding *)keyBindings->del(i); break; } } cmds = new GList(); for (i = 3; i < tokens->getLength(); ++i) { cmds->append(((GString *)tokens->get(i))->copy()); } keyBindings->append(new KeyBinding(code, mods, context, cmds)); } void GlobalParams::parseUnbind(GList *tokens, GString *fileName, int line) { KeyBinding *binding; int code, mods, context, i; if (tokens->getLength() != 3) { error(-1, "Bad 'unbind' config file command (%s:%d)", fileName->getCString(), line); return; } if (!parseKey((GString *)tokens->get(1), (GString *)tokens->get(2), &code, &mods, &context, "unbind", tokens, fileName, line)) { return; } for (i = 0; i < keyBindings->getLength(); ++i) { binding = (KeyBinding *)keyBindings->get(i); if (binding->code == code && binding->mods == mods && binding->context == context) { delete (KeyBinding *)keyBindings->del(i); break; } } } GBool GlobalParams::parseKey(GString *modKeyStr, GString *contextStr, int *code, int *mods, int *context, char *cmdName, GList * /*tokens*/, GString *fileName, int line) { char *p0; *mods = xpdfKeyModNone; p0 = modKeyStr->getCString(); while (1) { if (!strncmp(p0, "shift-", 6)) { *mods |= xpdfKeyModShift; p0 += 6; } else if (!strncmp(p0, "ctrl-", 5)) { *mods |= xpdfKeyModCtrl; p0 += 5; } else if (!strncmp(p0, "alt-", 4)) { *mods |= xpdfKeyModAlt; p0 += 4; } else { break; } } if (!strcmp(p0, "space")) { *code = ' '; } else if (!strcmp(p0, "tab")) { *code = xpdfKeyCodeTab; } else if (!strcmp(p0, "return")) { *code = xpdfKeyCodeReturn; } else if (!strcmp(p0, "enter")) { *code = xpdfKeyCodeEnter; } else if (!strcmp(p0, "backspace")) { *code = xpdfKeyCodeBackspace; } else if (!strcmp(p0, "insert")) { *code = xpdfKeyCodeInsert; } else if (!strcmp(p0, "delete")) { *code = xpdfKeyCodeDelete; } else if (!strcmp(p0, "home")) { *code = xpdfKeyCodeHome; } else if (!strcmp(p0, "end")) { *code = xpdfKeyCodeEnd; } else if (!strcmp(p0, "pgup")) { *code = xpdfKeyCodePgUp; } else if (!strcmp(p0, "pgdn")) { *code = xpdfKeyCodePgDn; } else if (!strcmp(p0, "left")) { *code = xpdfKeyCodeLeft; } else if (!strcmp(p0, "right")) { *code = xpdfKeyCodeRight; } else if (!strcmp(p0, "up")) { *code = xpdfKeyCodeUp; } else if (!strcmp(p0, "down")) { *code = xpdfKeyCodeDown; } else if (p0[0] == 'f' && p0[1] >= '1' && p0[1] <= '9' && !p0[2]) { *code = xpdfKeyCodeF1 + (p0[1] - '1'); } else if (p0[0] == 'f' && ((p0[1] >= '1' && p0[1] <= '2' && p0[2] >= '0' && p0[2] <= '9') || (p0[1] == '3' && p0[2] >= '0' && p0[2] <= '5')) && !p0[3]) { *code = xpdfKeyCodeF1 + 10 * (p0[1] - '0') + (p0[2] - '0') - 1; } else if (!strncmp(p0, "mousePress", 10) && p0[10] >= '1' && p0[10] <= '7' && !p0[11]) { *code = xpdfKeyCodeMousePress1 + (p0[10] - '1'); } else if (!strncmp(p0, "mouseRelease", 12) && p0[12] >= '1' && p0[12] <= '7' && !p0[13]) { *code = xpdfKeyCodeMouseRelease1 + (p0[12] - '1'); } else if (*p0 >= 0x20 && *p0 <= 0x7e && !p0[1]) { *code = (int)*p0; } else { error(-1, "Bad key/modifier in '%s' config file command (%s:%d)", cmdName, fileName->getCString(), line); return gFalse; } p0 = contextStr->getCString(); if (!strcmp(p0, "any")) { *context = xpdfKeyContextAny; } else { *context = xpdfKeyContextAny; while (1) { if (!strncmp(p0, "fullScreen", 10)) { *context |= xpdfKeyContextFullScreen; p0 += 10; } else if (!strncmp(p0, "window", 6)) { *context |= xpdfKeyContextWindow; p0 += 6; } else if (!strncmp(p0, "continuous", 10)) { *context |= xpdfKeyContextContinuous; p0 += 10; } else if (!strncmp(p0, "singlePage", 10)) { *context |= xpdfKeyContextSinglePage; p0 += 10; } else if (!strncmp(p0, "overLink", 8)) { *context |= xpdfKeyContextOverLink; p0 += 8; } else if (!strncmp(p0, "offLink", 7)) { *context |= xpdfKeyContextOffLink; p0 += 7; } else if (!strncmp(p0, "outline", 7)) { *context |= xpdfKeyContextOutline; p0 += 7; } else if (!strncmp(p0, "mainWin", 7)) { *context |= xpdfKeyContextMainWin; p0 += 7; } else if (!strncmp(p0, "scrLockOn", 9)) { *context |= xpdfKeyContextScrLockOn; p0 += 9; } else if (!strncmp(p0, "scrLockOff", 10)) { *context |= xpdfKeyContextScrLockOff; p0 += 10; } else { error(-1, "Bad context in '%s' config file command (%s:%d)", cmdName, fileName->getCString(), line); return gFalse; } if (!*p0) { break; } if (*p0 != ',') { error(-1, "Bad context in '%s' config file command (%s:%d)", cmdName, fileName->getCString(), line); return gFalse; } ++p0; } } return gTrue; } void GlobalParams::parseCommand(char *cmdName, GString **val, GList *tokens, GString *fileName, int line) { if (tokens->getLength() != 2) { error(-1, "Bad '%s' config file command (%s:%d)", cmdName, fileName->getCString(), line); return; } if (*val) { delete *val; } *val = ((GString *)tokens->get(1))->copy(); } void GlobalParams::parseYesNo(char *cmdName, GBool *flag, GList *tokens, GString *fileName, int line) { GString *tok; if (tokens->getLength() != 2) { error(-1, "Bad '%s' config file command (%s:%d)", cmdName, fileName->getCString(), line); return; } tok = (GString *)tokens->get(1); if (!parseYesNo2(tok->getCString(), flag)) { error(-1, "Bad '%s' config file command (%s:%d)", cmdName, fileName->getCString(), line); } } 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; } void GlobalParams::parseInteger(char *cmdName, int *val, GList *tokens, GString *fileName, int line) { GString *tok; int i; if (tokens->getLength() != 2) { error(-1, "Bad '%s' config file command (%s:%d)", cmdName, fileName->getCString(), line); return; } tok = (GString *)tokens->get(1); if (tok->getLength() == 0) { error(-1, "Bad '%s' config file command (%s:%d)", cmdName, fileName->getCString(), line); return; } if (tok->getChar(0) == '-') { i = 1; } else { i = 0; } for (; i < tok->getLength(); ++i) { if (tok->getChar(i) < '0' || tok->getChar(i) > '9') { error(-1, "Bad '%s' config file command (%s:%d)", cmdName, fileName->getCString(), line); return; } } *val = atoi(tok->getCString()); } void GlobalParams::parseFloat(char *cmdName, double *val, GList *tokens, GString *fileName, int line) { GString *tok; int i; if (tokens->getLength() != 2) { error(-1, "Bad '%s' config file command (%s:%d)", cmdName, fileName->getCString(), line); return; } tok = (GString *)tokens->get(1); if (tok->getLength() == 0) { error(-1, "Bad '%s' config file command (%s:%d)", cmdName, fileName->getCString(), line); return; } if (tok->getChar(0) == '-') { i = 1; } else { i = 0; } for (; i < tok->getLength(); ++i) { if (!((tok->getChar(i) >= '0' && tok->getChar(i) <= '9') || tok->getChar(i) == '.')) { error(-1, "Bad '%s' config file command (%s:%d)", cmdName, fileName->getCString(), line); return; } } *val = atof(tok->getCString()); } GlobalParams::~GlobalParams() { GHashIter *iter; GString *key; GList *list; freeBuiltinFontTables(); delete macRomanReverseMap; delete baseDir; delete nameToUnicode; deleteGHash(cidToUnicodes, GString); deleteGHash(unicodeToUnicodes, GString); deleteGHash(residentUnicodeMaps, UnicodeMap); deleteGHash(unicodeMaps, GString); deleteGList(toUnicodeDirs, GString); deleteGHash(displayFonts, DisplayFontParam); deleteGHash(displayCIDFonts, DisplayFontParam); deleteGHash(displayNamedCIDFonts, DisplayFontParam); #ifdef WIN32 if (winFontList) { delete winFontList; } #endif if (psFile) { delete psFile; } deleteGHash(psFonts, PSFontParam); deleteGList(psNamedFonts16, PSFontParam); deleteGList(psFonts16, PSFontParam); delete textEncoding; deleteGList(fontDirs, GString); delete initialZoom; if (urlCommand) { delete urlCommand; } if (movieCommand) { delete movieCommand; } deleteGList(keyBindings, KeyBinding); cMapDirs->startIter(&iter); while (cMapDirs->getNext(&iter, &key, (void **)&list)) { deleteGList(list, GString); } delete cMapDirs; delete cidToUnicodeCache; delete unicodeToUnicodeCache; delete unicodeMapCache; delete cMapCache; #ifdef ENABLE_PLUGINS delete securityHandlers; deleteGList(plugins, Plugin); #endif #if MULTITHREADED gDestroyMutex(&mutex); gDestroyMutex(&unicodeMapCacheMutex); gDestroyMutex(&cMapCacheMutex); #endif } //------------------------------------------------------------------------ void GlobalParams::setBaseDir(char *dir) { delete baseDir; baseDir = new GString(dir); } void GlobalParams::setupBaseFonts(char *dir) { GString *fontName; GString *fileName; #ifdef WIN32 HMODULE shell32Lib; BOOL (__stdcall *SHGetSpecialFolderPathFunc)(HWND hwndOwner, LPTSTR lpszPath, int nFolder, BOOL fCreate); char winFontDir[MAX_PATH]; #endif FILE *f; DisplayFontParamKind kind; DisplayFontParam *dfp; int i, j; #ifdef WIN32 // SHGetSpecialFolderPath isn't available in older versions of // shell32.dll (Win95 and WinNT4), so do a dynamic load winFontDir[0] = '\0'; if ((shell32Lib = LoadLibrary("shell32.dll"))) { if ((SHGetSpecialFolderPathFunc = (BOOL (__stdcall *)(HWND hwndOwner, LPTSTR lpszPath, int nFolder, BOOL fCreate)) GetProcAddress(shell32Lib, "SHGetSpecialFolderPathA"))) { if (!(*SHGetSpecialFolderPathFunc)(NULL, winFontDir, CSIDL_FONTS, FALSE)) { winFontDir[0] = '\0'; } } } #endif for (i = 0; displayFontTab[i].name; ++i) { fontName = new GString(displayFontTab[i].name); fileName = NULL; kind = displayFontT1; // make gcc happy if (dir) { fileName = appendToPath(new GString(dir), displayFontTab[i].t1FileName); kind = displayFontT1; if ((f = fopen(fileName->getCString(), "rb"))) { fclose(f); } else { delete fileName; fileName = NULL; } } #ifdef WIN32 if (!fileName && winFontDir[0] && displayFontTab[i].ttFileName) { fileName = appendToPath(new GString(winFontDir), displayFontTab[i].ttFileName); kind = displayFontTT; if ((f = fopen(fileName->getCString(), "rb"))) { fclose(f); } else { delete fileName; fileName = NULL; } } // SHGetSpecialFolderPath(CSIDL_FONTS) doesn't work on Win 2k Server // or Win2003 Server, or with older versions of shell32.dll, so check // the "standard" directories if (displayFontTab[i].ttFileName) { for (j = 0; !fileName && displayFontDirs[j]; ++j) { fileName = appendToPath(new GString(displayFontDirs[j]), displayFontTab[i].ttFileName); kind = displayFontTT; if ((f = fopen(fileName->getCString(), "rb"))) { fclose(f); } else { delete fileName; fileName = NULL; } } } #else for (j = 0; !fileName && displayFontDirs[j]; ++j) { fileName = appendToPath(new GString(displayFontDirs[j]), displayFontTab[i].t1FileName); kind = displayFontT1; if ((f = fopen(fileName->getCString(), "rb"))) { fclose(f); } else { delete fileName; fileName = NULL; } } #endif if (!fileName) { error(-1, "No display font for '%s'", displayFontTab[i].name); delete fontName; continue; } dfp = new DisplayFontParam(fontName, kind); dfp->t1.fileName = fileName; globalParams->addDisplayFont(dfp); } #ifdef WIN32 if (winFontDir[0]) { winFontList = new WinFontList(winFontDir); } #endif } //------------------------------------------------------------------------ // accessors //------------------------------------------------------------------------ CharCode GlobalParams::getMacRomanCharCode(char *charName) { // no need to lock - macRomanReverseMap is constant return macRomanReverseMap->lookup(charName); } GString *GlobalParams::getBaseDir() { GString *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(GString *encodingName) { UnicodeMap *map; lockGlobalParams; map = (UnicodeMap *)residentUnicodeMaps->lookup(encodingName); unlockGlobalParams; if (map) { map->incRefCnt(); } return map; } FILE *GlobalParams::getUnicodeMapFile(GString *encodingName) { GString *fileName; FILE *f; lockGlobalParams; if ((fileName = (GString *)unicodeMaps->lookup(encodingName))) { f = fopen(fileName->getCString(), "r"); } else { f = NULL; } unlockGlobalParams; return f; } FILE *GlobalParams::findCMapFile(GString *collection, GString *cMapName) { GList *list; GString *dir; GString *fileName; FILE *f; int i; lockGlobalParams; if (!(list = (GList *)cMapDirs->lookup(collection))) { unlockGlobalParams; return NULL; } for (i = 0; i < list->getLength(); ++i) { dir = (GString *)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(GString *name) { GString *dir, *fileName; FILE *f; int i; lockGlobalParams; for (i = 0; i < toUnicodeDirs->getLength(); ++i) { dir = (GString *)toUnicodeDirs->get(i); fileName = appendToPath(dir->copy(), name->getCString()); f = fopen(fileName->getCString(), "r"); delete fileName; if (f) { unlockGlobalParams; return f; } } unlockGlobalParams; return NULL; } // KPDF: parse xpdf font name into family and style // Helvetica-BoldOblique => name=Helvetica, weight=Bold, slant=Oblique void parseStyle(TQString& name, int& weight, int& slant, int& width) { if (name.find("MS-") == 0) name = "MS " + name.remove(0,3); if (!name.contains('-') && !name.contains(',')) return; TQString type = name.section(TQRegExp("[-,]"),-1); name = name.section(TQRegExp("[-,]"),0,-2); if (type.contains("Oblique")) slant=FC_SLANT_OBLIQUE; if (type.contains("Italic")) slant=FC_SLANT_ITALIC; if (type.contains("Bold")) weight=FC_WEIGHT_BOLD; if (type.contains("Light")) weight=FC_WEIGHT_LIGHT; if (type.contains("Condensed")) width=FC_WIDTH_CONDENSED; } DisplayFontParam *GlobalParams::getDisplayFont(GString *fontName) { DisplayFontParam *dfp; FcPattern *p=0,*m=0; FcChar8* s; char * ext; FcResult res; lockGlobalParams; dfp = (DisplayFontParam *)displayFonts->lookup(fontName); // KPDF: try to find font using Xft if (!dfp) { int weight=FC_WEIGHT_MEDIUM, slant=FC_SLANT_ROMAN, width=FC_WIDTH_NORMAL; TQString name(fontName->getCString()); parseStyle(name,weight,slant,width); p = FcPatternBuild(0,FC_FAMILY,FcTypeString, name.ascii(), FC_SLANT, FcTypeInteger, slant, FC_WEIGHT, FcTypeInteger, weight, FC_WIDTH, FcTypeInteger, width, FC_LANG, FcTypeString, "xx", (char*)0); if (!p) goto fin; m = XftFontMatch(qt_xdisplay(),qt_xscreen(),p,&res); if (!m) goto fin; res = FcPatternGetString (m, FC_FILE, 0, &s); if (res != FcResultMatch || !s) goto fin; ext = rindex((char*)s,'.'); if (!ext) goto fin; if (!strncasecmp(ext,".ttf",4) || !strncasecmp(ext,".ttc",4)) { dfp = new DisplayFontParam(fontName->copy(), displayFontTT); dfp->tt.fileName = new GString((char*)s); FcPatternGetInteger(m, 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 GString((char*)s); } else goto fin; displayFonts->add(dfp->name,dfp); } fin: unlockGlobalParams; if (m) FcPatternDestroy(m); if (p) FcPatternDestroy(p); return dfp; } DisplayFontParam *GlobalParams::getDisplayCIDFont(GString *fontName, GString *collection) { DisplayFontParam *dfp; lockGlobalParams; if (!fontName || !(dfp = (DisplayFontParam *)displayNamedCIDFonts->lookup(fontName))) { dfp = (DisplayFontParam *)displayCIDFonts->lookup(collection); } unlockGlobalParams; if (!dfp) dfp = getDisplayFont(fontName); return dfp; } GString *GlobalParams::getPSFile() { GString *s; lockGlobalParams; s = psFile ? psFile->copy() : (GString *)NULL; unlockGlobalParams; return s; } int GlobalParams::getPSPaperWidth() { int w; lockGlobalParams; w = psPaperWidth; unlockGlobalParams; return w; } int GlobalParams::getPSPaperHeight() { int h; lockGlobalParams; h = psPaperHeight; unlockGlobalParams; return h; } void GlobalParams::getPSImageableArea(int *llx, int *lly, int *urx, int *ury) { lockGlobalParams; *llx = psImageableLLX; *lly = psImageableLLY; *urx = psImageableURX; *ury = psImageableURY; unlockGlobalParams; } GBool GlobalParams::getPSCrop() { GBool f; lockGlobalParams; f = psCrop; unlockGlobalParams; return f; } 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; } GBool GlobalParams::getPSDuplex() { GBool d; lockGlobalParams; d = psDuplex; unlockGlobalParams; return d; } PSLevel GlobalParams::getPSLevel() { PSLevel level; lockGlobalParams; level = psLevel; unlockGlobalParams; return level; } PSFontParam *GlobalParams::getPSFont(GString *fontName) { PSFontParam *p; lockGlobalParams; p = (PSFontParam *)psFonts->lookup(fontName); unlockGlobalParams; return p; } PSFontParam *GlobalParams::getPSFont16(GString *fontName, GString *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::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; } GString *GlobalParams::getTextEncodingName() { GString *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; } GString *GlobalParams::findFontFile(GString *fontName, char **exts) { GString *dir, *fileName; char **ext; FILE *f; int i; lockGlobalParams; for (i = 0; i < fontDirs->getLength(); ++i) { dir = (GString *)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; } GString *GlobalParams::getInitialZoom() { GString *s; lockGlobalParams; s = initialZoom->copy(); unlockGlobalParams; return s; } GBool GlobalParams::getContinuousView() { GBool f; lockGlobalParams; f = continuousView; unlockGlobalParams; return f; } GBool GlobalParams::getEnableT1lib() { GBool f; lockGlobalParams; f = enableT1lib; unlockGlobalParams; return f; } 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; } GList *GlobalParams::getKeyBinding(int code, int mods, int context) { KeyBinding *binding; GList *cmds; int modMask; int i, j; lockGlobalParams; cmds = NULL; // for ASCII chars, ignore the shift modifier modMask = code <= 0xff ? ~xpdfKeyModShift : ~0; for (i = 0; i < keyBindings->getLength(); ++i) { binding = (KeyBinding *)keyBindings->get(i); if (binding->code == code && (binding->mods & modMask) == (mods & modMask) && (~binding->context | context) == ~0) { cmds = new GList(); for (j = 0; j < binding->cmds->getLength(); ++j) { cmds->append(((GString *)binding->cmds->get(j))->copy()); } break; } } unlockGlobalParams; return cmds; } GBool GlobalParams::getPrintCommands() { GBool p; lockGlobalParams; p = printCommands; unlockGlobalParams; return p; } GBool GlobalParams::getErrQuiet() { // no locking -- this function may get called from inside a locked // section return errQuiet; } CharCodeToUnicode *GlobalParams::getCIDToUnicode(GString *collection) { GString *fileName; CharCodeToUnicode *ctu; lockGlobalParams; if (!(ctu = cidToUnicodeCache->getCharCodeToUnicode(collection))) { if ((fileName = (GString *)cidToUnicodes->lookup(collection)) && (ctu = CharCodeToUnicode::parseCIDToUnicode(fileName, collection))) { cidToUnicodeCache->add(ctu); } } unlockGlobalParams; return ctu; } CharCodeToUnicode *GlobalParams::getUnicodeToUnicode(GString *fontName) { CharCodeToUnicode *ctu; GHashIter *iter; GString *fontPattern, *fileName; lockGlobalParams; fileName = NULL; unicodeToUnicodes->startIter(&iter); while (unicodeToUnicodes->getNext(&iter, &fontPattern, (void **)&fileName)) { if (strstr(fontName->getCString(), fontPattern->getCString())) { unicodeToUnicodes->killIter(&iter); break; } fileName = NULL; } if (fileName) { if (!(ctu = unicodeToUnicodeCache->getCharCodeToUnicode(fileName))) { if ((ctu = CharCodeToUnicode::parseUnicodeToUnicode(fileName))) { unicodeToUnicodeCache->add(ctu); } } } else { ctu = NULL; } unlockGlobalParams; return ctu; } UnicodeMap *GlobalParams::getUnicodeMap(GString *encodingName) { return getUnicodeMap2(encodingName); } UnicodeMap *GlobalParams::getUnicodeMap2(GString *encodingName) { UnicodeMap *map; if (!(map = getResidentUnicodeMap(encodingName))) { lockUnicodeMapCache; map = unicodeMapCache->getUnicodeMap(encodingName); unlockUnicodeMapCache; } return map; } CMap *GlobalParams::getCMap(GString *collection, GString *cMapName) { CMap *cMap; lockCMapCache; cMap = cMapCache->getCMap(collection, cMapName); unlockCMapCache; return cMap; } UnicodeMap *GlobalParams::getTextEncoding() { return getUnicodeMap2(textEncoding); } //------------------------------------------------------------------------ // functions to set parameters //------------------------------------------------------------------------ void GlobalParams::addDisplayFont(DisplayFontParam *param) { DisplayFontParam *old; lockGlobalParams; if ((old = (DisplayFontParam *)displayFonts->remove(param->name))) { delete old; } displayFonts->add(param->name, param); unlockGlobalParams; } void GlobalParams::setPSFile(char *file) { lockGlobalParams; if (psFile) { delete psFile; } psFile = new GString(file); unlockGlobalParams; } GBool GlobalParams::setPSPaperSize(char *size) { lockGlobalParams; if (!strcmp(size, "match")) { psPaperWidth = psPaperHeight = -1; } else if (!strcmp(size, "letter")) { psPaperWidth = 612; psPaperHeight = 792; } else if (!strcmp(size, "legal")) { psPaperWidth = 612; psPaperHeight = 1008; } else if (!strcmp(size, "A4")) { psPaperWidth = 595; psPaperHeight = 842; } else if (!strcmp(size, "A3")) { psPaperWidth = 842; psPaperHeight = 1190; } else { unlockGlobalParams; return gFalse; } psImageableLLX = psImageableLLY = 0; psImageableURX = psPaperWidth; psImageableURY = psPaperHeight; unlockGlobalParams; return gTrue; } void GlobalParams::setPSPaperWidth(int width) { lockGlobalParams; psPaperWidth = width; psImageableLLX = 0; psImageableURX = psPaperWidth; unlockGlobalParams; } void GlobalParams::setPSPaperHeight(int height) { lockGlobalParams; psPaperHeight = height; psImageableLLY = 0; psImageableURY = psPaperHeight; unlockGlobalParams; } void GlobalParams::setPSImageableArea(int llx, int lly, int urx, int ury) { lockGlobalParams; psImageableLLX = llx; psImageableLLY = lly; psImageableURX = urx; psImageableURY = ury; unlockGlobalParams; } void GlobalParams::setPSCrop(GBool crop) { lockGlobalParams; psCrop = crop; unlockGlobalParams; } 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::setPSDuplex(GBool duplex) { lockGlobalParams; psDuplex = duplex; 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::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 GString(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; } void GlobalParams::setInitialZoom(char *s) { lockGlobalParams; delete initialZoom; initialZoom = new GString(s); unlockGlobalParams; } void GlobalParams::setContinuousView(GBool cont) { lockGlobalParams; continuousView = cont; unlockGlobalParams; } GBool GlobalParams::setEnableT1lib(char *s) { GBool ok; lockGlobalParams; ok = parseYesNo2(s, &enableT1lib); unlockGlobalParams; return ok; } 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::setScreenType(ScreenType t) { lockGlobalParams; screenType = t; unlockGlobalParams; } void GlobalParams::setScreenSize(int size) { lockGlobalParams; screenSize = size; unlockGlobalParams; } void GlobalParams::setScreenDotRadius(int r) { lockGlobalParams; screenDotRadius = r; unlockGlobalParams; } void GlobalParams::setScreenGamma(double gamma) { lockGlobalParams; screenGamma = gamma; unlockGlobalParams; } void GlobalParams::setScreenBlackThreshold(double thresh) { lockGlobalParams; screenBlackThreshold = thresh; unlockGlobalParams; } void GlobalParams::setScreenWhiteThreshold(double thresh) { lockGlobalParams; screenWhiteThreshold = thresh; 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::setErrQuiet(GBool errQuietA) { lockGlobalParams; errQuiet = errQuietA; unlockGlobalParams; } void GlobalParams::addSecurityHandler(XpdfSecurityHandler *handler) { #ifdef ENABLE_PLUGINS lockGlobalParams; securityHandlers->append(handler); unlockGlobalParams; #else (void)handler; #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; } 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