| // 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); |
| } |
