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