1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #include "../../include/reflow/reflowengine.h"
8 #include "reflowedpage.h"
CPDF_ProgressiveReflowPageParser()9 CPDF_ProgressiveReflowPageParser::CPDF_ProgressiveReflowPageParser()
10 {
11 m_nObjProcessed = 0;
12 m_pReflowEngine = NULL;
13 m_pProvider = NULL;
14 }
~CPDF_ProgressiveReflowPageParser()15 CPDF_ProgressiveReflowPageParser::~CPDF_ProgressiveReflowPageParser()
16 {
17 if(m_pProvider) {
18 delete m_pProvider;
19 }
20 m_pProvider = NULL;
21 if(m_pReflowEngine) {
22 delete m_pReflowEngine;
23 }
24 m_pReflowEngine = NULL;
25 }
Init()26 void CPDF_ProgressiveReflowPageParser::Init()
27 {
28 m_Status = Ready;
29 }
CPDF_ReflowedPage(CFX_GrowOnlyPool * pMemoryPool)30 CPDF_ReflowedPage::CPDF_ReflowedPage(CFX_GrowOnlyPool* pMemoryPool)
31 {
32 m_PageWidth = 0;
33 m_PageHeight = 0;
34 m_bWaiting = TRUE;
35 if(pMemoryPool) {
36 m_pMemoryPool = pMemoryPool;
37 m_bCreateMemoryPool = FALSE;
38 } else {
39 m_pMemoryPool = FX_NEW CFX_GrowOnlyPool;
40 m_bCreateMemoryPool = TRUE;
41 }
42 m_pCharState = FX_NEW CRF_CharStateArray(10);
43 m_pReflowed = FX_NEW CRF_DataPtrArray(500);
44 m_pPageInfos = NULL;
45 }
~CPDF_ReflowedPage()46 CPDF_ReflowedPage::~CPDF_ReflowedPage()
47 {
48 if (m_pReflowed) {
49 for(int i = 0; i < m_pReflowed->GetSize(); i++) {
50 CRF_Data* pData = (*m_pReflowed)[i];
51 if(pData->m_Type == CRF_Data::Image) {
52 delete ((CRF_ImageData*)pData)->m_pBitmap;
53 }
54 }
55 m_pReflowed->RemoveAll();
56 delete m_pReflowed;
57 }
58 m_pReflowed = NULL;
59 if (m_pCharState) {
60 m_pCharState->RemoveAll();
61 delete m_pCharState;
62 }
63 m_pCharState = NULL;
64 if(m_bCreateMemoryPool && m_pMemoryPool) {
65 m_pMemoryPool->FreeAll();
66 }
67 if (m_pMemoryPool) {
68 delete m_pMemoryPool;
69 }
70 m_pMemoryPool = NULL;
71 m_pPDFPage = NULL;
72 if (m_pPageInfos) {
73 ReleasePageObjsMemberShip();
74 }
75 }
RetainPageObjsMemberShip()76 FX_BOOL CPDF_ReflowedPage::RetainPageObjsMemberShip()
77 {
78 if (NULL == m_pPDFPage) {
79 return FALSE;
80 }
81 if (NULL == m_pPageInfos) {
82 m_pPageInfos = FX_NEW CFX_MapPtrToPtr();
83 } else {
84 return TRUE;
85 }
86 FX_POSITION pos = m_pPDFPage->GetFirstObjectPosition();
87 if (!pos) {
88 return FALSE;
89 }
90 CPDF_PageObject* pPageObj = NULL;
91 while (pos) {
92 pPageObj = m_pPDFPage->GetNextObject(pos);
93 MarkPageObjMemberShip(pPageObj, NULL);
94 pPageObj = NULL;
95 }
96 return TRUE;
97 }
MarkPageObjMemberShip(CPDF_PageObject * pObj,CRF_PageInfo * pParent)98 void CPDF_ReflowedPage::MarkPageObjMemberShip(CPDF_PageObject* pObj, CRF_PageInfo* pParent)
99 {
100 if (NULL == m_pPageInfos) {
101 return;
102 }
103 CRF_PageInfo* pPageInfo = FX_NEW CRF_PageInfo(pObj, pParent);
104 if (NULL == pPageInfo) {
105 return;
106 }
107 m_pPageInfos->SetAt(pObj, pPageInfo);
108 if (PDFPAGE_FORM != pObj->m_Type) {
109 return;
110 }
111 CPDF_FormObject* pFormObj = (CPDF_FormObject*)pObj;
112 FX_POSITION pos;
113 pos = pFormObj->m_pForm->GetFirstObjectPosition();
114 if (!pos) {
115 return;
116 }
117 CPDF_PageObject* pPageObj = NULL;
118 while (pos) {
119 pPageObj = pFormObj->m_pForm->GetNextObject(pos);
120 MarkPageObjMemberShip(pPageObj, pPageInfo);
121 pPageObj = NULL;
122 }
123 }
ReleasePageObjsMemberShip()124 void CPDF_ReflowedPage::ReleasePageObjsMemberShip()
125 {
126 if (NULL == m_pPageInfos) {
127 return;
128 }
129 CPDF_PageObject* pPageObj = NULL;
130 CRF_PageInfo* pPageInfo = NULL;
131 FX_POSITION pos = m_pPageInfos->GetStartPosition();
132 while (pos) {
133 m_pPageInfos->GetNextAssoc(pos, (void*&)pPageObj, (void*&)pPageInfo);
134 delete pPageInfo;
135 }
136 m_pPageInfos->RemoveAll();
137 delete m_pPageInfos;
138 m_pPageInfos = NULL;
139 }
GetFormResDict(CPDF_PageObject * pObj)140 CPDF_Dictionary* CPDF_ReflowedPage::GetFormResDict(CPDF_PageObject* pObj)
141 {
142 if (NULL == m_pPageInfos) {
143 return NULL;
144 }
145 if (FALSE == RetainPageObjsMemberShip()) {
146 return NULL;
147 }
148 CRF_PageInfo* pPageInfo = (CRF_PageInfo*)m_pPageInfos->GetValueAt(pObj);
149 if (NULL == pPageInfo) {
150 return NULL;
151 }
152 return pPageInfo->GetFormDict();
153 }
GetDisplayMatrix(CFX_AffineMatrix & matrix,FX_INT32 xPos,FX_INT32 yPos,FX_INT32 xSize,FX_INT32 ySize,FX_INT32 iRotate,const CFX_AffineMatrix * pPageMatrix)154 void CPDF_ReflowedPage::GetDisplayMatrix(CFX_AffineMatrix& matrix, FX_INT32 xPos, FX_INT32 yPos, FX_INT32 xSize, FX_INT32 ySize, FX_INT32 iRotate, const CFX_AffineMatrix* pPageMatrix)
155 {
156 CFX_AffineMatrix display_matrix;
157 if(m_PageHeight == 0) {
158 matrix.Set(1, 0, 0, -1, 0, 0);
159 return;
160 }
161 FX_INT32 x0, y0, x1, y1, x2, y2;
162 iRotate %= 4;
163 switch (iRotate) {
164 case 0:
165 x0 = xPos;
166 y0 = yPos;
167 x1 = xPos;
168 y1 = yPos + ySize;
169 x2 = xPos + xSize;
170 y2 = yPos;
171 break;
172 case 3:
173 x0 = xPos;
174 y0 = ySize + yPos;
175 x1 = xPos + xSize;
176 y1 = yPos + ySize;
177 x2 = xPos;
178 y2 = yPos;
179 break;
180 case 2:
181 x0 = xSize + xPos;
182 y0 = ySize + yPos;
183 x1 = xSize + xPos ;
184 y1 = yPos;
185 x2 = xPos;
186 y2 = ySize + yPos;
187 break;
188 case 1:
189 x0 = xPos + xSize;
190 y0 = yPos;
191 x1 = xPos;
192 y1 = yPos;
193 x2 = xPos + xSize;
194 y2 = yPos + ySize;
195 break;
196 }
197 display_matrix.Set(FXSYS_Div((FX_FLOAT)(x2 - x0), m_PageWidth),
198 FXSYS_Div((FX_FLOAT)(y2 - y0), m_PageWidth),
199 FXSYS_Div((FX_FLOAT)(x1 - x0), m_PageHeight),
200 FXSYS_Div((FX_FLOAT)(y1 - y0), m_PageHeight),
201 (FX_FLOAT)(x0), (FX_FLOAT)(y0));
202 matrix.Set(1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f);
203 matrix.Concat(display_matrix);
204 return;
205 }
GetPageHeight()206 FX_FLOAT CPDF_ReflowedPage::GetPageHeight()
207 {
208 return m_PageHeight;
209 }
FocusGetData(const CFX_AffineMatrix matrix,FX_INT32 x,FX_INT32 y,CFX_ByteString & str)210 void CPDF_ReflowedPage::FocusGetData(const CFX_AffineMatrix matrix, FX_INT32 x, FX_INT32 y, CFX_ByteString& str)
211 {
212 if (NULL == m_pReflowed) {
213 return;
214 }
215 CFX_AffineMatrix revMatrix;
216 revMatrix.SetReverse(matrix);
217 FX_FLOAT x1, y1;
218 revMatrix.Transform((float)x, (float)y, x1, y1);
219 int count = m_pReflowed->GetSize();
220 FX_FLOAT dx = 1000, dy = 1000;
221 FX_INT32 pos = 0;
222 FX_INT32 i;
223 for(i = 0; i < count; i++) {
224 CRF_Data* pData = (*m_pReflowed)[i];
225 FX_FLOAT tempdy = FXSYS_fabs(pData->m_PosY - y1);
226 if(FXSYS_fabs(tempdy - dy) < 1) {
227 continue;
228 }
229 CFX_FloatRect rect (0, pData->m_PosY + pData->m_Height, this->m_PageWidth, pData->m_PosY);
230 if(rect.Contains(x1, y1)) {
231 pos = i;
232 dx = 0;
233 dy = 0;
234 break;
235 } else if(tempdy < dy) {
236 dy = tempdy;
237 dx = FXSYS_fabs(pData->m_PosX - x1);
238 pos = i;
239 } else if (tempdy == dy) {
240 FX_FLOAT tempdx = FXSYS_fabs(pData->m_PosX - x1);
241 if(tempdx < dx) {
242 dx = tempdx;
243 pos = i;
244 }
245 } else if (tempdy > dy) {
246 break;
247 }
248 }
249 if(dx != 0 || dy != 0) {
250 count = count < (pos + 10) ? count : (pos + 10);
251 for(i = 0 > (pos - 10) ? 0 : (pos - 10); i < count; i++) {
252 CRF_Data* pData = (*m_pReflowed)[i];
253 FX_FLOAT tempdy = FXSYS_fabs(pData->m_PosY - y1);
254 if(tempdy < dy) {
255 dy = tempdy;
256 dx = FXSYS_fabs(pData->m_PosX - x1);
257 pos = i;
258 } else if (tempdy == dy) {
259 FX_FLOAT tempdx = FXSYS_fabs(pData->m_PosX - x1);
260 if(tempdx < dx) {
261 dx = tempdx;
262 pos = i;
263 }
264 }
265 }
266 }
267 str.Format("%d", pos);
268 }
FocusGetPosition(const CFX_AffineMatrix matrix,CFX_ByteString str,FX_INT32 & x,FX_INT32 & y)269 FX_BOOL CPDF_ReflowedPage::FocusGetPosition(const CFX_AffineMatrix matrix, CFX_ByteString str, FX_INT32& x, FX_INT32& y)
270 {
271 if (NULL == m_pReflowed) {
272 return FALSE;
273 }
274 FX_INT32 pos = FXSYS_atoi(str);
275 if(pos < 0 || pos >= m_pReflowed->GetSize()) {
276 return FALSE;
277 }
278 CRF_Data* pData = (*m_pReflowed)[pos];
279 FX_FLOAT x1, y1;
280 matrix.Transform(pData->m_PosX, pData->m_PosY + pData->m_Height, x1, y1);
281 x = (int)x1;
282 y = (int)y1;
283 return TRUE;
284 }
GetPosition()285 int CPDF_ProgressiveReflowPageParser::GetPosition()
286 {
287 if(!m_pProvider) {
288 return 0;
289 }
290 if(!m_pReflowEngine) {
291 return m_pProvider->GetPosition() / 2;
292 }
293 return m_pProvider->GetPosition() / 2 + m_pReflowEngine->GetPosition() / 2;
294 }
Continue(IFX_Pause * pPause)295 void CPDF_ProgressiveReflowPageParser::Continue(IFX_Pause* pPause)
296 {
297 if (NULL == m_pReflowPage) {
298 return;
299 }
300 if(m_Status != ToBeContinued) {
301 return;
302 }
303 m_pPause = pPause;
304 if(m_pReflowEngine) {
305 if(m_pReflowEngine->Continue() != LayoutToBeContinued) {
306 m_Status = Done;
307 }
308 } else {
309 if(m_pProvider->Continue() == LayoutFinished) {
310 m_pReflowEngine = IPDF_LayoutProcessor::Create_LayoutProcessor_Reflow(m_TopIndent, m_ReflowedWidth, m_fScreenHeight, m_pReflowPage, m_flags, m_ParseStyle.m_LineSpace);
311 CFX_AffineMatrix matrix;
312 m_pPDFPage->GetDisplayMatrix(matrix, 0, 0, (int)(m_pPDFPage->GetPageWidth()), (int)(m_pPDFPage->GetPageHeight()), 0);
313 if(m_pReflowEngine->StartProcess(m_pProvider->GetRoot(), m_pPause, &matrix) != LayoutToBeContinued) {
314 m_Status = Done;
315 }
316 }
317 }
318 if(m_TopIndent && m_Status == Done) {
319 m_pReflowPage->m_PageHeight -= m_TopIndent;
320 }
321 }
Clear()322 void CPDF_ProgressiveReflowPageParser::Clear()
323 {
324 this->Init();
325 return;
326 }
IsTaggedPage(CPDF_PageObjects * pPage)327 FX_BOOL IPDF_ProgressiveReflowPageParser::IsTaggedPage(CPDF_PageObjects*pPage)
328 {
329 if(!pPage) {
330 return FALSE;
331 }
332 CPDF_StructTree* pPageTree = CPDF_StructTree::LoadPage(pPage->m_pDocument, pPage->m_pFormDict);
333 if(pPageTree) {
334 int count = pPageTree->CountTopElements();
335 if(count) {
336 for(int i = 0; i < count; i++) {
337 CPDF_StructElement* pElm = pPageTree->GetTopElement(i);
338 if(pElm) {
339 delete pPageTree;
340 pPageTree = NULL;
341 return TRUE;
342 }
343 }
344 }
345 delete pPageTree;
346 pPageTree = NULL;
347 return FALSE;
348 }
349 return FALSE;
350 }
Start(IPDF_ReflowedPage * pReflowPage,CPDF_Page * pPage,FX_FLOAT topIndent,FX_FLOAT fWidth,FX_FLOAT fHeight,IFX_Pause * pPause,int flags)351 void CPDF_ProgressiveReflowPageParser::Start(IPDF_ReflowedPage* pReflowPage, CPDF_Page* pPage, FX_FLOAT topIndent, FX_FLOAT fWidth, FX_FLOAT fHeight, IFX_Pause* pPause, int flags)
352 {
353 if (NULL == pReflowPage) {
354 m_Status = Failed;
355 return;
356 }
357 m_flags = flags;
358 m_pReflowPage = (CPDF_ReflowedPage*)pReflowPage;
359 m_pReflowPage->m_pPDFPage = pPage;
360 m_pReflowPage->ReleasePageObjsMemberShip();
361 m_pPDFPage = pPage;
362 m_TopIndent = topIndent;
363 m_pPause = pPause;
364 m_fScreenHeight = fHeight;
365 m_ReflowedWidth = fWidth;
366 m_pProvider = IPDF_LayoutProvider::Create_LayoutProvider_TaggedPDF(m_pPDFPage);
367 LayoutStatus status = m_pProvider->StartLoad(pPause);
368 if(status == LayoutError) {
369 delete m_pProvider;
370 m_pProvider = IPDF_LayoutProvider::Create_LayoutProvider_AutoReflow(m_pPDFPage, m_flags & RF_PARSER_READERORDER);
371 if (NULL == m_pProvider) {
372 m_Status = Failed;
373 return;
374 }
375 status = m_pProvider->StartLoad(pPause);
376 }
377 if(status == LayoutError) {
378 delete m_pProvider;
379 m_pProvider = NULL;
380 m_Status = Failed;
381 return;
382 }
383 if(status == LayoutToBeContinued) {
384 m_Status = ToBeContinued;
385 } else if (status == LayoutFinished) {
386 m_pReflowEngine = IPDF_LayoutProcessor::Create_LayoutProcessor_Reflow(topIndent, fWidth, fHeight, pReflowPage, m_flags, m_ParseStyle.m_LineSpace);
387 if(NULL == m_pReflowEngine) {
388 delete m_pProvider;
389 m_pProvider = NULL;
390 m_Status = Failed;
391 return;
392 }
393 CFX_AffineMatrix matrix;
394 pPage->GetDisplayMatrix(matrix, 0, 0, (int)(pPage->GetPageWidth()), (int)(pPage->GetPageHeight()), 0);
395 CFX_AffineMatrix matrix1 = pPage->GetPageMatrix();
396 if((status = m_pReflowEngine->StartProcess(m_pProvider->GetRoot(), pPause, &matrix)) != LayoutToBeContinued) {
397 delete m_pReflowEngine;
398 m_pReflowEngine = NULL;
399 m_Status = Done;
400 } else {
401 m_Status = ToBeContinued;
402 }
403 }
404 if(status != LayoutToBeContinued) {
405 delete m_pProvider;
406 m_pProvider = NULL;
407 }
408 if(m_TopIndent && m_Status == Done) {
409 m_pReflowPage->m_PageHeight -= m_TopIndent;
410 }
411 return;
412 }
~CPDF_ProgressiveReflowPageRender()413 CPDF_ProgressiveReflowPageRender::~CPDF_ProgressiveReflowPageRender()
414 {
415 if(m_pDisplayMatrix) {
416 delete m_pDisplayMatrix;
417 }
418 m_pDisplayMatrix = NULL;
419 }
CPDF_ProgressiveReflowPageRender()420 CPDF_ProgressiveReflowPageRender::CPDF_ProgressiveReflowPageRender()
421 {
422 m_Status = Ready;
423 m_pReflowPage = NULL;
424 m_pDisplayMatrix = NULL;
425 m_CurrNum = 0;
426 m_pFontEncoding = NULL;
427 m_DisplayColor = -1;
428 }
_CIDTransformToFloat(FX_BYTE ch)429 static FX_FLOAT _CIDTransformToFloat(FX_BYTE ch)
430 {
431 if (ch < 128) {
432 return ch * 1.0f / 127;
433 }
434 return (-255 + ch) * 1.0f / 127;
435 }
GetPosition()436 int CPDF_ProgressiveReflowPageRender::GetPosition()
437 {
438 if(m_CurrNum == 0 || NULL == m_pReflowPage) {
439 return 0;
440 }
441 int size = m_pReflowPage->m_pReflowed->GetSize();
442 if(size == 0 || m_CurrNum >= size) {
443 return 100;
444 }
445 return (int)(m_CurrNum * 100 / size);
446 }
Display(IFX_Pause * pPause)447 void CPDF_ProgressiveReflowPageRender::Display(IFX_Pause* pPause)
448 {
449 if (NULL == m_pReflowPage) {
450 m_Status = Done;
451 return;
452 }
453 FX_RECT clipBox = m_pFXDevice->GetClipBox();
454 int size = m_pReflowPage->m_pReflowed->GetSize();
455 if (size < 1 || NULL == m_pDisplayMatrix) {
456 m_Status = Done;
457 return;
458 }
459 for(int i = m_CurrNum; i < size; i++) {
460 CRF_Data* pData = (*m_pReflowPage->m_pReflowed)[i];
461 if(!pData) {
462 continue;
463 }
464 CFX_FloatRect rect (pData->m_PosX, pData->m_PosY + pData->m_Height, pData->m_PosX + pData->m_Width, pData->m_PosY);
465 m_pDisplayMatrix->TransformRect(rect);
466 if(rect.left > clipBox.right || rect.right < clipBox.left || rect.bottom > clipBox.bottom || rect.top < clipBox.top) {
467 continue;
468 }
469 if(pData->GetType() == CRF_Data::Text) {
470 CRF_CharData* pCharData = (CRF_CharData*)pData;
471 CPDF_Font* pPDFFont = pCharData->m_pCharState->m_pFont;
472 if(pPDFFont->GetFontType() == PDFFONT_TYPE3) {
473 continue;
474 }
475 FX_FLOAT x = pData->m_PosX, y = pData->m_PosY - pCharData->m_pCharState->m_fDescent;
476 FXTEXT_CHARPOS charpos ;
477 charpos.m_GlyphIndex = pPDFFont->GlyphFromCharCode(pCharData->m_CharCode);
478 charpos.m_FontCharWidth = pPDFFont->m_Font.GetGlyphWidth(charpos.m_GlyphIndex);
479 charpos.m_OriginX = x;
480 charpos.m_OriginY = y;
481 FX_FLOAT charW = pData->m_Width * 1000 / pData->m_Height;
482 if(charW != charpos.m_FontCharWidth) {
483 charpos.m_bGlyphAdjust = TRUE;
484 charpos.m_AdjustMatrix[0] = charW / charpos.m_FontCharWidth;
485 charpos.m_AdjustMatrix[1] = 0;
486 charpos.m_AdjustMatrix[2] = 0;
487 charpos.m_AdjustMatrix[3] = 1;
488 } else {
489 charpos.m_bGlyphAdjust = FALSE;
490 }
491 FX_BOOL bRet = FALSE;
492 if(m_DisplayColor == -1)
493 bRet = m_pFXDevice->DrawNormalText(1, &charpos, &(pPDFFont->m_Font),
494 NULL, pCharData->m_pCharState->m_fFontSize,
495 m_pDisplayMatrix, pCharData->m_pCharState->m_Color + 0xff000000, FXTEXT_CLEARTYPE);
496 else
497 bRet = m_pFXDevice->DrawNormalText(1, &charpos, &(pPDFFont->m_Font),
498 NULL, pCharData->m_pCharState->m_fFontSize, m_pDisplayMatrix, m_DisplayColor, FXTEXT_CLEARTYPE);
499 } else if(pData->GetType() == CRF_Data::Image) {
500 CRF_ImageData* pImageData = (CRF_ImageData*)pData;
501 if(!pImageData->m_pBitmap) {
502 continue;
503 }
504 int left = 0, top = 0;
505 CFX_DIBitmap* pDiBmp = NULL;
506 CFX_DIBSource* pDispSource = pImageData->m_pBitmap;
507 if(pImageData->m_Matrix.d < 0) {
508 CFX_AffineMatrix matrix(pImageData->m_Matrix.a, 0, 0, -pImageData->m_Matrix.d, 0, 0);
509 int left, top;
510 pDiBmp = pImageData->m_pBitmap->TransformTo(&matrix, left, top);
511 pDispSource = pDiBmp;
512 }
513 if (NULL == pDispSource) {
514 continue;
515 }
516 if (pDispSource->GetFormat() == FXDIB_1bppMask || pDispSource->GetFormat() == FXDIB_8bppMask) {
517 m_pFXDevice->StretchBitMask(pDispSource, (int)(rect.left + 0.5), (int)(rect.bottom + 0.5), (int)(rect.Width() + 0.5), (int)(rect.Height() + 0.5), 0xff000000);
518 } else {
519 m_pFXDevice->StretchDIBits(pDispSource, (int)(rect.left + 0.5), (int)(rect.bottom + 0.5), (int)(rect.Width() + 0.5), (int)(rect.Height() + 0.5));
520 }
521 if(m_pFXDevice->GetBitmap() && m_pFXDevice->GetBitmap()->GetFormat() == FXDIB_8bppRgb &&
522 m_pFXDevice->GetBitmap()->GetPalette() == NULL) {
523 int nPalette = 0;
524 switch(m_DitherBits) {
525 case 0:
526 nPalette = 0;
527 break;
528 case 1:
529 nPalette = 2;
530 break;
531 case 2:
532 nPalette = 4;
533 break;
534 case 3:
535 nPalette = 8;
536 break;
537 case 4:
538 nPalette = 16;
539 break;
540 case 5:
541 nPalette = 32;
542 break;
543 case 6:
544 nPalette = 64;
545 break;
546 case 7:
547 nPalette = 128;
548 break;
549 default:
550 nPalette = 256;
551 break;
552 }
553 if(nPalette >= 2) {
554 FX_ARGB * palette = FX_Alloc(FX_ARGB, nPalette);
555 nPalette --;
556 palette[0] = 0;
557 palette[nPalette] = 255;
558 FX_FLOAT Dither = (FX_FLOAT)255 / (nPalette);
559 for(int i = 1; i < nPalette; i++) {
560 palette[i] = (FX_ARGB)(Dither * i + 0.5);
561 }
562 FX_RECT tmpRect = rect.GetOutterRect();
563 m_pFXDevice->GetBitmap()->DitherFS(palette, nPalette + 1, &tmpRect);
564 FX_Free (palette);
565 }
566 }
567 if(pDiBmp) {
568 delete pDiBmp;
569 }
570 } else if(pData->GetType() == CRF_Data::Path) {
571 }
572 if(!(i % 10)) {
573 if(pPause && pPause->NeedToPauseNow()) {
574 i++;
575 m_CurrNum = i;
576 m_Status = ToBeContinued;
577 return;
578 }
579 }
580 }
581 m_CurrNum = size;
582 m_Status = Done;
583 }
Start(IPDF_ReflowedPage * pReflowPage,CFX_RenderDevice * pDevice,const CFX_AffineMatrix * pMatrix,IFX_Pause * pPause,int DitherBits)584 void CPDF_ProgressiveReflowPageRender::Start(IPDF_ReflowedPage* pReflowPage, CFX_RenderDevice* pDevice, const CFX_AffineMatrix* pMatrix, IFX_Pause* pPause, int DitherBits)
585 {
586 if(!pReflowPage || !pDevice || !pMatrix) {
587 m_Status = Failed;
588 return;
589 }
590 m_DitherBits = DitherBits;
591 m_Status = Ready;
592 m_CurrNum = 0;
593 m_pReflowPage = (CPDF_ReflowedPage*)pReflowPage;
594 m_pFXDevice = pDevice;
595 if(NULL == m_pDisplayMatrix) {
596 m_pDisplayMatrix = FX_NEW CFX_AffineMatrix;
597 }
598 if (m_pDisplayMatrix) {
599 m_pDisplayMatrix->Copy(*pMatrix);
600 }
601 m_Status = ToBeContinued;
602 Display(pPause);
603 }
Continue(IFX_Pause * pPause)604 void CPDF_ProgressiveReflowPageRender::Continue(IFX_Pause* pPause)
605 {
606 Display(pPause);
607 }
SetDisplayColor(FX_COLORREF color)608 void CPDF_ProgressiveReflowPageRender::SetDisplayColor(FX_COLORREF color)
609 {
610 m_DisplayColor = color;
611 }
Clear()612 void CPDF_ProgressiveReflowPageRender::Clear()
613 {
614 if (m_pDisplayMatrix) {
615 delete m_pDisplayMatrix;
616 }
617 m_pDisplayMatrix = NULL;
618 m_pReflowPage = NULL;
619 m_pFXDevice = NULL;
620 m_CurrNum = 0;
621 m_Status = Ready;
622 }
623