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 "render_int.h"
8 
9 #include "core/include/fpdfapi/fpdf_pageobj.h"
10 #include "core/include/fpdfapi/fpdf_render.h"
11 #include "core/include/fxge/fx_ge.h"
12 #include "core/src/fpdfapi/fpdf_page/pageint.h"
13 
~CPDF_Type3Cache()14 CPDF_Type3Cache::~CPDF_Type3Cache() {
15   for (const auto& pair : m_SizeMap) {
16     delete pair.second;
17   }
18   m_SizeMap.clear();
19 }
LoadGlyph(FX_DWORD charcode,const CFX_Matrix * pMatrix,FX_FLOAT retinaScaleX,FX_FLOAT retinaScaleY)20 CFX_GlyphBitmap* CPDF_Type3Cache::LoadGlyph(FX_DWORD charcode,
21                                             const CFX_Matrix* pMatrix,
22                                             FX_FLOAT retinaScaleX,
23                                             FX_FLOAT retinaScaleY) {
24   _CPDF_UniqueKeyGen keygen;
25   keygen.Generate(
26       4, FXSYS_round(pMatrix->a * 10000), FXSYS_round(pMatrix->b * 10000),
27       FXSYS_round(pMatrix->c * 10000), FXSYS_round(pMatrix->d * 10000));
28   CFX_ByteStringC FaceGlyphsKey(keygen.m_Key, keygen.m_KeyLen);
29   CPDF_Type3Glyphs* pSizeCache;
30   auto it = m_SizeMap.find(FaceGlyphsKey);
31   if (it == m_SizeMap.end()) {
32     pSizeCache = new CPDF_Type3Glyphs;
33     m_SizeMap[FaceGlyphsKey] = pSizeCache;
34   } else {
35     pSizeCache = it->second;
36   }
37   auto it2 = pSizeCache->m_GlyphMap.find(charcode);
38   if (it2 != pSizeCache->m_GlyphMap.end())
39     return it2->second;
40 
41   CFX_GlyphBitmap* pGlyphBitmap =
42       RenderGlyph(pSizeCache, charcode, pMatrix, retinaScaleX, retinaScaleY);
43   pSizeCache->m_GlyphMap[charcode] = pGlyphBitmap;
44   return pGlyphBitmap;
45 }
~CPDF_Type3Glyphs()46 CPDF_Type3Glyphs::~CPDF_Type3Glyphs() {
47   for (const auto& pair : m_GlyphMap)
48     delete pair.second;
49 }
_AdjustBlue(FX_FLOAT pos,int & count,int blues[])50 static int _AdjustBlue(FX_FLOAT pos, int& count, int blues[]) {
51   FX_FLOAT min_distance = 1000000.0f * 1.0f;
52   int closest_pos = -1;
53   for (int i = 0; i < count; i++) {
54     FX_FLOAT distance = (FX_FLOAT)FXSYS_fabs(pos - (FX_FLOAT)blues[i]);
55     if (distance < 1.0f * 80.0f / 100.0f && distance < min_distance) {
56       min_distance = distance;
57       closest_pos = i;
58     }
59   }
60   if (closest_pos >= 0) {
61     return blues[closest_pos];
62   }
63   int new_pos = FXSYS_round(pos);
64   if (count == TYPE3_MAX_BLUES) {
65     return new_pos;
66   }
67   blues[count++] = new_pos;
68   return new_pos;
69 }
AdjustBlue(FX_FLOAT top,FX_FLOAT bottom,int & top_line,int & bottom_line)70 void CPDF_Type3Glyphs::AdjustBlue(FX_FLOAT top,
71                                   FX_FLOAT bottom,
72                                   int& top_line,
73                                   int& bottom_line) {
74   top_line = _AdjustBlue(top, m_TopBlueCount, m_TopBlue);
75   bottom_line = _AdjustBlue(bottom, m_BottomBlueCount, m_BottomBlue);
76 }
_IsScanLine1bpp(uint8_t * pBuf,int width)77 static FX_BOOL _IsScanLine1bpp(uint8_t* pBuf, int width) {
78   int size = width / 8;
79   for (int i = 0; i < size; i++)
80     if (pBuf[i]) {
81       return TRUE;
82     }
83   if (width % 8)
84     if (pBuf[width / 8] & (0xff << (8 - width % 8))) {
85       return TRUE;
86     }
87   return FALSE;
88 }
_IsScanLine8bpp(uint8_t * pBuf,int width)89 static FX_BOOL _IsScanLine8bpp(uint8_t* pBuf, int width) {
90   for (int i = 0; i < width; i++)
91     if (pBuf[i] > 0x40) {
92       return TRUE;
93     }
94   return FALSE;
95 }
_DetectFirstLastScan(const CFX_DIBitmap * pBitmap,FX_BOOL bFirst)96 static int _DetectFirstLastScan(const CFX_DIBitmap* pBitmap, FX_BOOL bFirst) {
97   int height = pBitmap->GetHeight(), pitch = pBitmap->GetPitch(),
98       width = pBitmap->GetWidth();
99   int bpp = pBitmap->GetBPP();
100   if (bpp > 8) {
101     width *= bpp / 8;
102   }
103   uint8_t* pBuf = pBitmap->GetBuffer();
104   int line = bFirst ? 0 : height - 1;
105   int line_step = bFirst ? 1 : -1;
106   int line_end = bFirst ? height : -1;
107   while (line != line_end) {
108     if (bpp == 1) {
109       if (_IsScanLine1bpp(pBuf + line * pitch, width)) {
110         return line;
111       }
112     } else {
113       if (_IsScanLine8bpp(pBuf + line * pitch, width)) {
114         return line;
115       }
116     }
117     line += line_step;
118   }
119   return -1;
120 }
RenderGlyph(CPDF_Type3Glyphs * pSize,FX_DWORD charcode,const CFX_Matrix * pMatrix,FX_FLOAT retinaScaleX,FX_FLOAT retinaScaleY)121 CFX_GlyphBitmap* CPDF_Type3Cache::RenderGlyph(CPDF_Type3Glyphs* pSize,
122                                               FX_DWORD charcode,
123                                               const CFX_Matrix* pMatrix,
124                                               FX_FLOAT retinaScaleX,
125                                               FX_FLOAT retinaScaleY) {
126   const CPDF_Type3Char* pChar = m_pFont->LoadChar(charcode);
127   if (!pChar || !pChar->m_pBitmap)
128     return nullptr;
129 
130   CFX_DIBitmap* pBitmap = pChar->m_pBitmap;
131   CFX_Matrix image_matrix, text_matrix;
132   image_matrix = pChar->m_ImageMatrix;
133   text_matrix.Set(pMatrix->a, pMatrix->b, pMatrix->c, pMatrix->d, 0, 0);
134   image_matrix.Concat(text_matrix);
135   CFX_DIBitmap* pResBitmap = NULL;
136   int left, top;
137   if (FXSYS_fabs(image_matrix.b) < FXSYS_fabs(image_matrix.a) / 100 &&
138       FXSYS_fabs(image_matrix.c) < FXSYS_fabs(image_matrix.d) / 100) {
139     int top_line, bottom_line;
140     top_line = _DetectFirstLastScan(pBitmap, TRUE);
141     bottom_line = _DetectFirstLastScan(pBitmap, FALSE);
142     if (top_line == 0 && bottom_line == pBitmap->GetHeight() - 1) {
143       FX_FLOAT top_y = image_matrix.d + image_matrix.f;
144       FX_FLOAT bottom_y = image_matrix.f;
145       FX_BOOL bFlipped = top_y > bottom_y;
146       if (bFlipped) {
147         FX_FLOAT temp = top_y;
148         top_y = bottom_y;
149         bottom_y = temp;
150       }
151       pSize->AdjustBlue(top_y, bottom_y, top_line, bottom_line);
152       pResBitmap = pBitmap->StretchTo(
153           (int)(FXSYS_round(image_matrix.a) * retinaScaleX),
154           (int)((bFlipped ? top_line - bottom_line : bottom_line - top_line) *
155                 retinaScaleY));
156       top = top_line;
157       if (image_matrix.a < 0) {
158         image_matrix.Scale(retinaScaleX, retinaScaleY);
159         left = FXSYS_round(image_matrix.e + image_matrix.a);
160       } else {
161         left = FXSYS_round(image_matrix.e);
162       }
163     } else {
164     }
165   }
166   if (!pResBitmap) {
167     image_matrix.Scale(retinaScaleX, retinaScaleY);
168     pResBitmap = pBitmap->TransformTo(&image_matrix, left, top);
169   }
170   if (!pResBitmap) {
171     return NULL;
172   }
173   CFX_GlyphBitmap* pGlyph = new CFX_GlyphBitmap;
174   pGlyph->m_Left = left;
175   pGlyph->m_Top = -top;
176   pGlyph->m_Bitmap.TakeOver(pResBitmap);
177   delete pResBitmap;
178   return pGlyph;
179 }
Generate(int count,...)180 void _CPDF_UniqueKeyGen::Generate(int count, ...) {
181   va_list argList;
182   va_start(argList, count);
183   for (int i = 0; i < count; i++) {
184     int p = va_arg(argList, int);
185     ((FX_DWORD*)m_Key)[i] = p;
186   }
187   va_end(argList);
188   m_KeyLen = count * sizeof(FX_DWORD);
189 }
ProcessText(const CPDF_TextObject * textobj,const CFX_Matrix * pObj2Device,CFX_PathData * pClippingPath)190 FX_BOOL CPDF_RenderStatus::ProcessText(const CPDF_TextObject* textobj,
191                                        const CFX_Matrix* pObj2Device,
192                                        CFX_PathData* pClippingPath) {
193   if (textobj->m_nChars == 0) {
194     return TRUE;
195   }
196   int text_render_mode = textobj->m_TextState.GetObject()->m_TextMode;
197   if (text_render_mode == 3) {
198     return TRUE;
199   }
200   CPDF_Font* pFont = textobj->m_TextState.GetFont();
201   if (pFont->GetFontType() == PDFFONT_TYPE3) {
202     return ProcessType3Text(textobj, pObj2Device);
203   }
204   FX_BOOL bFill = FALSE, bStroke = FALSE, bClip = FALSE;
205   if (pClippingPath) {
206     bClip = TRUE;
207   } else {
208     switch (text_render_mode) {
209       case 0:
210       case 4:
211         bFill = TRUE;
212         break;
213       case 1:
214       case 5:
215         if (!pFont->GetFace() &&
216             !(pFont->GetSubstFont()->m_SubstFlags & FXFONT_SUBST_GLYPHPATH)) {
217           bFill = TRUE;
218         } else {
219           bStroke = TRUE;
220         }
221         break;
222       case 2:
223       case 6:
224         if (!pFont->GetFace() &&
225             !(pFont->GetSubstFont()->m_SubstFlags & FXFONT_SUBST_GLYPHPATH)) {
226           bFill = TRUE;
227         } else {
228           bFill = bStroke = TRUE;
229         }
230         break;
231       case 3:
232       case 7:
233         return TRUE;
234       default:
235         bFill = TRUE;
236     }
237   }
238   FX_ARGB stroke_argb = 0, fill_argb = 0;
239   FX_BOOL bPattern = FALSE;
240   if (bStroke) {
241     if (textobj->m_ColorState.GetStrokeColor()->IsPattern()) {
242       bPattern = TRUE;
243     } else {
244       stroke_argb = GetStrokeArgb(textobj);
245     }
246   }
247   if (bFill) {
248     if (textobj->m_ColorState.GetFillColor()->IsPattern()) {
249       bPattern = TRUE;
250     } else {
251       fill_argb = GetFillArgb(textobj);
252     }
253   }
254   CFX_Matrix text_matrix;
255   textobj->GetTextMatrix(&text_matrix);
256   if (IsAvailableMatrix(text_matrix) == FALSE) {
257     return TRUE;
258   }
259   FX_FLOAT font_size = textobj->m_TextState.GetFontSize();
260   if (bPattern) {
261     DrawTextPathWithPattern(textobj, pObj2Device, pFont, font_size,
262                             &text_matrix, bFill, bStroke);
263     return TRUE;
264   }
265   if (bClip || bStroke) {
266     const CFX_Matrix* pDeviceMatrix = pObj2Device;
267     CFX_Matrix device_matrix;
268     if (bStroke) {
269       const FX_FLOAT* pCTM = textobj->m_TextState.GetObject()->m_CTM;
270       if (pCTM[0] != 1.0f || pCTM[3] != 1.0f) {
271         CFX_Matrix ctm(pCTM[0], pCTM[1], pCTM[2], pCTM[3], 0, 0);
272         text_matrix.ConcatInverse(ctm);
273         device_matrix.Copy(ctm);
274         device_matrix.Concat(*pObj2Device);
275         pDeviceMatrix = &device_matrix;
276       }
277     }
278     int flag = 0;
279     if (bStroke && bFill) {
280       flag |= FX_FILL_STROKE;
281       flag |= FX_STROKE_TEXT_MODE;
282     }
283     const CPDF_GeneralStateData* pGeneralData =
284         ((CPDF_PageObject*)textobj)->m_GeneralState;
285     if (pGeneralData && pGeneralData->m_StrokeAdjust) {
286       flag |= FX_STROKE_ADJUST;
287     }
288     if (m_Options.m_Flags & RENDER_NOTEXTSMOOTH) {
289       flag |= FXFILL_NOPATHSMOOTH;
290     }
291     return CPDF_TextRenderer::DrawTextPath(
292         m_pDevice, textobj->m_nChars, textobj->m_pCharCodes,
293         textobj->m_pCharPos, pFont, font_size, &text_matrix, pDeviceMatrix,
294         textobj->m_GraphState, fill_argb, stroke_argb, pClippingPath, flag);
295   }
296   text_matrix.Concat(*pObj2Device);
297   return CPDF_TextRenderer::DrawNormalText(
298       m_pDevice, textobj->m_nChars, textobj->m_pCharCodes, textobj->m_pCharPos,
299       pFont, font_size, &text_matrix, fill_argb, &m_Options);
300 }
GetCachedType3(CPDF_Type3Font * pFont)301 CPDF_Type3Cache* CPDF_RenderStatus::GetCachedType3(CPDF_Type3Font* pFont) {
302   if (!pFont->m_pDocument) {
303     return NULL;
304   }
305   pFont->m_pDocument->GetPageData()->GetFont(pFont->GetFontDict(), FALSE);
306   return pFont->m_pDocument->GetRenderData()->GetCachedType3(pFont);
307 }
ReleaseCachedType3(CPDF_Type3Font * pFont)308 static void ReleaseCachedType3(CPDF_Type3Font* pFont) {
309   if (!pFont->m_pDocument) {
310     return;
311   }
312   pFont->m_pDocument->GetRenderData()->ReleaseCachedType3(pFont);
313   pFont->m_pDocument->GetPageData()->ReleaseFont(pFont->GetFontDict());
314 }
LoadBitmap(CPDF_RenderContext * pContext)315 FX_BOOL CPDF_Type3Char::LoadBitmap(CPDF_RenderContext* pContext) {
316   if (m_pBitmap || !m_pForm) {
317     return TRUE;
318   }
319   if (m_pForm->CountObjects() == 1 && !m_bColored) {
320     CPDF_PageObject* pPageObj =
321         m_pForm->GetObjectAt(m_pForm->GetFirstObjectPosition());
322     if (pPageObj->m_Type == PDFPAGE_IMAGE) {
323       CPDF_ImageObject* pImage = (CPDF_ImageObject*)pPageObj;
324       m_ImageMatrix = pImage->m_Matrix;
325       const CFX_DIBSource* pSource = pImage->m_pImage->LoadDIBSource();
326       if (pSource) {
327         m_pBitmap = pSource->Clone();
328         delete pSource;
329       }
330       delete m_pForm;
331       m_pForm = NULL;
332       return TRUE;
333     }
334   }
335   return FALSE;
336 }
337 class CPDF_RefType3Cache {
338  public:
CPDF_RefType3Cache(CPDF_Type3Font * pType3Font)339   CPDF_RefType3Cache(CPDF_Type3Font* pType3Font) {
340     m_dwCount = 0;
341     m_pType3Font = pType3Font;
342   }
~CPDF_RefType3Cache()343   ~CPDF_RefType3Cache() {
344     while (m_dwCount--) {
345       ReleaseCachedType3(m_pType3Font);
346     }
347   }
348   FX_DWORD m_dwCount;
349   CPDF_Type3Font* m_pType3Font;
350 };
ProcessType3Text(const CPDF_TextObject * textobj,const CFX_Matrix * pObj2Device)351 FX_BOOL CPDF_RenderStatus::ProcessType3Text(const CPDF_TextObject* textobj,
352                                             const CFX_Matrix* pObj2Device) {
353   CPDF_Type3Font* pType3Font = textobj->m_TextState.GetFont()->GetType3Font();
354   for (int j = 0; j < m_Type3FontCache.GetSize(); j++) {
355     if (m_Type3FontCache.GetAt(j) == pType3Font)
356       return TRUE;
357   }
358   CFX_Matrix dCTM = m_pDevice->GetCTM();
359   FX_FLOAT sa = FXSYS_fabs(dCTM.a);
360   FX_FLOAT sd = FXSYS_fabs(dCTM.d);
361   CFX_Matrix text_matrix;
362   textobj->GetTextMatrix(&text_matrix);
363   CFX_Matrix char_matrix = pType3Font->GetFontMatrix();
364   FX_FLOAT font_size = textobj->m_TextState.GetFontSize();
365   char_matrix.Scale(font_size, font_size);
366   FX_ARGB fill_argb = GetFillArgb(textobj, TRUE);
367   int fill_alpha = FXARGB_A(fill_argb);
368   int device_class = m_pDevice->GetDeviceClass();
369   FXTEXT_GLYPHPOS* pGlyphAndPos = NULL;
370   if (device_class == FXDC_DISPLAY) {
371     pGlyphAndPos = FX_Alloc(FXTEXT_GLYPHPOS, textobj->m_nChars);
372   } else if (fill_alpha < 255) {
373     return FALSE;
374   }
375   CPDF_RefType3Cache refTypeCache(pType3Font);
376   FX_DWORD* pChars = textobj->m_pCharCodes;
377   if (textobj->m_nChars == 1) {
378     pChars = (FX_DWORD*)(&textobj->m_pCharCodes);
379   }
380   for (int iChar = 0; iChar < textobj->m_nChars; iChar++) {
381     FX_DWORD charcode = pChars[iChar];
382     if (charcode == (FX_DWORD)-1) {
383       continue;
384     }
385     CPDF_Type3Char* pType3Char = pType3Font->LoadChar(charcode);
386     if (!pType3Char) {
387       continue;
388     }
389     CFX_Matrix matrix = char_matrix;
390     matrix.e += iChar ? textobj->m_pCharPos[iChar - 1] : 0;
391     matrix.Concat(text_matrix);
392     matrix.Concat(*pObj2Device);
393     if (!pType3Char->LoadBitmap(m_pContext)) {
394       if (pGlyphAndPos) {
395         for (int i = 0; i < iChar; i++) {
396           FXTEXT_GLYPHPOS& glyph = pGlyphAndPos[i];
397           if (!glyph.m_pGlyph) {
398             continue;
399           }
400           m_pDevice->SetBitMask(&glyph.m_pGlyph->m_Bitmap,
401                                 glyph.m_OriginX + glyph.m_pGlyph->m_Left,
402                                 glyph.m_OriginY - glyph.m_pGlyph->m_Top,
403                                 fill_argb);
404         }
405         FX_Free(pGlyphAndPos);
406         pGlyphAndPos = NULL;
407       }
408       CPDF_GraphicStates* pStates = CloneObjStates(textobj, FALSE);
409       CPDF_RenderOptions Options = m_Options;
410       Options.m_Flags |= RENDER_FORCE_HALFTONE | RENDER_RECT_AA;
411       Options.m_Flags &= ~RENDER_FORCE_DOWNSAMPLE;
412       CPDF_Dictionary* pFormResource = NULL;
413       if (pType3Char->m_pForm && pType3Char->m_pForm->m_pFormDict) {
414         pFormResource = pType3Char->m_pForm->m_pFormDict->GetDict("Resources");
415       }
416       if (fill_alpha == 255) {
417         CPDF_RenderStatus status;
418         status.Initialize(m_pContext, m_pDevice, NULL, NULL, this, pStates,
419                           &Options, pType3Char->m_pForm->m_Transparency,
420                           m_bDropObjects, pFormResource, FALSE, pType3Char,
421                           fill_argb);
422         status.m_Type3FontCache.Append(m_Type3FontCache);
423         status.m_Type3FontCache.Add(pType3Font);
424         m_pDevice->SaveState();
425         status.RenderObjectList(pType3Char->m_pForm, &matrix);
426         m_pDevice->RestoreState();
427       } else {
428         CFX_FloatRect rect_f = pType3Char->m_pForm->CalcBoundingBox();
429         rect_f.Transform(&matrix);
430         FX_RECT rect = rect_f.GetOutterRect();
431         CFX_FxgeDevice bitmap_device;
432         if (!bitmap_device.Create((int)(rect.Width() * sa),
433                                   (int)(rect.Height() * sd), FXDIB_Argb)) {
434           return TRUE;
435         }
436         bitmap_device.GetBitmap()->Clear(0);
437         CPDF_RenderStatus status;
438         status.Initialize(m_pContext, &bitmap_device, NULL, NULL, this, pStates,
439                           &Options, pType3Char->m_pForm->m_Transparency,
440                           m_bDropObjects, pFormResource, FALSE, pType3Char,
441                           fill_argb);
442         status.m_Type3FontCache.Append(m_Type3FontCache);
443         status.m_Type3FontCache.Add(pType3Font);
444         matrix.TranslateI(-rect.left, -rect.top);
445         matrix.Scale(sa, sd);
446         status.RenderObjectList(pType3Char->m_pForm, &matrix);
447         m_pDevice->SetDIBits(bitmap_device.GetBitmap(), rect.left, rect.top);
448       }
449       delete pStates;
450     } else if (pType3Char->m_pBitmap) {
451       if (device_class == FXDC_DISPLAY) {
452         CPDF_Type3Cache* pCache = GetCachedType3(pType3Font);
453         refTypeCache.m_dwCount++;
454         CFX_GlyphBitmap* pBitmap = pCache->LoadGlyph(charcode, &matrix, sa, sd);
455         if (!pBitmap) {
456           continue;
457         }
458         int origin_x = FXSYS_round(matrix.e);
459         int origin_y = FXSYS_round(matrix.f);
460         if (pGlyphAndPos) {
461           pGlyphAndPos[iChar].m_pGlyph = pBitmap;
462           pGlyphAndPos[iChar].m_OriginX = origin_x;
463           pGlyphAndPos[iChar].m_OriginY = origin_y;
464         } else {
465           m_pDevice->SetBitMask(&pBitmap->m_Bitmap, origin_x + pBitmap->m_Left,
466                                 origin_y - pBitmap->m_Top, fill_argb);
467         }
468       } else {
469         CFX_Matrix image_matrix = pType3Char->m_ImageMatrix;
470         image_matrix.Concat(matrix);
471         CPDF_ImageRenderer renderer;
472         if (renderer.Start(this, pType3Char->m_pBitmap, fill_argb, 255,
473                            &image_matrix, 0, FALSE)) {
474           renderer.Continue(NULL);
475         }
476         if (!renderer.m_Result) {
477           return FALSE;
478         }
479       }
480     }
481   }
482   if (pGlyphAndPos) {
483     FX_RECT rect =
484         FXGE_GetGlyphsBBox(pGlyphAndPos, textobj->m_nChars, 0, sa, sd);
485     CFX_DIBitmap bitmap;
486     if (!bitmap.Create((int)(rect.Width() * sa), (int)(rect.Height() * sd),
487                        FXDIB_8bppMask)) {
488       FX_Free(pGlyphAndPos);
489       return TRUE;
490     }
491     bitmap.Clear(0);
492     for (int iChar = 0; iChar < textobj->m_nChars; iChar++) {
493       FXTEXT_GLYPHPOS& glyph = pGlyphAndPos[iChar];
494       if (!glyph.m_pGlyph) {
495         continue;
496       }
497       bitmap.TransferBitmap(
498           (int)((glyph.m_OriginX + glyph.m_pGlyph->m_Left - rect.left) * sa),
499           (int)((glyph.m_OriginY - glyph.m_pGlyph->m_Top - rect.top) * sd),
500           glyph.m_pGlyph->m_Bitmap.GetWidth(),
501           glyph.m_pGlyph->m_Bitmap.GetHeight(), &glyph.m_pGlyph->m_Bitmap, 0,
502           0);
503     }
504     m_pDevice->SetBitMask(&bitmap, rect.left, rect.top, fill_argb);
505     FX_Free(pGlyphAndPos);
506   }
507   return TRUE;
508 }
509 class CPDF_CharPosList {
510  public:
511   CPDF_CharPosList();
512   ~CPDF_CharPosList();
513   void Load(int nChars,
514             FX_DWORD* pCharCodes,
515             FX_FLOAT* pCharPos,
516             CPDF_Font* pFont,
517             FX_FLOAT font_size);
518   FXTEXT_CHARPOS* m_pCharPos;
519   FX_DWORD m_nChars;
520 };
521 
CPDF_CharPosList()522 CPDF_CharPosList::CPDF_CharPosList() {
523   m_pCharPos = NULL;
524 }
~CPDF_CharPosList()525 CPDF_CharPosList::~CPDF_CharPosList() {
526   FX_Free(m_pCharPos);
527 }
Load(int nChars,FX_DWORD * pCharCodes,FX_FLOAT * pCharPos,CPDF_Font * pFont,FX_FLOAT FontSize)528 void CPDF_CharPosList::Load(int nChars,
529                             FX_DWORD* pCharCodes,
530                             FX_FLOAT* pCharPos,
531                             CPDF_Font* pFont,
532                             FX_FLOAT FontSize) {
533   m_pCharPos = FX_Alloc(FXTEXT_CHARPOS, nChars);
534   m_nChars = 0;
535   CPDF_CIDFont* pCIDFont = pFont->GetCIDFont();
536   FX_BOOL bVertWriting = pCIDFont && pCIDFont->IsVertWriting();
537   for (int iChar = 0; iChar < nChars; iChar++) {
538     FX_DWORD CharCode =
539         nChars == 1 ? (FX_DWORD)(uintptr_t)pCharCodes : pCharCodes[iChar];
540     if (CharCode == (FX_DWORD)-1) {
541       continue;
542     }
543     FX_BOOL bVert = FALSE;
544     FXTEXT_CHARPOS& charpos = m_pCharPos[m_nChars++];
545     if (pCIDFont) {
546       charpos.m_bFontStyle = pCIDFont->IsFontStyleFromCharCode(CharCode);
547     }
548     charpos.m_GlyphIndex = pFont->GlyphFromCharCode(CharCode, &bVert);
549 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
550     charpos.m_ExtGID = pFont->GlyphFromCharCodeExt(CharCode);
551 #endif
552     if (!pFont->IsEmbedded() && pFont->GetFontType() != PDFFONT_CIDFONT) {
553       charpos.m_FontCharWidth = pFont->GetCharWidthF(CharCode);
554     } else {
555       charpos.m_FontCharWidth = 0;
556     }
557     charpos.m_OriginX = iChar ? pCharPos[iChar - 1] : 0;
558     charpos.m_OriginY = 0;
559     charpos.m_bGlyphAdjust = FALSE;
560     if (!pCIDFont) {
561       continue;
562     }
563     FX_WORD CID = pCIDFont->CIDFromCharCode(CharCode);
564     if (bVertWriting) {
565       charpos.m_OriginY = charpos.m_OriginX;
566       charpos.m_OriginX = 0;
567       short vx, vy;
568       pCIDFont->GetVertOrigin(CID, vx, vy);
569       charpos.m_OriginX -= FontSize * vx / 1000;
570       charpos.m_OriginY -= FontSize * vy / 1000;
571     }
572     const uint8_t* pTransform = pCIDFont->GetCIDTransform(CID);
573     if (pTransform && !bVert) {
574       charpos.m_AdjustMatrix[0] = pCIDFont->CIDTransformToFloat(pTransform[0]);
575       charpos.m_AdjustMatrix[2] = pCIDFont->CIDTransformToFloat(pTransform[2]);
576       charpos.m_AdjustMatrix[1] = pCIDFont->CIDTransformToFloat(pTransform[1]);
577       charpos.m_AdjustMatrix[3] = pCIDFont->CIDTransformToFloat(pTransform[3]);
578       charpos.m_OriginX +=
579           pCIDFont->CIDTransformToFloat(pTransform[4]) * FontSize;
580       charpos.m_OriginY +=
581           pCIDFont->CIDTransformToFloat(pTransform[5]) * FontSize;
582       charpos.m_bGlyphAdjust = TRUE;
583     }
584   }
585 }
DrawTextPath(CFX_RenderDevice * pDevice,int nChars,FX_DWORD * pCharCodes,FX_FLOAT * pCharPos,CPDF_Font * pFont,FX_FLOAT font_size,const CFX_Matrix * pText2User,const CFX_Matrix * pUser2Device,const CFX_GraphStateData * pGraphState,FX_ARGB fill_argb,FX_ARGB stroke_argb,CFX_PathData * pClippingPath,int nFlag)586 FX_BOOL CPDF_TextRenderer::DrawTextPath(CFX_RenderDevice* pDevice,
587                                         int nChars,
588                                         FX_DWORD* pCharCodes,
589                                         FX_FLOAT* pCharPos,
590                                         CPDF_Font* pFont,
591                                         FX_FLOAT font_size,
592                                         const CFX_Matrix* pText2User,
593                                         const CFX_Matrix* pUser2Device,
594                                         const CFX_GraphStateData* pGraphState,
595                                         FX_ARGB fill_argb,
596                                         FX_ARGB stroke_argb,
597                                         CFX_PathData* pClippingPath,
598                                         int nFlag) {
599   CFX_FontCache* pCache =
600       pFont->m_pDocument ? pFont->m_pDocument->GetRenderData()->GetFontCache()
601                          : NULL;
602   CPDF_CharPosList CharPosList;
603   CharPosList.Load(nChars, pCharCodes, pCharPos, pFont, font_size);
604   return pDevice->DrawTextPath(CharPosList.m_nChars, CharPosList.m_pCharPos,
605                                &pFont->m_Font, pCache, font_size, pText2User,
606                                pUser2Device, pGraphState, fill_argb,
607                                stroke_argb, pClippingPath, nFlag);
608 }
DrawTextString(CFX_RenderDevice * pDevice,int left,int top,CPDF_Font * pFont,int height,const CFX_ByteString & str,FX_ARGB argb)609 void CPDF_TextRenderer::DrawTextString(CFX_RenderDevice* pDevice,
610                                        int left,
611                                        int top,
612                                        CPDF_Font* pFont,
613                                        int height,
614                                        const CFX_ByteString& str,
615                                        FX_ARGB argb) {
616   FX_RECT font_bbox;
617   pFont->GetFontBBox(font_bbox);
618   FX_FLOAT font_size =
619       (FX_FLOAT)height * 1000.0f / (FX_FLOAT)(font_bbox.top - font_bbox.bottom);
620   FX_FLOAT origin_x = (FX_FLOAT)left;
621   FX_FLOAT origin_y =
622       (FX_FLOAT)top + font_size * (FX_FLOAT)font_bbox.top / 1000.0f;
623   CFX_Matrix matrix(1.0f, 0, 0, -1.0f, 0, 0);
624   DrawTextString(pDevice, origin_x, origin_y, pFont, font_size, &matrix, str,
625                  argb);
626 }
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)627 void CPDF_TextRenderer::DrawTextString(CFX_RenderDevice* pDevice,
628                                        FX_FLOAT origin_x,
629                                        FX_FLOAT origin_y,
630                                        CPDF_Font* pFont,
631                                        FX_FLOAT font_size,
632                                        const CFX_Matrix* pMatrix,
633                                        const CFX_ByteString& str,
634                                        FX_ARGB fill_argb,
635                                        FX_ARGB stroke_argb,
636                                        const CFX_GraphStateData* pGraphState,
637                                        const CPDF_RenderOptions* pOptions) {
638   int nChars = pFont->CountChar(str, str.GetLength());
639   if (nChars == 0) {
640     return;
641   }
642   FX_DWORD charcode;
643   int offset = 0;
644   FX_DWORD* pCharCodes;
645   FX_FLOAT* pCharPos;
646   if (nChars == 1) {
647     charcode = pFont->GetNextChar(str, str.GetLength(), offset);
648     pCharCodes = (FX_DWORD*)(uintptr_t)charcode;
649     pCharPos = NULL;
650   } else {
651     pCharCodes = FX_Alloc(FX_DWORD, nChars);
652     pCharPos = FX_Alloc(FX_FLOAT, nChars - 1);
653     FX_FLOAT cur_pos = 0;
654     for (int i = 0; i < nChars; i++) {
655       pCharCodes[i] = pFont->GetNextChar(str, str.GetLength(), offset);
656       if (i) {
657         pCharPos[i - 1] = cur_pos;
658       }
659       cur_pos += pFont->GetCharWidthF(pCharCodes[i]) * font_size / 1000;
660     }
661   }
662   CFX_Matrix matrix;
663   if (pMatrix) {
664     matrix = *pMatrix;
665   }
666   matrix.e = origin_x;
667   matrix.f = origin_y;
668   if (pFont->GetFontType() == PDFFONT_TYPE3)
669     ;
670   else if (stroke_argb == 0) {
671     DrawNormalText(pDevice, nChars, pCharCodes, pCharPos, pFont, font_size,
672                    &matrix, fill_argb, pOptions);
673   } else
674     DrawTextPath(pDevice, nChars, pCharCodes, pCharPos, pFont, font_size,
675                  &matrix, NULL, pGraphState, fill_argb, stroke_argb, NULL);
676   if (nChars > 1) {
677     FX_Free(pCharCodes);
678     FX_Free(pCharPos);
679   }
680 }
DrawNormalText(CFX_RenderDevice * pDevice,int nChars,FX_DWORD * pCharCodes,FX_FLOAT * pCharPos,CPDF_Font * pFont,FX_FLOAT font_size,const CFX_Matrix * pText2Device,FX_ARGB fill_argb,const CPDF_RenderOptions * pOptions)681 FX_BOOL CPDF_TextRenderer::DrawNormalText(CFX_RenderDevice* pDevice,
682                                           int nChars,
683                                           FX_DWORD* pCharCodes,
684                                           FX_FLOAT* pCharPos,
685                                           CPDF_Font* pFont,
686                                           FX_FLOAT font_size,
687                                           const CFX_Matrix* pText2Device,
688                                           FX_ARGB fill_argb,
689                                           const CPDF_RenderOptions* pOptions) {
690   CFX_FontCache* pCache =
691       pFont->m_pDocument ? pFont->m_pDocument->GetRenderData()->GetFontCache()
692                          : NULL;
693   CPDF_CharPosList CharPosList;
694   CharPosList.Load(nChars, pCharCodes, pCharPos, pFont, font_size);
695   int FXGE_flags = 0;
696   if (pOptions) {
697     FX_DWORD dwFlags = pOptions->m_Flags;
698     if (dwFlags & RENDER_CLEARTYPE) {
699       FXGE_flags |= FXTEXT_CLEARTYPE;
700       if (dwFlags & RENDER_BGR_STRIPE) {
701         FXGE_flags |= FXTEXT_BGR_STRIPE;
702       }
703     }
704     if (dwFlags & RENDER_NOTEXTSMOOTH) {
705       FXGE_flags |= FXTEXT_NOSMOOTH;
706     }
707     if (dwFlags & RENDER_PRINTGRAPHICTEXT) {
708       FXGE_flags |= FXTEXT_PRINTGRAPHICTEXT;
709     }
710     if (dwFlags & RENDER_NO_NATIVETEXT) {
711       FXGE_flags |= FXTEXT_NO_NATIVETEXT;
712     }
713     if (dwFlags & RENDER_PRINTIMAGETEXT) {
714       FXGE_flags |= FXTEXT_PRINTIMAGETEXT;
715     }
716   } else {
717     FXGE_flags = FXTEXT_CLEARTYPE;
718   }
719   if (pFont->GetFontType() & PDFFONT_CIDFONT) {
720     FXGE_flags |= FXFONT_CIDFONT;
721   }
722   return pDevice->DrawNormalText(CharPosList.m_nChars, CharPosList.m_pCharPos,
723                                  &pFont->m_Font, pCache, font_size,
724                                  pText2Device, fill_argb, FXGE_flags);
725 }
DrawTextPathWithPattern(const CPDF_TextObject * textobj,const CFX_Matrix * pObj2Device,CPDF_Font * pFont,FX_FLOAT font_size,const CFX_Matrix * pTextMatrix,FX_BOOL bFill,FX_BOOL bStroke)726 void CPDF_RenderStatus::DrawTextPathWithPattern(const CPDF_TextObject* textobj,
727                                                 const CFX_Matrix* pObj2Device,
728                                                 CPDF_Font* pFont,
729                                                 FX_FLOAT font_size,
730                                                 const CFX_Matrix* pTextMatrix,
731                                                 FX_BOOL bFill,
732                                                 FX_BOOL bStroke) {
733   if (!bStroke) {
734     CPDF_PathObject path;
735     CPDF_TextObject* pCopy = new CPDF_TextObject;
736     pCopy->Copy(textobj);
737     path.m_bStroke = FALSE;
738     path.m_FillType = FXFILL_WINDING;
739     path.m_ClipPath.AppendTexts(&pCopy, 1);
740     path.m_ColorState = textobj->m_ColorState;
741     path.m_Path.New()->AppendRect(textobj->m_Left, textobj->m_Bottom,
742                                   textobj->m_Right, textobj->m_Top);
743     path.m_Left = textobj->m_Left;
744     path.m_Bottom = textobj->m_Bottom;
745     path.m_Right = textobj->m_Right;
746     path.m_Top = textobj->m_Top;
747     RenderSingleObject(&path, pObj2Device);
748     return;
749   }
750   CFX_FontCache* pCache;
751   if (pFont->m_pDocument) {
752     pCache = pFont->m_pDocument->GetRenderData()->GetFontCache();
753   } else {
754     pCache = CFX_GEModule::Get()->GetFontCache();
755   }
756   CFX_FaceCache* pFaceCache = pCache->GetCachedFace(&pFont->m_Font);
757   FX_FONTCACHE_DEFINE(pCache, &pFont->m_Font);
758   CPDF_CharPosList CharPosList;
759   CharPosList.Load(textobj->m_nChars, textobj->m_pCharCodes,
760                    textobj->m_pCharPos, pFont, font_size);
761   for (FX_DWORD i = 0; i < CharPosList.m_nChars; i++) {
762     FXTEXT_CHARPOS& charpos = CharPosList.m_pCharPos[i];
763     const CFX_PathData* pPath = pFaceCache->LoadGlyphPath(
764         &pFont->m_Font, charpos.m_GlyphIndex, charpos.m_FontCharWidth);
765     if (!pPath) {
766       continue;
767     }
768     CPDF_PathObject path;
769     path.m_GraphState = textobj->m_GraphState;
770     path.m_ColorState = textobj->m_ColorState;
771     CFX_Matrix matrix;
772     if (charpos.m_bGlyphAdjust)
773       matrix.Set(charpos.m_AdjustMatrix[0], charpos.m_AdjustMatrix[1],
774                  charpos.m_AdjustMatrix[2], charpos.m_AdjustMatrix[3], 0, 0);
775     matrix.Concat(font_size, 0, 0, font_size, charpos.m_OriginX,
776                   charpos.m_OriginY);
777     path.m_Path.New()->Append(pPath, &matrix);
778     path.m_Matrix = *pTextMatrix;
779     path.m_bStroke = bStroke;
780     path.m_FillType = bFill ? FXFILL_WINDING : 0;
781     path.CalcBoundingBox();
782     ProcessPath(&path, pObj2Device);
783   }
784 }
785 
LoadGlyphPath(FX_DWORD charcode,int dest_width)786 CFX_PathData* CPDF_Font::LoadGlyphPath(FX_DWORD charcode, int dest_width) {
787   int glyph_index = GlyphFromCharCode(charcode);
788   if (!m_Font.GetFace())
789     return nullptr;
790   return m_Font.LoadGlyphPath(glyph_index, dest_width);
791 }
792