void pdfshow::paintEvent(QPaintEvent *)
{
iViewWidth = width();
iViewHeight = height();
QPainter painter(this);
HDC hdc = painter.paintEngine()->getDC(); // THIS IS THE CRITICAL STEP!
//HDC hdc = getDC(); // THIS IS THE CRITICAL STEP!
// 将点数转换为像素
size_x = iViewWidth;
size_y = ((page_height*1000*iViewWidth)/page_width)/1000;
HWND hwnd = winId();
if(bCrossPage == false)
{
pdf_page = FPDF_LoadPage(pdf_doc, iCurrentPage);
FPDF_RenderPage(hdc, pdf_page, 0, iCurrentPage*size_y-iBeginy,size_x ,size_y, 0, 0);
FPDF_ClosePage(pdf_page);
}
else
{
pdf_page = FPDF_LoadPage(pdf_doc, iCurrentPage);
FPDF_RenderPage(hdc, pdf_page, 0, iCurrentPage*size_y-iBeginy,size_x ,size_y, 0, 0);
FPDF_ClosePage(pdf_page);
pdf_page = FPDF_LoadPage(pdf_doc, iCurrentPage+1);
FPDF_RenderPage(hdc, pdf_page, 0, (iCurrentPage+1)*size_y-iBeginy,size_x ,size_y, 0, 0);
FPDF_ClosePage(pdf_page);
}
ReleaseDC(hwnd, hdc);
//releaseDC(hdc);
}
csPDFiumTextPage csPDFiumDocument::textPage(const int no) const
{
if( isEmpty() ) {
return csPDFiumTextPage();
}
CSPDFIUM_DOCIMPL();
if( no < 0 || no >= FPDF_GetPageCount(impl->document) ) {
return csPDFiumTextPage();
}
const FPDF_PAGE page = FPDF_LoadPage(impl->document, no);
if( page == NULL ) {
return csPDFiumTextPage();
}
const QMatrix ctm = util::getPageCTM(page);
const csPDFiumTextPage result(no, util::extractTexts(page, ctm));
FPDF_ClosePage(page);
return result;
}
static jlong nativeOpenPageAndGetSize(JNIEnv* env, jclass thiz, jlong documentPtr,
jint pageIndex, jobject outSize) {
FPDF_DOCUMENT document = reinterpret_cast<FPDF_DOCUMENT>(documentPtr);
FPDF_PAGE page = FPDF_LoadPage(document, pageIndex);
if (!page) {
jniThrowException(env, "java/lang/IllegalStateException",
"cannot load page");
return -1;
}
double width = 0;
double height = 0;
const int result = FPDF_GetPageSizeByIndex(document, pageIndex, &width, &height);
if (!result) {
jniThrowException(env, "java/lang/IllegalStateException",
"cannot get page size");
return -1;
}
env->SetIntField(outSize, gPointClassInfo.x, width);
env->SetIntField(outSize, gPointClassInfo.y, height);
return reinterpret_cast<jlong>(page);
}
csPDFiumTextPages csPDFiumDocument::textPages(const int first, const int count) const
{
if( isEmpty() ) {
return csPDFiumTextPages();
}
CSPDFIUM_DOCIMPL();
const int pageCount = FPDF_GetPageCount(impl->document);
if( first < 0 || first >= pageCount ) {
return csPDFiumTextPages();
}
const int last = count <= 0
? pageCount-1
: qBound(0, first+count-1, pageCount-1);
csPDFiumTextPages results;
for(int pageNo = first; pageNo <= last; pageNo++) {
const FPDF_PAGE page = FPDF_LoadPage(impl->document, pageNo);
if( page == NULL ) {
continue;
}
const QMatrix ctm = util::getPageCTM(page);
results.push_back(csPDFiumTextPage(pageNo,
util::extractTexts(page, ctm)));
FPDF_ClosePage(page);
}
return results;
}
csPDFiumWordsPages csPDFiumDocument::wordsPages(const int firstIndex,
const int count) const
{
if( isEmpty() ) {
return csPDFiumWordsPages();
}
CSPDFIUM_DOCIMPL();
const int pageCount = FPDF_GetPageCount(impl->document);
if( firstIndex < 0 || firstIndex >= pageCount ) {
csPDFiumWordsPages();
}
const int lastIndex = count <= 0
? pageCount-1
: qBound(0, firstIndex+count-1, pageCount-1);
csPDFiumWordsPages result;
for(int index = firstIndex; index <= lastIndex; index++) {
const FPDF_PAGE page = FPDF_LoadPage(impl->document, index);
if( page == NULL ) {
continue;
}
const csPDFiumWordsPage wordsPage(index, util::extractWords(page));
if( !wordsPage.second.isEmpty() ) {
result.push_back(wordsPage);
}
FPDF_ClosePage(page);
}
return result;
}
csPDFiumPage csPDFiumDocument::page(const int no) const
{
if( isEmpty() ) {
return csPDFiumPage();
}
CSPDFIUM_DOCIMPL();
if( no < 0 || no >= FPDF_GetPageCount(impl->document) ) {
return csPDFiumPage();
}
csPDFiumPageImpl *pimpl = new csPDFiumPageImpl();
if( pimpl == 0 ) {
return csPDFiumPage();
}
pimpl->page = FPDF_LoadPage(impl->document, no);
if( pimpl->page == NULL ) {
delete pimpl;
return csPDFiumPage();
}
pimpl->ctm = util::getPageCTM(pimpl->page);
pimpl->doc = impl;
pimpl->no = no;
csPDFiumPage page;
page.impl = QSharedPointer<csPDFiumPageImpl>(pimpl);
return page;
}
pdfshow::pdfshow(QWidget *parent)
: QWidget(parent)
{
//get instance of current program (self)
HINSTANCE hInst= GetModuleHandle (0);
FPDF_InitLibrary(hInst);
setAttribute(Qt::WA_PaintOnScreen,true);
// 首先，加载文档（没有指定的密码）
pdf_doc = FPDF_LoadDocument("./manual/usermanual.pdf", NULL);
if (pdf_doc == NULL)// error handling
{
printf("加载pdf文档错误\n");
}
// 现在加载首页（页面索引为0）
pdf_page = FPDF_LoadPage(pdf_doc, 0);
iPageNum = FPDF_GetPageCount(pdf_doc);
if (pdf_page == NULL)
{
printf("加载pdf页面错误\n");
}
page_width = FPDF_GetPageWidth(pdf_page);
page_height = FPDF_GetPageHeight(pdf_page);
FPDF_ClosePage(pdf_page);
}
static bool nativeGetPageBox(JNIEnv* env, jclass thiz, jlong documentPtr, jint pageIndex,
PageBox pageBox, jobject outBox) {
FPDF_DOCUMENT document = reinterpret_cast<FPDF_DOCUMENT>(documentPtr);
FPDF_PAGE page = FPDF_LoadPage(document, pageIndex);
if (!page) {
jniThrowException(env, "java/lang/IllegalStateException",
"cannot open page");
return false;
}
float left;
float top;
float right;
float bottom;
const FPDF_BOOL success = (pageBox == PAGE_BOX_MEDIA)
? FPDFPage_GetMediaBox(page, &left, &top, &right, &bottom)
: FPDFPage_GetCropBox(page, &left, &top, &right, &bottom);
FPDF_ClosePage(page);
if (!success) {
return false;
}
env->SetIntField(outBox, gRectClassInfo.left, (int) left);
env->SetIntField(outBox, gRectClassInfo.top, (int) top);
env->SetIntField(outBox, gRectClassInfo.right, (int) right);
env->SetIntField(outBox, gRectClassInfo.bottom, (int) bottom);
return true;
}
FPDF_PAGE EmbedderTest::LoadPage(int page_number) {
FPDF_PAGE page = FPDF_LoadPage(document_, page_number);
if (!page) {
return nullptr;
}
FORM_OnAfterLoadPage(page, form_handle_);
FORM_DoPageAAction(page, form_handle_, FPDFPAGE_AACTION_OPEN);
return page;
}
FPDF_PAGE wxPDFViewPage::GetPage()
{
if (!m_page)
{
m_page = FPDF_LoadPage(m_pages->doc(), m_index);
if (m_pages->form())
FORM_OnAfterLoadPage(m_page, m_pages->form());
}
return m_page;
}
TEST_F(FPDFDocEmbedderTest, GetXFALinks) {
EXPECT_TRUE(OpenDocument("simple_xfa.pdf"));
ScopedFPDFPage page(FPDF_LoadPage(document(), 0));
ASSERT_TRUE(page);
FPDFLink_GetLinkAtPoint(page.get(), 150, 360);
FPDFLink_GetLinkAtPoint(page.get(), 150, 420);
// Test passes if it doesn't crash. See https://crbug.com/840922
}
static void nativeSetTransformAndClip(JNIEnv* env, jclass thiz, jlong documentPtr, jint pageIndex,
jlong transformPtr, jint clipLeft, jint clipTop, jint clipRight, jint clipBottom) {
FPDF_DOCUMENT document = reinterpret_cast<FPDF_DOCUMENT>(documentPtr);
CPDF_Page* page = (CPDF_Page*) FPDF_LoadPage(document, pageIndex);
if (!page) {
jniThrowException(env, "java/lang/IllegalStateException",
"cannot open page");
return;
}
double width = 0;
double height = 0;
const int result = FPDF_GetPageSizeByIndex(document, pageIndex, &width, &height);
if (!result) {
jniThrowException(env, "java/lang/IllegalStateException",
"cannot get page size");
return;
}
CFX_AffineMatrix matrix;
SkMatrix* skTransform = reinterpret_cast<SkMatrix*>(transformPtr);
SkScalar transformValues[6];
if (!skTransform->asAffine(transformValues)) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"transform matrix has perspective. Only affine matrices are allowed.");
return;
}
// PDF's coordinate system origin is left-bottom while in graphics it
// is the top-left. So, translate the PDF coordinates to ours.
matrix.Set(1, 0, 0, -1, 0, page->GetPageHeight());
// Apply the transformation what was created in our coordinates.
matrix.Concat(transformValues[SkMatrix::kAScaleX], transformValues[SkMatrix::kASkewY],
transformValues[SkMatrix::kASkewX], transformValues[SkMatrix::kAScaleY],
transformValues[SkMatrix::kATransX], transformValues[SkMatrix::kATransY]);
// Translate the result back to PDF coordinates.
matrix.Concat(1, 0, 0, -1, 0, page->GetPageHeight());
FS_MATRIX transform = {matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f};
FS_RECTF clip = {(float) clipLeft, (float) clipTop, (float) clipRight, (float) clipBottom};
FPDFPage_TransFormWithClip(page, &transform, &clip);
FPDF_ClosePage(page);
}
FPDF_PAGE EmbedderTest::Delegate::GetPage(FPDF_FORMHANDLE form_handle,
FPDF_DOCUMENT document,
int page_index) {
auto it = m_pageMap.find(page_index);
if (it != m_pageMap.end()) {
return it->second;
}
FPDF_PAGE page = FPDF_LoadPage(document, page_index);
if (!page) {
return nullptr;
}
m_pageMap[page_index] = page;
FORM_OnAfterLoadPage(page, form_handle);
return page;
}
FPDF_PAGE EmbedderTest::LoadPage(int page_number) {
// First check whether it is loaded already.
auto it = page_map_.find(page_number);
if (it != page_map_.end())
return it->second;
FPDF_PAGE page = FPDF_LoadPage(document_, page_number);
if (!page) {
return nullptr;
}
FORM_OnAfterLoadPage(page, form_handle_);
FORM_DoPageAAction(page, form_handle_, FPDFPAGE_AACTION_OPEN);
// Cache the page.
page_map_[page_number] = page;
page_reverse_map_[page] = page_number;
return page;
}
TEST_F(FPDFDocEmbedderTest, MultipleSamePage) {
EXPECT_TRUE(OpenDocument("hello_world.pdf"));
CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document());
std::set<FPDF_PAGE> unique_pages;
std::vector<ScopedFPDFPage> owned_pages(4);
for (auto& ref : owned_pages) {
ref.reset(FPDF_LoadPage(document(), 0));
unique_pages.insert(ref.get());
}
#ifdef PDF_ENABLE_XFA
EXPECT_EQ(1u, unique_pages.size());
EXPECT_EQ(1u, pDoc->GetParsedPageCountForTesting());
#else // PDF_ENABLE_XFA
EXPECT_EQ(4u, unique_pages.size());
EXPECT_EQ(4u, pDoc->GetParsedPageCountForTesting());
#endif // PDF_ENABLE_XFA
}
TEST_F(FPDFDocEmbeddertest, ActionGetFilePath) {
EXPECT_TRUE(OpenDocument("launch_action.pdf"));
FPDF_PAGE page = FPDF_LoadPage(document(), 0);
ASSERT_TRUE(page);
// The target action is nearly the size of the whole page.
FPDF_LINK link = FPDFLink_GetLinkAtPoint(page, 100, 100);
ASSERT_TRUE(link);
FPDF_ACTION action = FPDFLink_GetAction(link);
ASSERT_TRUE(action);
const char kExpectedResult[] = "test.pdf";
const unsigned long kExpectedLength = sizeof(kExpectedResult);
unsigned long bufsize = FPDFAction_GetFilePath(action, nullptr, 0);
ASSERT_EQ(kExpectedLength, bufsize);
char buf[kExpectedLength];
EXPECT_EQ(bufsize, FPDFAction_GetFilePath(action, buf, bufsize));
EXPECT_EQ(std::string(kExpectedResult), std::string(buf));
FPDF_ClosePage(page);
}
static void nativeSetPageBox(JNIEnv* env, jclass thiz, jlong documentPtr, jint pageIndex,
PageBox pageBox, jobject box) {
FPDF_DOCUMENT document = reinterpret_cast<FPDF_DOCUMENT>(documentPtr);
FPDF_PAGE page = FPDF_LoadPage(document, pageIndex);
if (!page) {
jniThrowException(env, "java/lang/IllegalStateException",
"cannot open page");
return;
}
const int left = env->GetIntField(box, gRectClassInfo.left);
const int top = env->GetIntField(box, gRectClassInfo.top);
const int right = env->GetIntField(box, gRectClassInfo.right);
const int bottom = env->GetIntField(box, gRectClassInfo.bottom);
if (pageBox == PAGE_BOX_MEDIA) {
FPDFPage_SetMediaBox(page, left, top, right, bottom);
} else {
FPDFPage_SetCropBox(page, left, top, right, bottom);
}
FPDF_ClosePage(page);
}
int _tmain(int argc, _TCHAR* argv[])
{
// Before we can do anything, we need to unlock the DLL
// NOTE: If you are evaluating FOXIT READER SDK, you don’t need unlock the DLL,
// then evaluation marks will be shown with all rendered pages.
FPDF_UnlockDLL("license_id", "unlock_code");
// first, load the document (no password specified)
pdf_doc = FPDF_LoadDocument("testdoc.pdf", NULL);
// error handling
if (pdf_doc == NULL)
{
fprintf(stderr, "ERROR - doc\n");
exit(1);
}
// Open the out file
fopen_s(&out, "test.spl", "wb");
// Send the StartDoc header
wchar_t* dname = L"desktop.ini - Editor";
wchar_t* prn = L"c:\\output.prn";
{
if (wcsnlen(dname, 255) == 255)
ErrorExit(L"dname too long");
if (wcsnlen(prn, 255) == 255)
ErrorExit(L"prn too long");
SPL_HEADER spl;
spl.SIGNATURE=SPLMETA_SIGNATURE;
spl.nSize=(DWORD)sizeof(spl)+wcslen(dname)*2+wcslen(prn)*2+4; // +4, because \0\0 is after dname and prn
spl.offDocumentName=(DWORD)sizeof(spl);
spl.offPort=(DWORD)sizeof(spl)+wcslen(dname)*2+2; // +2 because \0\0 is after dname
fwrite(&spl, sizeof(spl), 1, out);
fwrite(dname, wcslen(dname)*2, 1, out);
fwrite("\0\0", 2, 1, out);
fwrite(prn, wcslen(prn)*2, 1, out);
fwrite("\0\0", 2, 1, out);
}
// Load the first page and calculate the bbox
// based on the printer margins
pdf_page = FPDF_LoadPage(pdf_doc, 0);
if (pdf_page == NULL)
ErrorExit(L"FPDF_LoadPage");
double page_width, page_height;
page_width = FPDF_GetPageWidth(pdf_page);
page_height = FPDF_GetPageHeight(pdf_page);
#ifdef EXT_PRINT
#ifdef EXT_PRNDLG
PRINTDLG pd;
HWND hwnd = NULL;
// Initialize PRINTDLG
ZeroMemory(&pd, sizeof(pd));
pd.lStructSize = sizeof(pd);
pd.hwndOwner = hwnd;
pd.hDevMode = NULL; // Don't forget to free or store hDevMode
pd.hDevNames = NULL; // Don't forget to free or store hDevNames
pd.Flags = PD_USEDEVMODECOPIESANDCOLLATE | PD_RETURNDC;
pd.nCopies = 1;
pd.nFromPage = 0xFFFF;
pd.nToPage = 0xFFFF;
pd.nMinPage = 1;
pd.nMaxPage = 0xFFFF;
if (PrintDlg(&pd) != TRUE)
ErrorExit(L"PrintDialog\n");
hDC = pd.hDC;
#else
wchar_t* printer=L"FF";
if (!OpenPrinter(printer, &hPrinter, NULL))
ErrorExit(L"OpenPrinter\n");
DWORD dwNeeded = DocumentProperties(NULL, hPrinter, printer, NULL, NULL, 0);
lpDevMode = (LPDEVMODE)malloc(dwNeeded);
DocumentProperties(NULL, hPrinter, printer, lpDevMode, NULL, DM_OUT_BUFFER);
/* Try to set a higher print quality */
lpDevMode->dmPrintQuality=1200;
lpDevMode->dmFields|=DM_PRINTQUALITY;
DocumentProperties(NULL, hPrinter, printer, lpDevMode, lpDevMode, DM_IN_BUFFER | DM_OUT_BUFFER);
#ifdef EXT_PRNOPTS
DocumentProperties(NULL, hPrinter, printer, lpDevMode, lpDevMode, DM_IN_BUFFER | DM_PROMPT | DM_OUT_BUFFER);
#endif
hDC = CreateDC(L"WINEPS.DRV", printer, NULL, lpDevMode);
ClosePrinter(&hPrinter);
#endif
#else
hDC = CreateDC(L"WINEPS.DRV", L"FF", NULL, lpDevMode);
#endif
#ifdef PRINT
DOCINFO doc_info;
doc_info.cbSize=sizeof(DOCINFO)+12;
doc_info.lpszDocName=dname;
doc_info.lpszOutput=prn;
doc_info.lpszDatatype=NULL;
doc_info.fwType=0;
// Start a printer job
StartDoc(hDC, &doc_info);
#endif
// get number of pixels per inch (horizontally and vertically)
logpixelsx = GetDeviceCaps(hDC, LOGPIXELSX);
logpixelsy = GetDeviceCaps(hDC, LOGPIXELSY);
// convert points into pixels
size_x = (int)page_width / 72 * logpixelsx;
size_y = (int)page_height / 72 * logpixelsy;
DWORD p_width =GetDeviceCaps(hDC, HORZSIZE)*100;
DWORD p_height=GetDeviceCaps(hDC, VERTSIZE)*100;
SetRect( &rect, 0, 0, p_width, p_height );
#ifdef DEBUG
//fprintf(stderr, "x=%u, y=%u, pw=%u, ph=%u,sx=%u,sy=%u,lpx=%u,lpy=%u,size_x=%u,size_y=%u\n",x,y,page_width,page_height,sx,sy,logpixelsx,logpixelsy,size_x,size_y);
#endif
// now load the pages one after another
for (i=0; i < FPDF_GetPageCount(pdf_doc); i++)
{
#ifdef DEBUG
fprintf(stderr, "Load page %d/%d\n", i, FPDF_GetPageCount(pdf_doc));
#endif
// Load the next page
pdf_page = FPDF_LoadPage(pdf_doc, i);
if (pdf_page == NULL)
ErrorExit(L"FPDF_LoadPage");
fbuf=NULL;
#ifdef DEBUG
sprintf_s(buf, 255, "test-%d.emf", i);
//fbuf=buf;
#endif
// Create a metafile to render to
hMeta = CreateEnhMetaFileA(hDC,
fbuf,
&rect, "SPLFilter.exe\0Created by Fabian\0\0");
if (hMeta == NULL)
ErrorExit(L"CreateEnhMetaFileA");
// Call FPDF_RenderPage function to render the whole page
FPDF_RenderPage(hMeta, pdf_page, 0, 0, size_x, size_y, 0, 0);
#ifdef PRINT
// Start a new printing page
StartPage(hDC);
FPDF_RenderPage(hDC, pdf_page, 0, 0, size_x, size_y, 0, 0);
EndPage(hDC);
#endif
// Close PDF page
FPDF_ClosePage(pdf_page);
efile=CloseEnhMetaFile(hMeta);
if (efile == NULL)
ErrorExit(L"CloseEnhMetaFile");
// Write EMF data - via enumeration, because we want to embed fonts later
EnumEnhMetaFile(hDC, efile, enum_it, NULL, &rect);
// Write EndPage() record
{
SMR_EOPAGE smr_eopage;
smr_eopage.smrext.smr.iType=SRT_EXT_EOPAGE_VECTOR;
smr_eopage.smrext.smr.nSize=sizeof(smr_eopage)-sizeof(smr_eopage.smrext.smr);
/* FIXME: Need to calcualte low and high correctly */
smr_eopage.smrext.DistanceLow=bufSize+smr_eopage.smrext.smr.nSize;
smr_eopage.smrext.DistanceHigh=0;
fwrite(&smr_eopage, sizeof(smr_eopage), 1, out);
}
DeleteEnhMetaFile(efile);
}
#ifdef PRINT
EndDoc(hDC);
#endif
fclose(out);
out=NULL;
DeleteDC(hDC);
FPDF_CloseDocument(pdf_doc);
#ifdef DEBUG
fprintf(stderr, "SPLFilter: Conversion successful!\n");
#endif
exit(0);
}
