Basic APIs and tests for creating annotations
1. Added API for adding annotations and modifying common annotation
properties
* Added three embedder tests covering all of the API functions.
Bug=pdfium:737
Change-Id: I369d9e17f589f896f9e8c672382f082e524ae534
Reviewed-on: https://pdfium-review.googlesource.com/6351
Commit-Queue: dsinclair <dsinclair@chromium.org>
Reviewed-by: Lei Zhang <thestig@chromium.org>
Reviewed-by: dsinclair <dsinclair@chromium.org>
diff --git a/fpdfsdk/fpdfannot.cpp b/fpdfsdk/fpdfannot.cpp
index 6e5b7ba..941a5fd 100644
--- a/fpdfsdk/fpdfannot.cpp
+++ b/fpdfsdk/fpdfannot.cpp
@@ -6,9 +6,15 @@
#include "public/fpdf_annot.h"
+#include <utility>
+
#include "core/fpdfapi/page/cpdf_page.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_string.h"
#include "core/fpdfdoc/cpdf_annot.h"
#include "core/fpdfdoc/cpvt_color.h"
#include "core/fpdfdoc/cpvt_generateap.h"
@@ -92,10 +98,45 @@
FPDF_ANNOT_XFAWIDGET,
"CPDF_Annot::XFAWIDGET value mismatch");
+DLLEXPORT FPDF_BOOL STDCALL
+FPDFAnnot_IsSupportedSubtype(FPDF_ANNOTATION_SUBTYPE subtype) {
+ return subtype == FPDF_ANNOT_CIRCLE || subtype == FPDF_ANNOT_HIGHLIGHT ||
+ subtype == FPDF_ANNOT_INK || subtype == FPDF_ANNOT_POPUP ||
+ subtype == FPDF_ANNOT_SQUARE || subtype == FPDF_ANNOT_SQUIGGLY ||
+ subtype == FPDF_ANNOT_STRIKEOUT || subtype == FPDF_ANNOT_TEXT ||
+ subtype == FPDF_ANNOT_UNDERLINE;
+}
+
+DLLEXPORT FPDF_BOOL STDCALL
+FPDFPage_CreateAnnot(FPDF_PAGE page,
+ FPDF_ANNOTATION_SUBTYPE subtype,
+ FPDF_ANNOTATION* annot) {
+ CPDF_Page* pPage = CPDFPageFromFPDFPage(page);
+ if (!pPage || !FPDFAnnot_IsSupportedSubtype(subtype))
+ return false;
+
+ auto pDict = pdfium::MakeUnique<CPDF_Dictionary>(
+ pPage->m_pDocument->GetByteStringPool());
+ pDict->SetNewFor<CPDF_Name>("Type", "Annot");
+ pDict->SetNewFor<CPDF_Name>("Subtype",
+ CPDF_Annot::AnnotSubtypeToString(
+ static_cast<CPDF_Annot::Subtype>(subtype)));
+ if (annot)
+ *annot = FPDFAnnotationFromCPDFDictionary(pDict.get());
+
+ CPDF_Array* pAnnotList = pPage->m_pFormDict->GetArrayFor("Annots");
+ if (!pAnnotList)
+ pAnnotList = pPage->m_pFormDict->SetNewFor<CPDF_Array>("Annots");
+
+ pAnnotList->Add(std::move(pDict));
+ return true;
+}
+
DLLEXPORT int STDCALL FPDFPage_GetAnnotCount(FPDF_PAGE page) {
CPDF_Page* pPage = CPDFPageFromFPDFPage(page);
if (!pPage || !pPage->m_pFormDict)
return 0;
+
CPDF_Array* pAnnots = pPage->m_pFormDict->GetArrayFor("Annots");
return pAnnots ? pAnnots->GetCount() : 0;
}
@@ -106,6 +147,7 @@
CPDF_Page* pPage = CPDFPageFromFPDFPage(page);
if (!pPage || !pPage->m_pFormDict || index < 0 || !annot)
return false;
+
CPDF_Array* pAnnots = pPage->m_pFormDict->GetArrayFor("Annots");
if (!pAnnots || static_cast<size_t>(index) >= pAnnots->GetCount())
return false;
@@ -120,10 +162,39 @@
CPDF_Dictionary* pAnnotDict = CPDFDictionaryFromFPDFAnnotation(annot);
if (!pAnnotDict)
return FPDF_ANNOT_UNKNOWN;
+
return static_cast<FPDF_ANNOTATION_SUBTYPE>(
CPDF_Annot::StringToAnnotSubtype(pAnnotDict->GetStringFor("Subtype")));
}
+DLLEXPORT FPDF_BOOL STDCALL FPDFAnnot_SetColor(FPDF_ANNOTATION annot,
+ FPDFANNOT_COLORTYPE type,
+ unsigned int R,
+ unsigned int G,
+ unsigned int B,
+ unsigned int A) {
+ CPDF_Dictionary* pAnnotDict = CPDFDictionaryFromFPDFAnnotation(annot);
+ if (!pAnnotDict || R > 255 || G > 255 || B > 255 || A > 255)
+ return false;
+
+ // Set the opacity of the annotation.
+ pAnnotDict->SetNewFor<CPDF_Number>("CA", A / 255.f);
+
+ // Set the color of the annotation.
+ CFX_ByteString key = type == FPDFANNOT_COLORTYPE_InteriorColor ? "IC" : "C";
+ CPDF_Array* pColor = pAnnotDict->GetArrayFor(key);
+ if (pColor)
+ pColor->RemoveAt(0, pColor->GetCount());
+ else
+ pColor = pAnnotDict->SetNewFor<CPDF_Array>(key);
+
+ pColor->AddNew<CPDF_Number>(R / 255.f);
+ pColor->AddNew<CPDF_Number>(G / 255.f);
+ pColor->AddNew<CPDF_Number>(B / 255.f);
+
+ return true;
+}
+
DLLEXPORT FPDF_BOOL STDCALL FPDFAnnot_GetColor(FPDF_ANNOTATION annot,
FPDFANNOT_COLORTYPE type,
unsigned int* R,
@@ -183,6 +254,7 @@
FPDFAnnot_HasAttachmentPoints(FPDF_ANNOTATION annot) {
if (!annot)
return false;
+
FPDF_ANNOTATION_SUBTYPE subtype = FPDFAnnot_GetSubtype(annot);
return subtype == FPDF_ANNOT_LINK || subtype == FPDF_ANNOT_HIGHLIGHT ||
subtype == FPDF_ANNOT_UNDERLINE || subtype == FPDF_ANNOT_SQUIGGLY ||
@@ -190,14 +262,40 @@
}
DLLEXPORT FPDF_BOOL STDCALL
+FPDFAnnot_SetAttachmentPoints(FPDF_ANNOTATION annot,
+ FS_QUADPOINTSF quadPoints) {
+ if (!annot || !FPDFAnnot_HasAttachmentPoints(annot))
+ return false;
+
+ CPDF_Dictionary* pAnnotDict = CPDFDictionaryFromFPDFAnnotation(annot);
+ CPDF_Array* pQuadPoints = pAnnotDict->GetArrayFor("QuadPoints");
+ if (pQuadPoints)
+ pQuadPoints->RemoveAt(0, pQuadPoints->GetCount());
+ else
+ pQuadPoints = pAnnotDict->SetNewFor<CPDF_Array>("QuadPoints");
+
+ pQuadPoints->AddNew<CPDF_Number>(quadPoints.x1);
+ pQuadPoints->AddNew<CPDF_Number>(quadPoints.y1);
+ pQuadPoints->AddNew<CPDF_Number>(quadPoints.x2);
+ pQuadPoints->AddNew<CPDF_Number>(quadPoints.y2);
+ pQuadPoints->AddNew<CPDF_Number>(quadPoints.x3);
+ pQuadPoints->AddNew<CPDF_Number>(quadPoints.y3);
+ pQuadPoints->AddNew<CPDF_Number>(quadPoints.x4);
+ pQuadPoints->AddNew<CPDF_Number>(quadPoints.y4);
+ return true;
+}
+
+DLLEXPORT FPDF_BOOL STDCALL
FPDFAnnot_GetAttachmentPoints(FPDF_ANNOTATION annot,
FS_QUADPOINTSF* quadPoints) {
if (!annot || !quadPoints || !FPDFAnnot_HasAttachmentPoints(annot))
return false;
+
CPDF_Array* pArray =
CPDFDictionaryFromFPDFAnnotation(annot)->GetArrayFor("QuadPoints");
if (!pArray)
return false;
+
quadPoints->x1 = pArray->GetNumberAt(0);
quadPoints->y1 = pArray->GetNumberAt(1);
quadPoints->x2 = pArray->GetNumberAt(2);
@@ -209,12 +307,35 @@
return true;
}
+DLLEXPORT FPDF_BOOL STDCALL FPDFAnnot_SetRect(FPDF_ANNOTATION annot,
+ FS_RECTF rect) {
+ CPDF_Dictionary* pAnnotDict = CPDFDictionaryFromFPDFAnnotation(annot);
+ if (!pAnnotDict)
+ return false;
+
+ CPDF_Array* pRect = pAnnotDict->GetArrayFor("Rect");
+ if (pRect)
+ pRect->RemoveAt(0, pRect->GetCount());
+ else
+ pRect = pAnnotDict->SetNewFor<CPDF_Array>("Rect");
+
+ pRect->AddNew<CPDF_Number>(rect.left);
+ pRect->AddNew<CPDF_Number>(rect.bottom);
+ pRect->AddNew<CPDF_Number>(rect.right);
+ pRect->AddNew<CPDF_Number>(rect.top);
+ return true;
+}
+
DLLEXPORT FPDF_BOOL STDCALL FPDFAnnot_GetRect(FPDF_ANNOTATION annot,
FS_RECTF* rect) {
CPDF_Dictionary* pAnnotDict = CPDFDictionaryFromFPDFAnnotation(annot);
if (!rect || !pAnnotDict)
return false;
+
CFX_FloatRect rt = pAnnotDict->GetRectFor("Rect");
+ if (rt.IsEmpty())
+ return false;
+
rect->left = rt.left;
rect->bottom = rt.bottom;
rect->right = rt.right;
@@ -222,6 +343,20 @@
return true;
}
+DLLEXPORT FPDF_BOOL STDCALL FPDFAnnot_SetText(FPDF_ANNOTATION annot,
+ FPDFANNOT_TEXTTYPE type,
+ FPDF_WIDESTRING text) {
+ CPDF_Dictionary* pAnnotDict = CPDFDictionaryFromFPDFAnnotation(annot);
+ if (!pAnnotDict)
+ return false;
+
+ CFX_ByteString key = type == FPDFANNOT_TEXTTYPE_Author ? "T" : "Contents";
+ FX_STRSIZE len = CFX_WideString::WStringLength(text);
+ CFX_WideString encodedText = CFX_WideString::FromUTF16LE(text, len);
+ pAnnotDict->SetNewFor<CPDF_String>(key, encodedText.UTF8Encode(), false);
+ return true;
+}
+
DLLEXPORT unsigned long STDCALL FPDFAnnot_GetText(FPDF_ANNOTATION annot,
FPDFANNOT_TEXTTYPE type,
char* buffer,
@@ -229,10 +364,12 @@
CPDF_Dictionary* pAnnotDict = CPDFDictionaryFromFPDFAnnotation(annot);
if (!pAnnotDict)
return 0;
+
CFX_ByteString key = type == FPDFANNOT_TEXTTYPE_Author ? "T" : "Contents";
CFX_ByteString contents = pAnnotDict->GetUnicodeTextFor(key).UTF16LE_Encode();
unsigned long len = contents.GetLength();
if (buffer && buflen >= len)
memcpy(buffer, contents.c_str(), len);
+
return len;
}
diff --git a/fpdfsdk/fpdfannot_embeddertest.cpp b/fpdfsdk/fpdfannot_embeddertest.cpp
index 27a76ee..1f56d22 100644
--- a/fpdfsdk/fpdfannot_embeddertest.cpp
+++ b/fpdfsdk/fpdfannot_embeddertest.cpp
@@ -2,6 +2,8 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <memory>
+#include <string>
#include <vector>
#include "public/fpdf_annot.h"
@@ -9,7 +11,7 @@
#include "testing/embedder_test.h"
#include "testing/gtest/include/gtest/gtest.h"
-class FPDFAnnotEmbeddertest : public EmbedderTest {};
+class FPDFAnnotEmbeddertest : public EmbedderTest, public TestSaver {};
TEST_F(FPDFAnnotEmbeddertest, ExtractHighlightLongContent) {
// Open a file with one annotation and load its first page.
@@ -98,7 +100,7 @@
// Check that there is a total of 3 annotation on its first page.
EXPECT_EQ(3, FPDFPage_GetAnnotCount(page));
- // Check that the third annotation of type "ink".
+ // Check that the third annotation is of type "ink".
FPDF_ANNOTATION annot;
ASSERT_TRUE(FPDFPage_GetAnnot(page, 2, &annot));
EXPECT_EQ(FPDF_ANNOT_INK, FPDFAnnot_GetSubtype(annot));
@@ -130,3 +132,154 @@
UnloadPage(page);
}
+
+TEST_F(FPDFAnnotEmbeddertest, AddIllegalSubtypeAnnotation) {
+ // Open a file with one annotation and load its first page.
+ ASSERT_TRUE(OpenDocument("annotation_highlight_long_content.pdf"));
+ FPDF_PAGE page = FPDF_LoadPage(document(), 0);
+ ASSERT_TRUE(page);
+
+ // Add an annotation with an illegal subtype.
+ FPDF_ANNOTATION annot;
+ ASSERT_FALSE(FPDFPage_CreateAnnot(page, -1, &annot));
+
+ UnloadPage(page);
+}
+
+TEST_F(FPDFAnnotEmbeddertest, AddFirstTextAnnotation) {
+ // Open a file with no annotation and load its first page.
+ ASSERT_TRUE(OpenDocument("hello_world.pdf"));
+ FPDF_PAGE page = FPDF_LoadPage(document(), 0);
+ ASSERT_TRUE(page);
+ EXPECT_EQ(0, FPDFPage_GetAnnotCount(page));
+
+ // Add an underline annotation to the page.
+ FPDF_ANNOTATION annot;
+ ASSERT_TRUE(FPDFPage_CreateAnnot(page, FPDF_ANNOT_TEXT, &annot));
+
+ // Check that there is now 1 annotations on this page.
+ EXPECT_EQ(1, FPDFPage_GetAnnotCount(page));
+
+ // Check that the subtype of the annotation is correct.
+ EXPECT_EQ(FPDF_ANNOT_TEXT, FPDFAnnot_GetSubtype(annot));
+ ASSERT_TRUE(FPDFPage_GetAnnot(page, 0, &annot));
+ EXPECT_EQ(FPDF_ANNOT_TEXT, FPDFAnnot_GetSubtype(annot));
+
+ // Set the color of the annotation.
+ ASSERT_TRUE(
+ FPDFAnnot_SetColor(annot, FPDFANNOT_COLORTYPE_Color, 51, 102, 153, 204));
+ // Check that the color has been set correctly.
+ unsigned int R;
+ unsigned int G;
+ unsigned int B;
+ unsigned int A;
+ EXPECT_TRUE(
+ FPDFAnnot_GetColor(annot, FPDFANNOT_COLORTYPE_Color, &R, &G, &B, &A));
+ EXPECT_EQ(51u, R);
+ EXPECT_EQ(102u, G);
+ EXPECT_EQ(153u, B);
+ EXPECT_EQ(204u, A);
+
+ // Change the color of the annotation.
+ ASSERT_TRUE(
+ FPDFAnnot_SetColor(annot, FPDFANNOT_COLORTYPE_Color, 204, 153, 102, 51));
+ // Check that the color has been set correctly.
+ EXPECT_TRUE(
+ FPDFAnnot_GetColor(annot, FPDFANNOT_COLORTYPE_Color, &R, &G, &B, &A));
+ EXPECT_EQ(204u, R);
+ EXPECT_EQ(153u, G);
+ EXPECT_EQ(102u, B);
+ EXPECT_EQ(51u, A);
+
+ // Set the annotation rectangle.
+ FS_RECTF rect;
+ EXPECT_FALSE(FPDFAnnot_GetRect(annot, &rect));
+ rect.left = 35;
+ rect.bottom = 150;
+ rect.right = 53;
+ rect.top = 165;
+ ASSERT_TRUE(FPDFAnnot_SetRect(annot, rect));
+ // Check that the annotation rectangle has been set correctly.
+ ASSERT_TRUE(FPDFAnnot_GetRect(annot, &rect));
+ EXPECT_EQ(35.f, rect.left);
+ EXPECT_EQ(150.f, rect.bottom);
+ EXPECT_EQ(53.f, rect.right);
+ EXPECT_EQ(165.f, rect.top);
+
+ // Set the content of the annotation.
+ const wchar_t contents[] = L"Hello! This is a customized content.";
+ std::unique_ptr<unsigned short, pdfium::FreeDeleter> text =
+ GetFPDFWideString(contents);
+ ASSERT_TRUE(
+ FPDFAnnot_SetText(annot, FPDFANNOT_TEXTTYPE_Contents, text.get()));
+ // Check that the content has been set correctly.
+ unsigned long len =
+ FPDFAnnot_GetText(annot, FPDFANNOT_TEXTTYPE_Contents, nullptr, 0);
+ std::vector<char> buf(len);
+ EXPECT_EQ(74u, FPDFAnnot_GetText(annot, FPDFANNOT_TEXTTYPE_Contents,
+ buf.data(), len));
+ EXPECT_STREQ(contents,
+ GetPlatformWString(reinterpret_cast<unsigned short*>(buf.data()))
+ .c_str());
+
+ UnloadPage(page);
+}
+
+TEST_F(FPDFAnnotEmbeddertest, AddAndSaveUnderlineAnnotation) {
+ // Open a file with one annotation and load its first page.
+ ASSERT_TRUE(OpenDocument("annotation_highlight_long_content.pdf"));
+ FPDF_PAGE page = FPDF_LoadPage(document(), 0);
+ ASSERT_TRUE(page);
+
+ // Check that there is a total of one annotation on its first page, and verify
+ // its quadpoints.
+ EXPECT_EQ(1, FPDFPage_GetAnnotCount(page));
+ FPDF_ANNOTATION annot;
+ ASSERT_TRUE(FPDFPage_GetAnnot(page, 0, &annot));
+ FS_QUADPOINTSF quadpoints;
+ ASSERT_TRUE(FPDFAnnot_GetAttachmentPoints(annot, &quadpoints));
+ EXPECT_EQ(115.802643f, quadpoints.x1);
+ EXPECT_EQ(718.913940f, quadpoints.y1);
+ EXPECT_EQ(157.211182f, quadpoints.x4);
+ EXPECT_EQ(706.264465f, quadpoints.y4);
+
+ // Add an underline annotation to the page and set its quadpoints.
+ ASSERT_TRUE(FPDFPage_CreateAnnot(page, FPDF_ANNOT_UNDERLINE, &annot));
+ quadpoints.x1 = 140.802643f;
+ quadpoints.x3 = 140.802643f;
+ ASSERT_TRUE(FPDFAnnot_SetAttachmentPoints(annot, quadpoints));
+
+ // Save the document, closing the page and document.
+ EXPECT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
+ FPDF_ClosePage(page);
+
+ // Open the saved document.
+ std::string new_file = GetString();
+ FPDF_FILEACCESS file_access;
+ memset(&file_access, 0, sizeof(file_access));
+ file_access.m_FileLen = new_file.size();
+ file_access.m_GetBlock = GetBlockFromString;
+ file_access.m_Param = &new_file;
+ FPDF_DOCUMENT new_doc = FPDF_LoadCustomDocument(&file_access, nullptr);
+ ASSERT_TRUE(new_doc);
+ FPDF_PAGE new_page = FPDF_LoadPage(new_doc, 0);
+ ASSERT_TRUE(new_page);
+
+ // Check that the saved document has 2 annotations on the first page
+ EXPECT_EQ(2, FPDFPage_GetAnnotCount(new_page));
+
+ // Check that the second annotation is an underline annotation and verify
+ // its quadpoints.
+ FPDF_ANNOTATION new_annot;
+ ASSERT_TRUE(FPDFPage_GetAnnot(new_page, 1, &new_annot));
+ EXPECT_EQ(FPDF_ANNOT_UNDERLINE, FPDFAnnot_GetSubtype(new_annot));
+ FS_QUADPOINTSF new_quadpoints;
+ ASSERT_TRUE(FPDFAnnot_GetAttachmentPoints(new_annot, &new_quadpoints));
+ EXPECT_NEAR(quadpoints.x1, new_quadpoints.x1, 0.001f);
+ EXPECT_NEAR(quadpoints.y1, new_quadpoints.y1, 0.001f);
+ EXPECT_NEAR(quadpoints.x4, new_quadpoints.x4, 0.001f);
+ EXPECT_NEAR(quadpoints.y4, new_quadpoints.y4, 0.001f);
+
+ FPDF_ClosePage(new_page);
+ FPDF_CloseDocument(new_doc);
+}
diff --git a/public/fpdf_annot.h b/public/fpdf_annot.h
index 29207a6..19265d6 100644
--- a/public/fpdf_annot.h
+++ b/public/fpdf_annot.h
@@ -45,6 +45,40 @@
#define FPDF_ANNOT_RICHMEDIA 26
#define FPDF_ANNOT_XFAWIDGET 27
+typedef enum FPDFANNOT_COLORTYPE {
+ FPDFANNOT_COLORTYPE_Color = 0,
+ FPDFANNOT_COLORTYPE_InteriorColor
+} FPDFANNOT_COLORTYPE;
+
+typedef enum FPDFANNOT_TEXTTYPE {
+ FPDFANNOT_TEXTTYPE_Contents = 0,
+ FPDFANNOT_TEXTTYPE_Author
+} FPDFANNOT_TEXTTYPE;
+
+// Check if an annotation subtype is currently supported for creating and
+// displaying. The supported subtypes must be consistent with the ones supported
+// by AP generation - see the list of calls to CPVT_GenerateAP::Generate*AP() in
+// CPDF_Annot::GenerateAPIfNeeded().
+//
+// subtype - the subtype to be checked.
+//
+// Returns true if this subtype supported, false otherwise.
+DLLEXPORT FPDF_BOOL STDCALL
+FPDFAnnot_IsSupportedSubtype(FPDF_ANNOTATION_SUBTYPE subtype);
+
+// Create an annotation in |page| of the subtype |subtype|. If the specified
+// subtype is illegal or unsupported, then a new annotation will not be created.
+//
+// page - handle to a page.
+// subtype - the subtype of the new annotation.
+// annot - receives the newly created annotation.
+//
+// Returns true if successful, false otherwise.
+DLLEXPORT FPDF_BOOL STDCALL
+FPDFPage_CreateAnnot(FPDF_PAGE page,
+ FPDF_ANNOTATION_SUBTYPE subtype,
+ FPDF_ANNOTATION* annot);
+
// Get the number of annotations in |page|.
//
// page - handle to a page.
@@ -56,7 +90,7 @@
//
// page - handle to a page.
// index - the index of the annotation.
-// annot - receives the annotation
+// annot - receives the annotation.
//
// Returns true if successful, false otherwise.
DLLEXPORT FPDF_BOOL STDCALL FPDFPage_GetAnnot(FPDF_PAGE page,
@@ -71,18 +105,28 @@
DLLEXPORT FPDF_ANNOTATION_SUBTYPE STDCALL
FPDFAnnot_GetSubtype(FPDF_ANNOTATION annot);
-typedef enum FPDFANNOT_COLORTYPE {
- FPDFANNOT_COLORTYPE_Color = 0,
- FPDFANNOT_COLORTYPE_InteriorColor
-} FPDFANNOT_COLORTYPE;
+// Set the color of an annotation.
+//
+// annot - handle to an annotation.
+// type - type of the color to be set.
+// R, G, B - buffer to hold the RGB value of the color. Ranges from 0 to 255.
+// A - buffer to hold the opacity. Ranges from 0 to 255.
+//
+// Returns true if successful, false otherwise.
+DLLEXPORT FPDF_BOOL STDCALL FPDFAnnot_SetColor(FPDF_ANNOTATION annot,
+ FPDFANNOT_COLORTYPE type,
+ unsigned int R,
+ unsigned int G,
+ unsigned int B,
+ unsigned int A);
// Get the color of an annotation. If no color is specified, default to yellow
// for highlight annotation, black for all else.
//
-// annot - handle to an annotation.
-// type - type of the color requested. Default to Color.
+// annot - handle to an annotation.
+// type - type of the color requested.
// R, G, B - buffer to hold the RGB value of the color. Ranges from 0 to 255.
-// A - buffer to hold the opacity. Ranges from 0 to 255.
+// A - buffer to hold the opacity. Ranges from 0 to 255.
//
// Returns true if successful, false otherwise.
DLLEXPORT FPDF_BOOL STDCALL FPDFAnnot_GetColor(FPDF_ANNOTATION annot,
@@ -95,9 +139,9 @@
// Check if the annotation is of a type that has attachment points
// (i.e. quadpoints). Quadpoints are the vertices of the rectange that
// encompasses the texts affected by the annotation. They provide the
-// coordinates in the page where the annotation is attached. Only markup
-// annotations (i.e. highlight, strikeout, squiggly, underline, and link) have
-// quadpoints.
+// coordinates in the page where the annotation is attached. Only text markup
+// annotations (i.e. highlight, strikeout, squiggly, and underline) and link
+// annotations have quadpoints.
//
// annot - handle to an annotation.
//
@@ -106,40 +150,63 @@
DLLEXPORT FPDF_BOOL STDCALL
FPDFAnnot_HasAttachmentPoints(FPDF_ANNOTATION annot);
+// Set the attachment points (i.e. quadpoints) of an annotation.
+//
+// annot - handle to an annotation.
+// quadPoints - the quadpoints to be set.
+//
+// Returns true if successful, false otherwise.
+DLLEXPORT FPDF_BOOL STDCALL
+FPDFAnnot_SetAttachmentPoints(FPDF_ANNOTATION annot, FS_QUADPOINTSF quadPoints);
+
// Get the attachment points (i.e. quadpoints) of an annotation.
//
-// annot - handle to an annotation.
-// quadPoints - receives the attachment points
+// annot - handle to an annotation.
+// quadPoints - receives the attachment points.
//
// Returns true if successful, false otherwise.
DLLEXPORT FPDF_BOOL STDCALL
FPDFAnnot_GetAttachmentPoints(FPDF_ANNOTATION annot,
FS_QUADPOINTSF* quadPoints);
+// Set the annotation rectangle defining the location of the annotation.
+//
+// annot - handle to an annotation.
+// rect - the annotation rectangle to be set.
+//
+// Returns true if successful, false otherwise.
+DLLEXPORT FPDF_BOOL STDCALL FPDFAnnot_SetRect(FPDF_ANNOTATION annot,
+ FS_RECTF rect);
+
// Get the annotation rectangle defining the location of the annotation.
//
// annot - handle to an annotation.
-// rect - receives the annotation rectangle
+// rect - receives the annotation rectangle.
//
// Returns true if successful, false otherwise.
DLLEXPORT FPDF_BOOL STDCALL FPDFAnnot_GetRect(FPDF_ANNOTATION annot,
FS_RECTF* rect);
-typedef enum FPDFANNOT_TEXTTYPE {
- FPDFANNOT_TEXTTYPE_Contents = 0,
- FPDFANNOT_TEXTTYPE_Author
-} FPDFANNOT_TEXTTYPE;
+// Set the contents of an annotation.
+//
+// annot - handle to an annotation.
+// type - type of the text to be set.
+// text - the text to be set.
+//
+// Returns true if successful, false otherwise.
+DLLEXPORT FPDF_BOOL STDCALL FPDFAnnot_SetText(FPDF_ANNOTATION annot,
+ FPDFANNOT_TEXTTYPE type,
+ FPDF_WIDESTRING text);
// Get the contents of an annotation. |buffer| is only modified if |buflen|
// is longer than the length of contents.
//
// annot - handle to an annotation.
-// type - type of the text requested. Default to Contents.
+// type - type of the text requested.
// buffer - buffer for holding the contents string, encoded in UTF16-LE.
// buflen - length of the buffer.
//
// Returns the length of the contents.
-
DLLEXPORT unsigned long STDCALL FPDFAnnot_GetText(FPDF_ANNOTATION annot,
FPDFANNOT_TEXTTYPE type,
char* buffer,