// Copyright 2017 The PDFium Authors // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "public/fpdf_annot.h" #include #include #include #include #include "constants/annotation_common.h" #include "core/fpdfapi/edit/cpdf_pagecontentgenerator.h" #include "core/fpdfapi/page/cpdf_annotcontext.h" #include "core/fpdfapi/page/cpdf_form.h" #include "core/fpdfapi/page/cpdf_page.h" #include "core/fpdfapi/page/cpdf_pageobject.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_utility.h" #include "core/fpdfdoc/cpdf_annot.h" #include "core/fpdfdoc/cpdf_color_utils.h" #include "core/fpdfdoc/cpdf_formfield.h" #include "core/fpdfdoc/cpdf_generateap.h" #include "core/fpdfdoc/cpdf_interactiveform.h" #include "core/fxcrt/fx_safe_types.h" #include "core/fxcrt/fx_string_wrappers.h" #include "core/fxcrt/stl_util.h" #include "core/fxge/cfx_color.h" #include "fpdfsdk/cpdfsdk_formfillenvironment.h" #include "fpdfsdk/cpdfsdk_helpers.h" #include "fpdfsdk/cpdfsdk_interactiveform.h" #include "third_party/base/check.h" #include "third_party/base/containers/contains.h" #include "third_party/base/memory/ptr_util.h" #include "third_party/base/numerics/safe_conversions.h" namespace { // These checks ensure the consistency of annotation subtype values across core/ // and public. static_assert(static_cast(CPDF_Annot::Subtype::UNKNOWN) == FPDF_ANNOT_UNKNOWN, "CPDF_Annot::UNKNOWN value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::TEXT) == FPDF_ANNOT_TEXT, "CPDF_Annot::TEXT value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::LINK) == FPDF_ANNOT_LINK, "CPDF_Annot::LINK value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::FREETEXT) == FPDF_ANNOT_FREETEXT, "CPDF_Annot::FREETEXT value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::LINE) == FPDF_ANNOT_LINE, "CPDF_Annot::LINE value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::SQUARE) == FPDF_ANNOT_SQUARE, "CPDF_Annot::SQUARE value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::CIRCLE) == FPDF_ANNOT_CIRCLE, "CPDF_Annot::CIRCLE value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::POLYGON) == FPDF_ANNOT_POLYGON, "CPDF_Annot::POLYGON value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::POLYLINE) == FPDF_ANNOT_POLYLINE, "CPDF_Annot::POLYLINE value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::HIGHLIGHT) == FPDF_ANNOT_HIGHLIGHT, "CPDF_Annot::HIGHLIGHT value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::UNDERLINE) == FPDF_ANNOT_UNDERLINE, "CPDF_Annot::UNDERLINE value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::SQUIGGLY) == FPDF_ANNOT_SQUIGGLY, "CPDF_Annot::SQUIGGLY value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::STRIKEOUT) == FPDF_ANNOT_STRIKEOUT, "CPDF_Annot::STRIKEOUT value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::STAMP) == FPDF_ANNOT_STAMP, "CPDF_Annot::STAMP value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::CARET) == FPDF_ANNOT_CARET, "CPDF_Annot::CARET value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::INK) == FPDF_ANNOT_INK, "CPDF_Annot::INK value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::POPUP) == FPDF_ANNOT_POPUP, "CPDF_Annot::POPUP value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::FILEATTACHMENT) == FPDF_ANNOT_FILEATTACHMENT, "CPDF_Annot::FILEATTACHMENT value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::SOUND) == FPDF_ANNOT_SOUND, "CPDF_Annot::SOUND value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::MOVIE) == FPDF_ANNOT_MOVIE, "CPDF_Annot::MOVIE value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::WIDGET) == FPDF_ANNOT_WIDGET, "CPDF_Annot::WIDGET value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::SCREEN) == FPDF_ANNOT_SCREEN, "CPDF_Annot::SCREEN value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::PRINTERMARK) == FPDF_ANNOT_PRINTERMARK, "CPDF_Annot::PRINTERMARK value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::TRAPNET) == FPDF_ANNOT_TRAPNET, "CPDF_Annot::TRAPNET value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::WATERMARK) == FPDF_ANNOT_WATERMARK, "CPDF_Annot::WATERMARK value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::THREED) == FPDF_ANNOT_THREED, "CPDF_Annot::THREED value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::RICHMEDIA) == FPDF_ANNOT_RICHMEDIA, "CPDF_Annot::RICHMEDIA value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::XFAWIDGET) == FPDF_ANNOT_XFAWIDGET, "CPDF_Annot::XFAWIDGET value mismatch"); static_assert(static_cast(CPDF_Annot::Subtype::REDACT) == FPDF_ANNOT_REDACT, "CPDF_Annot::REDACT value mismatch"); // These checks ensure the consistency of annotation appearance mode values // across core/ and public. static_assert(static_cast(CPDF_Annot::AppearanceMode::kNormal) == FPDF_ANNOT_APPEARANCEMODE_NORMAL, "CPDF_Annot::AppearanceMode::Normal value mismatch"); static_assert(static_cast(CPDF_Annot::AppearanceMode::kRollover) == FPDF_ANNOT_APPEARANCEMODE_ROLLOVER, "CPDF_Annot::AppearanceMode::Rollover value mismatch"); static_assert(static_cast(CPDF_Annot::AppearanceMode::kDown) == FPDF_ANNOT_APPEARANCEMODE_DOWN, "CPDF_Annot::AppearanceMode::Down value mismatch"); // These checks ensure the consistency of dictionary value types across core/ // and public/. static_assert(static_cast(CPDF_Object::Type::kBoolean) == FPDF_OBJECT_BOOLEAN, "CPDF_Object::kBoolean value mismatch"); static_assert(static_cast(CPDF_Object::Type::kNumber) == FPDF_OBJECT_NUMBER, "CPDF_Object::kNumber value mismatch"); static_assert(static_cast(CPDF_Object::Type::kString) == FPDF_OBJECT_STRING, "CPDF_Object::kString value mismatch"); static_assert(static_cast(CPDF_Object::Type::kName) == FPDF_OBJECT_NAME, "CPDF_Object::kName value mismatch"); static_assert(static_cast(CPDF_Object::Type::kArray) == FPDF_OBJECT_ARRAY, "CPDF_Object::kArray value mismatch"); static_assert(static_cast(CPDF_Object::Type::kDictionary) == FPDF_OBJECT_DICTIONARY, "CPDF_Object::kDictionary value mismatch"); static_assert(static_cast(CPDF_Object::Type::kStream) == FPDF_OBJECT_STREAM, "CPDF_Object::kStream value mismatch"); static_assert(static_cast(CPDF_Object::Type::kNullobj) == FPDF_OBJECT_NULLOBJ, "CPDF_Object::kNullobj value mismatch"); static_assert(static_cast(CPDF_Object::Type::kReference) == FPDF_OBJECT_REFERENCE, "CPDF_Object::kReference value mismatch"); // These checks ensure the consistency of annotation additional action event // values across core/ and public. static_assert(static_cast(CPDF_AAction::kKeyStroke) == FPDF_ANNOT_AACTION_KEY_STROKE, "CPDF_AAction::kKeyStroke value mismatch"); static_assert(static_cast(CPDF_AAction::kFormat) == FPDF_ANNOT_AACTION_FORMAT, "CPDF_AAction::kFormat value mismatch"); static_assert(static_cast(CPDF_AAction::kValidate) == FPDF_ANNOT_AACTION_VALIDATE, "CPDF_AAction::kValidate value mismatch"); static_assert(static_cast(CPDF_AAction::kCalculate) == FPDF_ANNOT_AACTION_CALCULATE, "CPDF_AAction::kCalculate value mismatch"); bool HasAPStream(CPDF_Dictionary* pAnnotDict) { return !!GetAnnotAP(pAnnotDict, CPDF_Annot::AppearanceMode::kNormal); } void UpdateContentStream(CPDF_Form* pForm, CPDF_Stream* pStream) { DCHECK(pForm); DCHECK(pStream); CPDF_PageContentGenerator generator(pForm); fxcrt::ostringstream buf; generator.ProcessPageObjects(&buf); pStream->SetDataFromStringstreamAndRemoveFilter(&buf); } void SetQuadPointsAtIndex(CPDF_Array* array, size_t quad_index, const FS_QUADPOINTSF* quad_points) { DCHECK(array); DCHECK(quad_points); DCHECK(IsValidQuadPointsIndex(array, quad_index)); size_t nIndex = quad_index * 8; array->SetNewAt(nIndex, quad_points->x1); array->SetNewAt(++nIndex, quad_points->y1); array->SetNewAt(++nIndex, quad_points->x2); array->SetNewAt(++nIndex, quad_points->y2); array->SetNewAt(++nIndex, quad_points->x3); array->SetNewAt(++nIndex, quad_points->y3); array->SetNewAt(++nIndex, quad_points->x4); array->SetNewAt(++nIndex, quad_points->y4); } void AppendQuadPoints(CPDF_Array* array, const FS_QUADPOINTSF* quad_points) { DCHECK(quad_points); DCHECK(array); array->AppendNew(quad_points->x1); array->AppendNew(quad_points->y1); array->AppendNew(quad_points->x2); array->AppendNew(quad_points->y2); array->AppendNew(quad_points->x3); array->AppendNew(quad_points->y3); array->AppendNew(quad_points->x4); array->AppendNew(quad_points->y4); } void UpdateBBox(CPDF_Dictionary* annot_dict) { DCHECK(annot_dict); // Update BBox entry in appearance stream based on the bounding rectangle // of the annotation's quadpoints. RetainPtr pStream = GetAnnotAP(annot_dict, CPDF_Annot::AppearanceMode::kNormal); if (pStream) { CFX_FloatRect boundingRect = CPDF_Annot::BoundingRectFromQuadPoints(annot_dict); if (boundingRect.Contains(pStream->GetDict()->GetRectFor("BBox"))) pStream->GetMutableDict()->SetRectFor("BBox", boundingRect); } } const CPDF_Dictionary* GetAnnotDictFromFPDFAnnotation( const FPDF_ANNOTATION annot) { CPDF_AnnotContext* context = CPDFAnnotContextFromFPDFAnnotation(annot); return context ? context->GetAnnotDict() : nullptr; } RetainPtr GetMutableAnnotDictFromFPDFAnnotation( FPDF_ANNOTATION annot) { CPDF_AnnotContext* context = CPDFAnnotContextFromFPDFAnnotation(annot); return context ? context->GetMutableAnnotDict() : nullptr; } RetainPtr SetExtGStateInResourceDict( CPDF_Document* pDoc, const CPDF_Dictionary* pAnnotDict, const ByteString& sBlendMode) { auto pGSDict = pdfium::MakeRetain(pAnnotDict->GetByteStringPool()); // ExtGState represents a graphics state parameter dictionary. pGSDict->SetNewFor("Type", "ExtGState"); // CA respresents current stroking alpha specifying constant opacity // value that should be used in transparent imaging model. float fOpacity = pAnnotDict->GetFloatFor("CA"); pGSDict->SetNewFor("CA", fOpacity); // ca represents fill color alpha specifying constant opacity // value that should be used in transparent imaging model. pGSDict->SetNewFor("ca", fOpacity); // AIS represents alpha source flag specifying whether current alpha // constant shall be interpreted as shape value (true) or opacity value // (false). pGSDict->SetNewFor("AIS", false); // BM represents Blend Mode pGSDict->SetNewFor("BM", sBlendMode); auto pExtGStateDict = pdfium::MakeRetain(pAnnotDict->GetByteStringPool()); pExtGStateDict->SetFor("GS", pGSDict); auto pResourceDict = pDoc->New(); pResourceDict->SetFor("ExtGState", pExtGStateDict); return pResourceDict; } CPDF_FormField* GetFormField(FPDF_FORMHANDLE hHandle, FPDF_ANNOTATION annot) { const CPDF_Dictionary* pAnnotDict = GetAnnotDictFromFPDFAnnotation(annot); if (!pAnnotDict) return nullptr; CPDFSDK_InteractiveForm* pForm = FormHandleToInteractiveForm(hHandle); if (!pForm) return nullptr; CPDF_InteractiveForm* pPDFForm = pForm->GetInteractiveForm(); return pPDFForm->GetFieldByDict(pAnnotDict); } const CPDFSDK_Widget* GetRadioButtonOrCheckBoxWidget(FPDF_FORMHANDLE hHandle, FPDF_ANNOTATION annot) { const CPDF_Dictionary* pAnnotDict = GetAnnotDictFromFPDFAnnotation(annot); if (!pAnnotDict) return nullptr; CPDFSDK_InteractiveForm* pForm = FormHandleToInteractiveForm(hHandle); if (!pForm) return nullptr; CPDF_InteractiveForm* pPDFForm = pForm->GetInteractiveForm(); CPDF_FormField* pFormField = pPDFForm->GetFieldByDict(pAnnotDict); if (!pFormField || (pFormField->GetType() != CPDF_FormField::kCheckBox && pFormField->GetType() != CPDF_FormField::kRadioButton)) { return nullptr; } CPDF_FormControl* pFormControl = pPDFForm->GetControlByDict(pAnnotDict); return pFormControl ? pForm->GetWidget(pFormControl) : nullptr; } RetainPtr GetInkList(FPDF_ANNOTATION annot) { FPDF_ANNOTATION_SUBTYPE subtype = FPDFAnnot_GetSubtype(annot); if (subtype != FPDF_ANNOT_INK) return nullptr; const CPDF_Dictionary* annot_dict = GetAnnotDictFromFPDFAnnotation(annot); return annot_dict ? annot_dict->GetArrayFor(pdfium::annotation::kInkList) : nullptr; } } // namespace FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_IsSupportedSubtype(FPDF_ANNOTATION_SUBTYPE subtype) { // The supported subtypes must also be communicated in the user doc. switch (subtype) { case FPDF_ANNOT_CIRCLE: case FPDF_ANNOT_FREETEXT: case FPDF_ANNOT_HIGHLIGHT: case FPDF_ANNOT_INK: case FPDF_ANNOT_LINK: case FPDF_ANNOT_POPUP: case FPDF_ANNOT_SQUARE: case FPDF_ANNOT_SQUIGGLY: case FPDF_ANNOT_STAMP: case FPDF_ANNOT_STRIKEOUT: case FPDF_ANNOT_TEXT: case FPDF_ANNOT_UNDERLINE: return true; default: return false; } } FPDF_EXPORT FPDF_ANNOTATION FPDF_CALLCONV FPDFPage_CreateAnnot(FPDF_PAGE page, FPDF_ANNOTATION_SUBTYPE subtype) { CPDF_Page* pPage = CPDFPageFromFPDFPage(page); if (!pPage || !FPDFAnnot_IsSupportedSubtype(subtype)) return nullptr; auto pDict = pPage->GetDocument()->New(); pDict->SetNewFor(pdfium::annotation::kType, "Annot"); pDict->SetNewFor(pdfium::annotation::kSubtype, CPDF_Annot::AnnotSubtypeToString( static_cast(subtype))); auto pNewAnnot = std::make_unique(pDict, IPDFPageFromFPDFPage(page)); RetainPtr pAnnotList = pPage->GetOrCreateAnnotsArray(); pAnnotList->Append(pDict); // Caller takes ownership. return FPDFAnnotationFromCPDFAnnotContext(pNewAnnot.release()); } FPDF_EXPORT int FPDF_CALLCONV FPDFPage_GetAnnotCount(FPDF_PAGE page) { const CPDF_Page* pPage = CPDFPageFromFPDFPage(page); if (!pPage) return 0; RetainPtr pAnnots = pPage->GetAnnotsArray(); return pAnnots ? fxcrt::CollectionSize(*pAnnots) : 0; } FPDF_EXPORT FPDF_ANNOTATION FPDF_CALLCONV FPDFPage_GetAnnot(FPDF_PAGE page, int index) { CPDF_Page* pPage = CPDFPageFromFPDFPage(page); if (!pPage || index < 0) return nullptr; RetainPtr pAnnots = pPage->GetMutableAnnotsArray(); if (!pAnnots || static_cast(index) >= pAnnots->size()) return nullptr; RetainPtr pDict = ToDictionary(pAnnots->GetMutableDirectObjectAt(index)); if (!pDict) return nullptr; auto pNewAnnot = std::make_unique( std::move(pDict), IPDFPageFromFPDFPage(page)); // Caller takes ownership. return FPDFAnnotationFromCPDFAnnotContext(pNewAnnot.release()); } FPDF_EXPORT int FPDF_CALLCONV FPDFPage_GetAnnotIndex(FPDF_PAGE page, FPDF_ANNOTATION annot) { const CPDF_Page* pPage = CPDFPageFromFPDFPage(page); if (!pPage) return -1; const CPDF_Dictionary* pAnnotDict = GetAnnotDictFromFPDFAnnotation(annot); if (!pAnnotDict) return -1; RetainPtr pAnnots = pPage->GetAnnotsArray(); if (!pAnnots) return -1; CPDF_ArrayLocker locker(pAnnots); auto it = std::find_if(locker.begin(), locker.end(), [pAnnotDict](const RetainPtr& candidate) { return candidate->GetDirect() == pAnnotDict; }); if (it == locker.end()) return -1; return pdfium::base::checked_cast(it - locker.begin()); } FPDF_EXPORT void FPDF_CALLCONV FPDFPage_CloseAnnot(FPDF_ANNOTATION annot) { delete CPDFAnnotContextFromFPDFAnnotation(annot); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPage_RemoveAnnot(FPDF_PAGE page, int index) { CPDF_Page* pPage = CPDFPageFromFPDFPage(page); if (!pPage || index < 0) return false; RetainPtr pAnnots = pPage->GetMutableAnnotsArray(); if (!pAnnots || static_cast(index) >= pAnnots->size()) return false; pAnnots->RemoveAt(index); return true; } FPDF_EXPORT FPDF_ANNOTATION_SUBTYPE FPDF_CALLCONV FPDFAnnot_GetSubtype(FPDF_ANNOTATION annot) { const CPDF_Dictionary* pAnnotDict = GetAnnotDictFromFPDFAnnotation(annot); if (!pAnnotDict) return FPDF_ANNOT_UNKNOWN; return static_cast(CPDF_Annot::StringToAnnotSubtype( pAnnotDict->GetNameFor(pdfium::annotation::kSubtype))); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_IsObjectSupportedSubtype(FPDF_ANNOTATION_SUBTYPE subtype) { // The supported subtypes must also be communicated in the user doc. return subtype == FPDF_ANNOT_INK || subtype == FPDF_ANNOT_STAMP; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_UpdateObject(FPDF_ANNOTATION annot, FPDF_PAGEOBJECT obj) { CPDF_AnnotContext* pAnnot = CPDFAnnotContextFromFPDFAnnotation(annot); CPDF_PageObject* pObj = CPDFPageObjectFromFPDFPageObject(obj); if (!pAnnot || !pAnnot->HasForm() || !pObj) return false; // Check that the annotation type is supported by this method. if (!FPDFAnnot_IsObjectSupportedSubtype(FPDFAnnot_GetSubtype(annot))) return false; // Check that the annotation already has an appearance stream, since an // existing object is to be updated. RetainPtr pAnnotDict = pAnnot->GetMutableAnnotDict(); RetainPtr pStream = GetAnnotAP(pAnnotDict.Get(), CPDF_Annot::AppearanceMode::kNormal); if (!pStream) return false; // Check that the object is already in this annotation's object list. CPDF_Form* pForm = pAnnot->GetForm(); if (!pdfium::Contains(*pForm, fxcrt::MakeFakeUniquePtr(pObj))) return false; // Update the content stream data in the annotation's AP stream. UpdateContentStream(pForm, pStream.Get()); return true; } FPDF_EXPORT int FPDF_CALLCONV FPDFAnnot_AddInkStroke(FPDF_ANNOTATION annot, const FS_POINTF* points, size_t point_count) { if (FPDFAnnot_GetSubtype(annot) != FPDF_ANNOT_INK || !points || point_count == 0 || !pdfium::base::IsValueInRangeForNumericType(point_count)) { return -1; } RetainPtr annot_dict = GetMutableAnnotDictFromFPDFAnnotation(annot); RetainPtr inklist = annot_dict->GetOrCreateArrayFor("InkList"); FX_SAFE_SIZE_T safe_ink_size = inklist->size(); safe_ink_size += 1; if (!safe_ink_size.IsValid()) return -1; auto ink_coord_list = inklist->AppendNew(); for (size_t i = 0; i < point_count; i++) { ink_coord_list->AppendNew(points[i].x); ink_coord_list->AppendNew(points[i].y); } return static_cast(inklist->size() - 1); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_RemoveInkList(FPDF_ANNOTATION annot) { if (FPDFAnnot_GetSubtype(annot) != FPDF_ANNOT_INK) return false; RetainPtr annot_dict = CPDFAnnotContextFromFPDFAnnotation(annot)->GetMutableAnnotDict(); annot_dict->RemoveFor("InkList"); return true; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_AppendObject(FPDF_ANNOTATION annot, FPDF_PAGEOBJECT obj) { CPDF_AnnotContext* pAnnot = CPDFAnnotContextFromFPDFAnnotation(annot); CPDF_PageObject* pObj = CPDFPageObjectFromFPDFPageObject(obj); if (!pAnnot || !pObj) return false; // Check that the annotation type is supported by this method. if (!FPDFAnnot_IsObjectSupportedSubtype(FPDFAnnot_GetSubtype(annot))) return false; // If the annotation does not have an AP stream yet, generate and set it. RetainPtr pAnnotDict = pAnnot->GetMutableAnnotDict(); RetainPtr pStream = GetAnnotAP(pAnnotDict.Get(), CPDF_Annot::AppearanceMode::kNormal); if (!pStream) { CPDF_GenerateAP::GenerateEmptyAP(pAnnot->GetPage()->GetDocument(), pAnnotDict.Get()); pStream = GetAnnotAP(pAnnotDict.Get(), CPDF_Annot::AppearanceMode::kNormal); if (!pStream) return false; } // Get the annotation's corresponding form object for parsing its AP stream. if (!pAnnot->HasForm()) pAnnot->SetForm(pStream); // Check that the object did not come from the same annotation. If this check // succeeds, then it is assumed that the object came from // FPDFPageObj_CreateNew{Path|Rect}() or FPDFPageObj_New{Text|Image}Obj(). // Note that an object that came from a different annotation must not be // passed here, since an object cannot belong to more than one annotation. CPDF_Form* pForm = pAnnot->GetForm(); if (pdfium::Contains(*pForm, fxcrt::MakeFakeUniquePtr(pObj))) return false; // Append the object to the object list. pForm->AppendPageObject(pdfium::WrapUnique(pObj)); // Set the content stream data in the annotation's AP stream. UpdateContentStream(pForm, pStream.Get()); return true; } FPDF_EXPORT int FPDF_CALLCONV FPDFAnnot_GetObjectCount(FPDF_ANNOTATION annot) { CPDF_AnnotContext* pAnnot = CPDFAnnotContextFromFPDFAnnotation(annot); if (!pAnnot) return 0; if (!pAnnot->HasForm()) { RetainPtr pDict = pAnnot->GetMutableAnnotDict(); RetainPtr pStream = GetAnnotAP(pDict.Get(), CPDF_Annot::AppearanceMode::kNormal); if (!pStream) return 0; pAnnot->SetForm(std::move(pStream)); } return pdfium::base::checked_cast( pAnnot->GetForm()->GetPageObjectCount()); } FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV FPDFAnnot_GetObject(FPDF_ANNOTATION annot, int index) { CPDF_AnnotContext* pAnnot = CPDFAnnotContextFromFPDFAnnotation(annot); if (!pAnnot || index < 0) return nullptr; if (!pAnnot->HasForm()) { RetainPtr pAnnotDict = pAnnot->GetMutableAnnotDict(); RetainPtr pStream = GetAnnotAP(pAnnotDict.Get(), CPDF_Annot::AppearanceMode::kNormal); if (!pStream) return nullptr; pAnnot->SetForm(std::move(pStream)); } return FPDFPageObjectFromCPDFPageObject( pAnnot->GetForm()->GetPageObjectByIndex(index)); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_RemoveObject(FPDF_ANNOTATION annot, int index) { CPDF_AnnotContext* pAnnot = CPDFAnnotContextFromFPDFAnnotation(annot); if (!pAnnot || !pAnnot->HasForm() || index < 0) return false; // Check that the annotation type is supported by this method. if (!FPDFAnnot_IsObjectSupportedSubtype(FPDFAnnot_GetSubtype(annot))) return false; // Check that the annotation already has an appearance stream, since an // existing object is to be deleted. RetainPtr pAnnotDict = pAnnot->GetMutableAnnotDict(); RetainPtr pStream = GetAnnotAP(pAnnotDict.Get(), CPDF_Annot::AppearanceMode::kNormal); if (!pStream) return false; if (!pAnnot->GetForm()->ErasePageObjectAtIndex(index)) return false; UpdateContentStream(pAnnot->GetForm(), pStream.Get()); return true; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_SetColor(FPDF_ANNOTATION annot, FPDFANNOT_COLORTYPE type, unsigned int R, unsigned int G, unsigned int B, unsigned int A) { RetainPtr pAnnotDict = GetMutableAnnotDictFromFPDFAnnotation(annot); if (!pAnnotDict || R > 255 || G > 255 || B > 255 || A > 255) return false; // For annotations with their appearance streams already defined, the path // stream's own color definitions take priority over the annotation color // definitions set by this method, hence this method will simply fail. if (HasAPStream(pAnnotDict.Get())) return false; // Set the opacity of the annotation. pAnnotDict->SetNewFor("CA", A / 255.f); // Set the color of the annotation. ByteString key = type == FPDFANNOT_COLORTYPE_InteriorColor ? "IC" : "C"; RetainPtr pColor = pAnnotDict->GetMutableArrayFor(key); if (pColor) pColor->Clear(); else pColor = pAnnotDict->SetNewFor(key); pColor->AppendNew(R / 255.f); pColor->AppendNew(G / 255.f); pColor->AppendNew(B / 255.f); return true; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_GetColor(FPDF_ANNOTATION annot, FPDFANNOT_COLORTYPE type, unsigned int* R, unsigned int* G, unsigned int* B, unsigned int* A) { RetainPtr pAnnotDict = GetMutableAnnotDictFromFPDFAnnotation(annot); if (!pAnnotDict || !R || !G || !B || !A) return false; // For annotations with their appearance streams already defined, the path // stream's own color definitions take priority over the annotation color // definitions retrieved by this method, hence this method will simply fail. if (HasAPStream(pAnnotDict.Get())) return false; RetainPtr pColor = pAnnotDict->GetArrayFor( type == FPDFANNOT_COLORTYPE_InteriorColor ? "IC" : "C"); *A = (pAnnotDict->KeyExist("CA") ? pAnnotDict->GetFloatFor("CA") : 1) * 255.f; if (!pColor) { // Use default color. The default colors must be consistent with the ones // used to generate AP. See calls to GetColorStringWithDefault() in // CPDF_GenerateAP::Generate*AP(). if (pAnnotDict->GetNameFor(pdfium::annotation::kSubtype) == "Highlight") { *R = 255; *G = 255; *B = 0; } else { *R = 0; *G = 0; *B = 0; } return true; } CFX_Color color = fpdfdoc::CFXColorFromArray(*pColor); switch (color.nColorType) { case CFX_Color::Type::kRGB: *R = color.fColor1 * 255.f; *G = color.fColor2 * 255.f; *B = color.fColor3 * 255.f; break; case CFX_Color::Type::kGray: *R = 255.f * color.fColor1; *G = 255.f * color.fColor1; *B = 255.f * color.fColor1; break; case CFX_Color::Type::kCMYK: *R = 255.f * (1 - color.fColor1) * (1 - color.fColor4); *G = 255.f * (1 - color.fColor2) * (1 - color.fColor4); *B = 255.f * (1 - color.fColor3) * (1 - color.fColor4); break; case CFX_Color::Type::kTransparent: *R = 0; *G = 0; *B = 0; break; } return true; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV 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 || subtype == FPDF_ANNOT_STRIKEOUT; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_SetAttachmentPoints(FPDF_ANNOTATION annot, size_t quad_index, const FS_QUADPOINTSF* quad_points) { if (!FPDFAnnot_HasAttachmentPoints(annot) || !quad_points) return false; RetainPtr pAnnotDict = CPDFAnnotContextFromFPDFAnnotation(annot)->GetMutableAnnotDict(); RetainPtr pQuadPointsArray = GetMutableQuadPointsArrayFromDictionary(pAnnotDict.Get()); if (!IsValidQuadPointsIndex(pQuadPointsArray.Get(), quad_index)) return false; SetQuadPointsAtIndex(pQuadPointsArray.Get(), quad_index, quad_points); UpdateBBox(pAnnotDict.Get()); return true; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_AppendAttachmentPoints(FPDF_ANNOTATION annot, const FS_QUADPOINTSF* quad_points) { if (!FPDFAnnot_HasAttachmentPoints(annot) || !quad_points) return false; RetainPtr pAnnotDict = CPDFAnnotContextFromFPDFAnnotation(annot)->GetMutableAnnotDict(); RetainPtr pQuadPointsArray = GetMutableQuadPointsArrayFromDictionary(pAnnotDict.Get()); if (!pQuadPointsArray) pQuadPointsArray = AddQuadPointsArrayToDictionary(pAnnotDict.Get()); AppendQuadPoints(pQuadPointsArray.Get(), quad_points); UpdateBBox(pAnnotDict.Get()); return true; } FPDF_EXPORT size_t FPDF_CALLCONV FPDFAnnot_CountAttachmentPoints(FPDF_ANNOTATION annot) { if (!FPDFAnnot_HasAttachmentPoints(annot)) return 0; const CPDF_Dictionary* pAnnotDict = CPDFAnnotContextFromFPDFAnnotation(annot)->GetAnnotDict(); RetainPtr pArray = GetQuadPointsArrayFromDictionary(pAnnotDict); return pArray ? pArray->size() / 8 : 0; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_GetAttachmentPoints(FPDF_ANNOTATION annot, size_t quad_index, FS_QUADPOINTSF* quad_points) { if (!FPDFAnnot_HasAttachmentPoints(annot) || !quad_points) return false; const CPDF_Dictionary* pAnnotDict = CPDFAnnotContextFromFPDFAnnotation(annot)->GetAnnotDict(); RetainPtr pArray = GetQuadPointsArrayFromDictionary(pAnnotDict); if (!pArray) return false; return GetQuadPointsAtIndex(std::move(pArray), quad_index, quad_points); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_SetRect(FPDF_ANNOTATION annot, const FS_RECTF* rect) { RetainPtr pAnnotDict = GetMutableAnnotDictFromFPDFAnnotation(annot); if (!pAnnotDict || !rect) return false; CFX_FloatRect newRect = CFXFloatRectFromFSRectF(*rect); // Update the "Rect" entry in the annotation dictionary. pAnnotDict->SetRectFor(pdfium::annotation::kRect, newRect); // If the annotation's appearance stream is defined, the annotation is of a // type that does not have quadpoints, and the new rectangle is bigger than // the current bounding box, then update the "BBox" entry in the AP // dictionary too, since its "BBox" entry comes from annotation dictionary's // "Rect" entry. if (FPDFAnnot_HasAttachmentPoints(annot)) return true; RetainPtr pStream = GetAnnotAP(pAnnotDict.Get(), CPDF_Annot::AppearanceMode::kNormal); if (pStream && newRect.Contains(pStream->GetDict()->GetRectFor("BBox"))) pStream->GetMutableDict()->SetRectFor("BBox", newRect); return true; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_GetRect(FPDF_ANNOTATION annot, FS_RECTF* rect) { const CPDF_Dictionary* pAnnotDict = GetAnnotDictFromFPDFAnnotation(annot); if (!pAnnotDict || !rect) return false; *rect = FSRectFFromCFXFloatRect( pAnnotDict->GetRectFor(pdfium::annotation::kRect)); return true; } FPDF_EXPORT unsigned long FPDF_CALLCONV FPDFAnnot_GetVertices(FPDF_ANNOTATION annot, FS_POINTF* buffer, unsigned long length) { FPDF_ANNOTATION_SUBTYPE subtype = FPDFAnnot_GetSubtype(annot); if (subtype != FPDF_ANNOT_POLYGON && subtype != FPDF_ANNOT_POLYLINE) return 0; const CPDF_Dictionary* annot_dict = GetAnnotDictFromFPDFAnnotation(annot); if (!annot_dict) return 0; RetainPtr vertices = annot_dict->GetArrayFor(pdfium::annotation::kVertices); if (!vertices) return 0; // Truncate to an even number. const unsigned long points_len = fxcrt::CollectionSize(*vertices) / 2; if (buffer && length >= points_len) { for (unsigned long i = 0; i < points_len; ++i) { buffer[i].x = vertices->GetFloatAt(i * 2); buffer[i].y = vertices->GetFloatAt(i * 2 + 1); } } return points_len; } FPDF_EXPORT unsigned long FPDF_CALLCONV FPDFAnnot_GetInkListCount(FPDF_ANNOTATION annot) { RetainPtr ink_list = GetInkList(annot); return ink_list ? fxcrt::CollectionSize(*ink_list) : 0; } FPDF_EXPORT unsigned long FPDF_CALLCONV FPDFAnnot_GetInkListPath(FPDF_ANNOTATION annot, unsigned long path_index, FS_POINTF* buffer, unsigned long length) { RetainPtr ink_list = GetInkList(annot); if (!ink_list) return 0; RetainPtr path = ink_list->GetArrayAt(path_index); if (!path) return 0; // Truncate to an even number. const unsigned long points_len = fxcrt::CollectionSize(*path) / 2; if (buffer && length >= points_len) { for (unsigned long i = 0; i < points_len; ++i) { buffer[i].x = path->GetFloatAt(i * 2); buffer[i].y = path->GetFloatAt(i * 2 + 1); } } return points_len; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_GetLine(FPDF_ANNOTATION annot, FS_POINTF* start, FS_POINTF* end) { if (!start || !end) return false; FPDF_ANNOTATION_SUBTYPE subtype = FPDFAnnot_GetSubtype(annot); if (subtype != FPDF_ANNOT_LINE) return false; const CPDF_Dictionary* annot_dict = GetAnnotDictFromFPDFAnnotation(annot); if (!annot_dict) return false; RetainPtr line = annot_dict->GetArrayFor(pdfium::annotation::kL); if (!line || line->size() < 4) return false; start->x = line->GetFloatAt(0); start->y = line->GetFloatAt(1); end->x = line->GetFloatAt(2); end->y = line->GetFloatAt(3); return true; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_SetBorder(FPDF_ANNOTATION annot, float horizontal_radius, float vertical_radius, float border_width) { RetainPtr annot_dict = GetMutableAnnotDictFromFPDFAnnotation(annot); if (!annot_dict) return false; // Remove the appearance stream. Otherwise PDF viewers will render that and // not use the border values. annot_dict->RemoveFor(pdfium::annotation::kAP); auto border = annot_dict->SetNewFor(pdfium::annotation::kBorder); border->AppendNew(horizontal_radius); border->AppendNew(vertical_radius); border->AppendNew(border_width); return true; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_GetBorder(FPDF_ANNOTATION annot, float* horizontal_radius, float* vertical_radius, float* border_width) { if (!horizontal_radius || !vertical_radius || !border_width) return false; const CPDF_Dictionary* annot_dict = GetAnnotDictFromFPDFAnnotation(annot); if (!annot_dict) return false; RetainPtr border = annot_dict->GetArrayFor(pdfium::annotation::kBorder); if (!border || border->size() < 3) return false; *horizontal_radius = border->GetFloatAt(0); *vertical_radius = border->GetFloatAt(1); *border_width = border->GetFloatAt(2); return true; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_HasKey(FPDF_ANNOTATION annot, FPDF_BYTESTRING key) { const CPDF_Dictionary* pAnnotDict = GetAnnotDictFromFPDFAnnotation(annot); return pAnnotDict && pAnnotDict->KeyExist(key); } FPDF_EXPORT FPDF_OBJECT_TYPE FPDF_CALLCONV FPDFAnnot_GetValueType(FPDF_ANNOTATION annot, FPDF_BYTESTRING key) { if (!FPDFAnnot_HasKey(annot, key)) return FPDF_OBJECT_UNKNOWN; const CPDF_AnnotContext* pAnnot = CPDFAnnotContextFromFPDFAnnotation(annot); RetainPtr pObj = pAnnot->GetAnnotDict()->GetObjectFor(key); return pObj ? pObj->GetType() : FPDF_OBJECT_UNKNOWN; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_SetStringValue(FPDF_ANNOTATION annot, FPDF_BYTESTRING key, FPDF_WIDESTRING value) { RetainPtr pAnnotDict = GetMutableAnnotDictFromFPDFAnnotation(annot); if (!pAnnotDict) return false; pAnnotDict->SetNewFor( key, WideStringFromFPDFWideString(value).AsStringView()); return true; } FPDF_EXPORT unsigned long FPDF_CALLCONV FPDFAnnot_GetStringValue(FPDF_ANNOTATION annot, FPDF_BYTESTRING key, FPDF_WCHAR* buffer, unsigned long buflen) { const CPDF_Dictionary* pAnnotDict = GetAnnotDictFromFPDFAnnotation(annot); if (!pAnnotDict) return 0; return Utf16EncodeMaybeCopyAndReturnLength(pAnnotDict->GetUnicodeTextFor(key), buffer, buflen); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_GetNumberValue(FPDF_ANNOTATION annot, FPDF_BYTESTRING key, float* value) { if (!value) return false; const CPDF_Dictionary* pAnnotDict = GetAnnotDictFromFPDFAnnotation(annot); if (!pAnnotDict) return false; RetainPtr p = pAnnotDict->GetObjectFor(key); if (!p || p->GetType() != FPDF_OBJECT_NUMBER) return false; *value = p->GetNumber(); return true; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_SetAP(FPDF_ANNOTATION annot, FPDF_ANNOT_APPEARANCEMODE appearanceMode, FPDF_WIDESTRING value) { RetainPtr pAnnotDict = GetMutableAnnotDictFromFPDFAnnotation(annot); if (!pAnnotDict) return false; if (appearanceMode < 0 || appearanceMode >= FPDF_ANNOT_APPEARANCEMODE_COUNT) return false; static constexpr const char* kModeKeyForMode[] = {"N", "R", "D"}; static_assert(std::size(kModeKeyForMode) == FPDF_ANNOT_APPEARANCEMODE_COUNT, "length of kModeKeyForMode should be equal to " "FPDF_ANNOT_APPEARANCEMODE_COUNT"); const char* modeKey = kModeKeyForMode[appearanceMode]; RetainPtr pApDict = pAnnotDict->GetMutableDictFor(pdfium::annotation::kAP); // If value is null, we're in remove mode. Otherwise, we're in add/update // mode. if (value) { // Annotation object's non-empty bounding rect will be used as the /BBox // for the associated /XObject object CFX_FloatRect rect = pAnnotDict->GetRectFor(pdfium::annotation::kRect); constexpr float kMinSize = 0.000001f; if (rect.Width() < kMinSize || rect.Height() < kMinSize) return false; CPDF_AnnotContext* pAnnotContext = CPDFAnnotContextFromFPDFAnnotation(annot); CPDF_Document* pDoc = pAnnotContext->GetPage()->GetDocument(); if (!pDoc) return false; auto pNewIndirectStream = pDoc->NewIndirect(); ByteString newAPStream = PDF_EncodeText(WideStringFromFPDFWideString(value).AsStringView()); pNewIndirectStream->SetData(newAPStream.raw_span()); RetainPtr pStreamDict = pNewIndirectStream->GetMutableDict(); pStreamDict->SetNewFor(pdfium::annotation::kType, "XObject"); pStreamDict->SetNewFor(pdfium::annotation::kSubtype, "Form"); pStreamDict->SetRectFor("BBox", rect); // Transparency values are specified in range [0.0f, 1.0f]. We are strictly // checking for value < 1 and not <= 1 so that the output PDF size does not // unnecessarily bloat up by creating a new dictionary in case of solid // color. if (pAnnotDict->KeyExist("CA") && pAnnotDict->GetFloatFor("CA") < 1.0f) { RetainPtr pResourceDict = SetExtGStateInResourceDict(pDoc, pAnnotDict.Get(), "Normal"); pStreamDict->SetFor("Resources", pResourceDict); } // Storing reference to indirect object in annotation's AP if (!pApDict) { pApDict = pAnnotDict->SetNewFor(pdfium::annotation::kAP); } pApDict->SetNewFor(modeKey, pDoc, pNewIndirectStream->GetObjNum()); } else { if (pApDict) { if (appearanceMode == FPDF_ANNOT_APPEARANCEMODE_NORMAL) pAnnotDict->RemoveFor(pdfium::annotation::kAP); else pApDict->RemoveFor(modeKey); } } return true; } FPDF_EXPORT unsigned long FPDF_CALLCONV FPDFAnnot_GetAP(FPDF_ANNOTATION annot, FPDF_ANNOT_APPEARANCEMODE appearanceMode, FPDF_WCHAR* buffer, unsigned long buflen) { RetainPtr pAnnotDict = GetMutableAnnotDictFromFPDFAnnotation(annot); if (!pAnnotDict) return 0; if (appearanceMode < 0 || appearanceMode >= FPDF_ANNOT_APPEARANCEMODE_COUNT) return 0; CPDF_Annot::AppearanceMode mode = static_cast(appearanceMode); RetainPtr pStream = GetAnnotAPNoFallback(pAnnotDict.Get(), mode); return Utf16EncodeMaybeCopyAndReturnLength( pStream ? pStream->GetUnicodeText() : WideString(), buffer, buflen); } FPDF_EXPORT FPDF_ANNOTATION FPDF_CALLCONV FPDFAnnot_GetLinkedAnnot(FPDF_ANNOTATION annot, FPDF_BYTESTRING key) { CPDF_AnnotContext* pAnnot = CPDFAnnotContextFromFPDFAnnotation(annot); if (!pAnnot) return nullptr; RetainPtr pLinkedDict = pAnnot->GetMutableAnnotDict()->GetMutableDictFor(key); if (!pLinkedDict || pLinkedDict->GetNameFor("Type") != "Annot") return nullptr; auto pLinkedAnnot = std::make_unique( std::move(pLinkedDict), pAnnot->GetPage()); // Caller takes ownership. return FPDFAnnotationFromCPDFAnnotContext(pLinkedAnnot.release()); } FPDF_EXPORT int FPDF_CALLCONV FPDFAnnot_GetFlags(FPDF_ANNOTATION annot) { const CPDF_Dictionary* pAnnotDict = GetAnnotDictFromFPDFAnnotation(annot); return pAnnotDict ? pAnnotDict->GetIntegerFor(pdfium::annotation::kF) : FPDF_ANNOT_FLAG_NONE; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_SetFlags(FPDF_ANNOTATION annot, int flags) { RetainPtr pAnnotDict = GetMutableAnnotDictFromFPDFAnnotation(annot); if (!pAnnotDict) return false; pAnnotDict->SetNewFor(pdfium::annotation::kF, flags); return true; } FPDF_EXPORT int FPDF_CALLCONV FPDFAnnot_GetFormFieldFlags(FPDF_FORMHANDLE hHandle, FPDF_ANNOTATION annot) { CPDF_FormField* pFormField = GetFormField(hHandle, annot); return pFormField ? pFormField->GetFieldFlags() : FPDF_FORMFLAG_NONE; } FPDF_EXPORT FPDF_ANNOTATION FPDF_CALLCONV FPDFAnnot_GetFormFieldAtPoint(FPDF_FORMHANDLE hHandle, FPDF_PAGE page, const FS_POINTF* point) { if (!point) return nullptr; const CPDFSDK_InteractiveForm* pForm = FormHandleToInteractiveForm(hHandle); if (!pForm) return nullptr; const CPDF_Page* pPage = CPDFPageFromFPDFPage(page); if (!pPage) return nullptr; const CPDF_InteractiveForm* pPDFForm = pForm->GetInteractiveForm(); int annot_index = -1; const CPDF_FormControl* pFormCtrl = pPDFForm->GetControlAtPoint( pPage, CFXPointFFromFSPointF(*point), &annot_index); if (!pFormCtrl || annot_index == -1) return nullptr; return FPDFPage_GetAnnot(page, annot_index); } FPDF_EXPORT unsigned long FPDF_CALLCONV FPDFAnnot_GetFormFieldName(FPDF_FORMHANDLE hHandle, FPDF_ANNOTATION annot, FPDF_WCHAR* buffer, unsigned long buflen) { const CPDF_FormField* pFormField = GetFormField(hHandle, annot); if (!pFormField) return 0; return Utf16EncodeMaybeCopyAndReturnLength(pFormField->GetFullName(), buffer, buflen); } FPDF_EXPORT int FPDF_CALLCONV FPDFAnnot_GetFormFieldType(FPDF_FORMHANDLE hHandle, FPDF_ANNOTATION annot) { const CPDF_FormField* pFormField = GetFormField(hHandle, annot); return pFormField ? static_cast(pFormField->GetFieldType()) : -1; } FPDF_EXPORT unsigned long FPDF_CALLCONV FPDFAnnot_GetFormAdditionalActionJavaScript(FPDF_FORMHANDLE hHandle, FPDF_ANNOTATION annot, int event, FPDF_WCHAR* buffer, unsigned long buflen) { const CPDF_FormField* pFormField = GetFormField(hHandle, annot); if (!pFormField) return 0; if (event < FPDF_ANNOT_AACTION_KEY_STROKE || event > FPDF_ANNOT_AACTION_CALCULATE) { return 0; } auto type = static_cast(event); CPDF_AAction additional_action = pFormField->GetAdditionalAction(); CPDF_Action action = additional_action.GetAction(type); return Utf16EncodeMaybeCopyAndReturnLength(action.GetJavaScript(), buffer, buflen); } FPDF_EXPORT unsigned long FPDF_CALLCONV FPDFAnnot_GetFormFieldAlternateName(FPDF_FORMHANDLE hHandle, FPDF_ANNOTATION annot, FPDF_WCHAR* buffer, unsigned long buflen) { const CPDF_FormField* pFormField = GetFormField(hHandle, annot); if (!pFormField) return 0; return Utf16EncodeMaybeCopyAndReturnLength(pFormField->GetAlternateName(), buffer, buflen); } FPDF_EXPORT unsigned long FPDF_CALLCONV FPDFAnnot_GetFormFieldValue(FPDF_FORMHANDLE hHandle, FPDF_ANNOTATION annot, FPDF_WCHAR* buffer, unsigned long buflen) { const CPDF_FormField* pFormField = GetFormField(hHandle, annot); if (!pFormField) return 0; return Utf16EncodeMaybeCopyAndReturnLength(pFormField->GetValue(), buffer, buflen); } FPDF_EXPORT int FPDF_CALLCONV FPDFAnnot_GetOptionCount(FPDF_FORMHANDLE hHandle, FPDF_ANNOTATION annot) { const CPDF_FormField* pFormField = GetFormField(hHandle, annot); return pFormField ? pFormField->CountOptions() : -1; } FPDF_EXPORT unsigned long FPDF_CALLCONV FPDFAnnot_GetOptionLabel(FPDF_FORMHANDLE hHandle, FPDF_ANNOTATION annot, int index, FPDF_WCHAR* buffer, unsigned long buflen) { if (index < 0) return 0; const CPDF_FormField* pFormField = GetFormField(hHandle, annot); if (!pFormField || index >= pFormField->CountOptions()) return 0; WideString ws = pFormField->GetOptionLabel(index); return Utf16EncodeMaybeCopyAndReturnLength(ws, buffer, buflen); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_IsOptionSelected(FPDF_FORMHANDLE handle, FPDF_ANNOTATION annot, int index) { if (index < 0) return false; const CPDF_FormField* form_field = GetFormField(handle, annot); if (!form_field || index >= form_field->CountOptions()) return false; if (form_field->GetFieldType() != FormFieldType::kComboBox && form_field->GetFieldType() != FormFieldType::kListBox) { return false; } return form_field->IsItemSelected(index); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_GetFontSize(FPDF_FORMHANDLE hHandle, FPDF_ANNOTATION annot, float* value) { if (!value) return false; CPDFSDK_InteractiveForm* pForm = FormHandleToInteractiveForm(hHandle); if (!pForm) return false; const CPDF_Dictionary* pAnnotDict = GetAnnotDictFromFPDFAnnotation(annot); if (!pAnnotDict) return false; CPDF_InteractiveForm* pPDFForm = pForm->GetInteractiveForm(); CPDF_FormControl* pFormControl = pPDFForm->GetControlByDict(pAnnotDict); if (!pFormControl) return false; CPDFSDK_Widget* pWidget = pForm->GetWidget(pFormControl); if (!pWidget) return false; *value = pWidget->GetFontSize(); return true; } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_IsChecked(FPDF_FORMHANDLE hHandle, FPDF_ANNOTATION annot) { const CPDFSDK_Widget* pWidget = GetRadioButtonOrCheckBoxWidget(hHandle, annot); return pWidget && pWidget->IsChecked(); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_SetFocusableSubtypes(FPDF_FORMHANDLE hHandle, const FPDF_ANNOTATION_SUBTYPE* subtypes, size_t count) { CPDFSDK_FormFillEnvironment* pFormFillEnv = CPDFSDKFormFillEnvironmentFromFPDFFormHandle(hHandle); if (!pFormFillEnv) return false; if (count > 0 && !subtypes) return false; std::vector focusable_annot_types; focusable_annot_types.reserve(count); for (size_t i = 0; i < count; ++i) { focusable_annot_types.push_back( static_cast(subtypes[i])); } pFormFillEnv->SetFocusableAnnotSubtypes(focusable_annot_types); return true; } FPDF_EXPORT int FPDF_CALLCONV FPDFAnnot_GetFocusableSubtypesCount(FPDF_FORMHANDLE hHandle) { CPDFSDK_FormFillEnvironment* pFormFillEnv = CPDFSDKFormFillEnvironmentFromFPDFFormHandle(hHandle); if (!pFormFillEnv) return -1; return fxcrt::CollectionSize(pFormFillEnv->GetFocusableAnnotSubtypes()); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_GetFocusableSubtypes(FPDF_FORMHANDLE hHandle, FPDF_ANNOTATION_SUBTYPE* subtypes, size_t count) { CPDFSDK_FormFillEnvironment* pFormFillEnv = CPDFSDKFormFillEnvironmentFromFPDFFormHandle(hHandle); if (!pFormFillEnv) return false; if (!subtypes) return false; const std::vector& focusable_annot_types = pFormFillEnv->GetFocusableAnnotSubtypes(); // Host should allocate enough memory to get the list of currently supported // focusable subtypes. if (count < focusable_annot_types.size()) return false; for (size_t i = 0; i < focusable_annot_types.size(); ++i) { subtypes[i] = static_cast(focusable_annot_types[i]); } return true; } FPDF_EXPORT FPDF_LINK FPDF_CALLCONV FPDFAnnot_GetLink(FPDF_ANNOTATION annot) { if (FPDFAnnot_GetSubtype(annot) != FPDF_ANNOT_LINK) return nullptr; // Unretained reference in public API. NOLINTNEXTLINE return FPDFLinkFromCPDFDictionary( CPDFAnnotContextFromFPDFAnnotation(annot)->GetMutableAnnotDict()); } FPDF_EXPORT int FPDF_CALLCONV FPDFAnnot_GetFormControlCount(FPDF_FORMHANDLE hHandle, FPDF_ANNOTATION annot) { CPDF_FormField* pFormField = GetFormField(hHandle, annot); return pFormField ? pFormField->CountControls() : -1; } FPDF_EXPORT int FPDF_CALLCONV FPDFAnnot_GetFormControlIndex(FPDF_FORMHANDLE hHandle, FPDF_ANNOTATION annot) { const CPDF_Dictionary* pAnnotDict = GetAnnotDictFromFPDFAnnotation(annot); if (!pAnnotDict) return -1; CPDFSDK_InteractiveForm* pForm = FormHandleToInteractiveForm(hHandle); if (!pForm) return -1; CPDF_InteractiveForm* pPDFForm = pForm->GetInteractiveForm(); CPDF_FormField* pFormField = pPDFForm->GetFieldByDict(pAnnotDict); CPDF_FormControl* pFormControl = pPDFForm->GetControlByDict(pAnnotDict); return pFormField ? pFormField->GetControlIndex(pFormControl) : -1; } FPDF_EXPORT unsigned long FPDF_CALLCONV FPDFAnnot_GetFormFieldExportValue(FPDF_FORMHANDLE hHandle, FPDF_ANNOTATION annot, FPDF_WCHAR* buffer, unsigned long buflen) { const CPDFSDK_Widget* pWidget = GetRadioButtonOrCheckBoxWidget(hHandle, annot); if (!pWidget) return 0; return Utf16EncodeMaybeCopyAndReturnLength(pWidget->GetExportValue(), buffer, buflen); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFAnnot_SetURI(FPDF_ANNOTATION annot, const char* uri) { if (!uri || FPDFAnnot_GetSubtype(annot) != FPDF_ANNOT_LINK) return false; RetainPtr annot_dict = GetMutableAnnotDictFromFPDFAnnotation(annot); auto action = annot_dict->SetNewFor("A"); action->SetNewFor("Type", "Action"); action->SetNewFor("S", "URI"); action->SetNewFor("URI", uri, /*bHex=*/false); return true; }