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