// static
void CPDF_TextRenderer::DrawTextString(CFX_RenderDevice* pDevice,
FX_FLOAT origin_x,
FX_FLOAT origin_y,
CPDF_Font* pFont,
FX_FLOAT font_size,
const CFX_Matrix* pMatrix,
const CFX_ByteString& str,
FX_ARGB fill_argb,
FX_ARGB stroke_argb,
const CFX_GraphStateData* pGraphState,
const CPDF_RenderOptions* pOptions) {
if (pFont->IsType3Font())
return;
int nChars = pFont->CountChar(str.c_str(), str.GetLength());
if (nChars <= 0)
return;
int offset = 0;
uint32_t* pCharCodes;
FX_FLOAT* pCharPos;
std::vector<uint32_t> codes;
std::vector<FX_FLOAT> positions;
if (nChars == 1) {
pCharCodes = reinterpret_cast<uint32_t*>(
pFont->GetNextChar(str.c_str(), str.GetLength(), offset));
pCharPos = nullptr;
} else {
codes.resize(nChars);
positions.resize(nChars - 1);
FX_FLOAT cur_pos = 0;
for (int i = 0; i < nChars; i++) {
codes[i] = pFont->GetNextChar(str.c_str(), str.GetLength(), offset);
if (i)
positions[i - 1] = cur_pos;
cur_pos += pFont->GetCharWidthF(codes[i]) * font_size / 1000;
}
pCharCodes = codes.data();
pCharPos = positions.data();
}
CFX_Matrix matrix;
if (pMatrix)
matrix = *pMatrix;
matrix.e = origin_x;
matrix.f = origin_y;
if (stroke_argb == 0) {
DrawNormalText(pDevice, nChars, pCharCodes, pCharPos, pFont, font_size,
&matrix, fill_argb, pOptions);
} else {
DrawTextPath(pDevice, nChars, pCharCodes, pCharPos, pFont, font_size,
&matrix, nullptr, pGraphState, fill_argb, stroke_argb, nullptr,
0);
}
}
void CScript_SignaturePseudoModel::Script_SignaturePseudoModel_Sign(
CFXJSE_Arguments* pArguments) {
int32_t iLength = pArguments->GetLength();
if (iLength < 3 || iLength > 7) {
ThrowScriptErrorMessage(XFA_IDS_INCORRECT_NUMBER_OF_METHOD, L"sign");
return;
}
IXFA_Notify* pNotify = m_pDocument->GetParser()->GetNotify();
if (!pNotify) {
return;
}
IXFA_Doc* hDoc = pNotify->GetHDOC();
CXFA_NodeList* pNodeList = NULL;
CFX_WideString wsExpression;
CFX_WideString wsXMLIdent;
if (iLength >= 1) {
pNodeList = (CXFA_NodeList*)pArguments->GetObject(0);
}
if (iLength >= 2) {
CFX_ByteString bsExpression = pArguments->GetUTF8String(1);
wsExpression =
CFX_WideString::FromUTF8(bsExpression, bsExpression.GetLength());
}
if (iLength >= 3) {
CFX_ByteString bsXMLIdent = pArguments->GetUTF8String(2);
wsXMLIdent = CFX_WideString::FromUTF8(bsXMLIdent, bsXMLIdent.GetLength());
}
FX_BOOL bSign = pNotify->GetDocProvider()->Sign(hDoc, pNodeList, wsExpression,
wsXMLIdent);
FXJSE_HVALUE hValue = pArguments->GetReturnValue();
if (hValue) {
FXJSE_Value_SetBoolean(hValue, bSign);
}
}
void CPDFDoc_Environment::JS_docmailForm(void* mailData, int length, FPDF_BOOL bUI,
const FX_WCHAR* To, const FX_WCHAR* Subject,
const FX_WCHAR* CC, const FX_WCHAR* BCC,
const FX_WCHAR* Msg)
{
if (m_pInfo && m_pInfo->m_pJsPlatform && m_pInfo->m_pJsPlatform->Doc_mail)
{
CFX_ByteString bsTo = CFX_WideString(To).UTF16LE_Encode();
CFX_ByteString bsCC = CFX_WideString(Subject).UTF16LE_Encode();
CFX_ByteString bsBcc = CFX_WideString(BCC).UTF16LE_Encode();
CFX_ByteString bsSubject = CFX_WideString(Subject).UTF16LE_Encode();
CFX_ByteString bsMsg = CFX_WideString(Msg).UTF16LE_Encode();
FPDF_WIDESTRING pTo = (FPDF_WIDESTRING)bsTo.GetBuffer(bsTo.GetLength());
FPDF_WIDESTRING pCC = (FPDF_WIDESTRING)bsCC.GetBuffer(bsCC.GetLength());
FPDF_WIDESTRING pBcc = (FPDF_WIDESTRING)bsBcc.GetBuffer(bsBcc.GetLength());
FPDF_WIDESTRING pSubject = (FPDF_WIDESTRING)bsSubject.GetBuffer(bsSubject.GetLength());
FPDF_WIDESTRING pMsg = (FPDF_WIDESTRING)bsMsg.GetBuffer(bsMsg.GetLength());
m_pInfo->m_pJsPlatform->Doc_mail(m_pInfo->m_pJsPlatform, mailData, length, bUI, pTo, pSubject,
pCC, pBcc, pMsg);
bsTo.ReleaseBuffer();
bsCC.ReleaseBuffer();
bsBcc.ReleaseBuffer();
bsSubject.ReleaseBuffer();
bsMsg.ReleaseBuffer();
}
}
void CBC_QRDecodedBitStreamParser::DecodeAlphanumericSegment(
CBC_CommonBitSource* bits,
CFX_ByteString& result,
int32_t count,
FX_BOOL fac1InEffect,
int32_t& e) {
int32_t start = result.GetLength();
while (count > 1) {
int32_t nextTwoCharsBits = bits->ReadBits(11, e);
BC_EXCEPTION_CHECK_ReturnVoid(e);
BC_FX_ByteString_Append(result, 1,
ALPHANUMERIC_CHARS[nextTwoCharsBits / 45]);
BC_FX_ByteString_Append(result, 1,
ALPHANUMERIC_CHARS[nextTwoCharsBits % 45]);
count -= 2;
}
if (count == 1) {
int32_t itemp = bits->ReadBits(6, e);
BC_EXCEPTION_CHECK_ReturnVoid(e);
BC_FX_ByteString_Append(result, 1, ALPHANUMERIC_CHARS[itemp]);
}
if (fac1InEffect) {
for (int32_t i = start; i < result.GetLength(); i++) {
if (result[i] == '%') {
if ((i < result.GetLength() - 1) && result[i + 1] == '%') {
result.Delete(i + 1, 1);
} else {
result.SetAt(i, (FX_CHAR)0x1d);
}
}
}
}
}
int CPDFDoc_Environment::JS_appResponse(const FX_WCHAR* Question,
const FX_WCHAR* Title,
const FX_WCHAR* Default,
const FX_WCHAR* cLabel,
FPDF_BOOL bPassword,
void* response,
int length) {
if (m_pInfo && m_pInfo->m_pJsPlatform &&
m_pInfo->m_pJsPlatform->app_response) {
CFX_ByteString bsQuestion = CFX_WideString(Question).UTF16LE_Encode();
CFX_ByteString bsTitle = CFX_WideString(Title).UTF16LE_Encode();
CFX_ByteString bsDefault = CFX_WideString(Default).UTF16LE_Encode();
CFX_ByteString bsLabel = CFX_WideString(cLabel).UTF16LE_Encode();
FPDF_WIDESTRING pQuestion =
(FPDF_WIDESTRING)bsQuestion.GetBuffer(bsQuestion.GetLength());
FPDF_WIDESTRING pTitle =
(FPDF_WIDESTRING)bsTitle.GetBuffer(bsTitle.GetLength());
FPDF_WIDESTRING pDefault =
(FPDF_WIDESTRING)bsDefault.GetBuffer(bsDefault.GetLength());
FPDF_WIDESTRING pLabel =
(FPDF_WIDESTRING)bsLabel.GetBuffer(bsLabel.GetLength());
int ret = m_pInfo->m_pJsPlatform->app_response(
m_pInfo->m_pJsPlatform, pQuestion, pTitle, pDefault, pLabel, bPassword,
response, length);
bsQuestion.ReleaseBuffer();
bsTitle.ReleaseBuffer();
bsDefault.ReleaseBuffer();
bsLabel.ReleaseBuffer();
return ret;
}
return -1;
}
bool CFX_ByteString::operator<(const CFX_ByteString& str) const {
if (m_pData == str.m_pData)
return false;
int result = FXSYS_memcmp(c_str(), str.c_str(),
std::min(GetLength(), str.GetLength()));
return result < 0 || (result == 0 && GetLength() < str.GetLength());
}
void CPDF_TextRenderer::DrawTextString(CFX_RenderDevice* pDevice,
FX_FLOAT origin_x,
FX_FLOAT origin_y,
CPDF_Font* pFont,
FX_FLOAT font_size,
const CFX_AffineMatrix* pMatrix,
const CFX_ByteString& str,
FX_ARGB fill_argb,
FX_ARGB stroke_argb,
const CFX_GraphStateData* pGraphState,
const CPDF_RenderOptions* pOptions) {
int nChars = pFont->CountChar(str, str.GetLength());
if (nChars == 0) {
return;
}
FX_DWORD charcode;
int offset = 0;
FX_DWORD* pCharCodes;
FX_FLOAT* pCharPos;
if (nChars == 1) {
charcode = pFont->GetNextChar(str, str.GetLength(), offset);
pCharCodes = (FX_DWORD*)(uintptr_t)charcode;
pCharPos = NULL;
} else {
pCharCodes = FX_Alloc(FX_DWORD, nChars);
pCharPos = FX_Alloc(FX_FLOAT, nChars - 1);
FX_FLOAT cur_pos = 0;
for (int i = 0; i < nChars; i++) {
pCharCodes[i] = pFont->GetNextChar(str, str.GetLength(), offset);
if (i) {
pCharPos[i - 1] = cur_pos;
}
cur_pos += pFont->GetCharWidthF(pCharCodes[i]) * font_size / 1000;
}
}
CFX_AffineMatrix matrix;
if (pMatrix) {
matrix = *pMatrix;
}
matrix.e = origin_x;
matrix.f = origin_y;
if (pFont->GetFontType() == PDFFONT_TYPE3)
;
else if (stroke_argb == 0) {
DrawNormalText(pDevice, nChars, pCharCodes, pCharPos, pFont, font_size,
&matrix, fill_argb, pOptions);
} else
DrawTextPath(pDevice, nChars, pCharCodes, pCharPos, pFont, font_size,
&matrix, NULL, pGraphState, fill_argb, stroke_argb, NULL);
if (nChars > 1) {
FX_Free(pCharCodes);
FX_Free(pCharPos);
}
}
FX_BOOL CPDF_SecurityHandler::CheckSecurity(int32_t key_len) {
CFX_ByteString password = m_pParser->GetPassword();
if (!password.IsEmpty() &&
CheckPassword(password.raw_str(), password.GetLength(), TRUE,
m_EncryptKey, key_len)) {
m_bOwnerUnlocked = true;
return TRUE;
}
return CheckPassword(password.raw_str(), password.GetLength(), FALSE,
m_EncryptKey, key_len);
}
void CPWL_ListBox::GetThisAppearanceStream(CFX_ByteTextBuf& sAppStream) {
CPWL_Wnd::GetThisAppearanceStream(sAppStream);
CFX_ByteTextBuf sListItems;
if (m_pList) {
CFX_FloatRect rcPlate = m_pList->GetPlateRect();
for (int32_t i = 0, sz = m_pList->GetCount(); i < sz; i++) {
CFX_FloatRect rcItem = m_pList->GetItemRect(i);
if (rcItem.bottom > rcPlate.top || rcItem.top < rcPlate.bottom)
continue;
CFX_FloatPoint ptOffset(rcItem.left, (rcItem.top + rcItem.bottom) * 0.5f);
if (m_pList->IsItemSelected(i)) {
sListItems << CPWL_Utils::GetRectFillAppStream(rcItem,
PWL_DEFAULT_SELBACKCOLOR)
.AsStringC();
CFX_ByteString sItem =
CPWL_Utils::GetEditAppStream(m_pList->GetItemEdit(i), ptOffset);
if (sItem.GetLength() > 0) {
sListItems << "BT\n"
<< CPWL_Utils::GetColorAppStream(PWL_DEFAULT_SELTEXTCOLOR)
.AsStringC()
<< sItem.AsStringC() << "ET\n";
}
} else {
CFX_ByteString sItem =
CPWL_Utils::GetEditAppStream(m_pList->GetItemEdit(i), ptOffset);
if (sItem.GetLength() > 0) {
sListItems << "BT\n"
<< CPWL_Utils::GetColorAppStream(GetTextColor())
.AsStringC()
<< sItem.AsStringC() << "ET\n";
}
}
}
}
if (sListItems.GetLength() > 0) {
CFX_ByteTextBuf sClip;
CFX_FloatRect rcClient = GetClientRect();
sClip << "q\n";
sClip << rcClient.left << " " << rcClient.bottom << " "
<< rcClient.right - rcClient.left << " "
<< rcClient.top - rcClient.bottom << " re W n\n";
sClip << sListItems << "Q\n";
sAppStream << "/Tx BMC\n" << sClip << "EMC\n";
}
}
void CPDFXFA_DocEnvironment::GetTitle(CXFA_FFDoc* hDoc,
CFX_WideString& wsTitle) {
if (hDoc != m_pContext->GetXFADoc() || !m_pContext->GetPDFDoc())
return;
CPDF_Dictionary* pInfoDict = m_pContext->GetPDFDoc()->GetInfo();
if (!pInfoDict)
return;
CFX_ByteString csTitle = pInfoDict->GetStringFor("Title");
wsTitle = wsTitle.FromLocal(csTitle.GetBuffer(csTitle.GetLength()));
csTitle.ReleaseBuffer(csTitle.GetLength());
}
void CPDF_StandardSecurityHandler::AES256_SetPassword(
CPDF_Dictionary* pEncryptDict,
const uint8_t* password,
FX_DWORD size,
FX_BOOL bOwner,
const uint8_t* key) {
uint8_t sha[128];
CRYPT_SHA1Start(sha);
CRYPT_SHA1Update(sha, key, 32);
CRYPT_SHA1Update(sha, (uint8_t*)"hello", 5);
uint8_t digest[20];
CRYPT_SHA1Finish(sha, digest);
CFX_ByteString ukey = pEncryptDict->GetString(FX_BSTRC("U"));
uint8_t digest1[48];
if (m_Revision >= 6) {
Revision6_Hash(password, size, digest,
(bOwner ? (const uint8_t*)ukey : NULL), digest1);
} else {
CRYPT_SHA256Start(sha);
CRYPT_SHA256Update(sha, password, size);
CRYPT_SHA256Update(sha, digest, 8);
if (bOwner) {
CRYPT_SHA256Update(sha, ukey, ukey.GetLength());
}
CRYPT_SHA256Finish(sha, digest1);
}
FXSYS_memcpy(digest1 + 32, digest, 16);
pEncryptDict->SetAtString(bOwner ? FX_BSTRC("O") : FX_BSTRC("U"),
CFX_ByteString(digest1, 48));
if (m_Revision >= 6) {
Revision6_Hash(password, size, digest + 8,
(bOwner ? (const uint8_t*)ukey : NULL), digest1);
} else {
CRYPT_SHA256Start(sha);
CRYPT_SHA256Update(sha, password, size);
CRYPT_SHA256Update(sha, digest + 8, 8);
if (bOwner) {
CRYPT_SHA256Update(sha, ukey, ukey.GetLength());
}
CRYPT_SHA256Finish(sha, digest1);
}
uint8_t* aes = FX_Alloc(uint8_t, 2048);
CRYPT_AESSetKey(aes, 16, digest1, 32, TRUE);
uint8_t iv[16];
FXSYS_memset(iv, 0, 16);
CRYPT_AESSetIV(aes, iv);
CRYPT_AESEncrypt(aes, digest1, key, 32);
FX_Free(aes);
pEncryptDict->SetAtString(bOwner ? FX_BSTRC("OE") : FX_BSTRC("UE"),
CFX_ByteString(digest1, 32));
}
FX_BOOL CPDF_StandardSecurityHandler::CheckSecurity(FX_INT32 key_len)
{
CFX_ByteString password = m_pParser->GetPassword();
if (CheckPassword(password, password.GetLength(), TRUE, m_EncryptKey, key_len)) {
if (password.IsEmpty()) {
if (!CheckPassword(password, password.GetLength(), FALSE, m_EncryptKey, key_len)) {
return FALSE;
}
}
m_bOwner = TRUE;
return TRUE;
}
return CheckPassword(password, password.GetLength(), FALSE, m_EncryptKey, key_len);
}
void CBC_OneDimWriter::CalcTextInfo(const CFX_ByteString& text,
FXTEXT_CHARPOS* charPos,
CFX_Font* cFont,
FX_FLOAT geWidth,
int32_t fontSize,
FX_FLOAT& charsLen) {
std::unique_ptr<CFX_UnicodeEncodingEx> encoding(
FX_CreateFontEncodingEx(cFont));
int32_t length = text.GetLength();
uint32_t* pCharCode = FX_Alloc(uint32_t, text.GetLength());
FX_FLOAT charWidth = 0;
for (int32_t j = 0; j < text.GetLength(); j++) {
pCharCode[j] = encoding->CharCodeFromUnicode(text[j]);
int32_t glyp_code = encoding->GlyphFromCharCode(pCharCode[j]);
int32_t glyp_value = cFont->GetGlyphWidth(glyp_code);
FX_FLOAT temp = (FX_FLOAT)((glyp_value)*fontSize / 1000.0);
charWidth += temp;
}
charsLen = charWidth;
FX_FLOAT leftPositon = (FX_FLOAT)(geWidth - charsLen) / 2.0f;
if (leftPositon < 0 && geWidth == 0) {
leftPositon = 0;
}
FX_FLOAT penX = 0.0;
FX_FLOAT penY =
(FX_FLOAT)FXSYS_abs(cFont->GetDescent()) * (FX_FLOAT)fontSize / 1000.0f;
FX_FLOAT left = leftPositon;
FX_FLOAT top = 0.0;
charPos[0].m_OriginX = penX + left;
charPos[0].m_OriginY = penY + top;
charPos[0].m_GlyphIndex = encoding->GlyphFromCharCode(pCharCode[0]);
charPos[0].m_FontCharWidth = cFont->GetGlyphWidth(charPos[0].m_GlyphIndex);
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
charPos[0].m_ExtGID = charPos[0].m_GlyphIndex;
#endif
penX += (FX_FLOAT)(charPos[0].m_FontCharWidth) * (FX_FLOAT)fontSize / 1000.0f;
for (int32_t i = 1; i < length; i++) {
charPos[i].m_OriginX = penX + left;
charPos[i].m_OriginY = penY + top;
charPos[i].m_GlyphIndex = encoding->GlyphFromCharCode(pCharCode[i]);
charPos[i].m_FontCharWidth = cFont->GetGlyphWidth(charPos[i].m_GlyphIndex);
#if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
charPos[i].m_ExtGID = charPos[i].m_GlyphIndex;
#endif
penX +=
(FX_FLOAT)(charPos[i].m_FontCharWidth) * (FX_FLOAT)fontSize / 1000.0f;
}
FX_Free(pCharCode);
}
FPDF_BOOL ParserPageRangeString(CFX_ByteString rangstring,
CFX_WordArray* pageArray,
int nCount) {
if (rangstring.GetLength() != 0) {
rangstring.Remove(' ');
int nLength = rangstring.GetLength();
CFX_ByteString cbCompareString("0123456789-,");
for (int i = 0; i < nLength; ++i) {
if (cbCompareString.Find(rangstring[i]) == -1)
return FALSE;
}
CFX_ByteString cbMidRange;
int nStringFrom = 0;
int nStringTo = 0;
while (nStringTo < nLength) {
nStringTo = rangstring.Find(',', nStringFrom);
if (nStringTo == -1)
nStringTo = nLength;
cbMidRange = rangstring.Mid(nStringFrom, nStringTo - nStringFrom);
int nMid = cbMidRange.Find('-');
if (nMid == -1) {
long lPageNum = atol(cbMidRange);
if (lPageNum <= 0 || lPageNum > nCount)
return FALSE;
pageArray->Add((FX_WORD)lPageNum);
} else {
int nStartPageNum = atol(cbMidRange.Mid(0, nMid));
if (nStartPageNum == 0)
return FALSE;
++nMid;
int nEnd = cbMidRange.GetLength() - nMid;
if (nEnd == 0)
return FALSE;
int nEndPageNum = atol(cbMidRange.Mid(nMid, nEnd));
if (nStartPageNum < 0 || nStartPageNum > nEndPageNum ||
nEndPageNum > nCount) {
return FALSE;
}
for (int i = nStartPageNum; i <= nEndPageNum; ++i) {
pageArray->Add(i);
}
}
nStringFrom = nStringTo + 1;
}
}
return TRUE;
}
FX_BOOL CPDF_StandardSecurityHandler::CheckUserPassword(
const uint8_t* password,
FX_DWORD pass_size,
FX_BOOL bIgnoreEncryptMeta,
uint8_t* key,
int32_t key_len) {
CalcEncryptKey(m_pEncryptDict, password, pass_size, key, key_len,
bIgnoreEncryptMeta, m_pParser->GetIDArray());
CFX_ByteString ukey = m_pEncryptDict
? m_pEncryptDict->GetString(FX_BSTRC("U"))
: CFX_ByteString();
if (ukey.GetLength() < 16) {
return FALSE;
}
uint8_t ukeybuf[32];
if (m_Revision == 2) {
FXSYS_memcpy(ukeybuf, defpasscode, 32);
CRYPT_ArcFourCryptBlock(ukeybuf, 32, key, key_len);
} else {
uint8_t test[32], tmpkey[32];
FX_DWORD copy_len = sizeof(test);
if (copy_len > (FX_DWORD)ukey.GetLength()) {
copy_len = ukey.GetLength();
}
FXSYS_memset(test, 0, sizeof(test));
FXSYS_memset(tmpkey, 0, sizeof(tmpkey));
FXSYS_memcpy(test, ukey.c_str(), copy_len);
for (int i = 19; i >= 0; i--) {
for (int j = 0; j < key_len; j++) {
tmpkey[j] = key[j] ^ i;
}
CRYPT_ArcFourCryptBlock(test, 32, tmpkey, key_len);
}
uint8_t md5[100];
CRYPT_MD5Start(md5);
CRYPT_MD5Update(md5, defpasscode, 32);
CPDF_Array* pIdArray = m_pParser->GetIDArray();
if (pIdArray) {
CFX_ByteString id = pIdArray->GetString(0);
CRYPT_MD5Update(md5, (uint8_t*)id.c_str(), id.GetLength());
}
CRYPT_MD5Finish(md5, ukeybuf);
return FXSYS_memcmp(test, ukeybuf, 16) == 0;
}
if (FXSYS_memcmp((void*)ukey.c_str(), ukeybuf, 16) == 0) {
return TRUE;
}
return FALSE;
}
int CPDFDoc_Environment::JS_appAlert(const FX_WCHAR* Msg, const FX_WCHAR* Title, FX_UINT Type, FX_UINT Icon)
{
if (m_pInfo && m_pInfo->m_pJsPlatform && m_pInfo->m_pJsPlatform->app_alert)
{
CFX_ByteString bsMsg = CFX_WideString(Msg).UTF16LE_Encode();
CFX_ByteString bsTitle = CFX_WideString(Title).UTF16LE_Encode();
FPDF_WIDESTRING pMsg = (FPDF_WIDESTRING)bsMsg.GetBuffer(bsMsg.GetLength());
FPDF_WIDESTRING pTitle = (FPDF_WIDESTRING)bsTitle.GetBuffer(bsTitle.GetLength());
int ret = m_pInfo->m_pJsPlatform->app_alert(m_pInfo->m_pJsPlatform, pMsg, pTitle, Type, Icon);
bsMsg.ReleaseBuffer();
bsTitle.ReleaseBuffer();
return ret;
}
return -1;
}
int CPDF_InterForm::CompareFieldName(const CFX_ByteString& name1,
const CFX_ByteString& name2) {
if (name1.GetLength() == name2.GetLength())
return name1 == name2 ? 1 : 0;
const FX_CHAR* ptr1 = name1.c_str();
const FX_CHAR* ptr2 = name2.c_str();
int i = 0;
while (ptr1[i] == ptr2[i])
i++;
if (i == name1.GetLength())
return 2;
if (i == name2.GetLength())
return 3;
return 0;
}
CFX_ByteString CPWL_Image::GetImageAppStream() {
CFX_ByteTextBuf sAppStream;
CFX_ByteString sAlias = GetImageAlias();
CFX_FloatRect rcPlate = GetClientRect();
CFX_Matrix mt;
mt.SetReverse(GetImageMatrix());
FX_FLOAT fHScale = 1.0f;
FX_FLOAT fVScale = 1.0f;
GetScale(fHScale, fVScale);
FX_FLOAT fx = 0.0f;
FX_FLOAT fy = 0.0f;
GetImageOffset(fx, fy);
if (m_pPDFStream && sAlias.GetLength() > 0) {
sAppStream << "q\n";
sAppStream << rcPlate.left << " " << rcPlate.bottom << " "
<< rcPlate.right - rcPlate.left << " "
<< rcPlate.top - rcPlate.bottom << " re W n\n";
sAppStream << fHScale << " 0 0 " << fVScale << " " << rcPlate.left + fx
<< " " << rcPlate.bottom + fy << " cm\n";
sAppStream << mt.GetA() << " " << mt.GetB() << " " << mt.GetC() << " "
<< mt.GetD() << " " << mt.GetE() << " " << mt.GetF() << " cm\n";
sAppStream << "0 g 0 G 1 w /" << sAlias.AsStringC() << " Do\n"
<< "Q\n";
}
return sAppStream.MakeString();
}
void CBC_OneDimWriter::ShowDeviceChars(CFX_RenderDevice* device,
const CFX_Matrix* matrix,
const CFX_ByteString str,
FX_FLOAT geWidth,
FXTEXT_CHARPOS* pCharPos,
FX_FLOAT locX,
FX_FLOAT locY,
int32_t barWidth) {
int32_t iFontSize = (int32_t)fabs(m_fFontSize);
int32_t iTextHeight = iFontSize + 1;
CFX_FloatRect rect((FX_FLOAT)locX, (FX_FLOAT)locY, (FX_FLOAT)(locX + geWidth),
(FX_FLOAT)(locY + iTextHeight));
if (geWidth != m_Width) {
rect.right -= 1;
}
matrix->TransformRect(rect);
FX_RECT re = rect.GetOuterRect();
device->FillRect(&re, m_backgroundColor);
CFX_Matrix affine_matrix(1.0, 0.0, 0.0, -1.0, (FX_FLOAT)locX,
(FX_FLOAT)(locY + iFontSize));
if (matrix) {
affine_matrix.Concat(*matrix);
}
device->DrawNormalText(str.GetLength(), pCharPos, m_pFont,
(FX_FLOAT)iFontSize, &affine_matrix, m_fontColor,
FXTEXT_CLEARTYPE);
}
void CFX_FontMapper::AddInstalledFont(const CFX_ByteString& name, int charset) {
if (!m_pFontInfo)
return;
m_FaceArray.push_back({name, static_cast<uint32_t>(charset)});
if (name == m_LastFamily)
return;
const uint8_t* ptr = name.raw_str();
bool bLocalized = false;
for (int i = 0; i < name.GetLength(); i++) {
if (ptr[i] > 0x80) {
bLocalized = true;
break;
}
}
if (bLocalized) {
void* hFont = m_pFontInfo->GetFont(name.c_str());
if (!hFont) {
int iExact;
hFont = m_pFontInfo->MapFont(0, 0, FXFONT_DEFAULT_CHARSET, 0,
name.c_str(), iExact);
if (!hFont)
return;
}
CFX_ByteString new_name = GetPSNameFromTT(hFont);
if (!new_name.IsEmpty())
m_LocalizedTTFonts.push_back(std::make_pair(new_name, name));
m_pFontInfo->DeleteFont(hFont);
}
m_InstalledTTFonts.push_back(name);
m_LastFamily = name;
}
FX_BOOL CPDF_IndexedCS::GetRGB(FX_FLOAT* pBuf,
FX_FLOAT& R,
FX_FLOAT& G,
FX_FLOAT& B) const {
int index = (int32_t)(*pBuf);
if (index < 0 || index > m_MaxIndex) {
return FALSE;
}
if (m_nBaseComponents) {
if (index == INT_MAX || (index + 1) > INT_MAX / m_nBaseComponents ||
(index + 1) * m_nBaseComponents > (int)m_Table.GetLength()) {
R = G = B = 0;
return FALSE;
}
}
CFX_FixedBufGrow<FX_FLOAT, 16> Comps(m_nBaseComponents);
FX_FLOAT* comps = Comps;
const uint8_t* pTable = m_Table;
for (int i = 0; i < m_nBaseComponents; i++) {
comps[i] =
m_pCompMinMax[i * 2] +
m_pCompMinMax[i * 2 + 1] * pTable[index * m_nBaseComponents + i] / 255;
}
m_pBaseCS->GetRGB(comps, R, G, B);
return TRUE;
}
int32_t CBC_OnedCode128Writer::Encode128C(const CFX_ByteString& contents,
CFX_PtrArray& patterns) {
int32_t checkSum = 0;
int32_t checkWeight = 1;
int32_t position = 0;
patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[CODE_START_C]);
checkSum += CODE_START_C * checkWeight;
while (position < contents.GetLength()) {
int32_t patternIndex = 0;
FX_CHAR ch = contents.GetAt(position);
if (ch < '0' || ch > '9') {
patternIndex = (int32_t)ch;
position++;
} else {
patternIndex = FXSYS_atoi(contents.Mid(position, 2));
if (contents.GetAt(position + 1) < '0' ||
contents.GetAt(position + 1) > '9') {
position += 1;
} else {
position += 2;
}
}
patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[patternIndex]);
checkSum += patternIndex * checkWeight;
if (position != 0) {
checkWeight++;
}
}
return checkSum;
}
DLLEXPORT void STDCALL FPDF_Widget_Cut(FPDF_DOCUMENT document,
FPDF_WIDGET hWidget,
FPDF_WIDESTRING wsText,
FPDF_DWORD* size) {
if (!hWidget || !document)
return;
CPDFXFA_Context* pContext = static_cast<CPDFXFA_Context*>(document);
if (pContext->GetDocType() != XFA_DOCTYPE_Dynamic &&
pContext->GetDocType() != XFA_DOCTYPE_Static)
return;
CFX_WideString wsCpText;
static_cast<CXFA_FFWidget*>(hWidget)->Cut(wsCpText);
CFX_ByteString bsCpText = wsCpText.UTF16LE_Encode();
uint32_t len = bsCpText.GetLength() / sizeof(unsigned short);
if (!wsText) {
*size = len;
return;
}
uint32_t real_size = len < *size ? len : *size;
if (real_size > 0) {
FXSYS_memcpy((void*)wsText,
bsCpText.GetBuffer(real_size * sizeof(unsigned short)),
real_size * sizeof(unsigned short));
bsCpText.ReleaseBuffer(real_size * sizeof(unsigned short));
}
*size = real_size;
}
CFX_ByteString PDF_NameEncode(const CFX_ByteString& orig) {
uint8_t* src_buf = (uint8_t*)orig.c_str();
int src_len = orig.GetLength();
int dest_len = 0;
int i;
for (i = 0; i < src_len; i++) {
uint8_t ch = src_buf[i];
if (ch >= 0x80 || PDFCharIsWhitespace(ch) || ch == '#' ||
PDFCharIsDelimiter(ch)) {
dest_len += 3;
} else {
dest_len++;
}
}
if (dest_len == src_len)
return orig;
CFX_ByteString res;
FX_CHAR* dest_buf = res.GetBuffer(dest_len);
dest_len = 0;
for (i = 0; i < src_len; i++) {
uint8_t ch = src_buf[i];
if (ch >= 0x80 || PDFCharIsWhitespace(ch) || ch == '#' ||
PDFCharIsDelimiter(ch)) {
dest_buf[dest_len++] = '#';
dest_buf[dest_len++] = "0123456789ABCDEF"[ch / 16];
dest_buf[dest_len++] = "0123456789ABCDEF"[ch % 16];
} else {
dest_buf[dest_len++] = ch;
}
}
dest_buf[dest_len] = 0;
res.ReleaseBuffer();
return res;
}
int FXJS_Execute(v8::Isolate* pIsolate,
IJS_Context* pJSContext,
const wchar_t* script,
FXJSErr* pError) {
v8::Isolate::Scope isolate_scope(pIsolate);
v8::TryCatch try_catch(pIsolate);
CFX_ByteString bsScript = CFX_WideString(script).UTF8Encode();
v8::Local<v8::Context> context = pIsolate->GetCurrentContext();
v8::Local<v8::Script> compiled_script;
if (!v8::Script::Compile(
context, v8::String::NewFromUtf8(
pIsolate, bsScript.c_str(), v8::NewStringType::kNormal,
bsScript.GetLength()).ToLocalChecked())
.ToLocal(&compiled_script)) {
v8::String::Utf8Value error(try_catch.Exception());
// TODO(tsepez): return error via pError->message.
return -1;
}
v8::Local<v8::Value> result;
if (!compiled_script->Run(context).ToLocal(&result)) {
v8::String::Utf8Value error(try_catch.Exception());
// TODO(tsepez): return error via pError->message.
return -1;
}
return 0;
}
DLLEXPORT void STDCALL FPDF_Widget_Cut(FPDF_DOCUMENT document,
FPDF_WIDGET hWidget,
FPDF_WIDESTRING wsText,
FPDF_DWORD* size) {
if (NULL == hWidget || NULL == document)
return;
CPDFXFA_Document* pDocument = (CPDFXFA_Document*)document;
if (pDocument->GetDocType() != XFA_DOCTYPE_Dynamic &&
pDocument->GetDocType() != XFA_DOCTYPE_Static)
return;
IXFA_MenuHandler* pXFAMenuHander =
CPDFXFA_App::GetInstance()->GetXFAApp()->GetMenuHandler();
if (pXFAMenuHander == NULL)
return;
CFX_WideString wsCpText;
pXFAMenuHander->Cut((IXFA_Widget*)hWidget, wsCpText);
CFX_ByteString bsCpText = wsCpText.UTF16LE_Encode();
int len = bsCpText.GetLength() / sizeof(unsigned short);
if (wsText == NULL) {
*size = len;
return;
}
int real_size = len < *size ? len : *size;
if (real_size > 0) {
FXSYS_memcpy((void*)wsText,
bsCpText.GetBuffer(real_size * sizeof(unsigned short)),
real_size * sizeof(unsigned short));
bsCpText.ReleaseBuffer(real_size * sizeof(unsigned short));
}
*size = real_size;
}
FX_BOOL CScript_HostPseudoModel::Script_HostPseudoModel_ValidateArgsForMsg(
CFXJSE_Arguments* pArguments,
int32_t iArgIndex,
CFX_WideString& wsValue) {
if (pArguments == NULL || iArgIndex < 0) {
return FALSE;
}
FX_BOOL bIsJsType = FALSE;
if (m_pDocument->GetScriptContext()->GetType() ==
XFA_SCRIPTLANGTYPE_Javascript) {
bIsJsType = TRUE;
}
FXJSE_HVALUE hValueArg = pArguments->GetValue(iArgIndex);
if (!FXJSE_Value_IsUTF8String(hValueArg) && bIsJsType) {
ThrowScriptErrorMessage(XFA_IDS_ARGUMENT_MISMATCH);
FXJSE_Value_Release(hValueArg);
return FALSE;
}
if (FXJSE_Value_IsNull(hValueArg)) {
wsValue = FX_WSTRC(L"");
} else {
CFX_ByteString byMessage;
FXJSE_Value_ToUTF8String(hValueArg, byMessage);
wsValue = CFX_WideString::FromUTF8(byMessage, byMessage.GetLength());
}
FXJSE_Value_Release(hValueArg);
return TRUE;
}
FX_INT32 GetStyleType(const CFX_ByteString &bsStyle, FX_BOOL bRevert)
{
FX_INT32 iLen = bsStyle.GetLength();
if (!iLen) {
return -1;
}
int iSize = sizeof(g_FontStyles) / sizeof(FX_FontStyle);
const FX_FontStyle *pStyle = NULL;
for (int i = iSize - 1; i >= 0; --i) {
pStyle = g_FontStyles + i;
if (!pStyle || pStyle->len > iLen) {
continue;
}
if (!bRevert) {
if (bsStyle.Left(pStyle->len).Compare(pStyle->style) == 0) {
return i;
}
} else {
if (bsStyle.Right(pStyle->len).Compare(pStyle->style) == 0) {
return i;
}
}
}
return -1;
}
CFX_ByteArray& CBC_HighLevelEncoder::getBytesForMessage(CFX_WideString msg) {
CFX_ByteString bytestr;
CBC_UtilCodingConvert::UnicodeToUTF8(msg, bytestr);
for (int32_t i = 0; i < bytestr.GetLength(); i++) {
m_bytearray.Add(bytestr.GetAt(i));
}
return m_bytearray;
}
v8::Local<v8::String> CFXJS_Engine::WSToJSString(
const CFX_WideString& wsPropertyName) {
v8::Isolate* pIsolate = m_isolate ? m_isolate : v8::Isolate::GetCurrent();
CFX_ByteString bs = wsPropertyName.UTF8Encode();
return v8::String::NewFromUtf8(pIsolate, bs.c_str(),
v8::NewStringType::kNormal, bs.GetLength())
.ToLocalChecked();
}
