// Copyright 2014 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 "public/fpdf_formfill.h"
#include <memory>
#include <vector>
#include "core/fpdfapi/page/cpdf_page.h"
#include "core/fpdfapi/parser/cpdf_document.h"
#include "core/fpdfapi/render/cpdf_renderoptions.h"
#include "core/fpdfdoc/cpdf_formcontrol.h"
#include "core/fpdfdoc/cpdf_formfield.h"
#include "core/fpdfdoc/cpdf_interform.h"
#include "core/fpdfdoc/cpdf_occontext.h"
#include "core/fxge/cfx_defaultrenderdevice.h"
#include "fpdfsdk/cpdfsdk_formfillenvironment.h"
#include "fpdfsdk/cpdfsdk_interform.h"
#include "fpdfsdk/cpdfsdk_pageview.h"
#include "fpdfsdk/fsdk_actionhandler.h"
#include "fpdfsdk/fsdk_define.h"
#include "public/fpdfview.h"
#include "third_party/base/ptr_util.h"
#include "third_party/base/stl_util.h"
#ifdef PDF_ENABLE_XFA
#include "fpdfsdk/fpdfxfa/cpdfxfa_context.h"
#include "fpdfsdk/fpdfxfa/cpdfxfa_page.h"
#include "xfa/fxfa/cxfa_ffdocview.h"
#include "xfa/fxfa/cxfa_ffpageview.h"
#include "xfa/fxfa/cxfa_ffwidget.h"
static_assert(static_cast<int>(FormType::kNone) == FORMTYPE_NONE,
"None form types must match");
static_assert(static_cast<int>(FormType::kAcroForm) == FORMTYPE_ACRO_FORM,
"AcroForm form types must match");
static_assert(static_cast<int>(FormType::kXFAFull) == FORMTYPE_XFA_FULL,
"XFA full form types must match");
static_assert(static_cast<int>(FormType::kXFAForeground) ==
FORMTYPE_XFA_FOREGROUND,
"XFA foreground form types must match");
#endif // PDF_ENABLE_XFA
static_assert(static_cast<int>(FormFieldType::kUnknown) ==
FPDF_FORMFIELD_UNKNOWN,
"Unknown form field types must match");
static_assert(static_cast<int>(FormFieldType::kPushButton) ==
FPDF_FORMFIELD_PUSHBUTTON,
"PushButton form field types must match");
static_assert(static_cast<int>(FormFieldType::kCheckBox) ==
FPDF_FORMFIELD_CHECKBOX,
"CheckBox form field types must match");
static_assert(static_cast<int>(FormFieldType::kRadioButton) ==
FPDF_FORMFIELD_RADIOBUTTON,
"RadioButton form field types must match");
static_assert(static_cast<int>(FormFieldType::kComboBox) ==
FPDF_FORMFIELD_COMBOBOX,
"ComboBox form field types must match");
static_assert(static_cast<int>(FormFieldType::kListBox) ==
FPDF_FORMFIELD_LISTBOX,
"ListBox form field types must match");
static_assert(static_cast<int>(FormFieldType::kTextField) ==
FPDF_FORMFIELD_TEXTFIELD,
"TextField form field types must match");
static_assert(static_cast<int>(FormFieldType::kSignature) ==
FPDF_FORMFIELD_SIGNATURE,
"Signature form field types must match");
#ifdef PDF_ENABLE_XFA
static_assert(static_cast<int>(FormFieldType::kXFA) == FPDF_FORMFIELD_XFA,
"XFA form field types must match");
static_assert(static_cast<int>(FormFieldType::kXFA_CheckBox) ==
FPDF_FORMFIELD_XFA_CHECKBOX,
"XFA CheckBox form field types must match");
static_assert(static_cast<int>(FormFieldType::kXFA_ComboBox) ==
FPDF_FORMFIELD_XFA_COMBOBOX,
"XFA ComboBox form field types must match");
static_assert(static_cast<int>(FormFieldType::kXFA_ImageField) ==
FPDF_FORMFIELD_XFA_IMAGEFIELD,
"XFA ImageField form field types must match");
static_assert(static_cast<int>(FormFieldType::kXFA_ListBox) ==
FPDF_FORMFIELD_XFA_LISTBOX,
"XFA ListBox form field types must match");
static_assert(static_cast<int>(FormFieldType::kXFA_PushButton) ==
FPDF_FORMFIELD_XFA_PUSHBUTTON,
"XFA PushButton form field types must match");
static_assert(static_cast<int>(FormFieldType::kXFA_Signature) ==
FPDF_FORMFIELD_XFA_SIGNATURE,
"XFA Signature form field types must match");
static_assert(static_cast<int>(FormFieldType::kXFA_TextField) ==
FPDF_FORMFIELD_XFA_TEXTFIELD,
"XFA TextField form field types must match");
#endif // PDF_ENABLE_XFA
static_assert(kFormFieldTypeCount == FPDF_FORMFIELD_COUNT,
"Number of form field types must match");
namespace {
CPDFSDK_FormFillEnvironment* HandleToCPDFSDKEnvironment(
FPDF_FORMHANDLE handle) {
return static_cast<CPDFSDK_FormFillEnvironment*>(handle);
}
CPDFSDK_InterForm* FormHandleToInterForm(FPDF_FORMHANDLE hHandle) {
CPDFSDK_FormFillEnvironment* pFormFillEnv =
HandleToCPDFSDKEnvironment(hHandle);
return pFormFillEnv ? pFormFillEnv->GetInterForm() : nullptr;
}
CPDFSDK_PageView* FormHandleToPageView(FPDF_FORMHANDLE hHandle,
FPDF_PAGE page) {
UnderlyingPageType* pPage = UnderlyingFromFPDFPage(page);
if (!pPage)
return nullptr;
CPDFSDK_FormFillEnvironment* pFormFillEnv =
HandleToCPDFSDKEnvironment(hHandle);
return pFormFillEnv ? pFormFillEnv->GetPageView(pPage, true) : nullptr;
}
#ifdef PDF_ENABLE_XFA
std::vector<ByteString>* FromFPDFStringHandle(FPDF_STRINGHANDLE handle) {
return static_cast<std::vector<ByteString>*>(handle);
}
FPDF_STRINGHANDLE ToFPDFStringHandle(std::vector<ByteString>* strings) {
return static_cast<FPDF_STRINGHANDLE>(strings);
}
#endif // PDF_ENABLE_XFA
void FFLCommon(FPDF_FORMHANDLE hHandle,
FPDF_BITMAP bitmap,
FPDF_RECORDER recorder,
FPDF_PAGE page,
int start_x,
int start_y,
int size_x,
int size_y,
int rotate,
int flags) {
if (!hHandle)
return;
UnderlyingPageType* pPage = UnderlyingFromFPDFPage(page);
if (!pPage)
return;
#ifdef PDF_ENABLE_XFA
CPDFXFA_Context* pContext = pPage->GetContext();
if (!pContext)
return;
CPDF_Document* pPDFDoc = pContext->GetPDFDoc();
if (!pPDFDoc)
return;
CPDFSDK_FormFillEnvironment* pFormFillEnv =
HandleToCPDFSDKEnvironment(hHandle);
if (!pFormFillEnv)
return;
#endif // PDF_ENABLE_XFA
CFX_Matrix matrix =
pPage->GetDisplayMatrix(start_x, start_y, size_x, size_y, rotate);
FX_RECT clip(start_x, start_y, start_x + size_x, start_y + size_y);
auto pDevice = pdfium::MakeUnique<CFX_DefaultRenderDevice>();
#ifdef _SKIA_SUPPORT_
pDevice->AttachRecorder(static_cast<SkPictureRecorder*>(recorder));
#endif
RetainPtr<CFX_DIBitmap> holder(CFXBitmapFromFPDFBitmap(bitmap));
pDevice->Attach(holder, false, nullptr, false);
{
CFX_RenderDevice::StateRestorer restorer(pDevice.get());
pDevice->SetClip_Rect(clip);
CPDF_RenderOptions options;
uint32_t option_flags = options.GetFlags();
if (flags & FPDF_LCD_TEXT)
option_flags |= RENDER_CLEARTYPE;
else
option_flags &= ~RENDER_CLEARTYPE;
options.SetFlags(option_flags);
// Grayscale output
if (flags & FPDF_GRAYSCALE)
options.SetColorMode(CPDF_RenderOptions::kGray);
options.SetDrawAnnots(flags & FPDF_ANNOT);
#ifdef PDF_ENABLE_XFA
options.SetOCContext(
pdfium::MakeRetain<CPDF_OCContext>(pPDFDoc, CPDF_OCContext::View));
if (CPDFSDK_PageView* pPageView = pFormFillEnv->GetPageView(pPage, true))
pPageView->PageView_OnDraw(pDevice.get(), &matrix, &options, clip);
#else // PDF_ENABLE_XFA
options.SetOCContext(pdfium::MakeRetain<CPDF_OCContext>(
pPage->m_pDocument.Get(), CPDF_OCContext::View));
if (CPDFSDK_PageView* pPageView = FormHandleToPageView(hHandle, pPage))
pPageView->PageView_OnDraw(pDevice.get(), &matrix, &options);
#endif // PDF_ENABLE_XFA
}
#ifdef _SKIA_SUPPORT_PATHS_
pDevice->Flush(true);
holder->UnPreMultiply();
#endif
}
} // namespace
FPDF_EXPORT int FPDF_CALLCONV
FPDFPage_HasFormFieldAtPoint(FPDF_FORMHANDLE hHandle,
FPDF_PAGE page,
double page_x,
double page_y) {
if (!hHandle)
return -1;
CPDF_Page* pPage = CPDFPageFromFPDFPage(page);
if (pPage) {
CPDF_InterForm interform(pPage->m_pDocument.Get());
CPDF_FormControl* pFormCtrl = interform.GetControlAtPoint(
pPage,
CFX_PointF(static_cast<float>(page_x), static_cast<float>(page_y)),
nullptr);
if (!pFormCtrl)
return -1;
CPDF_FormField* pFormField = pFormCtrl->GetField();
return pFormField ? static_cast<int>(pFormField->GetFieldType()) : -1;
}
#ifdef PDF_ENABLE_XFA
CPDFXFA_Page* pXFAPage = UnderlyingFromFPDFPage(page);
if (!pXFAPage)
return -1;
CXFA_FFPageView* pPageView = pXFAPage->GetXFAPageView();
if (!pPageView)
return -1;
CXFA_FFDocView* pDocView = pPageView->GetDocView();
if (!pDocView)
return -1;
CXFA_FFWidgetHandler* pWidgetHandler = pDocView->GetWidgetHandler();
if (!pWidgetHandler)
return -1;
std::unique_ptr<IXFA_WidgetIterator> pWidgetIterator(
pPageView->CreateWidgetIterator(XFA_TRAVERSEWAY_Form,
XFA_WidgetStatus_Viewable));
if (!pWidgetIterator)
return -1;
CXFA_FFWidget* pXFAAnnot;
while ((pXFAAnnot = pWidgetIterator->MoveToNext()) != nullptr) {
CFX_RectF rcBBox = pXFAAnnot->GetBBox(0);
CFX_FloatRect rcWidget(rcBBox.left, rcBBox.top, rcBBox.left + rcBBox.width,
rcBBox.top + rcBBox.height);
rcWidget.Inflate(1.0f, 1.0f);
if (rcWidget.Contains(CFX_PointF(static_cast<float>(page_x),
static_cast<float>(page_y)))) {
return static_cast<int>(pXFAAnnot->GetFormFieldType());
}
}
#endif // PDF_ENABLE_XFA
return -1;
}
FPDF_EXPORT int FPDF_CALLCONV
FPDFPage_FormFieldZOrderAtPoint(FPDF_FORMHANDLE hHandle,
FPDF_PAGE page,
double page_x,
double page_y) {
if (!hHandle)
return -1;
CPDF_Page* pPage = CPDFPageFromFPDFPage(page);
if (!pPage)
return -1;
CPDF_InterForm interform(pPage->m_pDocument.Get());
int z_order = -1;
(void)interform.GetControlAtPoint(
pPage, CFX_PointF(static_cast<float>(page_x), static_cast<float>(page_y)),
&z_order);
return z_order;
}
FPDF_EXPORT FPDF_FORMHANDLE FPDF_CALLCONV
FPDFDOC_InitFormFillEnvironment(FPDF_DOCUMENT document,
FPDF_FORMFILLINFO* formInfo) {
#ifdef PDF_ENABLE_XFA
const int kRequiredVersion = 2;
#else // PDF_ENABLE_XFA
const int kRequiredVersion = 1;
#endif // PDF_ENABLE_XFA
if (!formInfo || formInfo->version != kRequiredVersion)
return nullptr;
UnderlyingDocumentType* pDocument = UnderlyingFromFPDFDocument(document);
if (!pDocument)
return nullptr;
#ifdef PDF_ENABLE_XFA
// If the CPDFXFA_Context has a FormFillEnvironment already then we've done
// this and can just return the old Env. Otherwise, we'll end up setting a new
// environment into the XFADocument and, that could get weird.
if (pDocument->GetFormFillEnv())
return pDocument->GetFormFillEnv();
#endif
auto pFormFillEnv =
pdfium::MakeUnique<CPDFSDK_FormFillEnvironment>(pDocument, formInfo);
#ifdef PDF_ENABLE_XFA
pDocument->SetFormFillEnv(pFormFillEnv.get());
#endif // PDF_ENABLE_XFA
return pFormFillEnv.release(); // Caller takes ownership.
}
FPDF_EXPORT void FPDF_CALLCONV
FPDFDOC_ExitFormFillEnvironment(FPDF_FORMHANDLE hHandle) {
CPDFSDK_FormFillEnvironment* pFormFillEnv =
HandleToCPDFSDKEnvironment(hHandle);
if (!pFormFillEnv)
return;
#ifdef PDF_ENABLE_XFA
// Reset the focused annotations and remove the SDK document from the
// XFA document.
pFormFillEnv->ClearAllFocusedAnnots();
// If the document was closed first, it's possible the XFA document
// is now a nullptr.
if (pFormFillEnv->GetXFAContext())
pFormFillEnv->GetXFAContext()->SetFormFillEnv(nullptr);
#endif // PDF_ENABLE_XFA
delete pFormFillEnv;
}
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnMouseMove(FPDF_FORMHANDLE hHandle,
FPDF_PAGE page,
int modifier,
double page_x,
double page_y) {
CPDFSDK_PageView* pPageView = FormHandleToPageView(hHandle, page);
if (!pPageView)
return false;
return pPageView->OnMouseMove(CFX_PointF(page_x, page_y), modifier);
}
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnFocus(FPDF_FORMHANDLE hHandle,
FPDF_PAGE page,
int modifier,
double page_x,
double page_y) {
CPDFSDK_PageView* pPageView = FormHandleToPageView(hHandle, page);
if (!pPageView)
return false;
return pPageView->OnFocus(CFX_PointF(page_x, page_y), modifier);
}
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnLButtonDown(FPDF_FORMHANDLE hHandle,
FPDF_PAGE page,
int modifier,
double page_x,
double page_y) {
CPDFSDK_PageView* pPageView = FormHandleToPageView(hHandle, page);
if (!pPageView)
return false;
return pPageView->OnLButtonDown(CFX_PointF(page_x, page_y), modifier);
}
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnLButtonUp(FPDF_FORMHANDLE hHandle,
FPDF_PAGE page,
int modifier,
double page_x,
double page_y) {
CPDFSDK_PageView* pPageView = FormHandleToPageView(hHandle, page);
if (!pPageView)
return false;
return pPageView->OnLButtonUp(CFX_PointF(page_x, page_y), modifier);
}
#ifdef PDF_ENABLE_XFA
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnRButtonDown(FPDF_FORMHANDLE hHandle,
FPDF_PAGE page,
int modifier,
double page_x,
double page_y) {
CPDFSDK_PageView* pPageView = FormHandleToPageView(hHandle, page);
if (!pPageView)
return false;
return pPageView->OnRButtonDown(CFX_PointF(page_x, page_y), modifier);
}
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnRButtonUp(FPDF_FORMHANDLE hHandle,
FPDF_PAGE page,
int modifier,
double page_x,
double page_y) {
CPDFSDK_PageView* pPageView = FormHandleToPageView(hHandle, page);
if (!pPageView)
return false;
return pPageView->OnRButtonUp(CFX_PointF(page_x, page_y), modifier);
}
#endif // PDF_ENABLE_XFA
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnKeyDown(FPDF_FORMHANDLE hHandle,
FPDF_PAGE page,
int nKeyCode,
int modifier) {
CPDFSDK_PageView* pPageView = FormHandleToPageView(hHandle, page);
if (!pPageView)
return false;
return pPageView->OnKeyDown(nKeyCode, modifier);
}
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnKeyUp(FPDF_FORMHANDLE hHandle,
FPDF_PAGE page,
int nKeyCode,
int modifier) {
CPDFSDK_PageView* pPageView = FormHandleToPageView(hHandle, page);
if (!pPageView)
return false;
return pPageView->OnKeyUp(nKeyCode, modifier);
}
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FORM_OnChar(FPDF_FORMHANDLE hHandle,
FPDF_PAGE page,
int nChar,
int modifier) {
CPDFSDK_PageView* pPageView = FormHandleToPageView(hHandle, page);
if (!pPageView)
return false;
return pPageView->OnChar(nChar, modifier);
}
FPDF_EXPORT unsigned long FPDF_CALLCONV
FORM_GetSelectedText(FPDF_FORMHANDLE hHandle,
FPDF_PAGE page,
void* buffer,
unsigned long buflen) {
CPDFSDK_PageView* pPageView = FormHandleToPageView(hHandle, page);
if (!pPageView)
return 0;
WideString wide_str_form_text = pPageView->GetSelectedText();
ByteString encoded_form_text = wide_str_form_text.UTF16LE_Encode();
unsigned long form_text_len = encoded_form_text.GetLength();
if (buffer && buflen >= form_text_len)
memcpy(buffer, encoded_form_text.c_str(), form_text_len);
return form_text_len;
}
FPDF_EXPORT void FPDF_CALLCONV FORM_ReplaceSelection(FPDF_FORMHANDLE hHandle,
FPDF_PAGE page,
FPDF_WIDESTRING wsText) {
CPDFSDK_PageView* pPageView = FormHandleToPageView(hHandle, page);
if (!pPageView)
return;
size_t len = WideString::WStringLength(wsText);
WideString wide_str_text = WideString::FromUTF16LE(wsText, len);
pPageView->ReplaceSelection(wide_str_text);
}
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV
FORM_ForceToKillFocus(FPDF_FORMHANDLE hHandle) {
CPDFSDK_FormFillEnvironment* pFormFillEnv =
HandleToCPDFSDKEnvironment(hHandle);
if (!pFormFillEnv)
return false;
return pFormFillEnv->KillFocusAnnot(0);
}
FPDF_EXPORT void FPDF_CALLCONV FPDF_FFLDraw(FPDF_FORMHANDLE hHandle,
FPDF_BITMAP bitmap,
FPDF_PAGE page,
int start_x,
int start_y,
int size_x,
int size_y,
int rotate,
int flags) {
FFLCommon(hHandle, bitmap, nullptr, page, start_x, start_y, size_x, size_y,
rotate, flags);
}
#ifdef _SKIA_SUPPORT_
FPDF_EXPORT void FPDF_CALLCONV FPDF_FFLRecord(FPDF_FORMHANDLE hHandle,
FPDF_RECORDER recorder,
FPDF_PAGE page,
int start_x,
int start_y,
int size_x,
int size_y,
int rotate,
int flags) {
FFLCommon(hHandle, nullptr, recorder, page, start_x, start_y, size_x, size_y,
rotate, flags);
}
#endif
#ifdef PDF_ENABLE_XFA
FPDF_EXPORT void FPDF_CALLCONV FPDF_Widget_Undo(FPDF_DOCUMENT document,
FPDF_WIDGET hWidget) {
if (!hWidget || !document)
return;
CPDFXFA_Context* pContext = static_cast<CPDFXFA_Context*>(document);
if (!pContext->ContainsXFAForm())
return;
static_cast<CXFA_FFWidget*>(hWidget)->Undo();
}
FPDF_EXPORT void FPDF_CALLCONV FPDF_Widget_Redo(FPDF_DOCUMENT document,
FPDF_WIDGET hWidget) {
if (!hWidget || !document)
return;
CPDFXFA_Context* pContext = static_cast<CPDFXFA_Context*>(document);
if (!pContext->ContainsXFAForm())
return;
static_cast<CXFA_FFWidget*>(hWidget)->Redo();
}
FPDF_EXPORT void FPDF_CALLCONV FPDF_Widget_SelectAll(FPDF_DOCUMENT document,
FPDF_WIDGET hWidget) {
if (!hWidget || !document)
return;
CPDFXFA_Context* pContext = static_cast<CPDFXFA_Context*>(document);
if (!pContext->ContainsXFAForm())
return;
static_cast<CXFA_FFWidget*>(hWidget)->SelectAll();
}
FPDF_EXPORT void FPDF_CALLCONV FPDF_Widget_Copy(FPDF_DOCUMENT document,
FPDF_WIDGET hWidget,
FPDF_WIDESTRING wsText,
FPDF_DWORD* size) {
if (!hWidget || !document)
return;
CPDFXFA_Context* pContext = static_cast<CPDFXFA_Context*>(document);
if (!pContext->ContainsXFAForm())
return;
WideString wsCpText =
static_cast<CXFA_FFWidget*>(hWidget)->Copy().value_or(WideString());
ByteString bsCpText = wsCpText.UTF16LE_Encode();
uint32_t len = bsCpText.GetLength() / sizeof(unsigned short);
if (!wsText) {
*size = len;
return;
}
uint32_t real_size = len < *size ? len : *size;
if (real_size > 0) {
memcpy((void*)wsText,
bsCpText.GetBuffer(real_size * sizeof(unsigned short)),
real_size * sizeof(unsigned short));
bsCpText.ReleaseBuffer(real_size * sizeof(unsigned short));
}
*size = real_size;
}
FPDF_EXPORT void FPDF_CALLCONV FPDF_Widget_Cut(FPDF_DOCUMENT document,
FPDF_WIDGET hWidget,
FPDF_WIDESTRING wsText,
FPDF_DWORD* size) {
if (!hWidget || !document)
return;
CPDFXFA_Context* pContext = static_cast<CPDFXFA_Context*>(document);
if (!pContext->ContainsXFAForm())
return;
WideString wsCpText =
static_cast<CXFA_FFWidget*>(hWidget)->Cut().value_or(WideString());
ByteString bsCpText = wsCpText.UTF16LE_Encode();
uint32_t len = bsCpText.GetLength() / sizeof(unsigned short);
if (!wsText) {
*size = len;
return;
}
uint32_t real_size = len < *size ? len : *size;
if (real_size > 0) {
memcpy((void*)wsText,
bsCpText.GetBuffer(real_size * sizeof(unsigned short)),
real_size * sizeof(unsigned short));
bsCpText.ReleaseBuffer(real_size * sizeof(unsigned short));
}
*size = real_size;
}
FPDF_EXPORT void FPDF_CALLCONV FPDF_Widget_Paste(FPDF_DOCUMENT document,
FPDF_WIDGET hWidget,
FPDF_WIDESTRING wsText,
FPDF_DWORD size) {
if (!hWidget || !document)
return;
CPDFXFA_Context* pContext = static_cast<CPDFXFA_Context*>(document);
if (!pContext->ContainsXFAForm())
return;
WideString wstr = WideString::FromUTF16LE(wsText, size);
static_cast<CXFA_FFWidget*>(hWidget)->Paste(wstr);
}
FPDF_EXPORT void FPDF_CALLCONV
FPDF_Widget_ReplaceSpellCheckWord(FPDF_DOCUMENT document,
FPDF_WIDGET hWidget,
float x,
float y,
FPDF_BYTESTRING bsText) {
if (!hWidget || !document)
return;
CPDFXFA_Context* pContext = static_cast<CPDFXFA_Context*>(document);
if (!pContext->ContainsXFAForm())
return;
CFX_PointF ptPopup;
ptPopup.x = x;
ptPopup.y = y;
ByteStringView bs(bsText);
static_cast<CXFA_FFWidget*>(hWidget)->ReplaceSpellCheckWord(ptPopup, bs);
}
FPDF_EXPORT void FPDF_CALLCONV
FPDF_Widget_GetSpellCheckWords(FPDF_DOCUMENT document,
FPDF_WIDGET hWidget,
float x,
float y,
FPDF_STRINGHANDLE* stringHandle) {
if (!hWidget || !document)
return;
auto* pContext = static_cast<CPDFXFA_Context*>(document);
if (!pContext->ContainsXFAForm())
return;
CFX_PointF ptPopup;
ptPopup.x = x;
ptPopup.y = y;
auto sSuggestWords = pdfium::MakeUnique<std::vector<ByteString>>();
static_cast<CXFA_FFWidget*>(hWidget)->GetSuggestWords(ptPopup,
sSuggestWords.get());
// Caller takes ownership.
*stringHandle = ToFPDFStringHandle(sSuggestWords.release());
}
FPDF_EXPORT int FPDF_CALLCONV
FPDF_StringHandleCounts(FPDF_STRINGHANDLE sHandle) {
std::vector<ByteString>* sSuggestWords = FromFPDFStringHandle(sHandle);
return sSuggestWords ? pdfium::CollectionSize<int>(*sSuggestWords) : -1;
}
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV
FPDF_StringHandleGetStringByIndex(FPDF_STRINGHANDLE sHandle,
int index,
FPDF_BYTESTRING bsText,
FPDF_DWORD* size) {
if (!sHandle || !size)
return false;
int count = FPDF_StringHandleCounts(sHandle);
if (index < 0 || index >= count)
return false;
std::vector<ByteString>* sSuggestWords = FromFPDFStringHandle(sHandle);
uint32_t len = (*sSuggestWords)[index].GetLength();
if (!bsText) {
*size = len;
return true;
}
uint32_t real_size = len < *size ? len : *size;
if (real_size > 0)
memcpy((void*)bsText, (*sSuggestWords)[index].c_str(), real_size);
*size = real_size;
return true;
}
FPDF_EXPORT void FPDF_CALLCONV
FPDF_StringHandleRelease(FPDF_STRINGHANDLE stringHandle) {
delete FromFPDFStringHandle(stringHandle);
}
FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV
FPDF_StringHandleAddString(FPDF_STRINGHANDLE stringHandle,
FPDF_BYTESTRING bsText,
FPDF_DWORD size) {
if (!stringHandle || !bsText || size == 0)
return false;
FromFPDFStringHandle(stringHandle)->push_back(ByteString(bsText, size));
return true;
}
#endif // PDF_ENABLE_XFA
FPDF_EXPORT void FPDF_CALLCONV
FPDF_SetFormFieldHighlightColor(FPDF_FORMHANDLE hHandle,
int fieldType,
unsigned long color) {
CPDFSDK_InterForm* interForm = FormHandleToInterForm(hHandle);
if (!interForm)
return;
Optional<FormFieldType> cast_input = IntToFormFieldType(fieldType);
if (!cast_input)
return;
if (cast_input.value() == FormFieldType::kUnknown) {
interForm->SetAllHighlightColors(color);
} else {
interForm->SetHighlightColor(color, cast_input.value());
}
}
FPDF_EXPORT void FPDF_CALLCONV
FPDF_SetFormFieldHighlightAlpha(FPDF_FORMHANDLE hHandle, unsigned char alpha) {
if (CPDFSDK_InterForm* pInterForm = FormHandleToInterForm(hHandle))
pInterForm->SetHighlightAlpha(alpha);
}
FPDF_EXPORT void FPDF_CALLCONV
FPDF_RemoveFormFieldHighlight(FPDF_FORMHANDLE hHandle) {
if (CPDFSDK_InterForm* pInterForm = FormHandleToInterForm(hHandle))
pInterForm->RemoveAllHighLights();
}
FPDF_EXPORT void FPDF_CALLCONV FORM_OnAfterLoadPage(FPDF_PAGE page,
FPDF_FORMHANDLE hHandle) {
if (CPDFSDK_PageView* pPageView = FormHandleToPageView(hHandle, page))
pPageView->SetValid(true);
}
FPDF_EXPORT void FPDF_CALLCONV FORM_OnBeforeClosePage(FPDF_PAGE page,
FPDF_FORMHANDLE hHandle) {
CPDFSDK_FormFillEnvironment* pFormFillEnv =
HandleToCPDFSDKEnvironment(hHandle);
if (!pFormFillEnv)
return;
UnderlyingPageType* pPage = UnderlyingFromFPDFPage(page);
if (!pPage)
return;
CPDFSDK_PageView* pPageView = pFormFillEnv->GetPageView(pPage, false);
if (pPageView) {
pPageView->SetValid(false);
// RemovePageView() takes care of the delete for us.
pFormFillEnv->RemovePageView(pPage);
}
}
FPDF_EXPORT void FPDF_CALLCONV
FORM_DoDocumentJSAction(FPDF_FORMHANDLE hHandle) {
CPDFSDK_FormFillEnvironment* pFormFillEnv =
HandleToCPDFSDKEnvironment(hHandle);
if (pFormFillEnv && pFormFillEnv->IsJSInitiated())
pFormFillEnv->ProcJavascriptFun();
}
FPDF_EXPORT void FPDF_CALLCONV
FORM_DoDocumentOpenAction(FPDF_FORMHANDLE hHandle) {
CPDFSDK_FormFillEnvironment* pFormFillEnv =
HandleToCPDFSDKEnvironment(hHandle);
if (pFormFillEnv && pFormFillEnv->IsJSInitiated())
pFormFillEnv->ProcOpenAction();
}
FPDF_EXPORT void FPDF_CALLCONV FORM_DoDocumentAAction(FPDF_FORMHANDLE hHandle,
int aaType) {
CPDFSDK_FormFillEnvironment* pFormFillEnv =
HandleToCPDFSDKEnvironment(hHandle);
if (!pFormFillEnv)
return;
CPDF_Document* pDoc = pFormFillEnv->GetPDFDocument();
const CPDF_Dictionary* pDict = pDoc->GetRoot();
if (!pDict)
return;
CPDF_AAction aa(pDict->GetDictFor("AA"));
auto type = static_cast<CPDF_AAction::AActionType>(aaType);
if (aa.ActionExist(type)) {
CPDF_Action action = aa.GetAction(type);
CPDFSDK_ActionHandler* pActionHandler =
HandleToCPDFSDKEnvironment(hHandle)->GetActionHandler();
pActionHandler->DoAction_Document(action, type, pFormFillEnv);
}
}
FPDF_EXPORT void FPDF_CALLCONV FORM_DoPageAAction(FPDF_PAGE page,
FPDF_FORMHANDLE hHandle,
int aaType) {
CPDFSDK_FormFillEnvironment* pFormFillEnv =
HandleToCPDFSDKEnvironment(hHandle);
if (!pFormFillEnv)
return;
UnderlyingPageType* pPage = UnderlyingFromFPDFPage(page);
CPDF_Page* pPDFPage = CPDFPageFromFPDFPage(page);
if (!pPDFPage)
return;
if (!pFormFillEnv->GetPageView(pPage, false))
return;
CPDFSDK_ActionHandler* pActionHandler = pFormFillEnv->GetActionHandler();
CPDF_Dictionary* pPageDict = pPDFPage->m_pFormDict.Get();
CPDF_AAction aa(pPageDict->GetDictFor("AA"));
CPDF_AAction::AActionType type = aaType == FPDFPAGE_AACTION_OPEN
? CPDF_AAction::OpenPage
: CPDF_AAction::ClosePage;
if (aa.ActionExist(type)) {
CPDF_Action action = aa.GetAction(type);
pActionHandler->DoAction_Page(action, type, pFormFillEnv);
}
}