| // Copyright 2016 The PDFium Authors |
| // 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/fpdfdoc/cpdf_generateap.h" |
| |
| #include <algorithm> |
| #include <sstream> |
| #include <utility> |
| |
| #include "constants/annotation_common.h" |
| #include "constants/appearance.h" |
| #include "constants/font_encodings.h" |
| #include "constants/form_fields.h" |
| #include "core/fpdfapi/edit/cpdf_contentstream_write_utils.h" |
| #include "core/fpdfapi/font/cpdf_font.h" |
| #include "core/fpdfapi/page/cpdf_docpagedata.h" |
| #include "core/fpdfapi/parser/cpdf_array.h" |
| #include "core/fpdfapi/parser/cpdf_boolean.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/fpdfapi/parser/cpdf_string.h" |
| #include "core/fpdfapi/parser/fpdf_parser_decode.h" |
| #include "core/fpdfapi/parser/fpdf_parser_utility.h" |
| #include "core/fpdfdoc/cpdf_annot.h" |
| #include "core/fpdfdoc/cpdf_color_utils.h" |
| #include "core/fpdfdoc/cpdf_defaultappearance.h" |
| #include "core/fpdfdoc/cpdf_formfield.h" |
| #include "core/fpdfdoc/cpvt_fontmap.h" |
| #include "core/fpdfdoc/cpvt_variabletext.h" |
| #include "core/fpdfdoc/cpvt_word.h" |
| #include "core/fxcrt/fx_string_wrappers.h" |
| #include "core/fxge/cfx_renderdevice.h" |
| |
| namespace { |
| |
| struct CPVT_Dash { |
| CPVT_Dash(int32_t dash, int32_t gap, int32_t phase) |
| : nDash(dash), nGap(gap), nPhase(phase) {} |
| |
| int32_t nDash; |
| int32_t nGap; |
| int32_t nPhase; |
| }; |
| |
| enum class PaintOperation { kStroke, kFill }; |
| |
| ByteString GetPDFWordString(IPVT_FontMap* pFontMap, |
| int32_t nFontIndex, |
| uint16_t Word, |
| uint16_t SubWord) { |
| if (SubWord > 0) |
| return ByteString::Format("%c", SubWord); |
| |
| if (!pFontMap) |
| return ByteString(); |
| |
| RetainPtr<CPDF_Font> pPDFFont = pFontMap->GetPDFFont(nFontIndex); |
| if (!pPDFFont) |
| return ByteString(); |
| |
| if (pPDFFont->GetBaseFontName() == "Symbol" || |
| pPDFFont->GetBaseFontName() == "ZapfDingbats") { |
| return ByteString::Format("%c", Word); |
| } |
| |
| ByteString sWord; |
| uint32_t dwCharCode = pPDFFont->CharCodeFromUnicode(Word); |
| if (dwCharCode != CPDF_Font::kInvalidCharCode) { |
| pPDFFont->AppendChar(&sWord, dwCharCode); |
| } |
| return sWord; |
| } |
| |
| ByteString GetWordRenderString(ByteStringView strWords) { |
| if (strWords.IsEmpty()) |
| return ByteString(); |
| return PDF_EncodeString(strWords) + " Tj\n"; |
| } |
| |
| ByteString GetFontSetString(IPVT_FontMap* pFontMap, |
| int32_t nFontIndex, |
| float fFontSize) { |
| fxcrt::ostringstream sRet; |
| if (pFontMap) { |
| ByteString sFontAlias = pFontMap->GetPDFFontAlias(nFontIndex); |
| if (sFontAlias.GetLength() > 0 && fFontSize > 0) { |
| sRet << "/" << sFontAlias << " "; |
| WriteFloat(sRet, fFontSize) << " Tf\n"; |
| } |
| } |
| return ByteString(sRet); |
| } |
| |
| ByteString GenerateEditAP(IPVT_FontMap* pFontMap, |
| CPVT_VariableText::Iterator* pIterator, |
| const CFX_PointF& ptOffset, |
| bool bContinuous, |
| uint16_t SubWord) { |
| fxcrt::ostringstream sEditStream; |
| fxcrt::ostringstream sLineStream; |
| CFX_PointF ptOld; |
| CFX_PointF ptNew; |
| int32_t nCurFontIndex = -1; |
| CPVT_WordPlace oldplace; |
| ByteString sWords; |
| pIterator->SetAt(0); |
| while (pIterator->NextWord()) { |
| CPVT_WordPlace place = pIterator->GetWordPlace(); |
| if (bContinuous) { |
| if (place.LineCmp(oldplace) != 0) { |
| if (!sWords.IsEmpty()) { |
| sLineStream << GetWordRenderString(sWords.AsStringView()); |
| sEditStream << sLineStream.str(); |
| sLineStream.str(""); |
| sWords.clear(); |
| } |
| CPVT_Word word; |
| if (pIterator->GetWord(word)) { |
| ptNew = CFX_PointF(word.ptWord.x + ptOffset.x, |
| word.ptWord.y + ptOffset.y); |
| } else { |
| CPVT_Line line; |
| pIterator->GetLine(line); |
| ptNew = CFX_PointF(line.ptLine.x + ptOffset.x, |
| line.ptLine.y + ptOffset.y); |
| } |
| if (ptNew != ptOld) { |
| WritePoint(sLineStream, ptNew - ptOld) << " Td\n"; |
| ptOld = ptNew; |
| } |
| } |
| CPVT_Word word; |
| if (pIterator->GetWord(word)) { |
| if (word.nFontIndex != nCurFontIndex) { |
| if (!sWords.IsEmpty()) { |
| sLineStream << GetWordRenderString(sWords.AsStringView()); |
| sWords.clear(); |
| } |
| sLineStream << GetFontSetString(pFontMap, word.nFontIndex, |
| word.fFontSize); |
| nCurFontIndex = word.nFontIndex; |
| } |
| sWords += GetPDFWordString(pFontMap, nCurFontIndex, word.Word, SubWord); |
| } |
| oldplace = place; |
| } else { |
| CPVT_Word word; |
| if (pIterator->GetWord(word)) { |
| ptNew = |
| CFX_PointF(word.ptWord.x + ptOffset.x, word.ptWord.y + ptOffset.y); |
| if (ptNew != ptOld) { |
| WritePoint(sEditStream, ptNew - ptOld) << " Td\n"; |
| ptOld = ptNew; |
| } |
| if (word.nFontIndex != nCurFontIndex) { |
| sEditStream << GetFontSetString(pFontMap, word.nFontIndex, |
| word.fFontSize); |
| nCurFontIndex = word.nFontIndex; |
| } |
| sEditStream << GetWordRenderString( |
| GetPDFWordString(pFontMap, nCurFontIndex, word.Word, SubWord) |
| .AsStringView()); |
| } |
| } |
| } |
| if (!sWords.IsEmpty()) { |
| sLineStream << GetWordRenderString(sWords.AsStringView()); |
| sEditStream << sLineStream.str(); |
| } |
| return ByteString(sEditStream); |
| } |
| |
| ByteString GenerateColorAP(const CFX_Color& color, PaintOperation nOperation) { |
| fxcrt::ostringstream sColorStream; |
| switch (color.nColorType) { |
| case CFX_Color::Type::kRGB: |
| WriteFloat(sColorStream, color.fColor1) << " "; |
| WriteFloat(sColorStream, color.fColor2) << " "; |
| WriteFloat(sColorStream, color.fColor3) << " "; |
| sColorStream << (nOperation == PaintOperation::kStroke ? "RG" : "rg") |
| << "\n"; |
| break; |
| case CFX_Color::Type::kGray: |
| WriteFloat(sColorStream, color.fColor1) << " "; |
| sColorStream << (nOperation == PaintOperation::kStroke ? "G" : "g") |
| << "\n"; |
| break; |
| case CFX_Color::Type::kCMYK: |
| WriteFloat(sColorStream, color.fColor1) << " "; |
| WriteFloat(sColorStream, color.fColor2) << " "; |
| WriteFloat(sColorStream, color.fColor3) << " "; |
| WriteFloat(sColorStream, color.fColor4) << " "; |
| sColorStream << (nOperation == PaintOperation::kStroke ? "K" : "k") |
| << "\n"; |
| break; |
| case CFX_Color::Type::kTransparent: |
| break; |
| } |
| return ByteString(sColorStream); |
| } |
| |
| ByteString GenerateBorderAP(const CFX_FloatRect& rect, |
| float width, |
| const CFX_Color& color, |
| const CFX_Color& crLeftTop, |
| const CFX_Color& crRightBottom, |
| BorderStyle nStyle, |
| const CPVT_Dash& dash) { |
| fxcrt::ostringstream sAppStream; |
| ByteString sColor; |
| const float fLeft = rect.left; |
| const float fRight = rect.right; |
| const float fTop = rect.top; |
| const float fBottom = rect.bottom; |
| if (width > 0.0f) { |
| const float half_width = width / 2.0f; |
| switch (nStyle) { |
| case BorderStyle::kSolid: |
| sColor = GenerateColorAP(color, PaintOperation::kFill); |
| if (sColor.GetLength() > 0) { |
| sAppStream << sColor; |
| WriteRect(sAppStream, rect) << " re\n"; |
| CFX_FloatRect inner_rect = rect; |
| inner_rect.Deflate(width, width); |
| WriteRect(sAppStream, inner_rect) << " re f*\n"; |
| } |
| break; |
| case BorderStyle::kDash: |
| sColor = GenerateColorAP(color, PaintOperation::kStroke); |
| if (sColor.GetLength() > 0) { |
| sAppStream << sColor; |
| WriteFloat(sAppStream, width) |
| << " w [" << dash.nDash << " " << dash.nGap << "] " << dash.nPhase |
| << " d\n"; |
| WritePoint(sAppStream, {fLeft + half_width, fBottom + half_width}) |
| << " m\n"; |
| WritePoint(sAppStream, {fLeft + half_width, fTop - half_width}) |
| << " l\n"; |
| WritePoint(sAppStream, {fRight - half_width, fTop - half_width}) |
| << " l\n"; |
| WritePoint(sAppStream, {fRight - half_width, fBottom + half_width}) |
| << " l\n"; |
| WritePoint(sAppStream, {fLeft + half_width, fBottom + half_width}) |
| << " l S\n"; |
| } |
| break; |
| case BorderStyle::kBeveled: |
| case BorderStyle::kInset: |
| sColor = GenerateColorAP(crLeftTop, PaintOperation::kFill); |
| if (sColor.GetLength() > 0) { |
| sAppStream << sColor; |
| WritePoint(sAppStream, {fLeft + half_width, fBottom + half_width}) |
| << " m\n"; |
| WritePoint(sAppStream, {fLeft + half_width, fTop - half_width}) |
| << " l\n"; |
| WritePoint(sAppStream, {fRight - half_width, fTop - half_width}) |
| << " l\n"; |
| WritePoint(sAppStream, {fRight - width, fTop - width}) << " l\n"; |
| WritePoint(sAppStream, {fLeft + width, fTop - width}) << " l\n"; |
| WritePoint(sAppStream, {fLeft + width, fBottom + width}) << " l f\n"; |
| } |
| sColor = GenerateColorAP(crRightBottom, PaintOperation::kFill); |
| if (sColor.GetLength() > 0) { |
| sAppStream << sColor; |
| WritePoint(sAppStream, {fRight - half_width, fTop - half_width}) |
| << " m\n"; |
| WritePoint(sAppStream, {fRight - half_width, fBottom + half_width}) |
| << " l\n"; |
| WritePoint(sAppStream, {fLeft + half_width, fBottom + half_width}) |
| << " l\n"; |
| WritePoint(sAppStream, {fLeft + width, fBottom + width}) << " l\n"; |
| WritePoint(sAppStream, {fRight - width, fBottom + width}) << " l\n"; |
| WritePoint(sAppStream, {fRight - width, fTop - width}) << " l f\n"; |
| } |
| sColor = GenerateColorAP(color, PaintOperation::kFill); |
| if (sColor.GetLength() > 0) { |
| sAppStream << sColor; |
| WriteRect(sAppStream, rect) << " re\n"; |
| CFX_FloatRect inner_rect = rect; |
| inner_rect.Deflate(half_width, half_width); |
| WriteRect(sAppStream, inner_rect) << " re f*\n"; |
| } |
| break; |
| case BorderStyle::kUnderline: |
| sColor = GenerateColorAP(color, PaintOperation::kStroke); |
| if (sColor.GetLength() > 0) { |
| sAppStream << sColor; |
| WriteFloat(sAppStream, width) << " w\n"; |
| WritePoint(sAppStream, {fLeft, fBottom + half_width}) << " m\n"; |
| WritePoint(sAppStream, {fRight, fBottom + half_width}) << " l S\n"; |
| } |
| break; |
| } |
| } |
| return ByteString(sAppStream); |
| } |
| |
| ByteString GetColorStringWithDefault(const CPDF_Array* pColor, |
| const CFX_Color& crDefaultColor, |
| PaintOperation nOperation) { |
| if (pColor) { |
| CFX_Color color = fpdfdoc::CFXColorFromArray(*pColor); |
| return GenerateColorAP(color, nOperation); |
| } |
| |
| return GenerateColorAP(crDefaultColor, nOperation); |
| } |
| |
| float GetBorderWidth(const CPDF_Dictionary* pDict) { |
| RetainPtr<const CPDF_Dictionary> pBorderStyleDict = pDict->GetDictFor("BS"); |
| if (pBorderStyleDict && pBorderStyleDict->KeyExist("W")) |
| return pBorderStyleDict->GetFloatFor("W"); |
| |
| auto pBorderArray = pDict->GetArrayFor(pdfium::annotation::kBorder); |
| if (pBorderArray && pBorderArray->size() > 2) |
| return pBorderArray->GetFloatAt(2); |
| |
| return 1; |
| } |
| |
| RetainPtr<const CPDF_Array> GetDashArray(const CPDF_Dictionary* pDict) { |
| RetainPtr<const CPDF_Dictionary> pBorderStyleDict = pDict->GetDictFor("BS"); |
| if (pBorderStyleDict && pBorderStyleDict->GetByteStringFor("S") == "D") |
| return pBorderStyleDict->GetArrayFor("D"); |
| |
| RetainPtr<const CPDF_Array> pBorderArray = |
| pDict->GetArrayFor(pdfium::annotation::kBorder); |
| if (pBorderArray && pBorderArray->size() == 4) |
| return pBorderArray->GetArrayAt(3); |
| |
| return nullptr; |
| } |
| |
| ByteString GetDashPatternString(const CPDF_Dictionary* pDict) { |
| RetainPtr<const CPDF_Array> pDashArray = GetDashArray(pDict); |
| if (!pDashArray || pDashArray->IsEmpty()) |
| return ByteString(); |
| |
| // Support maximum of ten elements in the dash array. |
| size_t pDashArrayCount = std::min<size_t>(pDashArray->size(), 10); |
| fxcrt::ostringstream sDashStream; |
| |
| sDashStream << "["; |
| for (size_t i = 0; i < pDashArrayCount; ++i) |
| WriteFloat(sDashStream, pDashArray->GetFloatAt(i)) << " "; |
| sDashStream << "] 0 d\n"; |
| |
| return ByteString(sDashStream); |
| } |
| |
| ByteString GetPopupContentsString(CPDF_Document* pDoc, |
| const CPDF_Dictionary& pAnnotDict, |
| RetainPtr<CPDF_Font> pDefFont, |
| const ByteString& sFontName) { |
| WideString swValue(pAnnotDict.GetUnicodeTextFor(pdfium::form_fields::kT)); |
| swValue += L'\n'; |
| swValue += pAnnotDict.GetUnicodeTextFor(pdfium::annotation::kContents); |
| |
| CPVT_FontMap map(pDoc, nullptr, std::move(pDefFont), sFontName); |
| CPVT_VariableText::Provider prd(&map); |
| CPVT_VariableText vt(&prd); |
| vt.SetPlateRect(pAnnotDict.GetRectFor(pdfium::annotation::kRect)); |
| vt.SetFontSize(12); |
| vt.SetAutoReturn(true); |
| vt.SetMultiLine(true); |
| vt.Initialize(); |
| vt.SetText(swValue); |
| vt.RearrangeAll(); |
| |
| CFX_PointF ptOffset(3.0f, -3.0f); |
| ByteString sContent = |
| GenerateEditAP(&map, vt.GetIterator(), ptOffset, false, 0); |
| |
| if (sContent.IsEmpty()) |
| return ByteString(); |
| |
| ByteString sColorAP = GenerateColorAP( |
| CFX_Color(CFX_Color::Type::kRGB, 0, 0, 0), PaintOperation::kFill); |
| |
| return ByteString{"BT\n", sColorAP.AsStringView(), sContent.AsStringView(), |
| "ET\n", "Q\n"}; |
| } |
| |
| RetainPtr<CPDF_Dictionary> GenerateFallbackFontDict(CPDF_Document* doc) { |
| auto font_dict = doc->NewIndirect<CPDF_Dictionary>(); |
| font_dict->SetNewFor<CPDF_Name>("Type", "Font"); |
| font_dict->SetNewFor<CPDF_Name>("Subtype", "Type1"); |
| font_dict->SetNewFor<CPDF_Name>("BaseFont", CFX_Font::kDefaultAnsiFontName); |
| font_dict->SetNewFor<CPDF_Name>("Encoding", |
| pdfium::font_encodings::kWinAnsiEncoding); |
| return font_dict; |
| } |
| |
| RetainPtr<CPDF_Dictionary> GenerateResourceFontDict( |
| CPDF_Document* doc, |
| const ByteString& font_name, |
| uint32_t font_dict_obj_num) { |
| auto resource_font_dict = doc->New<CPDF_Dictionary>(); |
| resource_font_dict->SetNewFor<CPDF_Reference>(font_name, doc, |
| font_dict_obj_num); |
| return resource_font_dict; |
| } |
| |
| ByteString GetPaintOperatorString(bool bIsStrokeRect, bool bIsFillRect) { |
| if (bIsStrokeRect) |
| return bIsFillRect ? "b" : "s"; |
| return bIsFillRect ? "f" : "n"; |
| } |
| |
| ByteString GenerateTextSymbolAP(const CFX_FloatRect& rect) { |
| fxcrt::ostringstream sAppStream; |
| sAppStream << GenerateColorAP(CFX_Color(CFX_Color::Type::kRGB, 1, 1, 0), |
| PaintOperation::kFill); |
| sAppStream << GenerateColorAP(CFX_Color(CFX_Color::Type::kRGB, 0, 0, 0), |
| PaintOperation::kStroke); |
| |
| constexpr int kBorderWidth = 1; |
| sAppStream << kBorderWidth << " w\n"; |
| |
| constexpr float kHalfWidth = kBorderWidth / 2.0f; |
| constexpr int kTipDelta = 4; |
| |
| CFX_FloatRect outerRect1 = rect; |
| outerRect1.Deflate(kHalfWidth, kHalfWidth); |
| outerRect1.bottom += kTipDelta; |
| |
| CFX_FloatRect outerRect2 = outerRect1; |
| outerRect2.left += kTipDelta; |
| outerRect2.right = outerRect2.left + kTipDelta; |
| outerRect2.top = outerRect2.bottom - kTipDelta; |
| float outerRect2Middle = (outerRect2.left + outerRect2.right) / 2; |
| |
| // Draw outer boxes. |
| WritePoint(sAppStream, {outerRect1.left, outerRect1.bottom}) << " m\n"; |
| WritePoint(sAppStream, {outerRect1.left, outerRect1.top}) << " l\n"; |
| WritePoint(sAppStream, {outerRect1.right, outerRect1.top}) << " l\n"; |
| WritePoint(sAppStream, {outerRect1.right, outerRect1.bottom}) << " l\n"; |
| WritePoint(sAppStream, {outerRect2.right, outerRect2.bottom}) << " l\n"; |
| WritePoint(sAppStream, {outerRect2Middle, outerRect2.top}) << " l\n"; |
| WritePoint(sAppStream, {outerRect2.left, outerRect2.bottom}) << " l\n"; |
| WritePoint(sAppStream, {outerRect1.left, outerRect1.bottom}) << " l\n"; |
| |
| // Draw inner lines. |
| CFX_FloatRect lineRect = outerRect1; |
| const float fXDelta = 2; |
| const float fYDelta = (lineRect.top - lineRect.bottom) / 4; |
| |
| lineRect.left += fXDelta; |
| lineRect.right -= fXDelta; |
| for (int i = 0; i < 3; ++i) { |
| lineRect.top -= fYDelta; |
| WritePoint(sAppStream, {lineRect.left, lineRect.top}) << " m\n"; |
| WritePoint(sAppStream, {lineRect.right, lineRect.top}) << " l\n"; |
| } |
| sAppStream << "B*\n"; |
| |
| return ByteString(sAppStream); |
| } |
| |
| RetainPtr<CPDF_Dictionary> GenerateExtGStateDict( |
| const CPDF_Dictionary& pAnnotDict, |
| const ByteString& sExtGSDictName, |
| const ByteString& sBlendMode) { |
| auto pGSDict = |
| pdfium::MakeRetain<CPDF_Dictionary>(pAnnotDict.GetByteStringPool()); |
| pGSDict->SetNewFor<CPDF_Name>("Type", "ExtGState"); |
| |
| float fOpacity = pAnnotDict.KeyExist("CA") ? pAnnotDict.GetFloatFor("CA") : 1; |
| pGSDict->SetNewFor<CPDF_Number>("CA", fOpacity); |
| pGSDict->SetNewFor<CPDF_Number>("ca", fOpacity); |
| pGSDict->SetNewFor<CPDF_Boolean>("AIS", false); |
| pGSDict->SetNewFor<CPDF_Name>("BM", sBlendMode); |
| |
| auto pExtGStateDict = |
| pdfium::MakeRetain<CPDF_Dictionary>(pAnnotDict.GetByteStringPool()); |
| pExtGStateDict->SetFor(sExtGSDictName, pGSDict); |
| return pExtGStateDict; |
| } |
| |
| RetainPtr<CPDF_Dictionary> GenerateResourceDict( |
| CPDF_Document* pDoc, |
| RetainPtr<CPDF_Dictionary> pExtGStateDict, |
| RetainPtr<CPDF_Dictionary> pResourceFontDict) { |
| auto pResourceDict = pDoc->New<CPDF_Dictionary>(); |
| if (pExtGStateDict) |
| pResourceDict->SetFor("ExtGState", pExtGStateDict); |
| if (pResourceFontDict) |
| pResourceDict->SetFor("Font", pResourceFontDict); |
| return pResourceDict; |
| } |
| |
| void GenerateAndSetAPDict(CPDF_Document* doc, |
| CPDF_Dictionary* annot_dict, |
| fxcrt::ostringstream* app_stream, |
| RetainPtr<CPDF_Dictionary> resource_dict, |
| bool is_text_markup_annotation) { |
| auto stream_dict = pdfium::MakeRetain<CPDF_Dictionary>(); |
| stream_dict->SetNewFor<CPDF_Number>("FormType", 1); |
| stream_dict->SetNewFor<CPDF_Name>("Type", "XObject"); |
| stream_dict->SetNewFor<CPDF_Name>("Subtype", "Form"); |
| stream_dict->SetMatrixFor("Matrix", CFX_Matrix()); |
| |
| CFX_FloatRect rect = is_text_markup_annotation |
| ? CPDF_Annot::BoundingRectFromQuadPoints(annot_dict) |
| : annot_dict->GetRectFor(pdfium::annotation::kRect); |
| stream_dict->SetRectFor("BBox", rect); |
| stream_dict->SetFor("Resources", std::move(resource_dict)); |
| |
| auto normal_stream = doc->NewIndirect<CPDF_Stream>(std::move(stream_dict)); |
| normal_stream->SetDataFromStringstream(app_stream); |
| |
| RetainPtr<CPDF_Dictionary> ap_dict = |
| annot_dict->GetOrCreateDictFor(pdfium::annotation::kAP); |
| ap_dict->SetNewFor<CPDF_Reference>("N", doc, normal_stream->GetObjNum()); |
| } |
| |
| bool GenerateCircleAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict) { |
| fxcrt::ostringstream sAppStream; |
| ByteString sExtGSDictName = "GS"; |
| sAppStream << "/" << sExtGSDictName << " gs "; |
| |
| RetainPtr<const CPDF_Array> pInteriorColor = pAnnotDict->GetArrayFor("IC"); |
| sAppStream << GetColorStringWithDefault( |
| pInteriorColor.Get(), CFX_Color(CFX_Color::Type::kTransparent), |
| PaintOperation::kFill); |
| |
| sAppStream << GetColorStringWithDefault( |
| pAnnotDict->GetArrayFor(pdfium::annotation::kC).Get(), |
| CFX_Color(CFX_Color::Type::kRGB, 0, 0, 0), PaintOperation::kStroke); |
| |
| float fBorderWidth = GetBorderWidth(pAnnotDict); |
| bool bIsStrokeRect = fBorderWidth > 0; |
| |
| if (bIsStrokeRect) { |
| sAppStream << fBorderWidth << " w "; |
| sAppStream << GetDashPatternString(pAnnotDict); |
| } |
| |
| CFX_FloatRect rect = pAnnotDict->GetRectFor(pdfium::annotation::kRect); |
| rect.Normalize(); |
| |
| if (bIsStrokeRect) { |
| // Deflating rect because stroking a path entails painting all points |
| // whose perpendicular distance from the path in user space is less than |
| // or equal to half the line width. |
| rect.Deflate(fBorderWidth / 2, fBorderWidth / 2); |
| } |
| |
| const float fMiddleX = (rect.left + rect.right) / 2; |
| const float fMiddleY = (rect.top + rect.bottom) / 2; |
| |
| // |fL| is precalculated approximate value of 4 * tan((3.14 / 2) / 4) / 3, |
| // where |fL| * radius is a good approximation of control points for |
| // arc with 90 degrees. |
| const float fL = 0.5523f; |
| const float fDeltaX = fL * rect.Width() / 2.0; |
| const float fDeltaY = fL * rect.Height() / 2.0; |
| |
| // Starting point |
| sAppStream << fMiddleX << " " << rect.top << " m\n"; |
| // First Bezier Curve |
| sAppStream << fMiddleX + fDeltaX << " " << rect.top << " " << rect.right |
| << " " << fMiddleY + fDeltaY << " " << rect.right << " " |
| << fMiddleY << " c\n"; |
| // Second Bezier Curve |
| sAppStream << rect.right << " " << fMiddleY - fDeltaY << " " |
| << fMiddleX + fDeltaX << " " << rect.bottom << " " << fMiddleX |
| << " " << rect.bottom << " c\n"; |
| // Third Bezier Curve |
| sAppStream << fMiddleX - fDeltaX << " " << rect.bottom << " " << rect.left |
| << " " << fMiddleY - fDeltaY << " " << rect.left << " " << fMiddleY |
| << " c\n"; |
| // Fourth Bezier Curve |
| sAppStream << rect.left << " " << fMiddleY + fDeltaY << " " |
| << fMiddleX - fDeltaX << " " << rect.top << " " << fMiddleX << " " |
| << rect.top << " c\n"; |
| |
| bool bIsFillRect = pInteriorColor && !pInteriorColor->IsEmpty(); |
| sAppStream << GetPaintOperatorString(bIsStrokeRect, bIsFillRect) << "\n"; |
| |
| auto pExtGStateDict = |
| GenerateExtGStateDict(*pAnnotDict, sExtGSDictName, "Normal"); |
| auto pResourceDict = |
| GenerateResourceDict(pDoc, std::move(pExtGStateDict), nullptr); |
| GenerateAndSetAPDict(pDoc, pAnnotDict, &sAppStream, std::move(pResourceDict), |
| false /*IsTextMarkupAnnotation*/); |
| return true; |
| } |
| |
| bool GenerateHighlightAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict) { |
| fxcrt::ostringstream sAppStream; |
| ByteString sExtGSDictName = "GS"; |
| sAppStream << "/" << sExtGSDictName << " gs "; |
| |
| sAppStream << GetColorStringWithDefault( |
| pAnnotDict->GetArrayFor(pdfium::annotation::kC).Get(), |
| CFX_Color(CFX_Color::Type::kRGB, 1, 1, 0), PaintOperation::kFill); |
| |
| RetainPtr<const CPDF_Array> pArray = pAnnotDict->GetArrayFor("QuadPoints"); |
| if (pArray) { |
| size_t nQuadPointCount = CPDF_Annot::QuadPointCount(pArray.Get()); |
| for (size_t i = 0; i < nQuadPointCount; ++i) { |
| CFX_FloatRect rect = CPDF_Annot::RectFromQuadPoints(pAnnotDict, i); |
| rect.Normalize(); |
| |
| sAppStream << rect.left << " " << rect.top << " m " << rect.right << " " |
| << rect.top << " l " << rect.right << " " << rect.bottom |
| << " l " << rect.left << " " << rect.bottom << " l h f\n"; |
| } |
| } |
| |
| auto pExtGStateDict = |
| GenerateExtGStateDict(*pAnnotDict, sExtGSDictName, "Multiply"); |
| auto pResourceDict = |
| GenerateResourceDict(pDoc, std::move(pExtGStateDict), nullptr); |
| GenerateAndSetAPDict(pDoc, pAnnotDict, &sAppStream, std::move(pResourceDict), |
| true /*IsTextMarkupAnnotation*/); |
| |
| return true; |
| } |
| |
| bool GenerateInkAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict) { |
| RetainPtr<const CPDF_Array> pInkList = pAnnotDict->GetArrayFor("InkList"); |
| if (!pInkList || pInkList->IsEmpty()) |
| return false; |
| |
| float fBorderWidth = GetBorderWidth(pAnnotDict); |
| const bool bIsStroke = fBorderWidth > 0; |
| if (!bIsStroke) |
| return false; |
| |
| ByteString sExtGSDictName = "GS"; |
| fxcrt::ostringstream sAppStream; |
| sAppStream << "/" << sExtGSDictName << " gs "; |
| sAppStream << GetColorStringWithDefault( |
| pAnnotDict->GetArrayFor(pdfium::annotation::kC).Get(), |
| CFX_Color(CFX_Color::Type::kRGB, 0, 0, 0), PaintOperation::kStroke); |
| |
| sAppStream << fBorderWidth << " w "; |
| sAppStream << GetDashPatternString(pAnnotDict); |
| |
| // Set inflated rect as a new rect because paths near the border with large |
| // width should not be clipped to the original rect. |
| CFX_FloatRect rect = pAnnotDict->GetRectFor(pdfium::annotation::kRect); |
| rect.Inflate(fBorderWidth / 2, fBorderWidth / 2); |
| pAnnotDict->SetRectFor(pdfium::annotation::kRect, rect); |
| |
| for (size_t i = 0; i < pInkList->size(); i++) { |
| RetainPtr<const CPDF_Array> pInkCoordList = pInkList->GetArrayAt(i); |
| if (!pInkCoordList || pInkCoordList->size() < 2) |
| continue; |
| |
| sAppStream << pInkCoordList->GetFloatAt(0) << " " |
| << pInkCoordList->GetFloatAt(1) << " m "; |
| |
| for (size_t j = 0; j < pInkCoordList->size() - 1; j += 2) { |
| sAppStream << pInkCoordList->GetFloatAt(j) << " " |
| << pInkCoordList->GetFloatAt(j + 1) << " l "; |
| } |
| |
| sAppStream << "S\n"; |
| } |
| |
| auto pExtGStateDict = |
| GenerateExtGStateDict(*pAnnotDict, sExtGSDictName, "Normal"); |
| auto pResourceDict = |
| GenerateResourceDict(pDoc, std::move(pExtGStateDict), nullptr); |
| GenerateAndSetAPDict(pDoc, pAnnotDict, &sAppStream, std::move(pResourceDict), |
| false /*IsTextMarkupAnnotation*/); |
| return true; |
| } |
| |
| bool GenerateTextAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict) { |
| fxcrt::ostringstream sAppStream; |
| ByteString sExtGSDictName = "GS"; |
| sAppStream << "/" << sExtGSDictName << " gs "; |
| |
| CFX_FloatRect rect = pAnnotDict->GetRectFor(pdfium::annotation::kRect); |
| const float fNoteLength = 20; |
| CFX_FloatRect noteRect(rect.left, rect.bottom, rect.left + fNoteLength, |
| rect.bottom + fNoteLength); |
| pAnnotDict->SetRectFor(pdfium::annotation::kRect, noteRect); |
| |
| sAppStream << GenerateTextSymbolAP(noteRect); |
| |
| auto pExtGStateDict = |
| GenerateExtGStateDict(*pAnnotDict, sExtGSDictName, "Normal"); |
| auto pResourceDict = |
| GenerateResourceDict(pDoc, std::move(pExtGStateDict), nullptr); |
| GenerateAndSetAPDict(pDoc, pAnnotDict, &sAppStream, std::move(pResourceDict), |
| false /*IsTextMarkupAnnotation*/); |
| return true; |
| } |
| |
| bool GenerateUnderlineAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict) { |
| fxcrt::ostringstream sAppStream; |
| ByteString sExtGSDictName = "GS"; |
| sAppStream << "/" << sExtGSDictName << " gs "; |
| |
| sAppStream << GetColorStringWithDefault( |
| pAnnotDict->GetArrayFor(pdfium::annotation::kC).Get(), |
| CFX_Color(CFX_Color::Type::kRGB, 0, 0, 0), PaintOperation::kStroke); |
| |
| RetainPtr<const CPDF_Array> pArray = pAnnotDict->GetArrayFor("QuadPoints"); |
| if (pArray) { |
| static constexpr int kLineWidth = 1; |
| sAppStream << kLineWidth << " w "; |
| size_t nQuadPointCount = CPDF_Annot::QuadPointCount(pArray.Get()); |
| for (size_t i = 0; i < nQuadPointCount; ++i) { |
| CFX_FloatRect rect = CPDF_Annot::RectFromQuadPoints(pAnnotDict, i); |
| rect.Normalize(); |
| sAppStream << rect.left << " " << rect.bottom + kLineWidth << " m " |
| << rect.right << " " << rect.bottom + kLineWidth << " l S\n"; |
| } |
| } |
| |
| auto pExtGStateDict = |
| GenerateExtGStateDict(*pAnnotDict, sExtGSDictName, "Normal"); |
| auto pResourceDict = |
| GenerateResourceDict(pDoc, std::move(pExtGStateDict), nullptr); |
| GenerateAndSetAPDict(pDoc, pAnnotDict, &sAppStream, std::move(pResourceDict), |
| true /*IsTextMarkupAnnotation*/); |
| return true; |
| } |
| |
| bool GeneratePopupAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict) { |
| fxcrt::ostringstream sAppStream; |
| ByteString sExtGSDictName = "GS"; |
| sAppStream << "/" << sExtGSDictName << " gs\n"; |
| |
| sAppStream << GenerateColorAP(CFX_Color(CFX_Color::Type::kRGB, 1, 1, 0), |
| PaintOperation::kFill); |
| sAppStream << GenerateColorAP(CFX_Color(CFX_Color::Type::kRGB, 0, 0, 0), |
| PaintOperation::kStroke); |
| |
| const float fBorderWidth = 1; |
| sAppStream << fBorderWidth << " w\n"; |
| |
| CFX_FloatRect rect = pAnnotDict->GetRectFor(pdfium::annotation::kRect); |
| rect.Normalize(); |
| rect.Deflate(fBorderWidth / 2, fBorderWidth / 2); |
| |
| sAppStream << rect.left << " " << rect.bottom << " " << rect.Width() << " " |
| << rect.Height() << " re b\n"; |
| |
| RetainPtr<CPDF_Dictionary> font_dict = GenerateFallbackFontDict(pDoc); |
| auto* pData = CPDF_DocPageData::FromDocument(pDoc); |
| RetainPtr<CPDF_Font> pDefFont = pData->GetFont(font_dict); |
| if (!pDefFont) |
| return false; |
| |
| const ByteString font_name = "FONT"; |
| RetainPtr<CPDF_Dictionary> resource_font_dict = |
| GenerateResourceFontDict(pDoc, font_name, font_dict->GetObjNum()); |
| RetainPtr<CPDF_Dictionary> pExtGStateDict = |
| GenerateExtGStateDict(*pAnnotDict, sExtGSDictName, "Normal"); |
| RetainPtr<CPDF_Dictionary> pResourceDict = GenerateResourceDict( |
| pDoc, std::move(pExtGStateDict), std::move(resource_font_dict)); |
| |
| sAppStream << GetPopupContentsString(pDoc, *pAnnotDict, std::move(pDefFont), |
| font_name); |
| GenerateAndSetAPDict(pDoc, pAnnotDict, &sAppStream, std::move(pResourceDict), |
| false /*IsTextMarkupAnnotation*/); |
| return true; |
| } |
| |
| bool GenerateSquareAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict) { |
| const ByteString sExtGSDictName = "GS"; |
| fxcrt::ostringstream sAppStream; |
| sAppStream << "/" << sExtGSDictName << " gs "; |
| |
| RetainPtr<const CPDF_Array> pInteriorColor = pAnnotDict->GetArrayFor("IC"); |
| sAppStream << GetColorStringWithDefault( |
| pInteriorColor.Get(), CFX_Color(CFX_Color::Type::kTransparent), |
| PaintOperation::kFill); |
| |
| sAppStream << GetColorStringWithDefault( |
| pAnnotDict->GetArrayFor(pdfium::annotation::kC).Get(), |
| CFX_Color(CFX_Color::Type::kRGB, 0, 0, 0), PaintOperation::kStroke); |
| |
| float fBorderWidth = GetBorderWidth(pAnnotDict); |
| const bool bIsStrokeRect = fBorderWidth > 0; |
| if (bIsStrokeRect) { |
| sAppStream << fBorderWidth << " w "; |
| sAppStream << GetDashPatternString(pAnnotDict); |
| } |
| |
| CFX_FloatRect rect = pAnnotDict->GetRectFor(pdfium::annotation::kRect); |
| rect.Normalize(); |
| |
| if (bIsStrokeRect) { |
| // Deflating rect because stroking a path entails painting all points |
| // whose perpendicular distance from the path in user space is less than |
| // or equal to half the line width. |
| rect.Deflate(fBorderWidth / 2, fBorderWidth / 2); |
| } |
| |
| const bool bIsFillRect = pInteriorColor && (pInteriorColor->size() > 0); |
| sAppStream << rect.left << " " << rect.bottom << " " << rect.Width() << " " |
| << rect.Height() << " re " |
| << GetPaintOperatorString(bIsStrokeRect, bIsFillRect) << "\n"; |
| |
| auto pExtGStateDict = |
| GenerateExtGStateDict(*pAnnotDict, sExtGSDictName, "Normal"); |
| auto pResourceDict = |
| GenerateResourceDict(pDoc, std::move(pExtGStateDict), nullptr); |
| GenerateAndSetAPDict(pDoc, pAnnotDict, &sAppStream, std::move(pResourceDict), |
| false /*IsTextMarkupAnnotation*/); |
| return true; |
| } |
| |
| bool GenerateSquigglyAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict) { |
| fxcrt::ostringstream sAppStream; |
| ByteString sExtGSDictName = "GS"; |
| sAppStream << "/" << sExtGSDictName << " gs "; |
| |
| sAppStream << GetColorStringWithDefault( |
| pAnnotDict->GetArrayFor(pdfium::annotation::kC).Get(), |
| CFX_Color(CFX_Color::Type::kRGB, 0, 0, 0), PaintOperation::kStroke); |
| |
| RetainPtr<const CPDF_Array> pArray = pAnnotDict->GetArrayFor("QuadPoints"); |
| if (pArray) { |
| static constexpr int kLineWidth = 1; |
| static constexpr int kDelta = 2; |
| sAppStream << kLineWidth << " w "; |
| size_t nQuadPointCount = CPDF_Annot::QuadPointCount(pArray.Get()); |
| for (size_t i = 0; i < nQuadPointCount; ++i) { |
| CFX_FloatRect rect = CPDF_Annot::RectFromQuadPoints(pAnnotDict, i); |
| rect.Normalize(); |
| |
| const float fTop = rect.bottom + kDelta; |
| const float fBottom = rect.bottom; |
| sAppStream << rect.left << " " << fTop << " m "; |
| |
| float fX = rect.left + kDelta; |
| bool isUpwards = false; |
| while (fX < rect.right) { |
| sAppStream << fX << " " << (isUpwards ? fTop : fBottom) << " l "; |
| fX += kDelta; |
| isUpwards = !isUpwards; |
| } |
| |
| float fRemainder = rect.right - (fX - kDelta); |
| if (isUpwards) |
| sAppStream << rect.right << " " << fBottom + fRemainder << " l "; |
| else |
| sAppStream << rect.right << " " << fTop - fRemainder << " l "; |
| |
| sAppStream << "S\n"; |
| } |
| } |
| |
| auto pExtGStateDict = |
| GenerateExtGStateDict(*pAnnotDict, sExtGSDictName, "Normal"); |
| auto pResourceDict = |
| GenerateResourceDict(pDoc, std::move(pExtGStateDict), nullptr); |
| GenerateAndSetAPDict(pDoc, pAnnotDict, &sAppStream, std::move(pResourceDict), |
| true /*IsTextMarkupAnnotation*/); |
| return true; |
| } |
| |
| bool GenerateStrikeOutAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict) { |
| fxcrt::ostringstream sAppStream; |
| ByteString sExtGSDictName = "GS"; |
| sAppStream << "/" << sExtGSDictName << " gs "; |
| |
| sAppStream << GetColorStringWithDefault( |
| pAnnotDict->GetArrayFor(pdfium::annotation::kC).Get(), |
| CFX_Color(CFX_Color::Type::kRGB, 0, 0, 0), PaintOperation::kStroke); |
| |
| RetainPtr<const CPDF_Array> pArray = pAnnotDict->GetArrayFor("QuadPoints"); |
| if (pArray) { |
| size_t nQuadPointCount = CPDF_Annot::QuadPointCount(pArray.Get()); |
| for (size_t i = 0; i < nQuadPointCount; ++i) { |
| CFX_FloatRect rect = CPDF_Annot::RectFromQuadPoints(pAnnotDict, i); |
| rect.Normalize(); |
| |
| float fY = (rect.top + rect.bottom) / 2; |
| constexpr int kLineWidth = 1; |
| sAppStream << kLineWidth << " w " << rect.left << " " << fY << " m " |
| << rect.right << " " << fY << " l S\n"; |
| } |
| } |
| |
| auto pExtGStateDict = |
| GenerateExtGStateDict(*pAnnotDict, sExtGSDictName, "Normal"); |
| auto pResourceDict = |
| GenerateResourceDict(pDoc, std::move(pExtGStateDict), nullptr); |
| GenerateAndSetAPDict(pDoc, pAnnotDict, &sAppStream, std::move(pResourceDict), |
| true /*IsTextMarkupAnnotation*/); |
| return true; |
| } |
| |
| } // namespace |
| |
| // static |
| void CPDF_GenerateAP::GenerateFormAP(CPDF_Document* pDoc, |
| CPDF_Dictionary* pAnnotDict, |
| FormType type) { |
| RetainPtr<CPDF_Dictionary> pRootDict = pDoc->GetMutableRoot(); |
| if (!pRootDict) |
| return; |
| |
| RetainPtr<CPDF_Dictionary> pFormDict = |
| pRootDict->GetMutableDictFor("AcroForm"); |
| if (!pFormDict) |
| return; |
| |
| ByteString DA; |
| RetainPtr<const CPDF_Object> pDAObj = |
| CPDF_FormField::GetFieldAttrForDict(pAnnotDict, "DA"); |
| if (pDAObj) |
| DA = pDAObj->GetString(); |
| if (DA.IsEmpty()) |
| DA = pFormDict->GetByteStringFor("DA"); |
| if (DA.IsEmpty()) |
| return; |
| |
| CPDF_DefaultAppearance appearance(DA); |
| |
| float fFontSize = 0; |
| std::optional<ByteString> font = appearance.GetFont(&fFontSize); |
| if (!font.has_value()) |
| return; |
| |
| ByteString font_name = font.value(); |
| |
| CFX_Color crText = fpdfdoc::CFXColorFromString(DA); |
| RetainPtr<CPDF_Dictionary> pDRDict = pFormDict->GetMutableDictFor("DR"); |
| if (!pDRDict) |
| return; |
| |
| RetainPtr<CPDF_Dictionary> pDRFontDict = pDRDict->GetMutableDictFor("Font"); |
| if (!ValidateFontResourceDict(pDRFontDict.Get())) |
| return; |
| |
| RetainPtr<CPDF_Dictionary> pFontDict = |
| pDRFontDict->GetMutableDictFor(font_name); |
| if (!pFontDict) { |
| pFontDict = GenerateFallbackFontDict(pDoc); |
| pDRFontDict->SetNewFor<CPDF_Reference>(font_name, pDoc, |
| pFontDict->GetObjNum()); |
| } |
| auto* pData = CPDF_DocPageData::FromDocument(pDoc); |
| RetainPtr<CPDF_Font> pDefFont = pData->GetFont(pFontDict); |
| if (!pDefFont) |
| return; |
| |
| CFX_FloatRect rcAnnot = pAnnotDict->GetRectFor(pdfium::annotation::kRect); |
| RetainPtr<const CPDF_Dictionary> pMKDict = pAnnotDict->GetDictFor("MK"); |
| int32_t nRotate = |
| pMKDict ? pMKDict->GetIntegerFor(pdfium::appearance::kR) : 0; |
| |
| CFX_FloatRect rcBBox; |
| CFX_Matrix matrix; |
| switch (nRotate % 360) { |
| case 0: |
| rcBBox = CFX_FloatRect(0, 0, rcAnnot.right - rcAnnot.left, |
| rcAnnot.top - rcAnnot.bottom); |
| break; |
| case 90: |
| matrix = CFX_Matrix(0, 1, -1, 0, rcAnnot.right - rcAnnot.left, 0); |
| rcBBox = CFX_FloatRect(0, 0, rcAnnot.top - rcAnnot.bottom, |
| rcAnnot.right - rcAnnot.left); |
| break; |
| case 180: |
| matrix = CFX_Matrix(-1, 0, 0, -1, rcAnnot.right - rcAnnot.left, |
| rcAnnot.top - rcAnnot.bottom); |
| rcBBox = CFX_FloatRect(0, 0, rcAnnot.right - rcAnnot.left, |
| rcAnnot.top - rcAnnot.bottom); |
| break; |
| case 270: |
| matrix = CFX_Matrix(0, -1, 1, 0, 0, rcAnnot.top - rcAnnot.bottom); |
| rcBBox = CFX_FloatRect(0, 0, rcAnnot.top - rcAnnot.bottom, |
| rcAnnot.right - rcAnnot.left); |
| break; |
| } |
| |
| BorderStyle nBorderStyle = BorderStyle::kSolid; |
| float fBorderWidth = 1; |
| CPVT_Dash dsBorder(3, 0, 0); |
| CFX_Color crLeftTop; |
| CFX_Color crRightBottom; |
| if (RetainPtr<const CPDF_Dictionary> pBSDict = pAnnotDict->GetDictFor("BS")) { |
| if (pBSDict->KeyExist("W")) |
| fBorderWidth = pBSDict->GetFloatFor("W"); |
| |
| if (RetainPtr<const CPDF_Array> pArray = pBSDict->GetArrayFor("D")) { |
| dsBorder = CPVT_Dash(pArray->GetIntegerAt(0), pArray->GetIntegerAt(1), |
| pArray->GetIntegerAt(2)); |
| } |
| if (pBSDict->GetByteStringFor("S").GetLength()) { |
| switch (pBSDict->GetByteStringFor("S")[0]) { |
| case 'S': |
| nBorderStyle = BorderStyle::kSolid; |
| break; |
| case 'D': |
| nBorderStyle = BorderStyle::kDash; |
| break; |
| case 'B': |
| nBorderStyle = BorderStyle::kBeveled; |
| fBorderWidth *= 2; |
| crLeftTop = CFX_Color(CFX_Color::Type::kGray, 1); |
| crRightBottom = CFX_Color(CFX_Color::Type::kGray, 0.5); |
| break; |
| case 'I': |
| nBorderStyle = BorderStyle::kInset; |
| fBorderWidth *= 2; |
| crLeftTop = CFX_Color(CFX_Color::Type::kGray, 0.5); |
| crRightBottom = CFX_Color(CFX_Color::Type::kGray, 0.75); |
| break; |
| case 'U': |
| nBorderStyle = BorderStyle::kUnderline; |
| break; |
| } |
| } |
| } |
| CFX_Color crBorder; |
| CFX_Color crBG; |
| if (pMKDict) { |
| RetainPtr<const CPDF_Array> pArray = |
| pMKDict->GetArrayFor(pdfium::appearance::kBC); |
| if (pArray) |
| crBorder = fpdfdoc::CFXColorFromArray(*pArray); |
| pArray = pMKDict->GetArrayFor(pdfium::appearance::kBG); |
| if (pArray) |
| crBG = fpdfdoc::CFXColorFromArray(*pArray); |
| } |
| fxcrt::ostringstream sAppStream; |
| ByteString sBG = GenerateColorAP(crBG, PaintOperation::kFill); |
| if (sBG.GetLength() > 0) { |
| sAppStream << "q\n" << sBG; |
| WriteRect(sAppStream, rcBBox) << " re f\nQ\n"; |
| } |
| ByteString sBorderStream = |
| GenerateBorderAP(rcBBox, fBorderWidth, crBorder, crLeftTop, crRightBottom, |
| nBorderStyle, dsBorder); |
| if (sBorderStream.GetLength() > 0) |
| sAppStream << "q\n" << sBorderStream << "Q\n"; |
| |
| CFX_FloatRect rcBody = |
| CFX_FloatRect(rcBBox.left + fBorderWidth, rcBBox.bottom + fBorderWidth, |
| rcBBox.right - fBorderWidth, rcBBox.top - fBorderWidth); |
| rcBody.Normalize(); |
| |
| RetainPtr<CPDF_Dictionary> pAPDict = |
| pAnnotDict->GetOrCreateDictFor(pdfium::annotation::kAP); |
| RetainPtr<CPDF_Stream> pNormalStream = pAPDict->GetMutableStreamFor("N"); |
| RetainPtr<CPDF_Dictionary> pStreamDict; |
| if (pNormalStream) { |
| pStreamDict = pNormalStream->GetMutableDict(); |
| RetainPtr<CPDF_Dictionary> pStreamResList = |
| pStreamDict->GetMutableDictFor("Resources"); |
| if (pStreamResList) { |
| RetainPtr<CPDF_Dictionary> pStreamResFontList = |
| pStreamResList->GetMutableDictFor("Font"); |
| if (pStreamResFontList) { |
| if (!ValidateFontResourceDict(pStreamResFontList.Get())) |
| return; |
| } else { |
| pStreamResFontList = pStreamResList->SetNewFor<CPDF_Dictionary>("Font"); |
| } |
| if (!pStreamResFontList->KeyExist(font_name)) { |
| pStreamResFontList->SetNewFor<CPDF_Reference>(font_name, pDoc, |
| pFontDict->GetObjNum()); |
| } |
| } else { |
| pStreamDict->SetFor("Resources", pFormDict->GetDictFor("DR")->Clone()); |
| } |
| pStreamDict->SetMatrixFor("Matrix", matrix); |
| pStreamDict->SetRectFor("BBox", rcBBox); |
| } else { |
| pNormalStream = |
| pDoc->NewIndirect<CPDF_Stream>(pdfium::MakeRetain<CPDF_Dictionary>()); |
| pAPDict->SetNewFor<CPDF_Reference>("N", pDoc, pNormalStream->GetObjNum()); |
| } |
| CPVT_FontMap map( |
| pDoc, pStreamDict ? pStreamDict->GetMutableDictFor("Resources") : nullptr, |
| std::move(pDefFont), font_name); |
| CPVT_VariableText::Provider prd(&map); |
| |
| switch (type) { |
| case CPDF_GenerateAP::kTextField: { |
| RetainPtr<const CPDF_Object> pV = CPDF_FormField::GetFieldAttrForDict( |
| pAnnotDict, pdfium::form_fields::kV); |
| WideString swValue = pV ? pV->GetUnicodeText() : WideString(); |
| RetainPtr<const CPDF_Object> pQ = |
| CPDF_FormField::GetFieldAttrForDict(pAnnotDict, "Q"); |
| int32_t nAlign = pQ ? pQ->GetInteger() : 0; |
| RetainPtr<const CPDF_Object> pFf = CPDF_FormField::GetFieldAttrForDict( |
| pAnnotDict, pdfium::form_fields::kFf); |
| uint32_t dwFlags = pFf ? pFf->GetInteger() : 0; |
| RetainPtr<const CPDF_Object> pMaxLen = |
| CPDF_FormField::GetFieldAttrForDict(pAnnotDict, "MaxLen"); |
| uint32_t dwMaxLen = pMaxLen ? pMaxLen->GetInteger() : 0; |
| CPVT_VariableText vt(&prd); |
| vt.SetPlateRect(rcBody); |
| vt.SetAlignment(nAlign); |
| if (FXSYS_IsFloatZero(fFontSize)) |
| vt.SetAutoFontSize(true); |
| else |
| vt.SetFontSize(fFontSize); |
| |
| bool bMultiLine = (dwFlags >> 12) & 1; |
| if (bMultiLine) { |
| vt.SetMultiLine(true); |
| vt.SetAutoReturn(true); |
| } |
| uint16_t subWord = 0; |
| if ((dwFlags >> 13) & 1) { |
| subWord = '*'; |
| vt.SetPasswordChar(subWord); |
| } |
| bool bCharArray = (dwFlags >> 24) & 1; |
| if (bCharArray) |
| vt.SetCharArray(dwMaxLen); |
| else |
| vt.SetLimitChar(dwMaxLen); |
| |
| vt.Initialize(); |
| vt.SetText(swValue); |
| vt.RearrangeAll(); |
| CFX_FloatRect rcContent = vt.GetContentRect(); |
| CFX_PointF ptOffset; |
| if (!bMultiLine) { |
| ptOffset = |
| CFX_PointF(0.0f, (rcContent.Height() - rcBody.Height()) / 2.0f); |
| } |
| ByteString sBody = GenerateEditAP(&map, vt.GetIterator(), ptOffset, |
| !bCharArray, subWord); |
| if (sBody.GetLength() > 0) { |
| sAppStream << "/Tx BMC\n" |
| << "q\n"; |
| if (rcContent.Width() > rcBody.Width() || |
| rcContent.Height() > rcBody.Height()) { |
| WriteRect(sAppStream, rcBody) << " re\nW\nn\n"; |
| } |
| sAppStream << "BT\n" |
| << GenerateColorAP(crText, PaintOperation::kFill) << sBody |
| << "ET\n" |
| << "Q\nEMC\n"; |
| } |
| break; |
| } |
| case CPDF_GenerateAP::kComboBox: { |
| RetainPtr<const CPDF_Object> pV = CPDF_FormField::GetFieldAttrForDict( |
| pAnnotDict, pdfium::form_fields::kV); |
| WideString swValue = pV ? pV->GetUnicodeText() : WideString(); |
| CPVT_VariableText vt(&prd); |
| CFX_FloatRect rcButton = rcBody; |
| rcButton.left = rcButton.right - 13; |
| rcButton.Normalize(); |
| CFX_FloatRect rcEdit = rcBody; |
| rcEdit.right = rcButton.left; |
| rcEdit.Normalize(); |
| vt.SetPlateRect(rcEdit); |
| if (FXSYS_IsFloatZero(fFontSize)) |
| vt.SetAutoFontSize(true); |
| else |
| vt.SetFontSize(fFontSize); |
| |
| vt.Initialize(); |
| vt.SetText(swValue); |
| vt.RearrangeAll(); |
| CFX_FloatRect rcContent = vt.GetContentRect(); |
| CFX_PointF ptOffset = |
| CFX_PointF(0.0f, (rcContent.Height() - rcEdit.Height()) / 2.0f); |
| ByteString sEdit = |
| GenerateEditAP(&map, vt.GetIterator(), ptOffset, true, 0); |
| if (sEdit.GetLength() > 0) { |
| sAppStream << "/Tx BMC\nq\n"; |
| WriteRect(sAppStream, rcEdit) << " re\nW\nn\n"; |
| sAppStream << "BT\n" |
| << GenerateColorAP(crText, PaintOperation::kFill) << sEdit |
| << "ET\n" |
| << "Q\nEMC\n"; |
| } |
| ByteString sButton = |
| GenerateColorAP(CFX_Color(CFX_Color::Type::kRGB, 220.0f / 255.0f, |
| 220.0f / 255.0f, 220.0f / 255.0f), |
| PaintOperation::kFill); |
| if (sButton.GetLength() > 0 && !rcButton.IsEmpty()) { |
| sAppStream << "q\n" << sButton; |
| WriteRect(sAppStream, rcButton) << " re f\n"; |
| sAppStream << "Q\n"; |
| ByteString sButtonBorder = |
| GenerateBorderAP(rcButton, 2, CFX_Color(CFX_Color::Type::kGray, 0), |
| CFX_Color(CFX_Color::Type::kGray, 1), |
| CFX_Color(CFX_Color::Type::kGray, 0.5), |
| BorderStyle::kBeveled, CPVT_Dash(3, 0, 0)); |
| if (sButtonBorder.GetLength() > 0) |
| sAppStream << "q\n" << sButtonBorder << "Q\n"; |
| |
| CFX_PointF ptCenter = CFX_PointF((rcButton.left + rcButton.right) / 2, |
| (rcButton.top + rcButton.bottom) / 2); |
| if (FXSYS_IsFloatBigger(rcButton.Width(), 6) && |
| FXSYS_IsFloatBigger(rcButton.Height(), 6)) { |
| sAppStream << "q\n" |
| << " 0 g\n"; |
| WritePoint(sAppStream, {ptCenter.x - 3, ptCenter.y + 1.5f}) << " m\n"; |
| WritePoint(sAppStream, {ptCenter.x + 3, ptCenter.y + 1.5f}) << " l\n"; |
| WritePoint(sAppStream, {ptCenter.x, ptCenter.y - 1.5f}) << " l\n"; |
| WritePoint(sAppStream, {ptCenter.x - 3, ptCenter.y + 1.5f}) |
| << " l f\n"; |
| sAppStream << sButton << "Q\n"; |
| } |
| } |
| break; |
| } |
| case CPDF_GenerateAP::kListBox: { |
| RetainPtr<const CPDF_Array> pOpts = |
| ToArray(CPDF_FormField::GetFieldAttrForDict(pAnnotDict, "Opt")); |
| RetainPtr<const CPDF_Array> pSels = |
| ToArray(CPDF_FormField::GetFieldAttrForDict(pAnnotDict, "I")); |
| RetainPtr<const CPDF_Object> pTi = |
| CPDF_FormField::GetFieldAttrForDict(pAnnotDict, "TI"); |
| int32_t nTop = pTi ? pTi->GetInteger() : 0; |
| fxcrt::ostringstream sBody; |
| if (pOpts) { |
| float fy = rcBody.top; |
| for (size_t i = nTop, sz = pOpts->size(); i < sz; i++) { |
| if (FXSYS_IsFloatSmaller(fy, rcBody.bottom)) |
| break; |
| |
| if (RetainPtr<const CPDF_Object> pOpt = pOpts->GetDirectObjectAt(i)) { |
| WideString swItem; |
| if (pOpt->IsString()) { |
| swItem = pOpt->GetUnicodeText(); |
| } else if (const CPDF_Array* pArray = pOpt->AsArray()) { |
| RetainPtr<const CPDF_Object> pDirectObj = |
| pArray->GetDirectObjectAt(1); |
| if (pDirectObj) |
| swItem = pDirectObj->GetUnicodeText(); |
| } |
| bool bSelected = false; |
| if (pSels) { |
| for (size_t s = 0, ssz = pSels->size(); s < ssz; s++) { |
| int value = pSels->GetIntegerAt(s); |
| if (value >= 0 && i == static_cast<size_t>(value)) { |
| bSelected = true; |
| break; |
| } |
| } |
| } |
| CPVT_VariableText vt(&prd); |
| vt.SetPlateRect( |
| CFX_FloatRect(rcBody.left, 0.0f, rcBody.right, 0.0f)); |
| vt.SetFontSize(FXSYS_IsFloatZero(fFontSize) ? 12.0f : fFontSize); |
| vt.Initialize(); |
| vt.SetText(swItem); |
| vt.RearrangeAll(); |
| |
| float fItemHeight = vt.GetContentRect().Height(); |
| if (bSelected) { |
| CFX_FloatRect rcItem = CFX_FloatRect( |
| rcBody.left, fy - fItemHeight, rcBody.right, fy); |
| sBody << "q\n" |
| << GenerateColorAP( |
| CFX_Color(CFX_Color::Type::kRGB, 0, 51.0f / 255.0f, |
| 113.0f / 255.0f), |
| PaintOperation::kFill); |
| WriteRect(sBody, rcItem) << " re f\nQ\n"; |
| sBody << "BT\n" |
| << GenerateColorAP(CFX_Color(CFX_Color::Type::kGray, 1), |
| PaintOperation::kFill) |
| << GenerateEditAP(&map, vt.GetIterator(), |
| CFX_PointF(0.0f, fy), true, 0) |
| << "ET\n"; |
| } else { |
| sBody << "BT\n" |
| << GenerateColorAP(crText, PaintOperation::kFill) |
| << GenerateEditAP(&map, vt.GetIterator(), |
| CFX_PointF(0.0f, fy), true, 0) |
| << "ET\n"; |
| } |
| fy -= fItemHeight; |
| } |
| } |
| } |
| if (sBody.tellp() > 0) { |
| sAppStream << "/Tx BMC\nq\n"; |
| WriteRect(sAppStream, rcBody) << " re\nW\nn\n" |
| << sBody.str() << "Q\nEMC\n"; |
| } |
| break; |
| } |
| } |
| |
| if (!pNormalStream) |
| return; |
| |
| pNormalStream->SetDataFromStringstreamAndRemoveFilter(&sAppStream); |
| pStreamDict = pNormalStream->GetMutableDict(); |
| pStreamDict->SetMatrixFor("Matrix", matrix); |
| pStreamDict->SetRectFor("BBox", rcBBox); |
| RetainPtr<CPDF_Dictionary> pStreamResList = |
| pStreamDict->GetMutableDictFor("Resources"); |
| if (!pStreamResList) { |
| pStreamDict->SetFor("Resources", pFormDict->GetDictFor("DR")->Clone()); |
| return; |
| } |
| |
| RetainPtr<CPDF_Dictionary> pStreamResFontList = |
| pStreamResList->GetMutableDictFor("Font"); |
| if (pStreamResFontList) { |
| if (!ValidateFontResourceDict(pStreamResFontList.Get())) |
| return; |
| } else { |
| pStreamResFontList = pStreamResList->SetNewFor<CPDF_Dictionary>("Font"); |
| } |
| |
| if (!pStreamResFontList->KeyExist(font_name)) { |
| pStreamResFontList->SetNewFor<CPDF_Reference>(font_name, pDoc, |
| pFontDict->GetObjNum()); |
| } |
| } |
| |
| // static |
| void CPDF_GenerateAP::GenerateEmptyAP(CPDF_Document* pDoc, |
| CPDF_Dictionary* pAnnotDict) { |
| auto pExtGStateDict = GenerateExtGStateDict(*pAnnotDict, "GS", "Normal"); |
| auto pResourceDict = |
| GenerateResourceDict(pDoc, std::move(pExtGStateDict), nullptr); |
| |
| fxcrt::ostringstream sStream; |
| GenerateAndSetAPDict(pDoc, pAnnotDict, &sStream, std::move(pResourceDict), |
| false); |
| } |
| |
| // static |
| bool CPDF_GenerateAP::GenerateAnnotAP(CPDF_Document* pDoc, |
| CPDF_Dictionary* pAnnotDict, |
| CPDF_Annot::Subtype subtype) { |
| switch (subtype) { |
| case CPDF_Annot::Subtype::CIRCLE: |
| return GenerateCircleAP(pDoc, pAnnotDict); |
| case CPDF_Annot::Subtype::HIGHLIGHT: |
| return GenerateHighlightAP(pDoc, pAnnotDict); |
| case CPDF_Annot::Subtype::INK: |
| return GenerateInkAP(pDoc, pAnnotDict); |
| case CPDF_Annot::Subtype::POPUP: |
| return GeneratePopupAP(pDoc, pAnnotDict); |
| case CPDF_Annot::Subtype::SQUARE: |
| return GenerateSquareAP(pDoc, pAnnotDict); |
| case CPDF_Annot::Subtype::SQUIGGLY: |
| return GenerateSquigglyAP(pDoc, pAnnotDict); |
| case CPDF_Annot::Subtype::STRIKEOUT: |
| return GenerateStrikeOutAP(pDoc, pAnnotDict); |
| case CPDF_Annot::Subtype::TEXT: |
| return GenerateTextAP(pDoc, pAnnotDict); |
| case CPDF_Annot::Subtype::UNDERLINE: |
| return GenerateUnderlineAP(pDoc, pAnnotDict); |
| default: |
| return false; |
| } |
| } |
