| // Copyright 2016 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/fpdfdoc/cpdf_annot.h" |
| |
| #include <algorithm> |
| #include <utility> |
| |
| #include "constants/annotation_common.h" |
| #include "constants/annotation_flags.h" |
| #include "core/fpdfapi/page/cpdf_form.h" |
| #include "core/fpdfapi/page/cpdf_page.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/fpdf_parser_utility.h" |
| #include "core/fpdfapi/render/cpdf_pagerendercache.h" |
| #include "core/fpdfapi/render/cpdf_rendercontext.h" |
| #include "core/fpdfapi/render/cpdf_renderoptions.h" |
| #include "core/fpdfdoc/cpdf_generateap.h" |
| #include "core/fxge/cfx_fillrenderoptions.h" |
| #include "core/fxge/cfx_graphstatedata.h" |
| #include "core/fxge/cfx_path.h" |
| #include "core/fxge/cfx_renderdevice.h" |
| #include "third_party/base/check.h" |
| |
| namespace { |
| |
| const char kPDFiumKey_HasGeneratedAP[] = "PDFIUM_HasGeneratedAP"; |
| |
| bool IsTextMarkupAnnotation(CPDF_Annot::Subtype type) { |
| return type == CPDF_Annot::Subtype::HIGHLIGHT || |
| type == CPDF_Annot::Subtype::SQUIGGLY || |
| type == CPDF_Annot::Subtype::STRIKEOUT || |
| type == CPDF_Annot::Subtype::UNDERLINE; |
| } |
| |
| CPDF_Form* AnnotGetMatrix(const CPDF_Page* pPage, |
| CPDF_Annot* pAnnot, |
| CPDF_Annot::AppearanceMode mode, |
| const CFX_Matrix& mtUser2Device, |
| CFX_Matrix* matrix) { |
| CPDF_Form* pForm = pAnnot->GetAPForm(pPage, mode); |
| if (!pForm) |
| return nullptr; |
| |
| CFX_Matrix form_matrix = pForm->GetDict()->GetMatrixFor("Matrix"); |
| CFX_FloatRect form_bbox = |
| form_matrix.TransformRect(pForm->GetDict()->GetRectFor("BBox")); |
| matrix->MatchRect(pAnnot->GetRect(), form_bbox); |
| matrix->Concat(mtUser2Device); |
| return pForm; |
| } |
| |
| CPDF_Stream* GetAnnotAPInternal(CPDF_Dictionary* pAnnotDict, |
| CPDF_Annot::AppearanceMode eMode, |
| bool bFallbackToNormal) { |
| CPDF_Dictionary* pAP = pAnnotDict->GetDictFor(pdfium::annotation::kAP); |
| if (!pAP) |
| return nullptr; |
| |
| const char* ap_entry = "N"; |
| if (eMode == CPDF_Annot::Down) |
| ap_entry = "D"; |
| else if (eMode == CPDF_Annot::Rollover) |
| ap_entry = "R"; |
| if (bFallbackToNormal && !pAP->KeyExist(ap_entry)) |
| ap_entry = "N"; |
| |
| CPDF_Object* psub = pAP->GetDirectObjectFor(ap_entry); |
| if (!psub) |
| return nullptr; |
| if (CPDF_Stream* pStream = psub->AsStream()) |
| return pStream; |
| |
| CPDF_Dictionary* pDict = psub->AsDictionary(); |
| if (!pDict) |
| return nullptr; |
| |
| ByteString as = pAnnotDict->GetStringFor(pdfium::annotation::kAS); |
| if (as.IsEmpty()) { |
| ByteString value = pAnnotDict->GetStringFor("V"); |
| if (value.IsEmpty()) { |
| const CPDF_Dictionary* pParentDict = pAnnotDict->GetDictFor("Parent"); |
| value = pParentDict ? pParentDict->GetStringFor("V") : ByteString(); |
| } |
| as = (!value.IsEmpty() && pDict->KeyExist(value)) ? value : "Off"; |
| } |
| return pDict->GetStreamFor(as); |
| } |
| |
| } // namespace |
| |
| CPDF_Annot::CPDF_Annot(RetainPtr<CPDF_Dictionary> pDict, |
| CPDF_Document* pDocument) |
| : m_pAnnotDict(std::move(pDict)), m_pDocument(pDocument) { |
| Init(); |
| } |
| |
| CPDF_Annot::CPDF_Annot(CPDF_Dictionary* pDict, CPDF_Document* pDocument) |
| : m_pAnnotDict(pDict), m_pDocument(pDocument) { |
| Init(); |
| } |
| |
| CPDF_Annot::~CPDF_Annot() { |
| ClearCachedAP(); |
| } |
| |
| void CPDF_Annot::Init() { |
| m_nSubtype = StringToAnnotSubtype( |
| m_pAnnotDict->GetStringFor(pdfium::annotation::kSubtype)); |
| m_bIsTextMarkupAnnotation = IsTextMarkupAnnotation(m_nSubtype); |
| m_bHasGeneratedAP = |
| m_pAnnotDict->GetBooleanFor(kPDFiumKey_HasGeneratedAP, false); |
| GenerateAPIfNeeded(); |
| } |
| |
| void CPDF_Annot::GenerateAPIfNeeded() { |
| if (!ShouldGenerateAP()) |
| return; |
| if (!CPDF_GenerateAP::GenerateAnnotAP(m_pDocument.Get(), m_pAnnotDict.Get(), |
| m_nSubtype)) { |
| return; |
| } |
| |
| m_pAnnotDict->SetNewFor<CPDF_Boolean>(kPDFiumKey_HasGeneratedAP, true); |
| m_bHasGeneratedAP = true; |
| } |
| |
| bool CPDF_Annot::ShouldGenerateAP() const { |
| // If AP dictionary exists and defines an appearance for normal mode, we use |
| // the appearance defined in the existing AP dictionary. |
| const CPDF_Dictionary* pAP = |
| m_pAnnotDict->GetDictFor(pdfium::annotation::kAP); |
| if (pAP && pAP->GetDictFor("N")) |
| return false; |
| |
| return !IsHidden(); |
| } |
| |
| bool CPDF_Annot::ShouldDrawAnnotation() const { |
| if (IsHidden()) |
| return false; |
| return m_bOpenState || m_nSubtype != CPDF_Annot::Subtype::POPUP; |
| } |
| |
| void CPDF_Annot::ClearCachedAP() { |
| m_APMap.clear(); |
| } |
| |
| CPDF_Annot::Subtype CPDF_Annot::GetSubtype() const { |
| return m_nSubtype; |
| } |
| |
| CFX_FloatRect CPDF_Annot::RectForDrawing() const { |
| bool bShouldUseQuadPointsCoords = |
| m_bIsTextMarkupAnnotation && m_bHasGeneratedAP; |
| if (bShouldUseQuadPointsCoords) |
| return BoundingRectFromQuadPoints(m_pAnnotDict.Get()); |
| return m_pAnnotDict->GetRectFor(pdfium::annotation::kRect); |
| } |
| |
| CFX_FloatRect CPDF_Annot::GetRect() const { |
| CFX_FloatRect rect = RectForDrawing(); |
| rect.Normalize(); |
| return rect; |
| } |
| |
| uint32_t CPDF_Annot::GetFlags() const { |
| return m_pAnnotDict->GetIntegerFor(pdfium::annotation::kF); |
| } |
| |
| bool CPDF_Annot::IsHidden() const { |
| return !!(GetFlags() & pdfium::annotation_flags::kHidden); |
| } |
| |
| CPDF_Stream* GetAnnotAP(CPDF_Dictionary* pAnnotDict, |
| CPDF_Annot::AppearanceMode eMode) { |
| DCHECK(pAnnotDict); |
| return GetAnnotAPInternal(pAnnotDict, eMode, true); |
| } |
| |
| CPDF_Stream* GetAnnotAPNoFallback(CPDF_Dictionary* pAnnotDict, |
| CPDF_Annot::AppearanceMode eMode) { |
| DCHECK(pAnnotDict); |
| return GetAnnotAPInternal(pAnnotDict, eMode, false); |
| } |
| |
| CPDF_Form* CPDF_Annot::GetAPForm(const CPDF_Page* pPage, AppearanceMode mode) { |
| CPDF_Stream* pStream = GetAnnotAP(m_pAnnotDict.Get(), mode); |
| if (!pStream) |
| return nullptr; |
| |
| auto it = m_APMap.find(pStream); |
| if (it != m_APMap.end()) |
| return it->second.get(); |
| |
| auto pNewForm = std::make_unique<CPDF_Form>(m_pDocument.Get(), |
| pPage->GetResources(), pStream); |
| pNewForm->ParseContent(); |
| |
| CPDF_Form* pResult = pNewForm.get(); |
| m_APMap[pStream] = std::move(pNewForm); |
| return pResult; |
| } |
| |
| // static |
| CFX_FloatRect CPDF_Annot::RectFromQuadPointsArray(const CPDF_Array* pArray, |
| size_t nIndex) { |
| DCHECK(pArray); |
| DCHECK(nIndex < pArray->size() / 8); |
| |
| // QuadPoints are defined with 4 pairs of numbers |
| // ([ pair0, pair1, pair2, pair3 ]), where |
| // pair0 = top_left |
| // pair1 = top_right |
| // pair2 = bottom_left |
| // pair3 = bottom_right |
| // |
| // On the other hand, /Rect is defined as 2 pairs [pair0, pair1] where: |
| // pair0 = bottom_left |
| // pair1 = top_right. |
| |
| return CFX_FloatRect( |
| pArray->GetNumberAt(4 + nIndex * 8), pArray->GetNumberAt(5 + nIndex * 8), |
| pArray->GetNumberAt(2 + nIndex * 8), pArray->GetNumberAt(3 + nIndex * 8)); |
| } |
| |
| // static |
| CFX_FloatRect CPDF_Annot::BoundingRectFromQuadPoints( |
| const CPDF_Dictionary* pAnnotDict) { |
| CFX_FloatRect ret; |
| const CPDF_Array* pArray = pAnnotDict->GetArrayFor("QuadPoints"); |
| size_t nQuadPointCount = pArray ? QuadPointCount(pArray) : 0; |
| if (nQuadPointCount == 0) |
| return ret; |
| |
| ret = RectFromQuadPointsArray(pArray, 0); |
| for (size_t i = 1; i < nQuadPointCount; ++i) { |
| CFX_FloatRect rect = RectFromQuadPointsArray(pArray, i); |
| ret.Union(rect); |
| } |
| return ret; |
| } |
| |
| // static |
| CFX_FloatRect CPDF_Annot::RectFromQuadPoints(const CPDF_Dictionary* pAnnotDict, |
| size_t nIndex) { |
| const CPDF_Array* pArray = pAnnotDict->GetArrayFor("QuadPoints"); |
| size_t nQuadPointCount = pArray ? QuadPointCount(pArray) : 0; |
| if (nIndex >= nQuadPointCount) |
| return CFX_FloatRect(); |
| return RectFromQuadPointsArray(pArray, nIndex); |
| } |
| |
| // static |
| CPDF_Annot::Subtype CPDF_Annot::StringToAnnotSubtype( |
| const ByteString& sSubtype) { |
| if (sSubtype == "Text") |
| return CPDF_Annot::Subtype::TEXT; |
| if (sSubtype == "Link") |
| return CPDF_Annot::Subtype::LINK; |
| if (sSubtype == "FreeText") |
| return CPDF_Annot::Subtype::FREETEXT; |
| if (sSubtype == "Line") |
| return CPDF_Annot::Subtype::LINE; |
| if (sSubtype == "Square") |
| return CPDF_Annot::Subtype::SQUARE; |
| if (sSubtype == "Circle") |
| return CPDF_Annot::Subtype::CIRCLE; |
| if (sSubtype == "Polygon") |
| return CPDF_Annot::Subtype::POLYGON; |
| if (sSubtype == "PolyLine") |
| return CPDF_Annot::Subtype::POLYLINE; |
| if (sSubtype == "Highlight") |
| return CPDF_Annot::Subtype::HIGHLIGHT; |
| if (sSubtype == "Underline") |
| return CPDF_Annot::Subtype::UNDERLINE; |
| if (sSubtype == "Squiggly") |
| return CPDF_Annot::Subtype::SQUIGGLY; |
| if (sSubtype == "StrikeOut") |
| return CPDF_Annot::Subtype::STRIKEOUT; |
| if (sSubtype == "Stamp") |
| return CPDF_Annot::Subtype::STAMP; |
| if (sSubtype == "Caret") |
| return CPDF_Annot::Subtype::CARET; |
| if (sSubtype == "Ink") |
| return CPDF_Annot::Subtype::INK; |
| if (sSubtype == "Popup") |
| return CPDF_Annot::Subtype::POPUP; |
| if (sSubtype == "FileAttachment") |
| return CPDF_Annot::Subtype::FILEATTACHMENT; |
| if (sSubtype == "Sound") |
| return CPDF_Annot::Subtype::SOUND; |
| if (sSubtype == "Movie") |
| return CPDF_Annot::Subtype::MOVIE; |
| if (sSubtype == "Widget") |
| return CPDF_Annot::Subtype::WIDGET; |
| if (sSubtype == "Screen") |
| return CPDF_Annot::Subtype::SCREEN; |
| if (sSubtype == "PrinterMark") |
| return CPDF_Annot::Subtype::PRINTERMARK; |
| if (sSubtype == "TrapNet") |
| return CPDF_Annot::Subtype::TRAPNET; |
| if (sSubtype == "Watermark") |
| return CPDF_Annot::Subtype::WATERMARK; |
| if (sSubtype == "3D") |
| return CPDF_Annot::Subtype::THREED; |
| if (sSubtype == "RichMedia") |
| return CPDF_Annot::Subtype::RICHMEDIA; |
| if (sSubtype == "XFAWidget") |
| return CPDF_Annot::Subtype::XFAWIDGET; |
| if (sSubtype == "Redact") |
| return CPDF_Annot::Subtype::REDACT; |
| return CPDF_Annot::Subtype::UNKNOWN; |
| } |
| |
| // static |
| ByteString CPDF_Annot::AnnotSubtypeToString(CPDF_Annot::Subtype nSubtype) { |
| if (nSubtype == CPDF_Annot::Subtype::TEXT) |
| return "Text"; |
| if (nSubtype == CPDF_Annot::Subtype::LINK) |
| return "Link"; |
| if (nSubtype == CPDF_Annot::Subtype::FREETEXT) |
| return "FreeText"; |
| if (nSubtype == CPDF_Annot::Subtype::LINE) |
| return "Line"; |
| if (nSubtype == CPDF_Annot::Subtype::SQUARE) |
| return "Square"; |
| if (nSubtype == CPDF_Annot::Subtype::CIRCLE) |
| return "Circle"; |
| if (nSubtype == CPDF_Annot::Subtype::POLYGON) |
| return "Polygon"; |
| if (nSubtype == CPDF_Annot::Subtype::POLYLINE) |
| return "PolyLine"; |
| if (nSubtype == CPDF_Annot::Subtype::HIGHLIGHT) |
| return "Highlight"; |
| if (nSubtype == CPDF_Annot::Subtype::UNDERLINE) |
| return "Underline"; |
| if (nSubtype == CPDF_Annot::Subtype::SQUIGGLY) |
| return "Squiggly"; |
| if (nSubtype == CPDF_Annot::Subtype::STRIKEOUT) |
| return "StrikeOut"; |
| if (nSubtype == CPDF_Annot::Subtype::STAMP) |
| return "Stamp"; |
| if (nSubtype == CPDF_Annot::Subtype::CARET) |
| return "Caret"; |
| if (nSubtype == CPDF_Annot::Subtype::INK) |
| return "Ink"; |
| if (nSubtype == CPDF_Annot::Subtype::POPUP) |
| return "Popup"; |
| if (nSubtype == CPDF_Annot::Subtype::FILEATTACHMENT) |
| return "FileAttachment"; |
| if (nSubtype == CPDF_Annot::Subtype::SOUND) |
| return "Sound"; |
| if (nSubtype == CPDF_Annot::Subtype::MOVIE) |
| return "Movie"; |
| if (nSubtype == CPDF_Annot::Subtype::WIDGET) |
| return "Widget"; |
| if (nSubtype == CPDF_Annot::Subtype::SCREEN) |
| return "Screen"; |
| if (nSubtype == CPDF_Annot::Subtype::PRINTERMARK) |
| return "PrinterMark"; |
| if (nSubtype == CPDF_Annot::Subtype::TRAPNET) |
| return "TrapNet"; |
| if (nSubtype == CPDF_Annot::Subtype::WATERMARK) |
| return "Watermark"; |
| if (nSubtype == CPDF_Annot::Subtype::THREED) |
| return "3D"; |
| if (nSubtype == CPDF_Annot::Subtype::RICHMEDIA) |
| return "RichMedia"; |
| if (nSubtype == CPDF_Annot::Subtype::XFAWIDGET) |
| return "XFAWidget"; |
| if (nSubtype == CPDF_Annot::Subtype::REDACT) |
| return "Redact"; |
| return ByteString(); |
| } |
| |
| // static |
| size_t CPDF_Annot::QuadPointCount(const CPDF_Array* pArray) { |
| return pArray->size() / 8; |
| } |
| |
| bool CPDF_Annot::DrawAppearance(CPDF_Page* pPage, |
| CFX_RenderDevice* pDevice, |
| const CFX_Matrix& mtUser2Device, |
| AppearanceMode mode, |
| const CPDF_RenderOptions* pOptions) { |
| if (!ShouldDrawAnnotation()) |
| return false; |
| |
| // It might happen that by the time this annotation instance was created, |
| // it was flagged as "hidden" (e.g. /F 2), and hence CPDF_GenerateAP decided |
| // to not "generate" its AP. |
| // If for a reason the object is no longer hidden, but still does not have |
| // its "AP" generated, generate it now. |
| GenerateAPIfNeeded(); |
| |
| CFX_Matrix matrix; |
| CPDF_Form* pForm = AnnotGetMatrix(pPage, this, mode, mtUser2Device, &matrix); |
| if (!pForm) |
| return false; |
| |
| CPDF_RenderContext context( |
| pPage->GetDocument(), pPage->GetPageResources(), |
| static_cast<CPDF_PageRenderCache*>(pPage->GetRenderCache())); |
| context.AppendLayer(pForm, matrix); |
| context.Render(pDevice, pOptions, nullptr); |
| return true; |
| } |
| |
| bool CPDF_Annot::DrawInContext(const CPDF_Page* pPage, |
| CPDF_RenderContext* pContext, |
| const CFX_Matrix& mtUser2Device, |
| AppearanceMode mode) { |
| if (!ShouldDrawAnnotation()) |
| return false; |
| |
| // It might happen that by the time this annotation instance was created, |
| // it was flagged as "hidden" (e.g. /F 2), and hence CPDF_GenerateAP decided |
| // to not "generate" its AP. |
| // If for a reason the object is no longer hidden, but still does not have |
| // its "AP" generated, generate it now. |
| GenerateAPIfNeeded(); |
| |
| CFX_Matrix matrix; |
| CPDF_Form* pForm = AnnotGetMatrix(pPage, this, mode, mtUser2Device, &matrix); |
| if (!pForm) |
| return false; |
| |
| pContext->AppendLayer(pForm, matrix); |
| return true; |
| } |
| |
| void CPDF_Annot::DrawBorder(CFX_RenderDevice* pDevice, |
| const CFX_Matrix* pUser2Device, |
| const CPDF_RenderOptions* pOptions) { |
| if (GetSubtype() == CPDF_Annot::Subtype::POPUP) |
| return; |
| |
| uint32_t annot_flags = GetFlags(); |
| if (annot_flags & pdfium::annotation_flags::kHidden) |
| return; |
| |
| bool bPrinting = pDevice->GetDeviceType() == DeviceType::kPrinter; |
| if (bPrinting && (annot_flags & pdfium::annotation_flags::kPrint) == 0) { |
| return; |
| } |
| if (!bPrinting && (annot_flags & pdfium::annotation_flags::kNoView)) { |
| return; |
| } |
| CPDF_Dictionary* pBS = m_pAnnotDict->GetDictFor("BS"); |
| char style_char; |
| float width; |
| CPDF_Array* pDashArray = nullptr; |
| if (!pBS) { |
| CPDF_Array* pBorderArray = |
| m_pAnnotDict->GetArrayFor(pdfium::annotation::kBorder); |
| style_char = 'S'; |
| if (pBorderArray) { |
| width = pBorderArray->GetNumberAt(2); |
| if (pBorderArray->size() == 4) { |
| pDashArray = pBorderArray->GetArrayAt(3); |
| if (!pDashArray) { |
| return; |
| } |
| size_t nLen = pDashArray->size(); |
| size_t i = 0; |
| for (; i < nLen; ++i) { |
| CPDF_Object* pObj = pDashArray->GetDirectObjectAt(i); |
| if (pObj && pObj->GetInteger()) { |
| break; |
| } |
| } |
| if (i == nLen) { |
| return; |
| } |
| style_char = 'D'; |
| } |
| } else { |
| width = 1; |
| } |
| } else { |
| ByteString style = pBS->GetStringFor("S"); |
| pDashArray = pBS->GetArrayFor("D"); |
| style_char = style[0]; |
| width = pBS->GetNumberFor("W"); |
| } |
| if (width <= 0) { |
| return; |
| } |
| CPDF_Array* pColor = m_pAnnotDict->GetArrayFor(pdfium::annotation::kC); |
| uint32_t argb = 0xff000000; |
| if (pColor) { |
| int R = static_cast<int32_t>(pColor->GetNumberAt(0) * 255); |
| int G = static_cast<int32_t>(pColor->GetNumberAt(1) * 255); |
| int B = static_cast<int32_t>(pColor->GetNumberAt(2) * 255); |
| argb = ArgbEncode(0xff, R, G, B); |
| } |
| CFX_GraphStateData graph_state; |
| graph_state.m_LineWidth = width; |
| if (style_char == 'U') { |
| // TODO(https://crbug.com/237527): Handle the "Underline" border style |
| // instead of drawing the rectangle border. |
| return; |
| } |
| |
| if (style_char == 'D') { |
| if (pDashArray) { |
| graph_state.m_DashArray = |
| ReadArrayElementsToVector(pDashArray, pDashArray->size()); |
| if (graph_state.m_DashArray.size() % 2) |
| graph_state.m_DashArray.push_back(graph_state.m_DashArray.back()); |
| } else { |
| graph_state.m_DashArray = {3.0f, 3.0f}; |
| } |
| } |
| |
| CFX_FloatRect rect = GetRect(); |
| rect.Deflate(width / 2, width / 2); |
| CFX_Path path; |
| path.AppendFloatRect(rect); |
| |
| CFX_FillRenderOptions fill_options; |
| if (pOptions && pOptions->GetOptions().bNoPathSmooth) |
| fill_options.aliased_path = true; |
| |
| pDevice->DrawPath(&path, pUser2Device, &graph_state, argb, argb, |
| fill_options); |
| } |