Use /RECT or /QuadPoints for annotation coordinates, depending on /AP

core/fpdfdoc/cpdf_annot.cpp

 // 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/include/cpdf_annot.h"
 
 #include "core/fpdfapi/fpdf_page/include/cpdf_form.h"
 #include "core/fpdfapi/fpdf_page/include/cpdf_page.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_array.h"
 #include "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
 #include "core/fpdfapi/fpdf_render/include/cpdf_rendercontext.h"
 #include "core/fpdfapi/fpdf_render/include/cpdf_renderoptions.h"
 #include "core/fpdfdoc/cpvt_generateap.h"
 #include "core/fxcrt/include/fx_memory.h"
 #include "core/fxge/include/cfx_graphstatedata.h"
 #include "core/fxge/include/cfx_pathdata.h"
 #include "core/fxge/include/cfx_renderdevice.h"
 
 namespace {
 
+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;
+}
+
 bool ShouldGenerateAPForAnnotation(CPDF_Dictionary* pAnnotDict) {
   // If AP dictionary exists, we use the appearance defined in the
   // existing AP dictionary.
   if (pAnnotDict->KeyExist("AP"))
     return false;
 
   return !CPDF_Annot::IsAnnotationHidden(pAnnotDict);
 }
 
 }  // namespace
 
 CPDF_Annot::CPDF_Annot(CPDF_Dictionary* pDict,
                        CPDF_Document* pDocument,
                        bool bToOwnDict)
     : m_bOwnedAnnotDict(bToOwnDict),
       m_pAnnotDict(pDict),
       m_pDocument(pDocument),
       m_bOpenState(false),
+      m_bHasGeneratedAP(false),
       m_pPopupAnnot(nullptr) {
   m_nSubtype = StringToAnnotSubtype(m_pAnnotDict->GetStringBy("Subtype"));
+  m_bIsMarkupAnnotation = IsTextMarkupAnnotation(m_nSubtype);

[jaepark, 2016/09/07 17:30:09]

m_bIsTextMarkupAnnotation

[tonikitoo, 2016/09/08 04:10:35]

Done.

   GenerateAPIfNeeded();
 }
 
 CPDF_Annot::~CPDF_Annot() {
   if (m_bOwnedAnnotDict)
     m_pAnnotDict->Release();
   ClearCachedAP();
 }
 
 void CPDF_Annot::GenerateAPIfNeeded() {
   if (!ShouldGenerateAPForAnnotation(m_pAnnotDict))
     return;
 
+  bool result = false;
   if (m_nSubtype == CPDF_Annot::Subtype::CIRCLE)
-    CPVT_GenerateAP::GenerateCircleAP(m_pDocument, m_pAnnotDict);
+    result = CPVT_GenerateAP::GenerateCircleAP(m_pDocument, m_pAnnotDict);
   else if (m_nSubtype == CPDF_Annot::Subtype::HIGHLIGHT)
-    CPVT_GenerateAP::GenerateHighlightAP(m_pDocument, m_pAnnotDict);
+    result = CPVT_GenerateAP::GenerateHighlightAP(m_pDocument, m_pAnnotDict);
   else if (m_nSubtype == CPDF_Annot::Subtype::INK)
-    CPVT_GenerateAP::GenerateInkAP(m_pDocument, m_pAnnotDict);
+    result = CPVT_GenerateAP::GenerateInkAP(m_pDocument, m_pAnnotDict);
   else if (m_nSubtype == CPDF_Annot::Subtype::POPUP)
-    CPVT_GenerateAP::GeneratePopupAP(m_pDocument, m_pAnnotDict);
+    result = CPVT_GenerateAP::GeneratePopupAP(m_pDocument, m_pAnnotDict);
   else if (m_nSubtype == CPDF_Annot::Subtype::SQUARE)
-    CPVT_GenerateAP::GenerateSquareAP(m_pDocument, m_pAnnotDict);
+    result = CPVT_GenerateAP::GenerateSquareAP(m_pDocument, m_pAnnotDict);
   else if (m_nSubtype == CPDF_Annot::Subtype::SQUIGGLY)
-    CPVT_GenerateAP::GenerateSquigglyAP(m_pDocument, m_pAnnotDict);
+    result = CPVT_GenerateAP::GenerateSquigglyAP(m_pDocument, m_pAnnotDict);
   else if (m_nSubtype == CPDF_Annot::Subtype::STRIKEOUT)
-    CPVT_GenerateAP::GenerateStrikeOutAP(m_pDocument, m_pAnnotDict);
+    result = CPVT_GenerateAP::GenerateStrikeOutAP(m_pDocument, m_pAnnotDict);
   else if (m_nSubtype == CPDF_Annot::Subtype::TEXT)
-    CPVT_GenerateAP::GenerateTextAP(m_pDocument, m_pAnnotDict);
+    result = CPVT_GenerateAP::GenerateTextAP(m_pDocument, m_pAnnotDict);
   else if (m_nSubtype == CPDF_Annot::Subtype::UNDERLINE)
-    CPVT_GenerateAP::GenerateUnderlineAP(m_pDocument, m_pAnnotDict);
+    result = CPVT_GenerateAP::GenerateUnderlineAP(m_pDocument, m_pAnnotDict);
+  m_bHasGeneratedAP = result;
 }
 
 void CPDF_Annot::ClearCachedAP() {
   m_APMap.clear();
 }
 
 CPDF_Annot::Subtype CPDF_Annot::GetSubtype() const {
   return m_nSubtype;
 }
 
+CFX_FloatRect CPDF_Annot::RectForDrawing() const {
+  if (!m_pAnnotDict)
+    return CFX_FloatRect();
+
+  bool shouldUseQuadPointsCoords = m_bIsMarkupAnnotation && m_bHasGeneratedAP;

[jaepark, 2016/09/07 17:30:09]

To me, checking m_bHasGeneratedAP in RectForDrawing seems a little bit odd. Why
do we need to check if annot has generated AP? 

RectForDrawing should only check whether an annot is a text markup annotation.
If it is, use QuadPoints, if not, use Rect.

[tonikitoo, 2016/09/08 04:10:35]

Checking for m_bHasGeneratedAP is important here because it toggles using either
QuadPoints or Rect coords.

In other words, when /AP is generated (i.e. it is absent in the PDF source) is
exactly the case we want to use /QuadPoints.

[jaepark, 2016/09/08 17:49:27]

Acknowledged.

+  if (shouldUseQuadPointsCoords)
+    return RectFromQuads(m_pAnnotDict);
+
+  return m_pAnnotDict->GetRectBy("Rect");
+}
+
 CFX_FloatRect CPDF_Annot::GetRect() const {
   if (!m_pAnnotDict)
     return CFX_FloatRect();
 
-  CFX_FloatRect rect = m_pAnnotDict->GetRectBy("Rect");
+  CFX_FloatRect rect = RectForDrawing();
   rect.Normalize();
   return rect;
 }
 
 uint32_t CPDF_Annot::GetFlags() const {
   return m_pAnnotDict->GetIntegerBy("F");
 }
 
 CPDF_Stream* FPDFDOC_GetAnnotAP(CPDF_Dictionary* pAnnotDict,
                                 CPDF_Annot::AppearanceMode mode) {
@@ skipping 60 matching lines @@
   }
   CFX_FloatRect form_bbox = pForm->m_pFormDict->GetRectBy("BBox");
   CFX_Matrix form_matrix = pForm->m_pFormDict->GetMatrixBy("Matrix");
   form_matrix.TransformRect(form_bbox);
   matrix.MatchRect(pAnnot->GetRect(), form_bbox);
   matrix.Concat(*pUser2Device);
   return pForm;
 }
 
 // Static.
+CFX_FloatRect CPDF_Annot::RectFromQuads(CPDF_Dictionary* pAnnotDict) {

[jaepark, 2016/09/07 17:30:09]

RectFromQuadPoints

[tonikitoo, 2016/09/08 04:10:35]

Done.

+  CPDF_Array* pArray = pAnnotDict->GetArrayBy("QuadPoints");
+  if (!pArray)
+    return CFX_FloatRect();
+
+  // 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 define as 2 pairs [pair0, pair1] where:
+  // pair0 = bottom_left
+  // pair1 = top_right.
+  return CFX_FloatRect(pArray->GetNumberAt(4), pArray->GetNumberAt(5),
+                       pArray->GetNumberAt(2), pArray->GetNumberAt(3));
+}
+
+// Static.
 bool CPDF_Annot::IsAnnotationHidden(CPDF_Dictionary* pAnnotDict) {
   return !!(pAnnotDict->GetIntegerBy("F") & ANNOTFLAG_HIDDEN);
 }
 
 // Static.
 CPDF_Annot::Subtype CPDF_Annot::StringToAnnotSubtype(
     const CFX_ByteString& sSubtype) {
   if (sSubtype == "Text")
     return CPDF_Annot::Subtype::TEXT;
   if (sSubtype == "Link")
@@ skipping 244 matching lines @@
   CFX_PathData path;
   width /= 2;
   path.AppendRect(rect.left + width, rect.bottom + width, rect.right - width,
                   rect.top - width);
   int fill_type = 0;
   if (pOptions && (pOptions->m_Flags & RENDER_NOPATHSMOOTH)) {
     fill_type |= FXFILL_NOPATHSMOOTH;
   }
   pDevice->DrawPath(&path, pUser2Device, &graph_state, argb, argb, fill_type);
 }