pengjunjie/core
1
0
Fork 1
mirror of https://github.com/ONLYOFFICE/core.git synced 2026-07-11 14:00:32 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
0655ef49e5cf6d6d42bbfa108433c29cd6fa187b
core/PdfReader/Src/Adaptors.cpp
KirillovIlya 5e7b33ba61 Add CMaps
2022-03-26 22:59:26 +03:00

319 lines
10 KiB
C++
Raw Blame History

#include "Adaptors.h"
#include "./lib/xpdf/NameToCharCode.h"
void GlobalParamsAdaptor::SetFontManager(NSFonts::IFontManager *pFontManager)
{
m_pFontManager = pFontManager;
}
void GlobalParamsAdaptor::SetCMapFolder(const std::wstring &wsFolder)
{
m_wsCMapFolder = wsFolder;
GString* sFolder = NSStrings::CreateString(wsFolder);
if (!sFolder)
return;
unicodeMaps->add(new GString("ISO-8859-6"), sFolder->copy()->append("/ISO-8859-6.unicodeMap"));
unicodeMaps->add(new GString("ISO-2022-CN"), sFolder->copy()->append("/ISO-2022-CN.unicodeMap"));
unicodeMaps->add(new GString("EUC-CN"), sFolder->copy()->append("/EUC-CN.unicodeMap"));
unicodeMaps->add(new GString("GBK"), sFolder->copy()->append("/GBK.unicodeMap"));
unicodeMaps->add(new GString("KOI8-R"), sFolder->copy()->append("/KOI8-R.unicodeMap"));
unicodeMaps->add(new GString("ISO-8859-7"), sFolder->copy()->append("/ISO-8859-7.unicodeMap"));
unicodeMaps->add(new GString("ISO-8859-8"), sFolder->copy()->append("/ISO-8859-8.unicodeMap"));
unicodeMaps->add(new GString("Windows-1255"), sFolder->copy()->append("/Windows-1255.unicodeMap"));
unicodeMaps->add(new GString("ISO-2022-JP"), sFolder->copy()->append("/ISO-2022-JP.unicodeMap"));
unicodeMaps->add(new GString("EUC-JP"), sFolder->copy()->append("/EUC-JP.unicodeMap"));
unicodeMaps->add(new GString("Shift-JIS"), sFolder->copy()->append("/Shift-JIS.unicodeMap"));
unicodeMaps->add(new GString("ISO-2022-KR"), sFolder->copy()->append("/ISO-2022-KR.unicodeMap"));
unicodeMaps->add(new GString("TIS-620"), sFolder->copy()->append("/TIS-620.unicodeMap"));
unicodeMaps->add(new GString("ISO-8859-9"), sFolder->copy()->append("/ISO-8859-9.unicodeMap"));
unicodeMaps->add(new GString("Latin2"), sFolder->copy()->append("/Latin2.unicodeMap"));
cidToUnicodes->add(new GString("Adobe-GB1"), sFolder->copy()->append("/Adobe-GB1.cidToUnicode"));
cidToUnicodes->add(new GString("Adobe-Korea1"), sFolder->copy()->append("/Adobe-Korea1.cidToUnicode"));
cidToUnicodes->add(new GString("Adobe-KR"), sFolder->copy()->append("/Adobe-KR.cidToUnicode"));
cidToUnicodes->add(new GString("Adobe-Japan1"), sFolder->copy()->append("/Adobe-Japan1.cidToUnicode"));
AddNameToUnicode(GString(sFolder->getCString()).append("/Bulgarian.nameToUnicode")->getCString());
AddNameToUnicode(GString(sFolder->getCString()).append("/Greek.nameToUnicode")->getCString());
AddNameToUnicode(GString(sFolder->getCString()).append("/Thai.nameToUnicode")->getCString());
AddCMapFolder("Adobe-GB1", sFolder);
AddCMapFolder("Adobe-Japan1", sFolder);
AddCMapFolder("Adobe-Korea1", sFolder);
AddCMapFolder("Adobe-KR", sFolder);
toUnicodeDirs->append(sFolder->copy()->append("/CMap"));
}
void GlobalParamsAdaptor::AddNameToUnicode(const char* sFile)
{
char *tok1, *tok2;
FILE *f;
char buf[256];
Unicode u;
if (!(f = openFile(sFile, "r")))
return;
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);
}
}
fclose(f);
}
void GlobalParamsAdaptor::AddCMapFolder(const char* sCollection, GString* sFolder)
{
GList *pList = new GList();
if (!pList)
return;
pList->append(sFolder->copy()->append("/CMap"));
cMapDirs->add(new GString(sCollection), pList);
}
bool operator==(const Ref &a, const Ref &b)
{
return a.gen == b.gen && a.num == b.gen;
}
bool operator<(const Ref &a, const Ref &b)
{
if (a.num < b.num)
return true;
else if (a.num == b.num)
return a.gen < b.gen;
else
return false;
}
bool operator<=(const Ref &a, const Ref &b)
{
return (a < b) || (a == b);
}
bool operator>=(const Ref &a, const Ref &b)
{
return !(a < b);
}
bool operator>(const Ref &a, const Ref &b)
{
return !(a <= b);
}
namespace NSStrings
{
GString *CreateString(const std::wstring &str)
{
std::string sUtf8 = U_TO_UTF8(str);
return new GString(sUtf8.c_str(), sUtf8.length());
}
GString *CreateString(const std::string &str)
{
return new GString(str.c_str(), str.length());
}
std::wstring GetString(GString *str)
{
if (!str)
return L"";
return NSFile::CUtf8Converter::GetUnicodeStringFromUTF8((BYTE *) str->getCString(), (LONG) str->getLength());
}
std::string GetStringA(GString *str)
{
return std::string(str->getCString(), str->getLength());
}
}
void XMLConverter::XRefToXml(XRef &xref, std::wstring &wsXml, bool bParseStreams)
{
for (int nNum = 0; nNum < xref.getSize(); ++nNum)
{
XRefEntry *pEntry = xref.getEntry(nNum);
if (xrefEntryFree != pEntry->type)
{
Object oTemp;
xref.fetch(nNum, 0/*pEntry->nGen*/, &oTemp);
if (oTemp.isDict() || oTemp.isStream())
{
if (xrefEntryCompressed == pEntry->type)
wsXml +=
L"<Obj num=\"" + std::to_wstring(nNum) + L"\" gen=\"" + std::to_wstring(0/*pEntry->nGen*/) +
L"\" compressed=\"true\">";
else
wsXml +=
L"<Obj num=\"" + std::to_wstring(nNum) + L"\" gen=\"" + std::to_wstring(0/*pEntry->nGen*/) +
L"\">";
if (oTemp.isDict())
{
ObjectToXml(&oTemp, wsXml);
} else if (oTemp.isStream())
{
Dict *pStreamDict = oTemp.streamGetDict();
StreamDictToXml(pStreamDict, wsXml);
wsXml += L"<Stream>";
if (bParseStreams)
{
std::wstring wsTemp;
Stream *pStream = oTemp.getStream();
pStream->reset();
Object oFilter;
pStreamDict->lookup("Filter", &oFilter);
if (oFilter.isNull() || oFilter.isName("FlateDecode"))
{
int nChar;
while (EOF != (nChar = pStream->getChar()))
{
char sTemp[1] = {(char) nChar};
switch (sTemp[0])
{
case '\"':
wsTemp += L"&quot;";
break;
case '&':
wsTemp += L"&amp;";
break;
case '<':
wsTemp += L"&lt;";
break;
case '>':
wsTemp += L"&gt;";
break;
default:
AppendStringToXml(wsTemp, std::string(sTemp));
}
}
} else
{
wsXml += L"BinaryData";
}
wsXml += wsTemp;
}
wsXml += L"</Stream>";
}
wsXml += L"</Obj>";
}
oTemp.free();
}
}
}
void XMLConverter::ObjectToXml(Object *obj, std::wstring &wsXml)
{
Object oTemp;
switch (obj->getType())
{
case objBool:
wsXml += obj->getBool() ? L"true" : L"false";
break;
case objInt:
wsXml += std::to_wstring(obj->getInt());
break;
case objReal:
wsXml += std::to_wstring(obj->getReal());
break;
case objString:
wsXml += L"(";
AppendStringToXml(wsXml, obj->getString()->getCString());
wsXml += L")";
break;
case objName:
wsXml += L"/";
AppendStringToXml(wsXml, obj->getName());
break;
case objNull:
wsXml += L"null";
break;
case objArray:
wsXml += L"[";
for (int nIndex = 0; nIndex < obj->arrayGetLength(); ++nIndex)
{
if (nIndex > 0)
wsXml += L" ";
obj->arrayGet(nIndex, &oTemp);
ObjectToXml(&oTemp, wsXml);
oTemp.free();
}
wsXml += L"]";
break;
case objDict:
for (int nIndex = 0; nIndex < obj->dictGetLength(); ++nIndex)
{
char *sKey = obj->dictGetKey(nIndex);
wsXml += L"<";
AppendStringToXml(wsXml, sKey);
wsXml += L">";
obj->dictGetVal(nIndex, &oTemp);
ObjectToXml(&oTemp, wsXml);
oTemp.free();
wsXml += L"</";
AppendStringToXml(wsXml, sKey);
wsXml += L">";
}
break;
case objStream:
wsXml += L"<stream/>";
// TODO: Запись стрима
break;
case objRef:
wsXml += std::to_wstring(obj->getRefNum());
wsXml += L" ";
wsXml += std::to_wstring(obj->getRefGen());
wsXml += L" R";
break;
case objCmd:
AppendStringToXml(wsXml, obj->getCmd());
break;
case objError:
wsXml += L"error";
break;
case objEOF:
wsXml += L"EOF";
break;
case objNone:
wsXml += L"none";
break;
}
}
void XMLConverter::StreamDictToXml(Dict *dict, std::wstring &wsXml)
{
Object oTemp;
for (int nIndex = 0; nIndex < dict->getLength(); ++nIndex)
{
char *sKey = dict->getKey(nIndex);
wsXml += L"<";
AppendStringToXml(wsXml, sKey);
wsXml += L">";
dict->getVal(nIndex, &oTemp);
ObjectToXml(&oTemp, wsXml);
oTemp.free();
wsXml += L"</";
AppendStringToXml(wsXml, sKey);
wsXml += L">";
}
}
Reference in New Issue View Git Blame Copy Permalink