CPDF_IccProfile* CPDF_DocPageData::GetIccProfile(
CPDF_Stream* pIccProfileStream) {
if (!pIccProfileStream)
return NULL;
auto it = m_IccProfileMap.find(pIccProfileStream);
if (it != m_IccProfileMap.end()) {
return it->second->AddRef();
}
CPDF_StreamAcc stream;
stream.LoadAllData(pIccProfileStream, FALSE);
uint8_t digest[20];
CRYPT_SHA1Generate(stream.GetData(), stream.GetSize(), digest);
auto hash_it = m_HashProfileMap.find(CFX_ByteStringC(digest, 20));
if (hash_it != m_HashProfileMap.end()) {
auto it_copied_stream = m_IccProfileMap.find(hash_it->second);
return it_copied_stream->second->AddRef();
}
CPDF_IccProfile* pProfile =
new CPDF_IccProfile(stream.GetData(), stream.GetSize());
CPDF_CountedIccProfile* ipData = new CPDF_CountedIccProfile(pProfile);
m_IccProfileMap[pIccProfileStream] = ipData;
m_HashProfileMap[CFX_ByteStringC(digest, 20)] = pIccProfileStream;
return ipData->AddRef();
}
CPDF_IccProfile* CPDF_DocPageData::GetIccProfile(CPDF_Stream* pIccProfileStream, FX_INT32 nComponents)
{
if (!pIccProfileStream) {
return NULL;
}
CPDF_CountedObject<CPDF_IccProfile*>* ipData = NULL;
if (m_IccProfileMap.Lookup(pIccProfileStream, ipData)) {
ipData->m_nCount++;
return ipData->m_Obj;
}
CPDF_StreamAcc stream;
stream.LoadAllData(pIccProfileStream, FALSE);
FX_BYTE digest[20];
CPDF_Stream* pCopiedStream = NULL;
CRYPT_SHA1Generate(stream.GetData(), stream.GetSize(), digest);
if (m_HashProfileMap.Lookup(CFX_ByteStringC(digest, 20), (void*&)pCopiedStream)) {
m_IccProfileMap.Lookup(pCopiedStream, ipData);
ipData->m_nCount++;
return ipData->m_Obj;
}
CPDF_IccProfile* pProfile = FX_NEW CPDF_IccProfile(stream.GetData(), stream.GetSize(), nComponents);
if (!pProfile) {
return NULL;
}
ipData = FX_NEW CPDF_CountedObject<CPDF_IccProfile*>;
if (!ipData) {
delete pProfile;
return NULL;
}
ipData->m_nCount = 2;
ipData->m_Obj = pProfile;
m_IccProfileMap.SetAt(pIccProfileStream, ipData);
m_HashProfileMap.SetAt(CFX_ByteStringC(digest, 20), pIccProfileStream);
return pProfile;
}
void CFX_SAXReader::NotifyAttribute() {
FXSYS_assert(m_pHandler != NULL);
if (m_pCurItem->m_eNode == FX_SAXNODE_Tag ||
m_pCurItem->m_eNode == FX_SAXNODE_Instruction) {
m_pHandler->OnTagAttribute(m_pCurItem->m_pNode,
CFX_ByteStringC(m_pszName, m_iNameLength),
CFX_ByteStringC(m_pszData, m_iDataLength));
}
}
static CFX_ByteStringC _CompactStringGet(_CompactString* pCompact) {
if (pCompact->m_CompactLen == 0xff) {
return CFX_ByteStringC(pCompact->m_pBuffer,
pCompact->m_LenHigh * 256 + pCompact->m_LenLow);
}
if (pCompact->m_CompactLen == 0xfe) {
return CFX_ByteStringC();
}
return CFX_ByteStringC(&pCompact->m_LenHigh, pCompact->m_CompactLen);
}
void CFX_SAXReader::NotifyTargetData() {
FXSYS_assert(m_pHandler != NULL);
if (m_pCurItem->m_eNode == FX_SAXNODE_Instruction) {
m_pHandler->OnTargetData(m_pCurItem->m_pNode, m_pCurItem->m_eNode,
CFX_ByteStringC(m_pszName, m_iNameLength),
m_dwNodePos);
} else if (m_pCurItem->m_eNode == FX_SAXNODE_Comment) {
m_pHandler->OnTargetData(m_pCurItem->m_pNode, m_pCurItem->m_eNode,
CFX_ByteStringC(m_pszData, m_iDataLength),
m_dwNodePos);
}
}
FX_BOOL CPDF_PSProc::Parse(CPDF_SimpleParser& parser)
{
while (1) {
CFX_ByteStringC word = parser.GetWord();
if (word.IsEmpty()) {
return FALSE;
}
if (word == FX_BSTRC("}")) {
return TRUE;
}
if (word == FX_BSTRC("{")) {
CPDF_PSProc* pProc = FX_NEW CPDF_PSProc;
m_Operators.Add((FX_LPVOID)PSOP_PROC);
m_Operators.Add(pProc);
if (!pProc->Parse(parser)) {
return FALSE;
}
} else {
int i = 0;
while (_PDF_PSOpNames[i].name) {
if (word == CFX_ByteStringC(_PDF_PSOpNames[i].name)) {
m_Operators.Add((FX_LPVOID)_PDF_PSOpNames[i].op);
break;
}
i ++;
}
if (_PDF_PSOpNames[i].name == NULL) {
FX_FLOAT* pd = FX_Alloc(FX_FLOAT, 1);
*pd = FX_atof(word);
m_Operators.Add((FX_LPVOID)PSOP_CONST);
m_Operators.Add(pd);
}
}
}
}
FX_BOOL CPDF_IndexedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
{
if (pArray->GetCount() < 4) {
return FALSE;
}
CPDF_Object* pBaseObj = pArray->GetElementValue(1);
if (pBaseObj == m_pArray) {
return FALSE;
}
CPDF_DocPageData* pDocPageData = pDoc->GetPageData();
m_pBaseCS = pDocPageData->GetColorSpace(pBaseObj, NULL);
if (m_pBaseCS == NULL) {
return FALSE;
}
m_nBaseComponents = m_pBaseCS->CountComponents();
m_pCompMinMax = FX_Alloc(FX_FLOAT, m_nBaseComponents * 2);
FX_FLOAT defvalue;
for (int i = 0; i < m_nBaseComponents; i ++) {
m_pBaseCS->GetDefaultValue(i, defvalue, m_pCompMinMax[i * 2], m_pCompMinMax[i * 2 + 1]);
m_pCompMinMax[i * 2 + 1] -= m_pCompMinMax[i * 2];
}
m_MaxIndex = pArray->GetInteger(2);
CPDF_Object* pTableObj = pArray->GetElementValue(3);
if (pTableObj == NULL) {
return FALSE;
}
if (pTableObj->GetType() == PDFOBJ_STRING) {
m_Table = ((CPDF_String*)pTableObj)->GetString();
} else if (pTableObj->GetType() == PDFOBJ_STREAM) {
CPDF_StreamAcc acc;
acc.LoadAllData((CPDF_Stream*)pTableObj, FALSE);
m_Table = CFX_ByteStringC(acc.GetData(), acc.GetSize());
}
return TRUE;
}
FX_BOOL CPDF_PSProc::Parse(CPDF_SimpleParser* parser) {
while (1) {
CFX_ByteStringC word = parser->GetWord();
if (word.IsEmpty()) {
return FALSE;
}
if (word == "}") {
return TRUE;
}
if (word == "{") {
std::unique_ptr<CPDF_PSProc> proc(new CPDF_PSProc);
std::unique_ptr<CPDF_PSOP> op(new CPDF_PSOP(std::move(proc)));
m_Operators.push_back(std::move(op));
if (!m_Operators.back()->GetProc()->Parse(parser)) {
return FALSE;
}
} else {
bool found = false;
for (const PDF_PSOpName& op_name : PDF_PSOpNames) {
if (word == CFX_ByteStringC(op_name.name)) {
std::unique_ptr<CPDF_PSOP> op(new CPDF_PSOP(op_name.op));
m_Operators.push_back(std::move(op));
found = true;
break;
}
}
if (!found) {
std::unique_ptr<CPDF_PSOP> op(new CPDF_PSOP(FX_atof(word)));
m_Operators.push_back(std::move(op));
}
}
}
}
CFGAS_GEFont* CFGAS_FontMgr::LoadFont(CFGAS_GEFont* pSrcFont,
uint32_t dwFontStyles,
uint16_t wCodePage) {
ASSERT(pSrcFont);
if (pSrcFont->GetFontStyles() == dwFontStyles)
return pSrcFont->Retain();
void* buffer[3] = {pSrcFont, (void*)(uintptr_t)dwFontStyles,
(void*)(uintptr_t)wCodePage};
uint32_t dwHash = FX_HashCode_GetA(
CFX_ByteStringC((uint8_t*)buffer, sizeof(buffer)), false);
CFGAS_GEFont* pFont = nullptr;
if (m_DeriveFonts.GetCount() > 0) {
m_DeriveFonts.Lookup((void*)(uintptr_t)dwHash, (void*&)pFont);
if (pFont)
return pFont->Retain();
}
pFont = pSrcFont->Derive(dwFontStyles, wCodePage);
if (!pFont)
return nullptr;
m_DeriveFonts.SetAt((void*)(uintptr_t)dwHash, (void*)pFont);
int32_t index = m_Fonts.Find(pFont);
if (index < 0) {
m_Fonts.Add(pFont);
pFont->Retain();
}
return pFont;
}
void* CFX_LinuxFontInfo::MapFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, const FX_CHAR* cstr_face, FX_BOOL& bExact)
{
CFX_ByteString face = cstr_face;
int iBaseFont;
for (iBaseFont = 0; iBaseFont < 12; iBaseFont ++)
if (face == CFX_ByteStringC(Base14Substs[iBaseFont].m_pName)) {
face = Base14Substs[iBaseFont].m_pSubstName;
bExact = TRUE;
break;
}
if (iBaseFont < 12) {
return GetFont(face);
}
void* p = NULL;
FX_BOOL bCJK = TRUE;
switch (charset) {
case FXFONT_SHIFTJIS_CHARSET: {
int32_t index = GetJapanesePreference(cstr_face, weight, pitch_family);
if (index < 0) {
break;
}
for (int32_t i = 0; i < LINUX_GPNAMESIZE; i++)
if (m_FontList.Lookup(LinuxGpFontList[index].NameArr[i], p)) {
return p;
}
}
break;
case FXFONT_GB2312_CHARSET: {
static int32_t s_gbCount = sizeof(g_LinuxGbFontList) / sizeof(const FX_CHAR*);
for (int32_t i = 0; i < s_gbCount; i++)
if (m_FontList.Lookup(g_LinuxGbFontList[i], p)) {
return p;
}
}
break;
case FXFONT_CHINESEBIG5_CHARSET: {
static int32_t s_b5Count = sizeof(g_LinuxB5FontList) / sizeof(const FX_CHAR*);
for (int32_t i = 0; i < s_b5Count; i++)
if (m_FontList.Lookup(g_LinuxB5FontList[i], p)) {
return p;
}
}
break;
case FXFONT_HANGEUL_CHARSET: {
static int32_t s_hgCount = sizeof(g_LinuxHGFontList) / sizeof(const FX_CHAR*);
for (int32_t i = 0; i < s_hgCount; i++)
if (m_FontList.Lookup(g_LinuxHGFontList[i], p)) {
return p;
}
}
break;
default:
bCJK = FALSE;
break;
}
if (charset == FXFONT_ANSI_CHARSET && (pitch_family & FXFONT_FF_FIXEDPITCH)) {
return GetFont("Courier New");
}
return FindFont(weight, bItalic, charset, pitch_family, cstr_face, !bCJK);
}
CFX_WideString CFXJS_Engine::ToString(v8::Local<v8::Value> pValue) {
if (pValue.IsEmpty())
return L"";
v8::Local<v8::Context> context = m_isolate->GetCurrentContext();
v8::String::Utf8Value s(pValue->ToString(context).ToLocalChecked());
return CFX_WideString::FromUTF8(CFX_ByteStringC(*s, s.length()));
}
CFX_ByteStringC CPDF_Array::GetConstString(FX_DWORD i) const
{
if (this && i < (FX_DWORD)m_Objects.GetSize()) {
CPDF_Object* p = (CPDF_Object*)m_Objects.GetAt(i);
return p->GetConstString();
}
return CFX_ByteStringC();
}
void CFX_SAXReader::NotifyEnd() {
FXSYS_assert(m_pHandler != NULL);
if (m_pCurItem->m_eNode == FX_SAXNODE_Tag) {
m_pHandler->OnTagEnd(m_pCurItem->m_pNode,
CFX_ByteStringC(m_pszData, m_iDataLength),
m_dwNodePos);
}
}
void CFX_SAXReader::NotifyData() {
FXSYS_assert(m_pHandler != NULL);
if (m_pCurItem->m_eNode == FX_SAXNODE_Tag)
m_pHandler->OnTagData(m_pCurItem->m_pNode,
m_bCharData ? FX_SAXNODE_CharData : FX_SAXNODE_Text,
CFX_ByteStringC(m_pszData, m_iDataLength),
m_File.m_dwCur + m_dwDataOffset);
}
CFX_ByteStringC CPDF_Dictionary::GetConstString(
const CFX_ByteStringC& key) const {
CPDF_Object* p = GetElement(key);
if (p) {
return p->GetConstString();
}
return CFX_ByteStringC();
}
CFX_ByteStringC CPDF_SimpleParser::GetWord() {
const uint8_t* pStart;
FX_DWORD dwSize;
int type;
ParseWord(pStart, dwSize, type);
if (dwSize == 1 && pStart[0] == '<') {
while (m_dwCurPos < m_dwSize && m_pData[m_dwCurPos] != '>') {
m_dwCurPos++;
}
if (m_dwCurPos < m_dwSize) {
m_dwCurPos++;
}
return CFX_ByteStringC(pStart,
(FX_STRSIZE)(m_dwCurPos - (pStart - m_pData)));
}
if (dwSize == 1 && pStart[0] == '(') {
int level = 1;
while (m_dwCurPos < m_dwSize) {
if (m_pData[m_dwCurPos] == ')') {
level--;
if (level == 0) {
break;
}
}
if (m_pData[m_dwCurPos] == '\\') {
if (m_dwSize <= m_dwCurPos) {
break;
}
m_dwCurPos++;
} else if (m_pData[m_dwCurPos] == '(') {
level++;
}
if (m_dwSize <= m_dwCurPos) {
break;
}
m_dwCurPos++;
}
if (m_dwCurPos < m_dwSize) {
m_dwCurPos++;
}
return CFX_ByteStringC(pStart,
(FX_STRSIZE)(m_dwCurPos - (pStart - m_pData)));
}
return CFX_ByteStringC(pStart, dwSize);
}
CFX_ByteStringC CPDF_Dictionary::GetConstString(FX_BSTR key, FX_BSTR def) const
{
CPDF_Object* p = NULL;
m_Map.Lookup(key, (void*&)p);
if (p)
return p->GetConstString();
else
return CFX_ByteStringC(def);
}
CFX_ByteStringC CPDF_Dictionary::GetConstString(const CFX_ByteStringC& key, const CFX_ByteStringC& def) const
{
CPDF_Object* p = NULL;
m_Map.Lookup(key, (void*&)p);
if (p) {
return p->GetConstString();
}
return CFX_ByteStringC(def);
}
void CPDF_StreamContentParser::AddNameParam(const FX_CHAR* name, int len) {
int index = GetNextParamPos();
if (len > 32) {
m_ParamBuf1[index].m_Type = 0;
m_ParamBuf1[index].m_pObject =
new CPDF_Name(PDF_NameDecode(CFX_ByteStringC(name, len)));
} else {
m_ParamBuf1[index].m_Type = PDFOBJ_NAME;
if (!FXSYS_memchr(name, '#', len)) {
FXSYS_memcpy(m_ParamBuf1[index].m_Name.m_Buffer, name, len);
m_ParamBuf1[index].m_Name.m_Len = len;
} else {
CFX_ByteString str = PDF_NameDecode(CFX_ByteStringC(name, len));
FXSYS_memcpy(m_ParamBuf1[index].m_Name.m_Buffer, str.c_str(),
str.GetLength());
m_ParamBuf1[index].m_Name.m_Len = str.GetLength();
}
}
}
CFX_ByteStringC CPDF_Dictionary::GetConstString(FX_BSTR key) const
{
if (this) {
CPDF_Object* p = NULL;
m_Map.Lookup(key, (void*&)p);
if (p) {
return p->GetConstString();
}
}
return CFX_ByteStringC();
}
void CPDF_StreamContentParser::EndNumber()
{
if (m_ObjectSize == 0) {
AddNumberParam((FX_LPCSTR)m_pWordBuf, m_WordSize);
return;
}
CPDF_Number *pObj = FX_NEW CPDF_Number(CFX_ByteStringC(m_pWordBuf, m_WordSize));
if (!SetToCurObj(pObj)) {
pObj->Release();
}
}
CFX_ByteStringC CPDF_Object::GetConstString() const
{
switch (m_Type) {
case PDFOBJ_STRING:
return CFX_ByteStringC((FX_LPCBYTE)((CPDF_String*)this)->m_String, ((CPDF_String*)this)->m_String.GetLength());
case PDFOBJ_NAME:
return CFX_ByteStringC((FX_LPCBYTE)((CPDF_Name*)this)->m_Name, ((CPDF_Name*)this)->m_Name.GetLength());
case PDFOBJ_REFERENCE: {
CPDF_Reference* pRef = (CPDF_Reference*)(FX_LPVOID)this;
if (pRef->m_pObjList == NULL) {
break;
}
CPDF_Object* pObj = pRef->m_pObjList->GetIndirectObject(pRef->m_RefObjNum);
if (pObj == NULL) {
return CFX_ByteStringC();
}
return pObj->GetConstString();
}
}
return CFX_ByteStringC();
}
void FX_XML_SplitQualifiedName(const CFX_ByteStringC& bsFullName,
CFX_ByteStringC& bsSpace,
CFX_ByteStringC& bsName) {
if (bsFullName.IsEmpty()) {
return;
}
int32_t iStart = 0;
for (; iStart < bsFullName.GetLength(); iStart++) {
if (bsFullName.GetAt(iStart) == ':') {
break;
}
}
if (iStart >= bsFullName.GetLength()) {
bsName = bsFullName;
} else {
bsSpace = CFX_ByteStringC(bsFullName.GetCStr(), iStart);
iStart++;
bsName = CFX_ByteStringC(bsFullName.GetCStr() + iStart,
bsFullName.GetLength() - iStart);
}
}
CFX_ByteStringC CPDF_Object::GetConstString() const {
switch (m_Type) {
case PDFOBJ_STRING: {
CFX_ByteString str = AsString()->m_String;
return CFX_ByteStringC((const uint8_t*)str, str.GetLength());
}
case PDFOBJ_NAME: {
CFX_ByteString name = AsName()->m_Name;
return CFX_ByteStringC((const uint8_t*)name, name.GetLength());
}
case PDFOBJ_REFERENCE: {
const CPDF_Reference* pRef = AsReference();
if (!pRef->m_pObjList)
break;
CPDF_Object* pObj =
pRef->m_pObjList->GetIndirectObject(pRef->GetRefObjNum(), nullptr);
return pObj ? pObj->GetConstString() : CFX_ByteStringC();
}
}
return CFX_ByteStringC();
}
void CPDF_StreamContentParser::Handle_ExecuteXObject() {
CFX_ByteString name = GetString(0);
if (name == m_LastImageName && m_pLastImage && m_pLastImage->GetStream() &&
m_pLastImage->GetStream()->GetObjNum()) {
AddImage(nullptr, m_pLastImage, FALSE);
return;
}
if (m_Options.m_bTextOnly) {
if (!m_pResources)
return;
CPDF_Dictionary* pList = m_pResources->GetDict("XObject");
if (!pList && m_pPageResources && m_pResources != m_pPageResources)
pList = m_pPageResources->GetDict("XObject");
if (!pList)
return;
CPDF_Reference* pRes = ToReference(pList->GetElement(name));
if (!pRes)
return;
FX_BOOL bForm;
if (m_pDocument->IsFormStream(pRes->GetRefObjNum(), bForm) && !bForm)
return;
}
CPDF_Stream* pXObject = ToStream(FindResourceObj("XObject", name));
if (!pXObject) {
m_bResourceMissing = TRUE;
return;
}
CFX_ByteStringC type = pXObject->GetDict()
? pXObject->GetDict()->GetConstString("Subtype")
: CFX_ByteStringC();
if (type == "Image") {
if (m_Options.m_bTextOnly) {
return;
}
CPDF_ImageObject* pObj = AddImage(pXObject, NULL, FALSE);
m_LastImageName = name;
m_pLastImage = pObj->m_pImage;
if (!m_pObjectList->m_bHasImageMask)
m_pObjectList->m_bHasImageMask = m_pLastImage->IsMask();
} else if (type == "Form") {
AddForm(pXObject);
} else {
return;
}
}
CFX_ByteString _FPDF_GetNameFromTT(FX_LPCBYTE name_table, FX_DWORD name_id)
{
FX_LPCBYTE ptr = name_table + 2;
int name_count = GET_TT_SHORT(ptr);
int string_offset = GET_TT_SHORT(ptr + 2);
FX_LPCBYTE string_ptr = name_table + string_offset;
ptr += 4;
for (int i = 0; i < name_count; i ++) {
if (GET_TT_SHORT(ptr + 6) == name_id && GET_TT_SHORT(ptr) == 1 && GET_TT_SHORT(ptr + 2) == 0) {
return CFX_ByteStringC(string_ptr + GET_TT_SHORT(ptr + 10), GET_TT_SHORT(ptr + 8));
}
ptr += 12;
}
return CFX_ByteString();
}
void* CFX_MacFontInfo::MapFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, FX_LPCSTR cstr_face, FX_BOOL& bExact)
{
CFX_ByteString face = cstr_face;
int iBaseFont;
for (iBaseFont = 0; iBaseFont < 12; iBaseFont ++)
if (face == CFX_ByteStringC(Base14Substs[iBaseFont].m_pName)) {
face = Base14Substs[iBaseFont].m_pSubstName;
bExact = TRUE;
break;
}
if (iBaseFont < 12) {
return GetFont(face);
}
FX_LPVOID p;
if (m_FontList.Lookup(face, p)) {
return p;
}
if (charset == FXFONT_ANSI_CHARSET && (pitch_family & FXFONT_FF_FIXEDPITCH)) {
return GetFont("Courier New");
}
if (charset == FXFONT_ANSI_CHARSET || charset == FXFONT_SYMBOL_CHARSET) {
return NULL;
}
switch (charset) {
case FXFONT_SHIFTJIS_CHARSET:
GetJapanesePreference(face, weight, pitch_family);
break;
case FXFONT_GB2312_CHARSET:
face = "STSong";
break;
case FXFONT_HANGEUL_CHARSET:
face = "AppleMyungjo";
break;
case FXFONT_CHINESEBIG5_CHARSET:
face = "LiSong Pro Light";
}
if (m_FontList.Lookup(face, p)) {
return p;
}
return NULL;
}
FX_BOOL CPDF_IndexedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray) {
if (pArray->GetCount() < 4) {
return FALSE;
}
CPDF_Object* pBaseObj = pArray->GetElementValue(1);
if (pBaseObj == m_pArray) {
return FALSE;
}
CPDF_DocPageData* pDocPageData = pDoc->GetPageData();
m_pBaseCS = pDocPageData->GetColorSpace(pBaseObj, NULL);
if (!m_pBaseCS) {
return FALSE;
}
m_pCountedBaseCS = pDocPageData->FindColorSpacePtr(m_pBaseCS->GetArray());
m_nBaseComponents = m_pBaseCS->CountComponents();
m_pCompMinMax = FX_Alloc2D(FX_FLOAT, m_nBaseComponents, 2);
FX_FLOAT defvalue;
for (int i = 0; i < m_nBaseComponents; i++) {
m_pBaseCS->GetDefaultValue(i, defvalue, m_pCompMinMax[i * 2],
m_pCompMinMax[i * 2 + 1]);
m_pCompMinMax[i * 2 + 1] -= m_pCompMinMax[i * 2];
}
m_MaxIndex = pArray->GetInteger(2);
CPDF_Object* pTableObj = pArray->GetElementValue(3);
if (!pTableObj)
return FALSE;
if (CPDF_String* pString = pTableObj->AsString()) {
m_Table = pString->GetString();
} else if (CPDF_Stream* pStream = pTableObj->AsStream()) {
CPDF_StreamAcc acc;
acc.LoadAllData(pStream, FALSE);
m_Table = CFX_ByteStringC(acc.GetData(), acc.GetSize());
}
return TRUE;
}
CFX_ByteStringC CFX_BinaryBuf::GetByteString() const {
return CFX_ByteStringC(m_pBuffer, m_DataSize);
}
FXFT_Face CFX_FontMapper::FindSubstFont(const CFX_ByteString& name, FX_BOOL bTrueType, FX_DWORD flags,
int weight, int italic_angle, int WindowCP, CFX_SubstFont* pSubstFont)
{
if (!(flags & FXFONT_USEEXTERNATTR)) {
weight = FXFONT_FW_NORMAL;
italic_angle = 0;
}
CFX_ByteString SubstName = name;
SubstName.Remove(0x20);
if (bTrueType) {
if (name[0] == '@') {
SubstName = name.Mid(1);
}
}
_PDF_GetStandardFontName(SubstName);
if (SubstName == FX_BSTRC("Symbol") && !bTrueType) {
pSubstFont->m_Family = "Chrome Symbol";
pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
if (m_FoxitFaces[12]) {
return m_FoxitFaces[12];
}
FX_LPCBYTE pFontData = NULL;
FX_DWORD size = 0;
m_pFontMgr->GetStandardFont(pFontData, size, 12);
m_FoxitFaces[12] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
return m_FoxitFaces[12];
}
if (SubstName == FX_BSTRC("ZapfDingbats")) {
pSubstFont->m_Family = "Chrome Dingbats";
pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
if (m_FoxitFaces[13]) {
return m_FoxitFaces[13];
}
FX_LPCBYTE pFontData = NULL;
FX_DWORD size = 0;
m_pFontMgr->GetStandardFont(pFontData, size, 13);
m_FoxitFaces[13] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
return m_FoxitFaces[13];
}
int iBaseFont = 0;
CFX_ByteString family, style;
FX_BOOL bHasComma = FALSE;
FX_BOOL bHasHypen = FALSE;
int find = SubstName.Find(FX_BSTRC(","), 0);
if (find >= 0) {
family = SubstName.Left(find);
_PDF_GetStandardFontName(family);
style = SubstName.Mid(find + 1);
bHasComma = TRUE;
} else {
family = SubstName;
}
for (; iBaseFont < 12; iBaseFont ++)
if (family == CFX_ByteStringC(g_Base14FontNames[iBaseFont])) {
break;
}
int PitchFamily = 0;
FX_BOOL bItalic = FALSE;
FX_DWORD nStyle = 0;
FX_BOOL bStyleAvail = FALSE;
FX_BOOL bFamilyStyleIsWhole = FALSE;
FX_BOOL bNextF = FALSE;
if (iBaseFont < 12) {
family = g_Base14FontNames[iBaseFont];
if ((iBaseFont % 4) == 1 || (iBaseFont % 4) == 2) {
nStyle |= FX_FONT_STYLE_Bold;
}
if ((iBaseFont % 4) / 2) {
nStyle |= FX_FONT_STYLE_Italic;
}
if (iBaseFont < 4) {
PitchFamily |= FXFONT_FF_FIXEDPITCH;
}
if (iBaseFont >= 8) {
PitchFamily |= FXFONT_FF_ROMAN;
}
} else {
if (!bHasComma) {
find = family.ReverseFind('-');
if (find >= 0) {
style = family.Mid(find + 1);
family = family.Left(find);
bHasHypen = TRUE;
}
}
if (!bHasHypen) {
int nLen = family.GetLength();
FX_INT32 nRet = GetStyleType(family, TRUE);
if (nRet > -1) {
family = family.Left(nLen - g_FontStyles[nRet].len);
if (nRet == 0) {
nStyle |= FX_FONT_STYLE_Bold;
}
if (nRet == 1) {
nStyle |= FX_FONT_STYLE_Italic;
}
if (nRet == 2) {
nStyle |= (FX_FONT_STYLE_Bold | FX_FONT_STYLE_Italic);
}
}
}
if (flags & FXFONT_SERIF) {
PitchFamily |= FXFONT_FF_ROMAN;
}
if (flags & FXFONT_SCRIPT) {
PitchFamily |= FXFONT_FF_SCRIPT;
}
if (flags & FXFONT_FIXED_PITCH) {
PitchFamily |= FXFONT_FF_FIXEDPITCH;
}
}
if (!style.IsEmpty()) {
int nLen = style.GetLength();
FX_LPCSTR pStyle = style;
int i = 0;
FX_BOOL bFirstItem = TRUE;
CFX_ByteString buf;
while (i < nLen) {
buf = ParseStyle(pStyle, nLen, i);
FX_INT32 nRet = GetStyleType(buf, FALSE);
if ((i && !bStyleAvail) || (!i && nRet < 0)) {
family = SubstName;
iBaseFont = 12;
break;
} else if (nRet >= 0) {
bStyleAvail = TRUE;
}
if (nRet == 0) {
if (nStyle & FX_FONT_STYLE_Bold) {
nStyle |= FX_FONT_STYLE_BoldBold;
} else {
nStyle |= FX_FONT_STYLE_Bold;
}
bFirstItem = FALSE;
}
if (nRet == 1) {
if (bFirstItem) {
nStyle |= FX_FONT_STYLE_Italic;
} else {
family = SubstName;
iBaseFont = 12;
}
break;
}
if (nRet == 2) {
nStyle |= FX_FONT_STYLE_Italic;
if (nStyle & FX_FONT_STYLE_Bold) {
nStyle |= FX_FONT_STYLE_BoldBold;
} else {
nStyle |= FX_FONT_STYLE_Bold;
}
bFirstItem = FALSE;
}
i += buf.GetLength() + 1;
}
}
weight = weight ? weight : FXFONT_FW_NORMAL;
int old_weight = weight;
if (nStyle) {
weight = nStyle & FX_FONT_STYLE_BoldBold ? 900 : (nStyle & FX_FONT_STYLE_Bold ? FXFONT_FW_BOLD : FXFONT_FW_NORMAL);
}
if (nStyle & FX_FONT_STYLE_Italic) {
bItalic = TRUE;
}
FX_BOOL bCJK = FALSE;
FX_BOOL bExact = FALSE;
int Charset = FXFONT_ANSI_CHARSET;
if (WindowCP) {
Charset = _GetCharsetFromCodePage(WindowCP);
} else if (iBaseFont == 12 && (flags & FXFONT_SYMBOLIC)) {
Charset = FXFONT_SYMBOL_CHARSET;
}
if (Charset == FXFONT_SHIFTJIS_CHARSET || Charset == FXFONT_GB2312_CHARSET ||
Charset == FXFONT_HANGEUL_CHARSET || Charset == FXFONT_CHINESEBIG5_CHARSET) {
bCJK = TRUE;
}
if (m_pFontInfo == NULL) {
pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
return UseInternalSubst(pSubstFont, iBaseFont, italic_angle, old_weight, PitchFamily);
}
family = _GetFontFamily(family, nStyle);
CFX_ByteString match = MatchInstalledFonts(_TT_NormalizeName(family));
if (match.IsEmpty() && family != SubstName && (!bHasComma && (!bHasHypen || (bHasHypen && !bStyleAvail)))) {
match = MatchInstalledFonts(_TT_NormalizeName(SubstName));
}
if (match.IsEmpty() && iBaseFont >= 12) {
if (!bCJK) {
if (!CheckSupportThirdPartFont(family, PitchFamily)) {
if (italic_angle != 0) {
bItalic = TRUE;
} else {
bItalic = FALSE;
}
weight = old_weight;
}
} else {
pSubstFont->m_bSubstOfCJK = TRUE;
if (nStyle) {
pSubstFont->m_WeightCJK = weight;
} else {
pSubstFont->m_WeightCJK = FXFONT_FW_NORMAL;
}
if (nStyle & FX_FONT_STYLE_Italic) {
pSubstFont->m_bItlicCJK = TRUE;
}
}
} else {
italic_angle = 0;
weight = nStyle & FX_FONT_STYLE_BoldBold ? 900 : (nStyle & FX_FONT_STYLE_Bold ? FXFONT_FW_BOLD : FXFONT_FW_NORMAL);
}
if (!match.IsEmpty() || iBaseFont < 12) {
pSubstFont->m_SubstFlags |= FXFONT_SUBST_EXACT;
if (!match.IsEmpty()) {
family = match;
}
if (iBaseFont < 12) {
if (nStyle && !(iBaseFont % 4)) {
if ((nStyle & 0x3) == 1) {
iBaseFont += 1;
}
if ((nStyle & 0x3) == 2) {
iBaseFont += 3;
}
if ((nStyle & 0x3) == 3) {
iBaseFont += 2;
}
}
if (m_pFontMgr->m_ExternalFonts[iBaseFont].m_pFontData) {
if (m_FoxitFaces[iBaseFont]) {
return m_FoxitFaces[iBaseFont];
}
m_FoxitFaces[iBaseFont] = m_pFontMgr->GetFixedFace(m_pFontMgr->m_ExternalFonts[iBaseFont].m_pFontData,
m_pFontMgr->m_ExternalFonts[iBaseFont].m_dwSize, 0);
if (m_FoxitFaces[iBaseFont]) {
return m_FoxitFaces[iBaseFont];
}
} else {
family = g_Base14FontNames[iBaseFont];
}
pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
}
} else {
if (flags & FXFONT_ITALIC) {
bItalic = TRUE;
}
}
bExact = !match.IsEmpty();
void* hFont = m_pFontInfo->MapFont(weight, bItalic, Charset, PitchFamily, family, bExact);
if (bExact) {
pSubstFont->m_SubstFlags |= FXFONT_SUBST_EXACT;
}
if (hFont == NULL) {
if (bCJK) {
if (italic_angle != 0) {
bItalic = TRUE;
} else {
bItalic = FALSE;
}
weight = old_weight;
}
if (!match.IsEmpty()) {
hFont = m_pFontInfo->GetFont(match);
if (hFont == NULL) {
return UseInternalSubst(pSubstFont, iBaseFont, italic_angle, old_weight, PitchFamily);
}
} else {
if (Charset == FXFONT_SYMBOL_CHARSET) {
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_ || _FXM_PLATFORM_ == _FXM_PLATFORM_ANDROID_
if (SubstName == FX_BSTRC("Symbol")) {
pSubstFont->m_Family = "Chrome Symbol";
pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
if (m_FoxitFaces[12]) {
return m_FoxitFaces[12];
}
FX_LPCBYTE pFontData = NULL;
FX_DWORD size = 0;
m_pFontMgr->GetStandardFont(pFontData, size, 12);
m_FoxitFaces[12] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
return m_FoxitFaces[12];
} else {
pSubstFont->m_SubstFlags |= FXFONT_SUBST_NONSYMBOL;
return FindSubstFont(family, bTrueType, flags & ~FXFONT_SYMBOLIC, weight, italic_angle, 0, pSubstFont);
}
#else
pSubstFont->m_SubstFlags |= FXFONT_SUBST_NONSYMBOL;
return FindSubstFont(family, bTrueType, flags & ~FXFONT_SYMBOLIC, weight, italic_angle, 0, pSubstFont);
#endif
}
if (Charset == FXFONT_ANSI_CHARSET) {
pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
return UseInternalSubst(pSubstFont, iBaseFont, italic_angle, old_weight, PitchFamily);
}
int index = m_CharsetArray.Find(Charset);
if (index < 0) {
return UseInternalSubst(pSubstFont, iBaseFont, italic_angle, old_weight, PitchFamily);
} else {
hFont = m_pFontInfo->GetFont(m_FaceArray[index]);
}
}
}
pSubstFont->m_ExtHandle = m_pFontInfo->RetainFont(hFont);
if (hFont == NULL) {
return NULL;
}
m_pFontInfo->GetFaceName(hFont, SubstName);
if (Charset == FXFONT_DEFAULT_CHARSET) {
m_pFontInfo->GetFontCharset(hFont, Charset);
}
FX_DWORD ttc_size = m_pFontInfo->GetFontData(hFont, 0x74746366, NULL, 0);
FX_DWORD font_size = m_pFontInfo->GetFontData(hFont, 0, NULL, 0);
if(font_size == 0 && ttc_size == 0) {
m_pFontInfo->DeleteFont(hFont);
return NULL;
}
FXFT_Face face = NULL;
if (ttc_size) {
FX_BYTE temp[1024];
m_pFontInfo->GetFontData(hFont, 0x74746366, temp, 1024);
FX_DWORD checksum = 0;
for (int i = 0; i < 256; i ++) {
checksum += ((FX_DWORD*)temp)[i];
}
FX_LPBYTE pFontData;
face = m_pFontMgr->GetCachedTTCFace(ttc_size, checksum, ttc_size - font_size, pFontData);
if (face == NULL) {
pFontData = FX_Alloc(FX_BYTE, ttc_size);
if (pFontData) {
m_pFontInfo->GetFontData(hFont, 0x74746366, pFontData, ttc_size);
face = m_pFontMgr->AddCachedTTCFace(ttc_size, checksum, pFontData, ttc_size,
ttc_size - font_size);
}
}
} else {
FX_LPBYTE pFontData;
face = m_pFontMgr->GetCachedFace(SubstName, weight, bItalic, pFontData);
if (face == NULL) {
pFontData = FX_Alloc(FX_BYTE, font_size);
if (!pFontData) {
m_pFontInfo->DeleteFont(hFont);
return NULL;
}
m_pFontInfo->GetFontData(hFont, 0, pFontData, font_size);
face = m_pFontMgr->AddCachedFace(SubstName, weight, bItalic, pFontData, font_size, m_pFontInfo->GetFaceIndex(hFont));
}
}
if (face == NULL) {
m_pFontInfo->DeleteFont(hFont);
return NULL;
}
pSubstFont->m_Family = SubstName;
pSubstFont->m_Charset = Charset;
FX_BOOL bNeedUpdateWeight = FALSE;
if (FXFT_Is_Face_Bold(face)) {
if (weight == FXFONT_FW_BOLD) {
bNeedUpdateWeight = FALSE;
} else {
bNeedUpdateWeight = TRUE;
}
} else {
if (weight == FXFONT_FW_NORMAL) {
bNeedUpdateWeight = FALSE;
} else {
bNeedUpdateWeight = TRUE;
}
}
if (bNeedUpdateWeight) {
pSubstFont->m_Weight = weight;
}
if (bItalic && !FXFT_Is_Face_Italic(face)) {
if (italic_angle == 0) {
italic_angle = -12;
} else if (FXSYS_abs(italic_angle) < 5) {
italic_angle = 0;
}
pSubstFont->m_ItalicAngle = italic_angle;
}
m_pFontInfo->DeleteFont(hFont);
return face;
}
