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);
}
}
}
}
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;
}
static int InsertNewPage(CPDF_Document* pDoc, int iPage, CPDF_Dictionary* pPageDict, CFX_DWordArray &pageList)
{
CPDF_Dictionary* pRoot = pDoc->GetRoot();
if (!pRoot) {
return -1;
}
CPDF_Dictionary* pPages = pRoot->GetDict(FX_BSTRC("Pages"));
if (!pPages) {
return -1;
}
int nPages = pDoc->GetPageCount();
if (iPage < 0 || iPage > nPages) {
return -1;
}
if (iPage == nPages) {
CPDF_Array* pPagesList = pPages->GetArray(FX_BSTRC("Kids"));
if (!pPagesList) {
pPagesList = FX_NEW CPDF_Array;
pPages->SetAt(FX_BSTRC("Kids"), pPagesList);
}
pPagesList->Add(pPageDict, pDoc);
pPages->SetAtInteger(FX_BSTRC("Count"), nPages + 1);
pPageDict->SetAtReference(FX_BSTRC("Parent"), pDoc, pPages->GetObjNum());
} else {
CFX_PtrArray stack;
stack.Add(pPages);
if (InsertDeletePDFPage(pDoc, pPages, iPage, pPageDict, TRUE, stack) < 0) {
return -1;
}
}
pageList.InsertAt(iPage, pPageDict->GetObjNum());
return iPage;
}
FX_BOOL Document::resetForm(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
{
ASSERT(m_pDocument != NULL);
if (!(m_pDocument->GetPermissions(FPDFPERM_MODIFY) ||
m_pDocument->GetPermissions(FPDFPERM_ANNOT_FORM) ||
m_pDocument->GetPermissions(FPDFPERM_FILL_FORM))) return FALSE;
CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
ASSERT(pInterForm != NULL);
CPDF_InterForm* pPDFForm = pInterForm->GetInterForm();
ASSERT(pPDFForm != NULL);
v8::Isolate* isolate = GetIsolate(cc);
CJS_Array aName(isolate);
if (params.size() > 0)
{
switch (params[0].GetType())
{
default:
aName.Attach(params[0].ToV8Array());
break;
case VT_string:
aName.SetElement(0,params[0]);
break;
}
CFX_PtrArray aFields;
for (int i=0,isz=aName.GetLength(); i<isz; i++)
{
CJS_Value valElement(isolate);
aName.GetElement(i,valElement);
CFX_WideString swVal = valElement.ToCFXWideString();
for (int j=0,jsz=pPDFForm->CountFields(swVal); j<jsz; j++)
{
aFields.Add((void*)pPDFForm->GetField(j,swVal));
}
}
if (aFields.GetSize() > 0)
{
pPDFForm->ResetForm(aFields, TRUE, TRUE);
m_pDocument->SetChangeMark();
}
}
else
{
pPDFForm->ResetForm(TRUE);
m_pDocument->SetChangeMark();
}
return TRUE;
}
CFX_PtrArray* CBC_ReedSolomonGF256Poly::Divide(CBC_ReedSolomonGF256Poly* other,
int32_t& e) {
if (other->IsZero()) {
e = BCExceptionDivideByZero;
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
}
CBC_ReedSolomonGF256Poly* rsg1 = m_field->GetZero()->Clone(e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> quotient(rsg1);
CBC_ReedSolomonGF256Poly* rsg2 = this->Clone(e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> remainder(rsg2);
int32_t denominatorLeadingTerm = other->GetCoefficients(other->GetDegree());
int32_t inverseDenominatorLeadingTeam =
m_field->Inverse(denominatorLeadingTerm, e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
while (remainder->GetDegree() >= other->GetDegree() && !remainder->IsZero()) {
int32_t degreeDifference = remainder->GetDegree() - other->GetDegree();
int32_t scale =
m_field->Multiply(remainder->GetCoefficients((remainder->GetDegree())),
inverseDenominatorLeadingTeam);
CBC_ReedSolomonGF256Poly* rsg3 =
other->MultiplyByMonomial(degreeDifference, scale, e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> term(rsg3);
CBC_ReedSolomonGF256Poly* rsg4 =
m_field->BuildMonomial(degreeDifference, scale, e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> iteratorQuotient(rsg4);
CBC_ReedSolomonGF256Poly* rsg5 =
quotient->AddOrSubtract(iteratorQuotient.get(), e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> temp(rsg5);
quotient = temp;
CBC_ReedSolomonGF256Poly* rsg6 = remainder->AddOrSubtract(term.get(), e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> temp1(rsg6);
remainder = temp1;
}
CFX_PtrArray* tempPtrA = new CFX_PtrArray;
tempPtrA->Add(quotient.release());
tempPtrA->Add(remainder.release());
return tempPtrA;
}
int32_t CBC_OnedCode128Writer::Encode128B(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_B]);
checkSum += CODE_START_B * checkWeight;
while (position < contents.GetLength()) {
int32_t patternIndex = 0;
patternIndex = contents[position] - ' ';
position += 1;
patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[patternIndex]);
checkSum += patternIndex * checkWeight;
if (position != 0) {
checkWeight++;
}
}
return checkSum;
}
uint8_t* CBC_OnedCode128Writer::Encode(const CFX_ByteString& contents,
int32_t& outLength,
int32_t& e) {
if (contents.GetLength() < 1 || contents.GetLength() > 80) {
e = BCExceptionContentsLengthShouldBetween1and80;
return NULL;
}
CFX_PtrArray patterns;
int32_t checkSum = 0;
if (m_codeFormat == BC_CODE128_B) {
checkSum = Encode128B(contents, patterns);
} else if (m_codeFormat == BC_CODE128_C) {
checkSum = Encode128C(contents, patterns);
} else {
e = BCExceptionFormatException;
return NULL;
}
checkSum %= 103;
patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[checkSum]);
patterns.Add((int32_t*)CBC_OnedCode128Reader::CODE_PATTERNS[CODE_STOP]);
m_iContentLen = contents.GetLength() + 3;
int32_t codeWidth = 0;
for (int32_t k = 0; k < patterns.GetSize(); k++) {
int32_t* pattern = (int32_t*)patterns[k];
for (int32_t j = 0; j < 7; j++) {
codeWidth += pattern[j];
}
}
outLength = codeWidth;
uint8_t* result = FX_Alloc(uint8_t, outLength);
int32_t pos = 0;
for (int32_t j = 0; j < patterns.GetSize(); j++) {
int32_t* pattern = (int32_t*)patterns[j];
pos += AppendPattern(result, pos, pattern, 7, 1, e);
if (e != BCExceptionNO) {
FX_Free(result);
return NULL;
}
}
return result;
}
int JS_DefineObj(IJS_Runtime* pJSRuntime, const wchar_t* sObjName, FXJSOBJTYPE eObjType, LP_CONSTRUCTOR pConstructor, LP_DESTRUCTOR pDestructor, unsigned bApplyNew)
{
v8::Isolate* isolate = (v8::Isolate*)pJSRuntime;
v8::Isolate::Scope isolate_scope(isolate);
v8::HandleScope handle_scope(isolate);
CFX_PtrArray* pArray = (CFX_PtrArray*)isolate->GetData(0);
if(!pArray)
{
pArray = new CFX_PtrArray();
isolate->SetData(0, pArray);
}
CJS_ObjDefintion* pObjDef = new CJS_ObjDefintion(isolate, sObjName, eObjType, pConstructor, pDestructor, bApplyNew);
pArray->Add(pObjDef);
return pArray->GetSize()-1;
}
CFX_PtrArray* CBC_Detector::detect(FX_BOOL multiple,
CBC_CommonBitMatrix* bitMatrix) {
CFX_PtrArray* barcodeCoordinates = new CFX_PtrArray;
int32_t row = 0;
int32_t column = 0;
FX_BOOL foundBarcodeInRow = FALSE;
while (row < bitMatrix->GetHeight()) {
CFX_PtrArray* vertices = findVertices(bitMatrix, row, column);
if (vertices->GetAt(0) == NULL && vertices->GetAt(3) == NULL) {
if (!foundBarcodeInRow) {
if (vertices) {
delete (vertices);
}
break;
}
foundBarcodeInRow = FALSE;
column = 0;
for (int32_t i = 0; i < barcodeCoordinates->GetSize(); i++) {
CFX_PtrArray* barcodeCoordinate =
(CFX_PtrArray*)barcodeCoordinates->GetAt(i);
if (barcodeCoordinate->GetAt(1) != NULL) {
row = row > ((CBC_ResultPoint*)barcodeCoordinate->GetAt(1))->GetY();
}
if (barcodeCoordinate->GetAt(3) != NULL) {
row = row > ((CBC_ResultPoint*)barcodeCoordinate->GetAt(3))->GetY();
}
}
row += ROW_STEP;
if (vertices) {
delete (vertices);
}
continue;
}
foundBarcodeInRow = TRUE;
barcodeCoordinates->Add(vertices);
if (!multiple) {
break;
}
if (vertices->GetAt(2) != NULL) {
column = (int32_t)((CBC_ResultPoint*)vertices->GetAt(2))->GetX();
row = (int32_t)((CBC_ResultPoint*)vertices->GetAt(2))->GetY();
} else {
column = (int32_t)((CBC_ResultPoint*)vertices->GetAt(4))->GetX();
row = (int32_t)((CBC_ResultPoint*)vertices->GetAt(4))->GetY();
}
}
return barcodeCoordinates;
}
void CFWL_GridImp::SetScaledColRowsSize(const CFX_PtrArray& spanScaleds,
FX_FLOAT fTotalSize,
FX_FLOAT fTotalScaledNum) {
int32_t iScaledColRows = spanScaleds.GetSize();
if (iScaledColRows < 1) {
return;
}
CFX_PtrArray autoNoMinMaxs;
FX_FLOAT fPerSize = fTotalSize / fTotalScaledNum;
for (int32_t i = 0; i < iScaledColRows; i++) {
CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(spanScaleds[i]);
if (!pColRow) {
continue;
}
FX_FLOAT fSize = fPerSize * pColRow->m_Size.fLength;
FX_FLOAT fOrgSize = pColRow->m_fActualSize;
if (SetColRowActualSize(pColRow, fSize, TRUE)) {
autoNoMinMaxs.Add(pColRow);
} else {
fTotalSize -= pColRow->m_fActualSize - fOrgSize;
fTotalScaledNum -= pColRow->m_Size.fLength;
int32_t iNoMinMax = iScaledColRows - (i + 1 - autoNoMinMaxs.GetSize());
if (iNoMinMax > 0 && fTotalSize > 0) {
fPerSize = fTotalSize / fTotalScaledNum;
} else {
break;
}
}
}
int32_t iNormals = autoNoMinMaxs.GetSize();
if (fTotalSize > 0) {
if (iNormals == iScaledColRows) {
fPerSize = fTotalSize / fTotalScaledNum;
for (int32_t i = 0; i < iNormals; i++) {
CFWL_GridColRow* pColRow =
static_cast<CFWL_GridColRow*>(autoNoMinMaxs[i]);
if (!pColRow) {
continue;
}
FX_FLOAT fSize = fPerSize * pColRow->m_Size.fLength;
pColRow->m_fActualSize = fSize;
}
} else {
SetScaledColRowsSize(autoNoMinMaxs, fTotalSize, fTotalScaledNum);
}
} else {
}
}
static int InsertDeletePDFPage(CPDF_Document* pDoc, CPDF_Dictionary* pPages,
int nPagesToGo, CPDF_Dictionary* pPage, FX_BOOL bInsert, CFX_PtrArray& stackList)
{
CPDF_Array* pKidList = pPages->GetArray("Kids");
if (!pKidList) {
return -1;
}
int nKids = pKidList->GetCount();
for (int i = 0; i < nKids; i ++) {
CPDF_Dictionary* pKid = pKidList->GetDict(i);
if (pKid->GetString("Type") == FX_BSTRC("Page")) {
if (nPagesToGo == 0) {
if (bInsert) {
pKidList->InsertAt(i, CPDF_Reference::Create(pDoc, pPage->GetObjNum()));
pPage->SetAtReference("Parent", pDoc, pPages->GetObjNum());
} else {
pKidList->RemoveAt(i);
}
pPages->SetAtInteger("Count", pPages->GetInteger("Count") + (bInsert ? 1 : -1));
return 1;
}
nPagesToGo --;
} else {
int nPages = pKid->GetInteger("Count");
if (nPagesToGo < nPages) {
int stackCount = stackList.GetSize();
for (int j = 0; j < stackCount; ++j) {
if (pKid == stackList[j]) {
return -1;
}
}
stackList.Add(pKid);
if (InsertDeletePDFPage(pDoc, pKid, nPagesToGo, pPage, bInsert, stackList) < 0) {
return -1;
}
stackList.RemoveAt(stackCount);
pPages->SetAtInteger("Count", pPages->GetInteger("Count") + (bInsert ? 1 : -1));
return 1;
}
nPagesToGo -= nPages;
}
}
return 0;
}
void CPDF_Document::DeletePage(int iPage)
{
CPDF_Dictionary* pRoot = GetRoot();
if (pRoot == NULL) {
return;
}
CPDF_Dictionary* pPages = pRoot->GetDict("Pages");
if (pPages == NULL) {
return;
}
int nPages = pPages->GetInteger("Count");
if (iPage < 0 || iPage >= nPages) {
return;
}
CFX_PtrArray stack;
stack.Add(pPages);
if (InsertDeletePDFPage(this, pPages, iPage, NULL, FALSE, stack) < 0) {
return;
}
m_PageList.RemoveAt(iPage);
}
void CFWL_GridImp::SetSpanAutoColRowSize(const CFX_PtrArray& spanAutos,
FX_FLOAT fTotalSize) {
int32_t iAutoColRows = spanAutos.GetSize();
if (iAutoColRows < 1) {
return;
}
CFX_PtrArray autoNoMinMaxs;
FX_FLOAT fAutoPer = fTotalSize / iAutoColRows;
for (int32_t j = 0; j < iAutoColRows; j++) {
CFWL_GridColRow* pColumn = static_cast<CFWL_GridColRow*>(spanAutos[j]);
FX_FLOAT fOrgSize = pColumn->m_fActualSize;
if (SetColRowActualSize(pColumn, pColumn->m_fActualSize + fAutoPer, TRUE)) {
autoNoMinMaxs.Add(pColumn);
} else {
fTotalSize -= pColumn->m_fActualSize - fOrgSize;
int32_t iNoMinMax = iAutoColRows - (j + 1 - autoNoMinMaxs.GetSize());
if (iNoMinMax > 0 && fTotalSize > 0) {
fAutoPer = fTotalSize / iNoMinMax;
} else {
break;
}
}
}
int32_t iNormals = autoNoMinMaxs.GetSize();
if (fTotalSize > 0) {
if (iNormals == iAutoColRows) {
fAutoPer = fTotalSize / iNormals;
for (int32_t k = 0; k < iNormals; k++) {
CFWL_GridColRow* pColumn =
static_cast<CFWL_GridColRow*>(autoNoMinMaxs[k]);
pColumn->m_fActualSize += fAutoPer;
}
} else {
SetSpanAutoColRowSize(autoNoMinMaxs, fTotalSize);
}
} else {
}
}
CFX_WideString CBC_HighLevelEncoder::encodeHighLevel(CFX_WideString msg,
CFX_WideString ecLevel,
SymbolShapeHint shape,
CBC_Dimension* minSize,
CBC_Dimension* maxSize,
int32_t& e) {
CBC_EncoderContext context(msg, ecLevel, e);
BC_EXCEPTION_CHECK_ReturnValue(e, (FX_WCHAR*)"");
context.setSymbolShape(shape);
context.setSizeConstraints(minSize, maxSize);
if ((msg.Mid(0, 6) == MACRO_05_HEADER) &&
(msg.Mid(msg.GetLength() - 1, 1) == MACRO_TRAILER)) {
context.writeCodeword(MACRO_05);
context.setSkipAtEnd(2);
context.m_pos += 6;
} else if ((msg.Mid(0, 6) == MACRO_06_HEADER) &&
(msg.Mid(msg.GetLength() - 1, 1) == MACRO_TRAILER)) {
context.writeCodeword(MACRO_06);
context.setSkipAtEnd(2);
context.m_pos += 6;
}
CFX_PtrArray encoders;
encoders.Add(new CBC_ASCIIEncoder());
encoders.Add(new CBC_C40Encoder());
encoders.Add(new CBC_TextEncoder());
encoders.Add(new CBC_X12Encoder());
encoders.Add(new CBC_EdifactEncoder());
encoders.Add(new CBC_Base256Encoder());
int32_t encodingMode = ASCII_ENCODATION;
while (context.hasMoreCharacters()) {
((CBC_Encoder*)encoders.GetAt(encodingMode))->Encode(context, e);
if (e != BCExceptionNO) {
for (int32_t i = 0; i < encoders.GetSize(); i++) {
delete (CBC_Encoder*)encoders.GetAt(i);
}
encoders.RemoveAll();
return (FX_WCHAR*)"";
}
if (context.m_newEncoding >= 0) {
encodingMode = context.m_newEncoding;
context.resetEncoderSignal();
}
}
int32_t len = context.m_codewords.GetLength();
context.updateSymbolInfo(e);
if (e != BCExceptionNO) {
for (int32_t i = 0; i < encoders.GetSize(); i++) {
delete (CBC_Encoder*)encoders.GetAt(i);
}
encoders.RemoveAll();
return (FX_WCHAR*)"";
}
int32_t capacity = context.m_symbolInfo->m_dataCapacity;
if (len < capacity) {
if (encodingMode != ASCII_ENCODATION &&
encodingMode != BASE256_ENCODATION) {
context.writeCodeword(0x00fe);
}
}
CFX_WideString codewords = context.m_codewords;
if (codewords.GetLength() < capacity) {
codewords += PAD;
}
while (codewords.GetLength() < capacity) {
codewords += (randomize253State(PAD, codewords.GetLength() + 1));
}
for (int32_t i = 0; i < encoders.GetSize(); i++) {
delete (CBC_Encoder*)encoders.GetAt(i);
}
encoders.RemoveAll();
return codewords;
}
FX_BOOL Document::submitForm(IFXJS_Context* cc, const CJS_Parameters& params, CJS_Value& vRet, CFX_WideString& sError)
{
ASSERT(m_pDocument != NULL);
CJS_Context* pContext = (CJS_Context*)cc;
int nSize = params.size();
if (nSize < 1) {
sError = JSGetStringFromID(pContext, IDS_STRING_JSPARAMERROR);
return FALSE;
}
CFX_WideString strURL;
FX_BOOL bFDF = TRUE;
FX_BOOL bEmpty = FALSE;
v8::Isolate* isolate = GetIsolate(cc);
CJS_Array aFields(isolate);
CJS_Value v = params[0];
if (v.GetType() == VT_string)
{
strURL = params[0].ToCFXWideString();
if (nSize > 1)
bFDF = params[1].ToBool();
if (nSize > 2)
bEmpty = params[2].ToBool();
if (nSize > 3)
aFields.Attach(params[3].ToV8Array());
}
else if (v.GetType() == VT_object)
{
JSObject pObj = params[0].ToV8Object();
v8::Handle<v8::Value> pValue = JS_GetObjectElement(isolate, pObj, L"cURL");
if (!pValue.IsEmpty())
strURL = CJS_Value(isolate, pValue, GET_VALUE_TYPE(pValue)).ToCFXWideString();
pValue = JS_GetObjectElement(isolate, pObj, L"bFDF");
bFDF = CJS_Value(isolate, pValue, GET_VALUE_TYPE(pValue)).ToBool();
pValue = JS_GetObjectElement(isolate, pObj, L"bEmpty");
bEmpty = CJS_Value(isolate, pValue, GET_VALUE_TYPE(pValue)).ToBool();
pValue = JS_GetObjectElement(isolate, pObj,L"aFields");
aFields.Attach(CJS_Value(isolate, pValue, GET_VALUE_TYPE(pValue)).ToV8Array());
}
CPDFSDK_InterForm* pInterForm = (CPDFSDK_InterForm*)m_pDocument->GetInterForm();
ASSERT(pInterForm != NULL);
CPDF_InterForm* pPDFInterForm = pInterForm->GetInterForm();
ASSERT(pPDFInterForm != NULL);
FX_BOOL bAll = (aFields.GetLength() == 0);
if (bAll && bEmpty)
{
CJS_Context* pContext = (CJS_Context*)cc;
ASSERT(pContext != NULL);
CJS_Runtime* pRuntime = pContext->GetJSRuntime();
ASSERT(pRuntime != NULL);
if (pPDFInterForm->CheckRequiredFields())
{
pRuntime->BeginBlock();
pInterForm->SubmitForm(strURL, FALSE);
pRuntime->EndBlock();
}
return TRUE;
}
else
{
CFX_PtrArray fieldObjects;
for (int i=0,sz=aFields.GetLength(); i<sz; i++)
{
CJS_Value valName(isolate);
aFields.GetElement(i, valName);
CFX_WideString sName = valName.ToCFXWideString();
CPDF_InterForm* pPDFForm = pInterForm->GetInterForm();
ASSERT(pPDFForm != NULL);
for (int j=0, jsz=pPDFForm->CountFields(sName); j<jsz; j++)
{
CPDF_FormField* pField = pPDFForm->GetField(j, sName);
if (!bEmpty && pField->GetValue().IsEmpty())
continue;
fieldObjects.Add(pField);
}
}
CJS_Context* pContext = (CJS_Context*)cc;
ASSERT(pContext != NULL);
CJS_Runtime* pRuntime = pContext->GetJSRuntime();
ASSERT(pRuntime != NULL);
if (pPDFInterForm->CheckRequiredFields(&fieldObjects, TRUE))
{
pRuntime->BeginBlock();
pInterForm->SubmitFields(strURL, fieldObjects, TRUE, !bFDF);
pRuntime->EndBlock();
}
return TRUE;
}
}
FX_BOOL CPDF_TextStream::ProcessObject(const CPDF_TextObject* pObj, FX_BOOL bFirstLine)
{
CPDF_Font* pFont = pObj->GetFont();
CFX_AffineMatrix matrix;
pObj->GetTextMatrix(&matrix);
int item_index = 0;
if (m_pLastObj) {
int result = FPDFText_ProcessInterObj(m_pLastObj, pObj);
if (result == 2) {
int len = m_Buffer.GetLength();
if (len && m_bUseLF && m_Buffer.GetBuffer()[len - 1] == L'-') {
m_Buffer.Delete(len - 1, 1);
if (m_pObjArray) {
m_pObjArray->RemoveAt((len - 1) * 2, 2);
}
} else {
if (bFirstLine) {
return TRUE;
}
if (m_bUseLF) {
m_Buffer.AppendChar(L'\r');
m_Buffer.AppendChar(L'\n');
if (m_pObjArray) {
for (int i = 0; i < 4; i ++) {
m_pObjArray->Add(NULL);
}
}
} else {
m_Buffer.AppendChar(' ');
if (m_pObjArray) {
m_pObjArray->Add(NULL);
m_pObjArray->Add(NULL);
}
}
}
} else if (result == 1) {
m_Buffer.AppendChar(L' ');
if (m_pObjArray) {
m_pObjArray->Add(NULL);
m_pObjArray->Add(NULL);
}
} else if (result == -1) {
m_pLastObj = pObj;
return FALSE;
} else if (result == 3) {
item_index = 1;
}
}
m_pLastObj = pObj;
int nItems = pObj->CountItems();
FX_FLOAT Ignorekerning = 0;
for(int i = 1; i < nItems - 1; i += 2) {
CPDF_TextObjectItem item;
pObj->GetItemInfo(i, &item);
if (item.m_CharCode == (FX_DWORD) - 1) {
if(i == 1) {
Ignorekerning = item.m_OriginX;
} else if(Ignorekerning > item.m_OriginX) {
Ignorekerning = item.m_OriginX;
}
} else {
Ignorekerning = 0;
break;
}
}
FX_FLOAT spacing = 0;
for (; item_index < nItems; item_index ++) {
CPDF_TextObjectItem item;
pObj->GetItemInfo(item_index, &item);
if (item.m_CharCode == (FX_DWORD) - 1) {
CFX_WideString wstr = m_Buffer.GetWideString();
if (wstr.IsEmpty() || wstr.GetAt(wstr.GetLength() - 1) == L' ') {
continue;
}
FX_FLOAT fontsize_h = pObj->m_TextState.GetFontSizeH();
spacing = -fontsize_h * (item.m_OriginX - Ignorekerning) / 1000;
continue;
}
FX_FLOAT charSpace = pObj->m_TextState.GetObject()->m_CharSpace;
if(nItems > 3 && !spacing) {
charSpace = 0;
}
if((spacing || charSpace) && item_index > 0) {
int last_width = 0;
FX_FLOAT fontsize_h = pObj->m_TextState.GetFontSizeH();
FX_DWORD space_charcode = pFont->CharCodeFromUnicode(' ');
FX_FLOAT threshold = 0;
if (space_charcode != -1) {
threshold = fontsize_h * pFont->GetCharWidthF(space_charcode) / 1000 ;
}
if(threshold > fontsize_h / 3) {
threshold = 0;
} else {
threshold /= 2;
}
if (threshold == 0) {
threshold = fontsize_h;
int this_width = FXSYS_abs(GetCharWidth(item.m_CharCode, pFont));
threshold = this_width > last_width ? (FX_FLOAT)this_width : (FX_FLOAT)last_width;
int nDivide = 6;
if (threshold < 300) {
nDivide = 2;
} else if (threshold < 500) {
nDivide = 4;
} else if (threshold < 700) {
nDivide = 5;
}
threshold = threshold / nDivide;
threshold = fontsize_h * threshold / 1000;
}
if(charSpace > 0.001) {
spacing += matrix.TransformDistance(charSpace);
} else if(charSpace < -0.001) {
spacing -= matrix.TransformDistance(FXSYS_fabs(charSpace));
}
if (threshold && (spacing && spacing >= threshold) ) {
m_Buffer.AppendChar(L' ');
if (m_pObjArray) {
m_pObjArray->Add(NULL);
m_pObjArray->Add(NULL);
}
}
if (item.m_CharCode == (FX_DWORD) - 1) {
continue;
}
spacing = 0;
}
CFX_WideString unicode_str = pFont->UnicodeFromCharCode(item.m_CharCode);
if (unicode_str.IsEmpty()) {
m_Buffer.AppendChar((FX_WCHAR)item.m_CharCode);
if (m_pObjArray) {
m_pObjArray->Add((void*)pObj);
m_pObjArray->Add((void*)(FX_INTPTR)item_index);
}
} else {
m_Buffer << unicode_str;
if (m_pObjArray) {
for (int i = 0; i < unicode_str.GetLength(); i ++) {
m_pObjArray->Add((void*)pObj);
m_pObjArray->Add((void*)(FX_INTPTR)item_index);
}
}
}
}
return FALSE;
}
FX_FLOAT CFWL_GridImp::ProcessUnCertainRows() {
int32_t iRows = m_Rows.GetSize();
if (iRows < 1) {
CFWL_GridColRow* pColRow = new CFWL_GridColRow;
pColRow->m_Size.eUnit = FWL_GRIDUNIT_Auto;
ProcAutoColRow(pColRow, 0, FALSE);
FX_FLOAT fWidth = pColRow->m_fActualSize;
delete pColRow;
return fWidth;
}
FX_FLOAT fFixedHeight = 0;
CFX_PtrArray autoRows;
CFX_PtrArray scaledRows;
FX_FLOAT fScaledRowNum = 0;
FX_FLOAT fScaledMaxPerHeight = 0;
for (int32_t i = 0; i < iRows; i++) {
CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Rows[i]);
if (!pColRow) {
continue;
}
switch (pColRow->m_Size.eUnit) {
case FWL_GRIDUNIT_Fixed: {
SetColRowActualSize(pColRow, pColRow->m_Size.fLength);
fFixedHeight += pColRow->m_fActualSize;
break;
}
case FWL_GRIDUNIT_Auto: {
ProcAutoColRow(pColRow, i, FALSE);
autoRows.Add(pColRow);
break;
}
case FWL_GRIDUNIT_Scaled:
default: {
ProcAutoColRow(pColRow, i, FALSE);
fScaledRowNum += pColRow->m_Size.fLength;
scaledRows.Add(pColRow);
if (pColRow->m_Size.fLength > 0) {
FX_FLOAT fPerHeight =
pColRow->m_fActualSize / pColRow->m_Size.fLength;
if (fPerHeight > fScaledMaxPerHeight) {
fScaledMaxPerHeight = fPerHeight;
}
}
break;
}
}
}
iRows = scaledRows.GetSize();
for (int32_t j = 0; j < iRows; j++) {
CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(scaledRows[j]);
if (!pColRow) {
continue;
}
SetColRowActualSize(pColRow, fScaledMaxPerHeight * pColRow->m_Size.fLength);
}
FX_POSITION ps = m_mapWidgetInfo.GetStartPosition();
while (ps) {
void* key = nullptr;
void* value = nullptr;
m_mapWidgetInfo.GetNextAssoc(ps, key, value);
IFWL_Widget* pWidget = static_cast<IFWL_Widget*>(key);
CFWL_GridWidgetInfo* pInfo = static_cast<CFWL_GridWidgetInfo*>(value);
if (pInfo->m_iRowSpan < 2) {
continue;
}
CFX_PtrArray spanAutoRows;
CFX_PtrArray spanScaledRows;
FX_FLOAT fSpanSize = 0;
FX_FLOAT fScaledSum = 0;
int32_t iAutoColRows = 0;
int32_t iScaledColRows = 0;
for (int32_t i = 0; i < pInfo->m_iRowSpan; i++) {
CFWL_GridColRow* pRow = reinterpret_cast<CFWL_GridColRow*>(
GetColRow(FALSE, pInfo->m_iRow + i));
if (!pRow) {
break;
}
fSpanSize += pRow->m_fActualSize;
if (pRow->m_Size.eUnit == FWL_GRIDUNIT_Auto) {
iAutoColRows++;
spanAutoRows.Add(pRow);
} else if (pRow->m_Size.eUnit == FWL_GRIDUNIT_Scaled) {
iScaledColRows++;
fScaledSum += pRow->m_Size.fLength;
spanScaledRows.Add(pRow);
}
}
if (iAutoColRows < 1 && iScaledColRows < 1) {
continue;
}
FX_FLOAT fWidgetHeight = CalcAutoColumnWidgetHeight(pWidget, pInfo);
if (fWidgetHeight > fSpanSize) {
if (iScaledColRows > 0) {
if (fScaledSum <= 0) {
continue;
}
SetSpanScaledColRowSize(spanScaledRows, fWidgetHeight - fSpanSize,
fScaledSum);
} else {
SetSpanAutoColRowSize(spanAutoRows, fWidgetHeight - fSpanSize);
}
}
}
FX_FLOAT fAutoHeigt = 0;
int32_t iAutoRows = autoRows.GetSize();
for (int32_t m = 0; m < iAutoRows; m++) {
fAutoHeigt += static_cast<CFWL_GridColRow*>(autoRows[m])->m_fActualSize;
}
FX_FLOAT fScaledHeight = 0;
iRows = scaledRows.GetSize();
for (int32_t n = 0; n < iRows; n++) {
fScaledHeight +=
static_cast<CFWL_GridColRow*>(scaledRows[n])->m_fActualSize;
}
return fFixedHeight + fAutoHeigt + fScaledHeight;
}
FX_FLOAT CFWL_GridImp::ProcessUnCertainColumns() {
int32_t iColumns = m_Columns.GetSize();
if (iColumns < 1) {
CFWL_GridColRow* pColRow = new CFWL_GridColRow;
pColRow->m_Size.eUnit = FWL_GRIDUNIT_Auto;
ProcAutoColRow(pColRow, 0, TRUE);
FX_FLOAT fWidth = pColRow->m_fActualSize;
delete pColRow;
return fWidth;
}
FX_FLOAT fFixedWidth = 0;
CFX_PtrArray autoColumns;
CFX_PtrArray scaledColumns;
FX_FLOAT fScaledColumnNum = 0;
FX_FLOAT fScaledMaxPerWidth = 0;
for (int32_t i = 0; i < iColumns; i++) {
CFWL_GridColRow* pColRow = reinterpret_cast<CFWL_GridColRow*>(m_Columns[i]);
if (!pColRow) {
continue;
}
switch (pColRow->m_Size.eUnit) {
case FWL_GRIDUNIT_Fixed: {
SetColRowActualSize(pColRow, pColRow->m_Size.fLength);
fFixedWidth += pColRow->m_fActualSize;
break;
}
case FWL_GRIDUNIT_Auto: {
ProcAutoColRow(pColRow, i, TRUE);
autoColumns.Add(pColRow);
break;
}
case FWL_GRIDUNIT_Scaled:
default: {
ProcAutoColRow(pColRow, i, TRUE);
fScaledColumnNum += pColRow->m_Size.fLength;
scaledColumns.Add(pColRow);
if (pColRow->m_Size.fLength <= 0) {
break;
}
FX_FLOAT fPerWidth = pColRow->m_fActualSize / pColRow->m_Size.fLength;
if (fPerWidth > fScaledMaxPerWidth) {
fScaledMaxPerWidth = fPerWidth;
}
}
}
}
iColumns = scaledColumns.GetSize();
for (int32_t j = 0; j < iColumns; j++) {
CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(scaledColumns[j]);
if (!pColRow) {
continue;
}
SetColRowActualSize(pColRow, fScaledMaxPerWidth * pColRow->m_Size.fLength);
}
FX_POSITION ps = m_mapWidgetInfo.GetStartPosition();
while (ps) {
IFWL_Widget* pWidget = NULL;
CFWL_GridWidgetInfo* pInfo = NULL;
m_mapWidgetInfo.GetNextAssoc(ps, (void*&)pWidget, (void*&)pInfo);
if (!pInfo || pInfo->m_iColumnSpan < 2) {
continue;
}
CFX_PtrArray spanAutoColumns;
CFX_PtrArray spanScaledColumns;
FX_FLOAT fSpanSize = 0;
FX_FLOAT fScaledSum = 0;
int32_t iAutoColRows = 0;
int32_t iScaledColRows = 0;
for (int32_t i = 0; i < pInfo->m_iColumnSpan; i++) {
CFWL_GridColRow* pColumn = reinterpret_cast<CFWL_GridColRow*>(
GetColRow(TRUE, pInfo->m_iColumn + i));
if (!pColumn) {
break;
}
fSpanSize += pColumn->m_fActualSize;
if (pColumn->m_Size.eUnit == FWL_GRIDUNIT_Auto) {
iAutoColRows++;
spanAutoColumns.Add(pColumn);
} else if (pColumn->m_Size.eUnit == FWL_GRIDUNIT_Scaled) {
iScaledColRows++;
fScaledSum += pColumn->m_Size.fLength;
spanScaledColumns.Add(pColumn);
}
}
if (iAutoColRows < 1 && iScaledColRows < 1) {
continue;
}
FX_FLOAT fWidgetWidth = CalcAutoColumnWidgetWidth(pWidget, pInfo);
if (fWidgetWidth > fSpanSize) {
if (iScaledColRows > 0) {
if (fScaledSum <= 0) {
continue;
}
SetSpanScaledColRowSize(spanScaledColumns, fWidgetWidth - fSpanSize,
fScaledSum);
} else {
SetSpanAutoColRowSize(spanAutoColumns, fWidgetWidth - fSpanSize);
}
}
}
FX_FLOAT fAutoWidth = 0;
int32_t iAutoCols = autoColumns.GetSize();
for (int32_t m = 0; m < iAutoCols; m++) {
fAutoWidth += static_cast<CFWL_GridColRow*>(autoColumns[m])->m_fActualSize;
}
FX_FLOAT fScaledWidth = 0;
iColumns = scaledColumns.GetSize();
for (int32_t n = 0; n < iColumns; n++) {
fScaledWidth +=
static_cast<CFWL_GridColRow*>(scaledColumns[n])->m_fActualSize;
}
return fFixedWidth + fAutoWidth + fScaledWidth;
}
FX_FLOAT CFWL_GridImp::ProcessRows(FX_FLOAT fHeight) {
if (fHeight <= 0) {
return ProcessUnCertainRows();
}
int32_t iRows = m_Rows.GetSize();
if (iRows < 1) {
return fHeight;
}
FX_FLOAT fFixedHeight = 0;
FX_FLOAT fAutoHeigt = 0;
CFX_PtrArray autoRows;
CFX_PtrArray scaledRows;
FX_FLOAT fScaledRowNum = 0;
for (int32_t i = 0; i < iRows; i++) {
CFWL_GridColRow* pColRow = static_cast<CFWL_GridColRow*>(m_Rows[i]);
if (!pColRow) {
continue;
}
switch (pColRow->m_Size.eUnit) {
case FWL_GRIDUNIT_Fixed: {
SetColRowActualSize(pColRow, pColRow->m_Size.fLength);
fFixedHeight += pColRow->m_fActualSize;
break;
}
case FWL_GRIDUNIT_Auto: {
ProcAutoColRow(pColRow, i, FALSE);
autoRows.Add(pColRow);
break;
}
case FWL_GRIDUNIT_Scaled:
default: {
fScaledRowNum += pColRow->m_Size.fLength;
scaledRows.Add(pColRow);
SetColRowActualSize(pColRow, 0);
break;
}
}
}
FX_POSITION ps = m_mapWidgetInfo.GetStartPosition();
while (ps) {
IFWL_Widget* pWidget = NULL;
CFWL_GridWidgetInfo* pInfo = NULL;
m_mapWidgetInfo.GetNextAssoc(ps, (void*&)pWidget, (void*&)pInfo);
if (!pInfo || pInfo->m_iRowSpan < 2) {
continue;
}
CFX_PtrArray spanAutoRows;
FX_FLOAT fSpanSize = 0;
int32_t iAutoColRows = 0;
int32_t iScaledColRows = 0;
for (int32_t i = 0; i < pInfo->m_iRowSpan; i++) {
CFWL_GridColRow* pRow = reinterpret_cast<CFWL_GridColRow*>(
GetColRow(FALSE, pInfo->m_iRow + i));
if (!pRow) {
break;
}
fSpanSize += pRow->m_fActualSize;
if (pRow->m_Size.eUnit == FWL_GRIDUNIT_Auto) {
iAutoColRows++;
spanAutoRows.Add(pRow);
} else if (pRow->m_Size.eUnit == FWL_GRIDUNIT_Scaled) {
iScaledColRows++;
}
}
if (iAutoColRows < 1) {
continue;
}
FX_FLOAT fWidgetHeight = CalcAutoColumnWidgetHeight(pWidget, pInfo);
if (fWidgetHeight > fSpanSize) {
if (iScaledColRows > 0) {
} else {
SetSpanAutoColRowSize(spanAutoRows, fWidgetHeight - fSpanSize);
}
}
}
int32_t iAutoRows = autoRows.GetSize();
for (int32_t k = 0; k < iAutoRows; k++) {
fAutoHeigt +=
reinterpret_cast<CFWL_GridColRow*>(autoRows[k])->m_fActualSize;
}
FX_FLOAT fScaledHeight = fHeight - fFixedHeight - fAutoHeigt;
if (fScaledHeight > 0 && fScaledRowNum > 0) {
SetScaledColRowsSize(scaledRows, fScaledHeight, fScaledRowNum);
}
return fHeight;
}
CBC_QRDetectorResult* CBC_DataMatrixDetector::Detect(int32_t& e) {
CFX_PtrArray* cornerPoints = m_rectangleDetector->Detect(e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_ResultPoint* pointA = (CBC_ResultPoint*)(*cornerPoints)[0];
CBC_ResultPoint* pointB = (CBC_ResultPoint*)(*cornerPoints)[1];
CBC_ResultPoint* pointC = (CBC_ResultPoint*)(*cornerPoints)[2];
CBC_ResultPoint* pointD = (CBC_ResultPoint*)(*cornerPoints)[3];
delete cornerPoints;
cornerPoints = NULL;
CFX_PtrArray transitions;
transitions.Add(TransitionsBetween(pointA, pointB));
transitions.Add(TransitionsBetween(pointA, pointC));
transitions.Add(TransitionsBetween(pointB, pointD));
transitions.Add(TransitionsBetween(pointC, pointD));
BC_FX_PtrArray_Sort(transitions, &ResultPointsAndTransitionsComparator);
delete ((CBC_ResultPointsAndTransitions*)transitions[2]);
delete ((CBC_ResultPointsAndTransitions*)transitions[3]);
CBC_ResultPointsAndTransitions* lSideOne =
(CBC_ResultPointsAndTransitions*)transitions[0];
CBC_ResultPointsAndTransitions* lSideTwo =
(CBC_ResultPointsAndTransitions*)transitions[1];
CFX_MapPtrTemplate<CBC_ResultPoint*, int32_t> pointCount;
Increment(pointCount, lSideOne->GetFrom());
Increment(pointCount, lSideOne->GetTo());
Increment(pointCount, lSideTwo->GetFrom());
Increment(pointCount, lSideTwo->GetTo());
delete ((CBC_ResultPointsAndTransitions*)transitions[1]);
delete ((CBC_ResultPointsAndTransitions*)transitions[0]);
transitions.RemoveAll();
CBC_ResultPoint* maybeTopLeft = NULL;
CBC_ResultPoint* bottomLeft = NULL;
CBC_ResultPoint* maybeBottomRight = NULL;
FX_POSITION itBegin = pointCount.GetStartPosition();
while (itBegin != NULL) {
CBC_ResultPoint* key = 0;
int32_t value = 0;
pointCount.GetNextAssoc(itBegin, key, value);
if (value == 2) {
bottomLeft = key;
} else {
if (maybeBottomRight == NULL) {
maybeBottomRight = key;
} else {
maybeTopLeft = key;
}
}
}
if (maybeTopLeft == NULL || bottomLeft == NULL || maybeBottomRight == NULL) {
delete pointA;
delete pointB;
delete pointC;
delete pointD;
e = BCExceptionNotFound;
return NULL;
}
CFX_PtrArray corners;
corners.SetSize(3);
corners[0] = maybeTopLeft;
corners[1] = bottomLeft;
corners[2] = maybeBottomRight;
OrderBestPatterns(&corners);
CBC_ResultPoint* bottomRight = (CBC_ResultPoint*)corners[0];
bottomLeft = (CBC_ResultPoint*)corners[1];
CBC_ResultPoint* topLeft = (CBC_ResultPoint*)corners[2];
CBC_ResultPoint* topRight = NULL;
int32_t value;
if (!pointCount.Lookup(pointA, value)) {
topRight = pointA;
} else if (!pointCount.Lookup(pointB, value)) {
topRight = pointB;
} else if (!pointCount.Lookup(pointC, value)) {
topRight = pointC;
} else {
topRight = pointD;
}
int32_t dimensionTop = CBC_AutoPtr<CBC_ResultPointsAndTransitions>(
TransitionsBetween(topLeft, topRight))
->GetTransitions();
int32_t dimensionRight = CBC_AutoPtr<CBC_ResultPointsAndTransitions>(
TransitionsBetween(bottomRight, topRight))
->GetTransitions();
if ((dimensionTop & 0x01) == 1) {
dimensionTop++;
}
dimensionTop += 2;
if ((dimensionRight & 0x01) == 1) {
dimensionRight++;
}
dimensionRight += 2;
CBC_AutoPtr<CBC_CommonBitMatrix> bits(NULL);
CBC_AutoPtr<CBC_ResultPoint> correctedTopRight(NULL);
if (4 * dimensionTop >= 7 * dimensionRight ||
4 * dimensionRight >= 7 * dimensionTop) {
correctedTopRight = CBC_AutoPtr<CBC_ResultPoint>(
CorrectTopRightRectangular(bottomLeft, bottomRight, topLeft, topRight,
dimensionTop, dimensionRight));
if (correctedTopRight.get() == NULL) {
correctedTopRight = CBC_AutoPtr<CBC_ResultPoint>(topRight);
} else {
delete topRight;
topRight = NULL;
}
dimensionTop = CBC_AutoPtr<CBC_ResultPointsAndTransitions>(
TransitionsBetween(topLeft, correctedTopRight.get()))
->GetTransitions();
dimensionRight =
CBC_AutoPtr<CBC_ResultPointsAndTransitions>(
TransitionsBetween(bottomRight, correctedTopRight.get()))
->GetTransitions();
if ((dimensionTop & 0x01) == 1) {
dimensionTop++;
}
if ((dimensionRight & 0x01) == 1) {
dimensionRight++;
}
bits = CBC_AutoPtr<CBC_CommonBitMatrix>(
SampleGrid(m_image, topLeft, bottomLeft, bottomRight,
correctedTopRight.get(), dimensionTop, dimensionRight, e));
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
} else {
int32_t dimension = std::min(dimensionRight, dimensionTop);
correctedTopRight = CBC_AutoPtr<CBC_ResultPoint>(
CorrectTopRight(bottomLeft, bottomRight, topLeft, topRight, dimension));
if (correctedTopRight.get() == NULL) {
correctedTopRight = CBC_AutoPtr<CBC_ResultPoint>(topRight);
} else {
delete topRight;
topRight = NULL;
}
int32_t dimensionCorrected =
std::max(CBC_AutoPtr<CBC_ResultPointsAndTransitions>(
TransitionsBetween(topLeft, correctedTopRight.get()))
->GetTransitions(),
CBC_AutoPtr<CBC_ResultPointsAndTransitions>(
TransitionsBetween(bottomRight, correctedTopRight.get()))
->GetTransitions());
dimensionCorrected++;
if ((dimensionCorrected & 0x01) == 1) {
dimensionCorrected++;
}
bits = CBC_AutoPtr<CBC_CommonBitMatrix>(SampleGrid(
m_image, topLeft, bottomLeft, bottomRight, correctedTopRight.get(),
dimensionCorrected, dimensionCorrected, e));
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
}
CFX_PtrArray* result = new CFX_PtrArray;
result->SetSize(4);
result->Add(topLeft);
result->Add(bottomLeft);
result->Add(bottomRight);
result->Add(correctedTopRight.release());
return new CBC_QRDetectorResult(bits.release(), result);
}
CFX_PtrArray* CBC_ReedSolomonDecoder::RunEuclideanAlgorithm(
CBC_ReedSolomonGF256Poly* a,
CBC_ReedSolomonGF256Poly* b,
int32_t R,
int32_t& e) {
if (a->GetDegree() < b->GetDegree()) {
CBC_ReedSolomonGF256Poly* temp = a;
a = b;
b = temp;
}
CBC_ReedSolomonGF256Poly* rsg1 = a->Clone(e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> rLast(rsg1);
CBC_ReedSolomonGF256Poly* rsg2 = b->Clone(e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> r(rsg2);
CBC_ReedSolomonGF256Poly* rsg3 = m_field->GetOne()->Clone(e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> sLast(rsg3);
CBC_ReedSolomonGF256Poly* rsg4 = m_field->GetZero()->Clone(e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> s(rsg4);
CBC_ReedSolomonGF256Poly* rsg5 = m_field->GetZero()->Clone(e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> tLast(rsg5);
CBC_ReedSolomonGF256Poly* rsg6 = m_field->GetOne()->Clone(e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> t(rsg6);
while (r->GetDegree() >= R / 2) {
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> rLastLast = rLast;
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> sLastLast = sLast;
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> tLastlast = tLast;
rLast = r;
sLast = s;
tLast = t;
if (rLast->IsZero()) {
e = BCExceptionR_I_1IsZero;
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
}
CBC_ReedSolomonGF256Poly* rsg7 = rLastLast->Clone(e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> rTemp(rsg7);
r = rTemp;
CBC_ReedSolomonGF256Poly* rsg8 = m_field->GetZero()->Clone(e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> q(rsg8);
int32_t denominatorLeadingTerm = rLast->GetCoefficients(rLast->GetDegree());
int32_t dltInverse = m_field->Inverse(denominatorLeadingTerm, e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
while (r->GetDegree() >= rLast->GetDegree() && !(r->IsZero())) {
int32_t degreeDiff = r->GetDegree() - rLast->GetDegree();
int32_t scale =
m_field->Multiply(r->GetCoefficients(r->GetDegree()), dltInverse);
CBC_ReedSolomonGF256Poly* rsgp1 =
m_field->BuildMonomial(degreeDiff, scale, e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> build(rsgp1);
CBC_ReedSolomonGF256Poly* rsgp2 = q->AddOrSubtract(build.get(), e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> temp(rsgp2);
q = temp;
CBC_ReedSolomonGF256Poly* rsgp3 =
rLast->MultiplyByMonomial(degreeDiff, scale, e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> multiply(rsgp3);
CBC_ReedSolomonGF256Poly* rsgp4 = r->AddOrSubtract(multiply.get(), e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> temp3(rsgp4);
r = temp3;
}
CBC_ReedSolomonGF256Poly* rsg9 = q->Multiply(sLast.get(), e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> temp1(rsg9);
CBC_ReedSolomonGF256Poly* rsg10 = temp1->AddOrSubtract(sLastLast.get(), e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> temp2(rsg10);
s = temp2;
CBC_ReedSolomonGF256Poly* rsg11 = q->Multiply(tLast.get(), e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> temp5(rsg11);
CBC_ReedSolomonGF256Poly* rsg12 = temp5->AddOrSubtract(tLastlast.get(), e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> temp6(rsg12);
t = temp6;
}
int32_t sigmaTildeAtZero = t->GetCoefficients(0);
if (sigmaTildeAtZero == 0) {
e = BCExceptionIsZero;
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
}
int32_t inverse = m_field->Inverse(sigmaTildeAtZero, e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_ReedSolomonGF256Poly* rsg13 = t->Multiply(inverse, e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> sigma(rsg13);
CBC_ReedSolomonGF256Poly* rsg14 = r->Multiply(inverse, e);
BC_EXCEPTION_CHECK_ReturnValue(e, NULL);
CBC_AutoPtr<CBC_ReedSolomonGF256Poly> omega(rsg14);
CFX_PtrArray* temp = new CFX_PtrArray;
temp->Add(sigma.release());
temp->Add(omega.release());
return temp;
}
FX_BOOL _SaveXFADocumentData(CPDFXFA_Document* pDocument,
CFX_PtrArray& fileList) {
if (!pDocument)
return FALSE;
if (pDocument->GetDocType() != DOCTYPE_DYNAMIC_XFA &&
pDocument->GetDocType() != DOCTYPE_STATIC_XFA)
return TRUE;
if (!CPDFXFA_App::GetInstance()->GetXFAApp())
return TRUE;
IXFA_DocView* pXFADocView = pDocument->GetXFADocView();
if (NULL == pXFADocView)
return TRUE;
IXFA_DocHandler* pXFADocHandler =
CPDFXFA_App::GetInstance()->GetXFAApp()->GetDocHandler();
CPDF_Document* pPDFDocument = pDocument->GetPDFDoc();
if (pDocument == NULL)
return FALSE;
CPDF_Dictionary* pRoot = pPDFDocument->GetRoot();
if (pRoot == NULL)
return FALSE;
CPDF_Dictionary* pAcroForm = pRoot->GetDict("AcroForm");
if (NULL == pAcroForm)
return FALSE;
CPDF_Object* pXFA = pAcroForm->GetElement("XFA");
if (pXFA == NULL)
return TRUE;
if (pXFA->GetType() != PDFOBJ_ARRAY)
return FALSE;
CPDF_Array* pArray = pXFA->GetArray();
if (NULL == pArray)
return FALSE;
int size = pArray->GetCount();
int iFormIndex = -1;
int iDataSetsIndex = -1;
int iTemplate = -1;
int iLast = size - 2;
for (int i = 0; i < size - 1; i++) {
CPDF_Object* pPDFObj = pArray->GetElement(i);
if (pPDFObj->GetType() != PDFOBJ_STRING)
continue;
if (pPDFObj->GetString() == "form")
iFormIndex = i + 1;
else if (pPDFObj->GetString() == "datasets")
iDataSetsIndex = i + 1;
else if (pPDFObj->GetString() == "template")
iTemplate = i + 1;
}
IXFA_ChecksumContext* pContext = NULL;
// Checksum
pContext = XFA_Checksum_Create();
FXSYS_assert(pContext);
pContext->StartChecksum();
// template
if (iTemplate > -1) {
CPDF_Stream* pTemplateStream = pArray->GetStream(iTemplate);
CPDF_StreamAcc streamAcc;
streamAcc.LoadAllData(pTemplateStream);
uint8_t* pData = (uint8_t*)streamAcc.GetData();
FX_DWORD dwSize2 = streamAcc.GetSize();
IFX_FileStream* pTemplate = FX_CreateMemoryStream(pData, dwSize2);
pContext->UpdateChecksum((IFX_FileRead*)pTemplate);
pTemplate->Release();
}
CPDF_Stream* pFormStream = NULL;
CPDF_Stream* pDataSetsStream = NULL;
if (iFormIndex != -1) {
// Get form CPDF_Stream
CPDF_Object* pFormPDFObj = pArray->GetElement(iFormIndex);
if (pFormPDFObj->GetType() == PDFOBJ_REFERENCE) {
CPDF_Object* pFormDircetObj = pFormPDFObj->GetDirect();
if (NULL != pFormDircetObj &&
pFormDircetObj->GetType() == PDFOBJ_STREAM) {
pFormStream = (CPDF_Stream*)pFormDircetObj;
}
} else if (pFormPDFObj->GetType() == PDFOBJ_STREAM) {
pFormStream = (CPDF_Stream*)pFormPDFObj;
}
}
if (iDataSetsIndex != -1) {
// Get datasets CPDF_Stream
CPDF_Object* pDataSetsPDFObj = pArray->GetElement(iDataSetsIndex);
if (pDataSetsPDFObj->GetType() == PDFOBJ_REFERENCE) {
CPDF_Reference* pDataSetsRefObj = (CPDF_Reference*)pDataSetsPDFObj;
CPDF_Object* pDataSetsDircetObj = pDataSetsRefObj->GetDirect();
if (NULL != pDataSetsDircetObj &&
pDataSetsDircetObj->GetType() == PDFOBJ_STREAM) {
pDataSetsStream = (CPDF_Stream*)pDataSetsDircetObj;
}
} else if (pDataSetsPDFObj->GetType() == PDFOBJ_STREAM) {
pDataSetsStream = (CPDF_Stream*)pDataSetsPDFObj;
}
}
// end
// L"datasets"
{
IFX_FileStream* pDsfileWrite = FX_CreateMemoryStream();
if (NULL == pDsfileWrite) {
pContext->Release();
pDsfileWrite->Release();
return FALSE;
}
if (pXFADocHandler->SavePackage(pXFADocView->GetDoc(),
CFX_WideStringC(L"datasets"),
pDsfileWrite) &&
pDsfileWrite->GetSize() > 0) {
// Datasets
pContext->UpdateChecksum((IFX_FileRead*)pDsfileWrite);
pContext->FinishChecksum();
CPDF_Dictionary* pDataDict = new CPDF_Dictionary;
if (iDataSetsIndex != -1) {
if (pDataSetsStream)
pDataSetsStream->InitStreamFromFile(pDsfileWrite, pDataDict);
} else {
CPDF_Stream* pData = new CPDF_Stream(NULL, 0, NULL);
pData->InitStreamFromFile(pDsfileWrite, pDataDict);
pPDFDocument->AddIndirectObject(pData);
iLast = pArray->GetCount() - 2;
pArray->InsertAt(iLast, new CPDF_String("datasets", FALSE));
pArray->InsertAt(iLast + 1, pData, pPDFDocument);
}
fileList.Add(pDsfileWrite);
}
}
// L"form"
{
IFX_FileStream* pfileWrite = FX_CreateMemoryStream();
if (NULL == pfileWrite) {
pContext->Release();
return FALSE;
}
if (pXFADocHandler->SavePackage(pXFADocView->GetDoc(),
CFX_WideStringC(L"form"), pfileWrite,
pContext) &&
pfileWrite > 0) {
CPDF_Dictionary* pDataDict = new CPDF_Dictionary;
if (iFormIndex != -1) {
if (pFormStream)
pFormStream->InitStreamFromFile(pfileWrite, pDataDict);
} else {
CPDF_Stream* pData = new CPDF_Stream(NULL, 0, NULL);
pData->InitStreamFromFile(pfileWrite, pDataDict);
pPDFDocument->AddIndirectObject(pData);
iLast = pArray->GetCount() - 2;
pArray->InsertAt(iLast, new CPDF_String("form", FALSE));
pArray->InsertAt(iLast + 1, pData, pPDFDocument);
}
fileList.Add(pfileWrite);
}
}
pContext->Release();
return TRUE;
}
