// Copyright 2017 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. #include <memory> #include <utility> #include "core/fpdfapi/cpdf_modulemgr.h" #include "core/fpdfapi/font/cpdf_font.h" #include "core/fpdfapi/font/cpdf_type1font.h" #include "core/fpdfapi/page/cpdf_textobject.h" #include "core/fpdfapi/parser/cpdf_array.h" #include "core/fpdfapi/parser/cpdf_dictionary.h" #include "core/fpdfapi/parser/cpdf_document.h" #include "core/fpdfapi/parser/cpdf_name.h" #include "core/fpdfapi/parser/cpdf_number.h" #include "core/fpdfapi/parser/cpdf_reference.h" #include "core/fpdfapi/parser/cpdf_stream.h" #include "core/fxge/cfx_fontmgr.h" #include "core/fxge/fx_font.h" #include "fpdfsdk/fsdk_define.h" #include "public/fpdf_edit.h" namespace { CPDF_Dictionary* LoadFontDesc(CPDF_Document* pDoc, const CFX_ByteString& font_name, CFX_Font* pFont, const uint8_t* data, uint32_t size, int font_type) { CPDF_Dictionary* fontDesc = pDoc->NewIndirect<CPDF_Dictionary>(); fontDesc->SetNewFor<CPDF_Name>("Type", "FontDescriptor"); fontDesc->SetNewFor<CPDF_Name>("FontName", font_name); int flags = 0; if (FXFT_Is_Face_fixedwidth(pFont->GetFace())) flags |= FXFONT_FIXED_PITCH; if (font_name.Find("Serif") > -1) flags |= FXFONT_SERIF; if (FXFT_Is_Face_Italic(pFont->GetFace())) flags |= FXFONT_ITALIC; if (FXFT_Is_Face_Bold(pFont->GetFace())) flags |= FXFONT_BOLD; // TODO(npm): How do I know if a font is symbolic, script, allcap, smallcap flags |= FXFONT_NONSYMBOLIC; fontDesc->SetNewFor<CPDF_Number>("Flags", flags); FX_RECT bbox; pFont->GetBBox(bbox); auto pBBox = pdfium::MakeUnique<CPDF_Array>(); pBBox->AddNew<CPDF_Number>(bbox.left); pBBox->AddNew<CPDF_Number>(bbox.bottom); pBBox->AddNew<CPDF_Number>(bbox.right); pBBox->AddNew<CPDF_Number>(bbox.top); fontDesc->SetFor("FontBBox", std::move(pBBox)); // TODO(npm): calculate italic angle correctly fontDesc->SetNewFor<CPDF_Number>("ItalicAngle", pFont->IsItalic() ? -12 : 0); fontDesc->SetNewFor<CPDF_Number>("Ascent", pFont->GetAscent()); fontDesc->SetNewFor<CPDF_Number>("Descent", pFont->GetDescent()); // TODO(npm): calculate the capheight, stemV correctly fontDesc->SetNewFor<CPDF_Number>("CapHeight", pFont->GetAscent()); fontDesc->SetNewFor<CPDF_Number>("StemV", pFont->IsBold() ? 120 : 70); CPDF_Stream* pStream = pDoc->NewIndirect<CPDF_Stream>(); pStream->SetData(data, size); CFX_ByteString fontFile = font_type == FPDF_FONT_TYPE1 ? "FontFile" : "FontFile2"; fontDesc->SetNewFor<CPDF_Reference>(fontFile, pDoc, pStream->GetObjNum()); return fontDesc; } void* LoadSimpleFont(CPDF_Document* pDoc, std::unique_ptr<CFX_Font> pFont, const uint8_t* data, uint32_t size, int font_type) { CPDF_Dictionary* fontDict = pDoc->NewIndirect<CPDF_Dictionary>(); fontDict->SetNewFor<CPDF_Name>("Type", "Font"); fontDict->SetNewFor<CPDF_Name>( "Subtype", font_type == FPDF_FONT_TYPE1 ? "Type1" : "TrueType"); CFX_ByteString name = pFont->GetFaceName(); if (name.IsEmpty()) name = "Unnamed"; fontDict->SetNewFor<CPDF_Name>("BaseFont", name); uint32_t glyphIndex; int currentChar = FXFT_Get_First_Char(pFont->GetFace(), &glyphIndex); fontDict->SetNewFor<CPDF_Number>("FirstChar", currentChar); CPDF_Array* widthsArray = pDoc->NewIndirect<CPDF_Array>(); while (true) { int width = pFont->GetGlyphWidth(glyphIndex); widthsArray->AddNew<CPDF_Number>(width); int nextChar = FXFT_Get_Next_Char(pFont->GetFace(), currentChar, &glyphIndex); // Simple fonts have 1-byte charcodes only. if (nextChar > 0xff || glyphIndex == 0) break; for (int i = currentChar + 1; i < nextChar; i++) widthsArray->AddNew<CPDF_Number>(0); currentChar = nextChar; } fontDict->SetNewFor<CPDF_Number>("LastChar", currentChar); fontDict->SetNewFor<CPDF_Reference>("Widths", pDoc, widthsArray->GetObjNum()); CPDF_Dictionary* fontDesc = LoadFontDesc(pDoc, name, pFont.get(), data, size, font_type); fontDict->SetNewFor<CPDF_Reference>("FontDescriptor", pDoc, fontDesc->GetObjNum()); return pDoc->LoadFont(fontDict); } void* LoadCompositeFont(CPDF_Document* pDoc, std::unique_ptr<CFX_Font> pFont, const uint8_t* data, uint32_t size, int font_type) { CPDF_Dictionary* fontDict = pDoc->NewIndirect<CPDF_Dictionary>(); fontDict->SetNewFor<CPDF_Name>("Type", "Font"); fontDict->SetNewFor<CPDF_Name>("Subtype", "Type0"); // TODO(npm): Get the correct encoding, if it's not identity. CFX_ByteString encoding = "Identity-H"; fontDict->SetNewFor<CPDF_Name>("Encoding", encoding); CFX_ByteString name = pFont->GetFaceName(); if (name.IsEmpty()) name = "Unnamed"; fontDict->SetNewFor<CPDF_Name>( "BaseFont", font_type == FPDF_FONT_TYPE1 ? name + "-" + encoding : name); CPDF_Dictionary* pCIDFont = pDoc->NewIndirect<CPDF_Dictionary>(); pCIDFont->SetNewFor<CPDF_Name>("Type", "Font"); pCIDFont->SetNewFor<CPDF_Name>("Subtype", font_type == FPDF_FONT_TYPE1 ? "CIDFontType0" : "CIDFontType2"); pCIDFont->SetNewFor<CPDF_Name>("BaseFont", name); // TODO(npm): Maybe use FT_Get_CID_Registry_Ordering_Supplement to get the // CIDSystemInfo CPDF_Dictionary* pCIDSystemInfo = pDoc->NewIndirect<CPDF_Dictionary>(); pCIDSystemInfo->SetNewFor<CPDF_Name>("Registry", "Adobe"); pCIDSystemInfo->SetNewFor<CPDF_Name>("Ordering", "Identity"); pCIDSystemInfo->SetNewFor<CPDF_Number>("Supplement", 0); pCIDFont->SetNewFor<CPDF_Reference>("CIDSystemInfo", pDoc, pCIDSystemInfo->GetObjNum()); CPDF_Dictionary* fontDesc = LoadFontDesc(pDoc, name, pFont.get(), data, size, font_type); pCIDFont->SetNewFor<CPDF_Reference>("FontDescriptor", pDoc, fontDesc->GetObjNum()); uint32_t glyphIndex; int currentChar = FXFT_Get_First_Char(pFont->GetFace(), &glyphIndex); CPDF_Array* widthsArray = pDoc->NewIndirect<CPDF_Array>(); while (true) { int width = pFont->GetGlyphWidth(glyphIndex); int nextChar = FXFT_Get_Next_Char(pFont->GetFace(), currentChar, &glyphIndex); if (glyphIndex == 0) { // Only one char left, use format c [w] auto oneW = pdfium::MakeUnique<CPDF_Array>(); oneW->AddNew<CPDF_Number>(width); widthsArray->AddNew<CPDF_Number>(currentChar); widthsArray->Add(std::move(oneW)); break; } int nextWidth = pFont->GetGlyphWidth(glyphIndex); if (nextChar == currentChar + 1 && nextWidth == width) { // The array can have a group c_first c_last w: all CIDs in the range from // c_first to c_last will have width w widthsArray->AddNew<CPDF_Number>(currentChar); currentChar = nextChar; while (true) { nextChar = FXFT_Get_Next_Char(pFont->GetFace(), currentChar, &glyphIndex); if (glyphIndex == 0) break; nextWidth = pFont->GetGlyphWidth(glyphIndex); if (nextChar != currentChar + 1 || nextWidth != width) break; currentChar = nextChar; } widthsArray->AddNew<CPDF_Number>(currentChar); widthsArray->AddNew<CPDF_Number>(width); } else { // Otherwise we can have a group of the form c [w1 w2 ...]: c has width // w1, c+1 has width w2, etc. widthsArray->AddNew<CPDF_Number>(currentChar); auto curWidthArray = pdfium::MakeUnique<CPDF_Array>(); curWidthArray->AddNew<CPDF_Number>(width); while (nextChar == currentChar + 1) { curWidthArray->AddNew<CPDF_Number>(nextWidth); currentChar = nextChar; nextChar = FXFT_Get_Next_Char(pFont->GetFace(), currentChar, &glyphIndex); if (glyphIndex == 0) break; nextWidth = pFont->GetGlyphWidth(glyphIndex); } widthsArray->Add(std::move(curWidthArray)); } if (glyphIndex == 0) break; currentChar = nextChar; } pCIDFont->SetNewFor<CPDF_Reference>("W", pDoc, widthsArray->GetObjNum()); // TODO(npm): Support vertical writing auto pDescendant = pdfium::MakeUnique<CPDF_Array>(); pDescendant->AddNew<CPDF_Reference>(pDoc, pCIDFont->GetObjNum()); fontDict->SetFor("DescendantFonts", std::move(pDescendant)); // TODO(npm): do we need a ToUnicode? return pDoc->LoadFont(fontDict); } } // namespace DLLEXPORT FPDF_PAGEOBJECT STDCALL FPDFPageObj_NewTextObj(FPDF_DOCUMENT document, FPDF_BYTESTRING font, float font_size) { CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document); if (!pDoc) return nullptr; CPDF_Font* pFont = CPDF_Font::GetStockFont(pDoc, CFX_ByteStringC(font)); if (!pFont) return nullptr; CPDF_TextObject* pTextObj = new CPDF_TextObject; pTextObj->m_TextState.SetFont(pFont); pTextObj->m_TextState.SetFontSize(font_size); pTextObj->DefaultStates(); return pTextObj; } DLLEXPORT FPDF_BOOL STDCALL FPDFText_SetText(FPDF_PAGEOBJECT text_object, FPDF_BYTESTRING text) { if (!text_object) return false; auto* pTextObj = reinterpret_cast<CPDF_TextObject*>(text_object); pTextObj->SetText(CFX_ByteString(text)); return true; } DLLEXPORT FPDF_FONT STDCALL FPDFText_LoadFont(FPDF_DOCUMENT document, const uint8_t* data, uint32_t size, int font_type, FPDF_BOOL cid) { CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document); if (!pDoc || !data || size == 0 || (font_type != FPDF_FONT_TYPE1 && font_type != FPDF_FONT_TRUETYPE)) { return nullptr; } auto pFont = pdfium::MakeUnique<CFX_Font>(); // TODO(npm): Maybe use FT_Get_X11_Font_Format to check format? Otherwise, we // are allowing giving any font that can be loaded on freetype and setting it // as any font type. if (!pFont->LoadEmbedded(data, size)) return nullptr; return cid ? LoadCompositeFont(pDoc, std::move(pFont), data, size, font_type) : LoadSimpleFont(pDoc, std::move(pFont), data, size, font_type); }