Add fallback fonts in pdfium

core/fpdfapi/fpdf_render/fpdf_render_text.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "core/fpdfapi/fpdf_render/render_int.h"
 
 #include <vector>
 
@@ skipping 353 matching lines @@
       : m_dwCount(0), m_pType3Font(pType3Font) {}
   ~CPDF_RefType3Cache() {
     while (m_dwCount--) {
       ReleaseCachedType3(m_pType3Font);
     }
   }
   uint32_t m_dwCount;
   CPDF_Type3Font* const m_pType3Font;
 };
 
+// TODO(npm): Font fallback for type 3 fonts? (Completely separate code!!)
 FX_BOOL CPDF_RenderStatus::ProcessType3Text(const CPDF_TextObject* textobj,
                                             const CFX_Matrix* pObj2Device) {
   CPDF_Type3Font* pType3Font = textobj->m_TextState.GetFont()->AsType3Font();
   for (int i = 0; i < m_Type3FontCache.GetSize(); ++i) {
     if (m_Type3FontCache.GetAt(i) == pType3Font)
       return TRUE;
   }
 
   CFX_Matrix dCTM = m_pDevice->GetCTM();
   FX_FLOAT sa = FXSYS_fabs(dCTM.a);
@@ skipping 181 matching lines @@
         nChars == 1 ? (uint32_t)(uintptr_t)pCharCodes : pCharCodes[iChar];
     if (CharCode == (uint32_t)-1) {
       continue;
     }
     bool bVert = false;
     FXTEXT_CHARPOS& charpos = m_pCharPos[m_nChars++];
     if (pCIDFont) {
       charpos.m_bFontStyle = true;
     }
     charpos.m_GlyphIndex = pFont->GlyphFromCharCode(CharCode, &bVert);
+    if (charpos.m_GlyphIndex != static_cast<uint32_t>(-1)) {
+      charpos.m_FallbackFontPosition = -1;
+    } else {
+      charpos.m_FallbackFontPosition =
+          pFont->FallbackFontFromCharcode(CharCode, &bVert);
+      charpos.m_GlyphIndex = pFont->FallbackGlyphFromCharcode(
+          charpos.m_FallbackFontPosition, CharCode, &bVert);
+    }
+// TODO(npm): Figure out how this affects m_ExtGID
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
     charpos.m_ExtGID = pFont->GlyphFromCharCodeExt(CharCode);
 #endif
     if (!pFont->IsEmbedded() && !pFont->IsCIDFont()) {
       charpos.m_FontCharWidth = pFont->GetCharWidthF(CharCode);
     } else {
       charpos.m_FontCharWidth = 0;
     }
     charpos.m_OriginX = iChar ? pCharPos[iChar - 1] : 0;
     charpos.m_OriginY = 0;
@@ skipping 37 matching lines @@
                                         const CFX_GraphStateData* pGraphState,
                                         FX_ARGB fill_argb,
                                         FX_ARGB stroke_argb,
                                         CFX_PathData* pClippingPath,
                                         int nFlag) {
   CFX_FontCache* pCache =
       pFont->m_pDocument ? pFont->m_pDocument->GetRenderData()->GetFontCache()
                          : nullptr;
   CPDF_CharPosList CharPosList;
   CharPosList.Load(nChars, pCharCodes, pCharPos, pFont, font_size);
-  return pDevice->DrawTextPath(CharPosList.m_nChars, CharPosList.m_pCharPos,
-                               &pFont->m_Font, pCache, font_size, pText2User,
-                               pUser2Device, pGraphState, fill_argb,
-                               stroke_argb, pClippingPath, nFlag);
+  if (CharPosList.m_nChars == 0)
+    return TRUE;
+  FX_BOOL bDraw = TRUE;

[Tom Sepez, 2016/08/24 16:23:49]

nit: this should be a bool if we are going to &= it, otherwise we're doing
bitwise ops against an underlying int type.  Generally prefer

if (!somthing) bDraw = false; 

down at line 654 just in case it becomes an fx_bool again.

[npm, 2016/08/24 17:47:15]

Done.

+  int32_t fontPosition = CharPosList.m_pCharPos[0].m_FallbackFontPosition;
+  uint32_t startIndex = 0;
+  for (uint32_t i = 0; i < CharPosList.m_nChars; i++) {
+    int32_t curFontPosition = CharPosList.m_pCharPos[i].m_FallbackFontPosition;
+    if (fontPosition == curFontPosition)
+      continue;
+    auto* font = fontPosition == -1

[Tom Sepez, 2016/08/24 16:23:49]

Is there a reason to separate default fonts from fallback fonts instead of
always putting the default at index [0] and just walking the array until we're
happy?

[npm, 2016/08/24 17:47:15]

CPDF_Font already has m_Font for its main font. If it is added to
this list (as I had in first patchset), there will be ownership issues
with this particular font, the vector will have to contain pointers
instead of unique_ptrs, and the fallbacks will probably leak.

+                     ? &pFont->m_Font
+                     : pFont->m_FontFallbacks[fontPosition].get();
+    bDraw &= pDevice->DrawTextPath(
+        i - startIndex, CharPosList.m_pCharPos + startIndex, font, pCache,
+        font_size, pText2User, pUser2Device, pGraphState, fill_argb,
+        stroke_argb, pClippingPath, nFlag);
+    fontPosition = curFontPosition;
+    startIndex = i;
+  }
+  auto* font = fontPosition == -1 ? &pFont->m_Font
+                                  : pFont->m_FontFallbacks[fontPosition].get();
+  bDraw &= pDevice->DrawTextPath(
+      CharPosList.m_nChars - startIndex, CharPosList.m_pCharPos + startIndex,
+      font, pCache, font_size, pText2User, pUser2Device, pGraphState, fill_argb,
+      stroke_argb, pClippingPath, nFlag);
+  return bDraw;
 }
 
 // static
 void CPDF_TextRenderer::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,
@@ skipping 55 matching lines @@
                                           CPDF_Font* pFont,
                                           FX_FLOAT font_size,
                                           const CFX_Matrix* pText2Device,
                                           FX_ARGB fill_argb,
                                           const CPDF_RenderOptions* pOptions) {
   CFX_FontCache* pCache =
       pFont->m_pDocument ? pFont->m_pDocument->GetRenderData()->GetFontCache()
                          : nullptr;
   CPDF_CharPosList CharPosList;
   CharPosList.Load(nChars, pCharCodes, pCharPos, pFont, font_size);
+  if (CharPosList.m_nChars == 0)
+    return TRUE;
   int FXGE_flags = 0;
   if (pOptions) {
     uint32_t dwFlags = pOptions->m_Flags;
     if (dwFlags & RENDER_CLEARTYPE) {
       FXGE_flags |= FXTEXT_CLEARTYPE;
       if (dwFlags & RENDER_BGR_STRIPE) {
         FXGE_flags |= FXTEXT_BGR_STRIPE;
       }
     }
     if (dwFlags & RENDER_NOTEXTSMOOTH) {
       FXGE_flags |= FXTEXT_NOSMOOTH;
     }
     if (dwFlags & RENDER_PRINTGRAPHICTEXT) {
       FXGE_flags |= FXTEXT_PRINTGRAPHICTEXT;
     }
     if (dwFlags & RENDER_NO_NATIVETEXT) {
       FXGE_flags |= FXTEXT_NO_NATIVETEXT;
     }
     if (dwFlags & RENDER_PRINTIMAGETEXT) {
       FXGE_flags |= FXTEXT_PRINTIMAGETEXT;
     }
   } else {
     FXGE_flags = FXTEXT_CLEARTYPE;
   }
   if (pFont->IsCIDFont()) {
     FXGE_flags |= FXFONT_CIDFONT;
   }
-  return pDevice->DrawNormalText(CharPosList.m_nChars, CharPosList.m_pCharPos,
-                                 &pFont->m_Font, pCache, font_size,
-                                 pText2Device, fill_argb, FXGE_flags);
+  FX_BOOL bDraw = TRUE;

[Tom Sepez, 2016/08/24 16:23:49]

nit: same here.

[npm, 2016/08/24 17:47:15]

Done.

+  int32_t fontPosition = CharPosList.m_pCharPos[0].m_FallbackFontPosition;
+  uint32_t startIndex = 0;
+  for (uint32_t i = 0; i < CharPosList.m_nChars; i++) {
+    int32_t curFontPosition = CharPosList.m_pCharPos[i].m_FallbackFontPosition;
+    if (fontPosition == curFontPosition)
+      continue;
+    auto* font = fontPosition == -1
+                     ? &pFont->m_Font
+                     : pFont->m_FontFallbacks[fontPosition].get();
+    bDraw &= pDevice->DrawNormalText(
+        i - startIndex, CharPosList.m_pCharPos + startIndex, font, pCache,
+        font_size, pText2Device, fill_argb, FXGE_flags);
+    fontPosition = curFontPosition;
+    startIndex = i;
+  }
+  auto* font = fontPosition == -1 ? &pFont->m_Font
+                                  : pFont->m_FontFallbacks[fontPosition].get();
+  bDraw &= pDevice->DrawNormalText(
+      CharPosList.m_nChars - startIndex, CharPosList.m_pCharPos + startIndex,
+      font, pCache, font_size, pText2Device, fill_argb, FXGE_flags);
+  return bDraw;
 }
 
 void CPDF_RenderStatus::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) {
   if (!bStroke) {
@@ skipping 12 matching lines @@
     path.m_Top = textobj->m_Top;
     RenderSingleObject(&path, pObj2Device);
     return;
   }
   CFX_FontCache* pCache;
   if (pFont->m_pDocument) {
     pCache = pFont->m_pDocument->GetRenderData()->GetFontCache();
   } else {
     pCache = CFX_GEModule::Get()->GetFontCache();
   }
-  CFX_FaceCache* pFaceCache = pCache->GetCachedFace(&pFont->m_Font);
-  CFX_AutoFontCache autoFontCache(pCache, &pFont->m_Font);
   CPDF_CharPosList CharPosList;
   CharPosList.Load(textobj->m_nChars, textobj->m_pCharCodes,
                    textobj->m_pCharPos, pFont, font_size);
+  std::vector<CFX_FaceCache*> faceCaches;
+  std::vector<CFX_AutoFontCache> autoFontCaches;
+  faceCaches.push_back(pCache->GetCachedFace(&pFont->m_Font));
+  autoFontCaches.push_back(CFX_AutoFontCache(pCache, &pFont->m_Font));
+  for (auto& font : pFont->m_FontFallbacks) {

[Tom Sepez, 2016/08/24 16:23:49]

nit: can this be const auto& font ?

[npm, 2016/08/24 17:47:15]

Done.

+    faceCaches.push_back(pCache->GetCachedFace(font.get()));
+    autoFontCaches.push_back(CFX_AutoFontCache(pCache, font.get()));
+  }
   for (uint32_t i = 0; i < CharPosList.m_nChars; i++) {
     FXTEXT_CHARPOS& charpos = CharPosList.m_pCharPos[i];
-    const CFX_PathData* pPath = pFaceCache->LoadGlyphPath(
-        &pFont->m_Font, charpos.m_GlyphIndex, charpos.m_FontCharWidth);
+    auto font =
+        charpos.m_FallbackFontPosition == -1
+            ? &pFont->m_Font
+            : pFont->m_FontFallbacks[charpos.m_FallbackFontPosition].get();
+    const CFX_PathData* pPath =
+        faceCaches[charpos.m_FallbackFontPosition + 1]->LoadGlyphPath(
+            font, charpos.m_GlyphIndex, charpos.m_FontCharWidth);
     if (!pPath) {
       continue;
     }
     CPDF_PathObject path;
     path.m_GraphState = textobj->m_GraphState;
     path.m_ColorState = textobj->m_ColorState;
     CFX_Matrix matrix;
     if (charpos.m_bGlyphAdjust)
       matrix.Set(charpos.m_AdjustMatrix[0], charpos.m_AdjustMatrix[1],
                  charpos.m_AdjustMatrix[2], charpos.m_AdjustMatrix[3], 0, 0);
     matrix.Concat(font_size, 0, 0, font_size, charpos.m_OriginX,
                   charpos.m_OriginY);
     path.m_Path.New()->Append(pPath, &matrix);
     path.m_Matrix = *pTextMatrix;
     path.m_bStroke = bStroke;
     path.m_FillType = bFill ? FXFILL_WINDING : 0;
     path.CalcBoundingBox();
     ProcessPath(&path, pObj2Device);
   }
 }