From 525147a1f6d6cd736a407d1e189ac25d2f4726e8 Mon Sep 17 00:00:00 2001 From: Tom Sepez Date: Thu, 3 May 2018 17:19:53 +0000 Subject: Use strict types in FPDF API, try #3 Rather than messing with actual inheritence, add type-checking wrappers and just blatantly cast to incomplete types. Along the way, this points out places where we would downcast without checking, which I fix. Change-Id: Ieb303eb46ad8522dfe082454f1f10f247ffd52d5 Reviewed-on: https://pdfium-review.googlesource.com/32030 Reviewed-by: dsinclair Commit-Queue: Tom Sepez --- BUILD.gn | 2 + core/fxge/skia/fx_skia_device_unittest.cpp | 2 +- fpdfsdk/cpdf_annotcontext.cpp | 35 ++++++ fpdfsdk/cpdf_annotcontext.h | 38 +++++++ fpdfsdk/cpdfsdk_helpers.cpp | 8 -- fpdfsdk/cpdfsdk_helpers.h | 167 +++++++++++++++++++++++++++-- fpdfsdk/fpdf_annot.cpp | 56 +++------- fpdfsdk/fpdf_attachment.cpp | 9 +- fpdfsdk/fpdf_doc.cpp | 59 ++++------ fpdfsdk/fpdf_doc_unittest.cpp | 27 +++-- fpdfsdk/fpdf_edit_embeddertest.cpp | 8 +- fpdfsdk/fpdf_editimg.cpp | 27 +++-- fpdfsdk/fpdf_editpage.cpp | 16 +-- fpdfsdk/fpdf_editpath.cpp | 17 +-- fpdfsdk/fpdf_edittext.cpp | 21 ++-- fpdfsdk/fpdf_formfill.cpp | 2 +- fpdfsdk/fpdf_progressive.cpp | 2 +- fpdfsdk/fpdf_searchex.cpp | 7 +- fpdfsdk/fpdf_structtree.cpp | 48 +++++---- fpdfsdk/fpdf_text.cpp | 32 +++--- fpdfsdk/fpdf_transformpage.cpp | 8 +- fpdfsdk/fpdf_view.cpp | 40 +++---- fpdfsdk/fpdfxfa/cpdfxfa_docenvironment.cpp | 3 +- public/fpdfview.h | 42 ++++---- 24 files changed, 438 insertions(+), 238 deletions(-) create mode 100644 fpdfsdk/cpdf_annotcontext.cpp create mode 100644 fpdfsdk/cpdf_annotcontext.h diff --git a/BUILD.gn b/BUILD.gn index 09fa89ace2..d6ab8d1e70 100644 --- a/BUILD.gn +++ b/BUILD.gn @@ -105,6 +105,8 @@ jumbo_static_library("pdfium") { sources = [ "fpdfsdk/cfx_systemhandler.cpp", "fpdfsdk/cfx_systemhandler.h", + "fpdfsdk/cpdf_annotcontext.cpp", + "fpdfsdk/cpdf_annotcontext.h", "fpdfsdk/cpdfsdk_actionhandler.cpp", "fpdfsdk/cpdfsdk_actionhandler.h", "fpdfsdk/cpdfsdk_annot.cpp", diff --git a/core/fxge/skia/fx_skia_device_unittest.cpp b/core/fxge/skia/fx_skia_device_unittest.cpp index fe90fb708e..dec1e7601a 100644 --- a/core/fxge/skia/fx_skia_device_unittest.cpp +++ b/core/fxge/skia/fx_skia_device_unittest.cpp @@ -125,7 +125,7 @@ void Harness(void (*Test)(CFX_SkiaDeviceDriver*, const State&), return; FPDFBitmap_FillRect(bitmap, 0, 0, w, h, 0x00000000); CFX_DefaultRenderDevice geDevice; - RetainPtr pBitmap(CFXBitmapFromFPDFBitmap(bitmap)); + RetainPtr pBitmap(CFXDIBitmapFromFPDFBitmap(bitmap)); geDevice.Attach(pBitmap, false, nullptr, false); CFX_SkiaDeviceDriver* driver = static_cast(geDevice.GetDeviceDriver()); diff --git a/fpdfsdk/cpdf_annotcontext.cpp b/fpdfsdk/cpdf_annotcontext.cpp new file mode 100644 index 0000000000..d76d5d2f8c --- /dev/null +++ b/fpdfsdk/cpdf_annotcontext.cpp @@ -0,0 +1,35 @@ +// Copyright 2018 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 "fpdfsdk/cpdf_annotcontext.h" + +#include "core/fpdfapi/page/cpdf_form.h" +#include "core/fpdfapi/page/cpdf_page.h" +#include "core/fpdfapi/parser/cpdf_dictionary.h" +#include "core/fpdfapi/parser/cpdf_stream.h" +#include "third_party/base/ptr_util.h" + +CPDF_AnnotContext::CPDF_AnnotContext(CPDF_Dictionary* pAnnotDict, + CPDF_Page* pPage, + CPDF_Stream* pStream) + : m_pAnnotDict(pAnnotDict), m_pPage(pPage) { + SetForm(pStream); +} + +CPDF_AnnotContext::~CPDF_AnnotContext() = default; + +void CPDF_AnnotContext::SetForm(CPDF_Stream* pStream) { + if (!pStream) + return; + + // Reset the annotation matrix to be the identity matrix, since the + // appearance stream already takes matrix into account. + pStream->GetDict()->SetMatrixFor("Matrix", CFX_Matrix()); + + m_pAnnotForm = pdfium::MakeUnique( + m_pPage->m_pDocument.Get(), m_pPage->m_pResources.Get(), pStream); + m_pAnnotForm->ParseContent(); +} diff --git a/fpdfsdk/cpdf_annotcontext.h b/fpdfsdk/cpdf_annotcontext.h new file mode 100644 index 0000000000..38cc91e031 --- /dev/null +++ b/fpdfsdk/cpdf_annotcontext.h @@ -0,0 +1,38 @@ +// Copyright 2018 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 + +#ifndef FPDFSDK_CPDF_ANNOTCONTEXT_H_ +#define FPDFSDK_CPDF_ANNOTCONTEXT_H_ + +#include + +#include "core/fxcrt/unowned_ptr.h" + +class CPDF_Dictionary; +class CPDF_Form; +class CPDF_Page; +class CPDF_Stream; + +class CPDF_AnnotContext { + public: + CPDF_AnnotContext(CPDF_Dictionary* pAnnotDict, + CPDF_Page* pPage, + CPDF_Stream* pStream); + ~CPDF_AnnotContext(); + + void SetForm(CPDF_Stream* pStream); + bool HasForm() const { return !!m_pAnnotForm; } + CPDF_Form* GetForm() const { return m_pAnnotForm.get(); } + CPDF_Dictionary* GetAnnotDict() const { return m_pAnnotDict.Get(); } + CPDF_Page* GetPage() const { return m_pPage.Get(); } + + private: + std::unique_ptr m_pAnnotForm; + UnownedPtr m_pAnnotDict; + UnownedPtr m_pPage; +}; + +#endif // FPDFSDK_CPDF_ANNOTCONTEXT_H_ diff --git a/fpdfsdk/cpdfsdk_helpers.cpp b/fpdfsdk/cpdfsdk_helpers.cpp index bffc6eb240..1b90497456 100644 --- a/fpdfsdk/cpdfsdk_helpers.cpp +++ b/fpdfsdk/cpdfsdk_helpers.cpp @@ -172,20 +172,12 @@ CPDF_Page* CPDFPageFromFPDFPage(FPDF_PAGE page) { #endif // PDF_ENABLE_XFA } -CPDF_PageObject* CPDFPageObjectFromFPDFPageObject(FPDF_PAGEOBJECT page_object) { - return static_cast(page_object); -} - ByteString CFXByteStringFromFPDFWideString(FPDF_WIDESTRING wide_string) { return WideString::FromUTF16LE(wide_string, WideString::WStringLength(wide_string)) .UTF8Encode(); } -CFX_DIBitmap* CFXBitmapFromFPDFBitmap(FPDF_BITMAP bitmap) { - return static_cast(bitmap); -} - void CheckUnSupportAnnot(CPDF_Document* pDoc, const CPDF_Annot* pPDFAnnot) { CPDF_Annot::Subtype nAnnotSubtype = pPDFAnnot->GetSubtype(); if (nAnnotSubtype == CPDF_Annot::Subtype::THREED) { diff --git a/fpdfsdk/cpdfsdk_helpers.h b/fpdfsdk/cpdfsdk_helpers.h index 937ceed75e..0cd2617412 100644 --- a/fpdfsdk/cpdfsdk_helpers.h +++ b/fpdfsdk/cpdfsdk_helpers.h @@ -23,17 +23,28 @@ #endif class CPDF_Annot; +class CPDF_AnnotContext; +class CPDF_ClipPath; +class CPDF_ContentMarkItem; +class CPDF_Object; +class CPDF_Font; +class CPDF_LinkExtract; class CPDF_Page; class CPDF_PageObject; class CPDF_PageRenderContext; class CPDF_PathObject; class CPDF_Stream; +class CPDF_StructElement; +class CPDF_StructTree; +class CPDF_TextPage; +class CPDF_TextPageFind; class IPDFSDK_PauseAdapter; class FX_PATHPOINT; #ifdef PDF_ENABLE_XFA class CPDFXFA_Context; class CPDFXFA_Page; +class CXFA_FFWidget; #endif // PDF_ENABLE_XFA // Object types for public FPDF_ types; these correspond to next layer down @@ -48,17 +59,161 @@ using UnderlyingPageType = CPDFXFA_Page; // Conversions to/from underlying types. UnderlyingPageType* UnderlyingFromFPDFPage(FPDF_PAGE page); FPDF_PAGE FPDFPageFromUnderlying(UnderlyingPageType* page); - -// Conversions to/from FPDF_ types. -CPDF_Document* CPDFDocumentFromFPDFDocument(FPDF_DOCUMENT doc); +CPDF_Page* CPDFPageFromFPDFPage(FPDF_PAGE page); FPDF_DOCUMENT FPDFDocumentFromCPDFDocument(CPDF_Document* doc); +CPDF_Document* CPDFDocumentFromFPDFDocument(FPDF_DOCUMENT doc); + +// Conversions to/from incomplete FPDF_ API types. +inline FPDF_ACTION FPDFActionFromCPDFDictionary(CPDF_Dictionary* action) { + return reinterpret_cast(action); +} +inline CPDF_Dictionary* CPDFDictionaryFromFPDFAction(FPDF_ACTION action) { + return reinterpret_cast(action); +} + +inline FPDF_ANNOTATION FPDFAnnotationFromCPDFAnnotContext( + CPDF_AnnotContext* annot) { + return reinterpret_cast(annot); +} +inline CPDF_AnnotContext* CPDFAnnotContextFromFPDFAnnotation( + FPDF_ANNOTATION annot) { + return reinterpret_cast(annot); +} + +inline FPDF_ATTACHMENT FPDFAttachmentFromCPDFObject(CPDF_Object* attachment) { + return reinterpret_cast(attachment); +} +inline CPDF_Object* CPDFObjectFromFPDFAttachment(FPDF_ATTACHMENT attachment) { + return reinterpret_cast(attachment); +} + +inline FPDF_BITMAP FPDFBitmapFromCFXDIBitmap(CFX_DIBitmap* bitmap) { + return reinterpret_cast(bitmap); +} +inline CFX_DIBitmap* CFXDIBitmapFromFPDFBitmap(FPDF_BITMAP bitmap) { + return reinterpret_cast(bitmap); +} + +inline FPDF_BOOKMARK FPDFBookmarkFromCPDFDictionary(CPDF_Dictionary* bookmark) { + return reinterpret_cast(bookmark); +} +inline CPDF_Dictionary* CPDFDictionaryFromFPDFBookmark(FPDF_BOOKMARK bookmark) { + return reinterpret_cast(bookmark); +} + +inline FPDF_CLIPPATH FPDFClipPathFromCPDFClipPath(CPDF_ClipPath* path) { + return reinterpret_cast(path); +} +inline CPDF_ClipPath* CPDFClipPathFromFPDFClipPath(FPDF_CLIPPATH path) { + return reinterpret_cast(path); +} + +inline FPDF_DEST FPDFDestFromCPDFArray(CPDF_Array* dest) { + return reinterpret_cast(dest); +} +inline CPDF_Array* CPDFArrayFromFPDFDest(FPDF_DEST dest) { + return reinterpret_cast(dest); +} + +inline FPDF_FONT FPDFFontFromCPDFFont(CPDF_Font* font) { + return reinterpret_cast(font); +} +inline CPDF_Font* CPDFFontFromFPDFFont(FPDF_FONT font) { + return reinterpret_cast(font); +} + +inline FPDF_LINK FPDFLinkFromCPDFDictionary(CPDF_Dictionary* link) { + return reinterpret_cast(link); +} +inline CPDF_Dictionary* CPDFDictionaryFromFPDFLink(FPDF_LINK link) { + return reinterpret_cast(link); +} + +inline FPDF_PAGELINK FPDFPageLinkFromCPDFLinkExtract(CPDF_LinkExtract* link) { + return reinterpret_cast(link); +} +inline CPDF_LinkExtract* CPDFLinkExtractFromFPDFPageLink(FPDF_PAGELINK link) { + return reinterpret_cast(link); +} + +inline FPDF_PAGEOBJECT FPDFPageObjectFromCPDFPageObject( + CPDF_PageObject* page_object) { + return reinterpret_cast(page_object); +} +inline CPDF_PageObject* CPDFPageObjectFromFPDFPageObject( + FPDF_PAGEOBJECT page_object) { + return reinterpret_cast(page_object); +} + +inline FPDF_PAGEOBJECTMARK FPDFPageObjectMarkFromCPDFContentMarkItem( + const CPDF_ContentMarkItem* mark) { + return reinterpret_cast(mark); +} +inline const CPDF_ContentMarkItem* CPDFContentMarkItemFromFPDFPageObjectMark( + FPDF_PAGEOBJECTMARK mark) { + return reinterpret_cast(mark); +} + +inline FPDF_PAGERANGE FPDFPageRangeFromCPDFArray(CPDF_Array* range) { + return reinterpret_cast(range); +} +inline CPDF_Array* CPDFArrayFromFPDFPageRange(FPDF_PAGERANGE range) { + return reinterpret_cast(range); +} + +inline FPDF_PATHSEGMENT FPDFPathSegmentFromFXPathPoint( + const FX_PATHPOINT* segment) { + return reinterpret_cast(segment); +} +inline const FX_PATHPOINT* FXPathPointFromFPDFPathSegment( + FPDF_PATHSEGMENT segment) { + return reinterpret_cast(segment); +} + +inline FPDF_STRUCTTREE FPDFStructTreeFromCPDFStructTree( + CPDF_StructTree* struct_tree) { + return reinterpret_cast(struct_tree); +} +inline CPDF_StructTree* CPDFStructTreeFromFPDFStructTree( + FPDF_STRUCTTREE struct_tree) { + return reinterpret_cast(struct_tree); +} + +inline FPDF_STRUCTELEMENT FPDFStructElementFromCPDFStructElement( + CPDF_StructElement* struct_element) { + return reinterpret_cast(struct_element); +} +inline CPDF_StructElement* CPDFStructElementFromFPDFStructElement( + FPDF_STRUCTELEMENT struct_element) { + return reinterpret_cast(struct_element); +} + +inline FPDF_TEXTPAGE FPDFTextPageFromCPDFTextPage(CPDF_TextPage* page) { + return reinterpret_cast(page); +} +inline CPDF_TextPage* CPDFTextPageFromFPDFTextPage(FPDF_TEXTPAGE page) { + return reinterpret_cast(page); +} + +inline FPDF_SCHHANDLE FPDFSchHandleFromCPDFTextPageFind( + CPDF_TextPageFind* handle) { + return reinterpret_cast(handle); +} +inline CPDF_TextPageFind* CPDFTextPageFindFromFPDFSchHandle( + FPDF_SCHHANDLE handle) { + return reinterpret_cast(handle); +} -CPDF_Page* CPDFPageFromFPDFPage(FPDF_PAGE page); -CPDF_PageObject* CPDFPageObjectFromFPDFPageObject(FPDF_PAGEOBJECT page_object); ByteString CFXByteStringFromFPDFWideString(FPDF_WIDESTRING wide_string); -CFX_DIBitmap* CFXBitmapFromFPDFBitmap(FPDF_BITMAP bitmap); #ifdef PDF_ENABLE_XFA +inline FPDF_WIDGET FPDFWidgetFromCXFAFFWidget(CXFA_FFWidget* widget) { + return reinterpret_cast(widget); +} +inline CXFA_FFWidget* CXFAFFWidgetFromFPDFWidget(FPDF_WIDGET widget) { + return reinterpret_cast(widget); +} + // Layering prevents fxcrt from knowing about FPDF_FILEHANDLER, so this can't // be a static method of IFX_SeekableStream. RetainPtr MakeSeekableStream( diff --git a/fpdfsdk/fpdf_annot.cpp b/fpdfsdk/fpdf_annot.cpp index 6504ee7402..0dbad498ce 100644 --- a/fpdfsdk/fpdf_annot.cpp +++ b/fpdfsdk/fpdf_annot.cpp @@ -22,6 +22,7 @@ #include "core/fpdfdoc/cpdf_interform.h" #include "core/fpdfdoc/cpvt_generateap.h" #include "core/fxge/cfx_color.h" +#include "fpdfsdk/cpdf_annotcontext.h" #include "fpdfsdk/cpdfsdk_helpers.h" namespace { @@ -141,45 +142,6 @@ static_assert(static_cast(CPDF_Object::Type::REFERENCE) == FPDF_OBJECT_REFERENCE, "CPDF_Object::REFERENCE value mismatch"); -class CPDF_AnnotContext { - public: - CPDF_AnnotContext(CPDF_Dictionary* pAnnotDict, - CPDF_Page* pPage, - CPDF_Stream* pStream) - : m_pAnnotDict(pAnnotDict), m_pPage(pPage) { - SetForm(pStream); - } - ~CPDF_AnnotContext() {} - - bool HasForm() const { return !!m_pAnnotForm; } - - void SetForm(CPDF_Stream* pStream) { - if (!pStream) - return; - - // Reset the annotation matrix to be the identity matrix, since the - // appearance stream already takes matrix into account. - pStream->GetDict()->SetMatrixFor("Matrix", CFX_Matrix()); - - m_pAnnotForm = pdfium::MakeUnique( - m_pPage->m_pDocument.Get(), m_pPage->m_pResources.Get(), pStream); - m_pAnnotForm->ParseContent(); - } - - CPDF_Form* GetForm() const { return m_pAnnotForm.get(); } - CPDF_Dictionary* GetAnnotDict() const { return m_pAnnotDict.Get(); } - CPDF_Page* GetPage() const { return m_pPage.Get(); } - - private: - std::unique_ptr m_pAnnotForm; - UnownedPtr m_pAnnotDict; - UnownedPtr m_pPage; -}; - -CPDF_AnnotContext* CPDFAnnotContextFromFPDFAnnotation(FPDF_ANNOTATION annot) { - return static_cast(annot); -} - bool HasAPStream(const CPDF_Dictionary* pAnnotDict) { return !!FPDFDOC_GetAnnotAP(pAnnotDict, CPDF_Annot::AppearanceMode::Normal); } @@ -270,9 +232,10 @@ FPDFPage_CreateAnnot(FPDF_PAGE page, FPDF_ANNOTATION_SUBTYPE subtype) { CPDF_Array* pAnnotList = pPage->m_pFormDict->GetArrayFor("Annots"); if (!pAnnotList) pAnnotList = pPage->m_pFormDict->SetNewFor("Annots"); - pAnnotList->Add(std::move(pDict)); - return pNewAnnot.release(); + + // Caller takes ownership. + return FPDFAnnotationFromCPDFAnnotContext(pNewAnnot.release()); } FPDF_EXPORT int FPDF_CALLCONV FPDFPage_GetAnnotCount(FPDF_PAGE page) { @@ -296,7 +259,9 @@ FPDF_EXPORT FPDF_ANNOTATION FPDF_CALLCONV FPDFPage_GetAnnot(FPDF_PAGE page, CPDF_Dictionary* pDict = ToDictionary(pAnnots->GetDirectObjectAt(index)); auto pNewAnnot = pdfium::MakeUnique(pDict, pPage, nullptr); - return pNewAnnot.release(); + + // Caller takes ownership. + return FPDFAnnotationFromCPDFAnnotContext(pNewAnnot.release()); } FPDF_EXPORT int FPDF_CALLCONV FPDFPage_GetAnnotIndex(FPDF_PAGE page, @@ -480,7 +445,8 @@ FPDFAnnot_GetObject(FPDF_ANNOTATION annot, int index) { pAnnot->SetForm(pStream); } - return pAnnot->GetForm()->GetPageObjectByIndex(index); + return FPDFPageObjectFromCPDFPageObject( + pAnnot->GetForm()->GetPageObjectByIndex(index)); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV @@ -868,7 +834,9 @@ FPDFAnnot_GetLinkedAnnot(FPDF_ANNOTATION annot, FPDF_BYTESTRING key) { auto pLinkedAnnot = pdfium::MakeUnique( pLinkedDict, pAnnot->GetPage(), nullptr); - return pLinkedAnnot.release(); + + // Caller takes ownership. + return FPDFAnnotationFromCPDFAnnotContext(pLinkedAnnot.release()); } FPDF_EXPORT int FPDF_CALLCONV FPDFAnnot_GetFlags(FPDF_ANNOTATION annot) { diff --git a/fpdfsdk/fpdf_attachment.cpp b/fpdfsdk/fpdf_attachment.cpp index 25957174bc..f2ed684e40 100644 --- a/fpdfsdk/fpdf_attachment.cpp +++ b/fpdfsdk/fpdf_attachment.cpp @@ -26,10 +26,6 @@ namespace { constexpr char kChecksumKey[] = "CheckSum"; -CPDF_Object* CPDFObjectFromFPDFAttachment(FPDF_ATTACHMENT attachment) { - return static_cast(attachment); -} - ByteString CFXByteStringHexDecode(const ByteString& bsHex) { uint8_t* result = nullptr; uint32_t size = 0; @@ -101,7 +97,7 @@ FPDFDoc_AddAttachment(FPDF_DOCUMENT document, FPDF_WIDESTRING name) { return nullptr; } - return pFile; + return FPDFAttachmentFromCPDFObject(pFile); } FPDF_EXPORT FPDF_ATTACHMENT FPDF_CALLCONV @@ -115,7 +111,8 @@ FPDFDoc_GetAttachment(FPDF_DOCUMENT document, int index) { return nullptr; WideString csName; - return nameTree.LookupValueAndName(index, &csName); + return FPDFAttachmentFromCPDFObject( + nameTree.LookupValueAndName(index, &csName)); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV diff --git a/fpdfsdk/fpdf_doc.cpp b/fpdfsdk/fpdf_doc.cpp index 54718a9409..17cfce0b24 100644 --- a/fpdfsdk/fpdf_doc.cpp +++ b/fpdfsdk/fpdf_doc.cpp @@ -61,22 +61,6 @@ CPDF_LinkList* GetLinkList(CPDF_Page* page) { return pHolder->get(); } -CPDF_Array* CPDFArrayFromDest(FPDF_DEST dest) { - return static_cast(dest); -} - -CPDF_Dictionary* CPDFDictionaryFromFPDFAction(FPDF_ACTION action) { - return ToDictionary(static_cast(action)); -} - -CPDF_Dictionary* CPDFDictionaryFromFPDFBookmark(FPDF_BOOKMARK bookmark) { - return ToDictionary(static_cast(bookmark)); -} - -CPDF_Dictionary* CPDFDictionaryFromFPDFLink(FPDF_LINK link) { - return ToDictionary(static_cast(link)); -} - } // namespace FPDF_EXPORT FPDF_BOOKMARK FPDF_CALLCONV @@ -86,19 +70,22 @@ FPDFBookmark_GetFirstChild(FPDF_DOCUMENT document, FPDF_BOOKMARK pDict) { return nullptr; CPDF_BookmarkTree tree(pDoc); CPDF_Bookmark bookmark(CPDFDictionaryFromFPDFBookmark(pDict)); - return tree.GetFirstChild(bookmark).GetDict(); + return FPDFBookmarkFromCPDFDictionary(tree.GetFirstChild(bookmark).GetDict()); } FPDF_EXPORT FPDF_BOOKMARK FPDF_CALLCONV FPDFBookmark_GetNextSibling(FPDF_DOCUMENT document, FPDF_BOOKMARK pDict) { if (!pDict) return nullptr; + CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document); if (!pDoc) return nullptr; + CPDF_BookmarkTree tree(pDoc); CPDF_Bookmark bookmark(CPDFDictionaryFromFPDFBookmark(pDict)); - return tree.GetNextSibling(bookmark).GetDict(); + return FPDFBookmarkFromCPDFDictionary( + tree.GetNextSibling(bookmark).GetDict()); } FPDF_EXPORT unsigned long FPDF_CALLCONV @@ -121,7 +108,8 @@ FPDFBookmark_Find(FPDF_DOCUMENT document, FPDF_WIDESTRING title) { size_t len = WideString::WStringLength(title); WideString encodedTitle = WideString::FromUTF16LE(title, len); std::set visited; - return FindBookmark(tree, CPDF_Bookmark(), encodedTitle, &visited).GetDict(); + return FPDFBookmarkFromCPDFDictionary( + FindBookmark(tree, CPDF_Bookmark(), encodedTitle, &visited).GetDict()); } FPDF_EXPORT FPDF_DEST FPDF_CALLCONV FPDFBookmark_GetDest(FPDF_DOCUMENT document, @@ -134,13 +122,13 @@ FPDF_EXPORT FPDF_DEST FPDF_CALLCONV FPDFBookmark_GetDest(FPDF_DOCUMENT document, CPDF_Bookmark bookmark(CPDFDictionaryFromFPDFBookmark(pDict)); CPDF_Dest dest = bookmark.GetDest(pDoc); if (dest.GetObject()) - return dest.GetObject(); + return FPDFDestFromCPDFArray(dest.GetObject()); // If this bookmark is not directly associated with a dest, we try to get // action CPDF_Action action = bookmark.GetAction(); if (!action.GetDict()) return nullptr; - return action.GetDest(pDoc).GetObject(); + return FPDFDestFromCPDFArray(action.GetDest(pDoc).GetObject()); } FPDF_EXPORT FPDF_ACTION FPDF_CALLCONV @@ -148,7 +136,7 @@ FPDFBookmark_GetAction(FPDF_BOOKMARK pDict) { if (!pDict) return nullptr; CPDF_Bookmark bookmark(CPDFDictionaryFromFPDFBookmark(pDict)); - return bookmark.GetAction().GetDict(); + return FPDFActionFromCPDFDictionary(bookmark.GetAction().GetDict()); } FPDF_EXPORT unsigned long FPDF_CALLCONV FPDFAction_GetType(FPDF_ACTION pDict) { @@ -179,7 +167,7 @@ FPDF_EXPORT FPDF_DEST FPDF_CALLCONV FPDFAction_GetDest(FPDF_DOCUMENT document, if (!pDoc) return nullptr; CPDF_Action action(CPDFDictionaryFromFPDFAction(pDict)); - return action.GetDest(pDoc).GetObject(); + return FPDFDestFromCPDFArray(action.GetDest(pDoc).GetObject()); } FPDF_EXPORT unsigned long FPDF_CALLCONV @@ -223,7 +211,7 @@ FPDFDest_GetPageIndex(FPDF_DOCUMENT document, FPDF_DEST dest) { if (!pDoc) return 0; - CPDF_Dest destination(CPDFArrayFromDest(dest)); + CPDF_Dest destination(CPDFArrayFromFPDFDest(dest)); return destination.GetPageIndexDeprecated(pDoc); } @@ -236,7 +224,7 @@ FPDF_EXPORT int FPDF_CALLCONV FPDFDest_GetDestPageIndex(FPDF_DOCUMENT document, if (!pDoc) return -1; - CPDF_Dest destination(CPDFArrayFromDest(dest)); + CPDF_Dest destination(CPDFArrayFromFPDFDest(dest)); return destination.GetDestPageIndex(pDoc); } @@ -249,7 +237,7 @@ FPDFDest_GetView(FPDF_DEST pDict, return 0; } - CPDF_Dest destination(CPDFArrayFromDest(pDict)); + CPDF_Dest destination(CPDFArrayFromFPDFDest(pDict)); unsigned long nParams = destination.GetNumParams(); ASSERT(nParams <= 4); *pNumParams = nParams; @@ -269,7 +257,7 @@ FPDFDest_GetLocationInPage(FPDF_DEST pDict, if (!pDict) return false; - auto dest = pdfium::MakeUnique(CPDFArrayFromDest(pDict)); + auto dest = pdfium::MakeUnique(CPDFArrayFromFPDFDest(pDict)); // FPDF_BOOL is an int, GetXYZ expects bools. bool bHasX; @@ -295,11 +283,10 @@ FPDF_EXPORT FPDF_LINK FPDF_CALLCONV FPDFLink_GetLinkAtPoint(FPDF_PAGE page, if (!pLinkList) return nullptr; - return pLinkList - ->GetLinkAtPoint(pPage, - CFX_PointF(static_cast(x), static_cast(y)), - nullptr) - .GetDict(); + CPDF_Link link = pLinkList->GetLinkAtPoint( + pPage, CFX_PointF(static_cast(x), static_cast(y)), nullptr); + + return FPDFLinkFromCPDFDictionary(link.GetDict()); } FPDF_EXPORT int FPDF_CALLCONV FPDFLink_GetLinkZOrderAtPoint(FPDF_PAGE page, @@ -328,14 +315,14 @@ FPDF_EXPORT FPDF_DEST FPDF_CALLCONV FPDFLink_GetDest(FPDF_DOCUMENT document, if (!pDoc) return nullptr; CPDF_Link link(CPDFDictionaryFromFPDFLink(pDict)); - FPDF_DEST dest = link.GetDest(pDoc).GetObject(); + FPDF_DEST dest = FPDFDestFromCPDFArray(link.GetDest(pDoc).GetObject()); if (dest) return dest; // If this link is not directly associated with a dest, we try to get action CPDF_Action action = link.GetAction(); if (!action.GetDict()) return nullptr; - return action.GetDest(pDoc).GetObject(); + return FPDFDestFromCPDFArray(action.GetDest(pDoc).GetObject()); } FPDF_EXPORT FPDF_ACTION FPDF_CALLCONV FPDFLink_GetAction(FPDF_LINK pDict) { @@ -343,7 +330,7 @@ FPDF_EXPORT FPDF_ACTION FPDF_CALLCONV FPDFLink_GetAction(FPDF_LINK pDict) { return nullptr; CPDF_Link link(CPDFDictionaryFromFPDFLink(pDict)); - return link.GetAction().GetDict(); + return FPDFActionFromCPDFDictionary(link.GetAction().GetDict()); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFLink_Enumerate(FPDF_PAGE page, @@ -363,7 +350,7 @@ FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFLink_Enumerate(FPDF_PAGE page, continue; if (pDict->GetStringFor("Subtype") == "Link") { *start_pos = static_cast(i + 1); - *link_annot = static_cast(pDict); + *link_annot = FPDFLinkFromCPDFDictionary(pDict); return true; } } diff --git a/fpdfsdk/fpdf_doc_unittest.cpp b/fpdfsdk/fpdf_doc_unittest.cpp index 0f285a14c3..0234d47833 100644 --- a/fpdfsdk/fpdf_doc_unittest.cpp +++ b/fpdfsdk/fpdf_doc_unittest.cpp @@ -127,11 +127,13 @@ TEST_F(PDFDocTest, FindBookmark) { // Title with a match. title = GetFPDFWideString(L"Chapter 2"); - EXPECT_EQ(bookmarks[2].obj, FPDFBookmark_Find(m_pDoc.get(), title.get())); + EXPECT_EQ(FPDFBookmarkFromCPDFDictionary(bookmarks[2].obj), + FPDFBookmark_Find(m_pDoc.get(), title.get())); // Title match is case insensitive. title = GetFPDFWideString(L"cHaPter 2"); - EXPECT_EQ(bookmarks[2].obj, FPDFBookmark_Find(m_pDoc.get(), title.get())); + EXPECT_EQ(FPDFBookmarkFromCPDFDictionary(bookmarks[2].obj), + FPDFBookmark_Find(m_pDoc.get(), title.get())); } { // Circular bookmarks in depth. @@ -166,7 +168,8 @@ TEST_F(PDFDocTest, FindBookmark) { // Title with a match. title = GetFPDFWideString(L"Chapter 2"); - EXPECT_EQ(bookmarks[2].obj, FPDFBookmark_Find(m_pDoc.get(), title.get())); + EXPECT_EQ(FPDFBookmarkFromCPDFDictionary(bookmarks[2].obj), + FPDFBookmark_Find(m_pDoc.get(), title.get())); } { // Circular bookmarks in breadth. @@ -207,7 +210,8 @@ TEST_F(PDFDocTest, FindBookmark) { // Title with a match. title = GetFPDFWideString(L"Chapter 3"); - EXPECT_EQ(bookmarks[3].obj, FPDFBookmark_Find(m_pDoc.get(), title.get())); + EXPECT_EQ(FPDFBookmarkFromCPDFDictionary(bookmarks[3].obj), + FPDFBookmark_Find(m_pDoc.get(), title.get())); } } @@ -226,8 +230,9 @@ TEST_F(PDFDocTest, GetLocationInPage) { FS_FLOAT y; FS_FLOAT zoom; - EXPECT_TRUE(FPDFDest_GetLocationInPage(array.get(), &hasX, &hasY, &hasZoom, - &x, &y, &zoom)); + EXPECT_TRUE(FPDFDest_GetLocationInPage(FPDFDestFromCPDFArray(array.get()), + &hasX, &hasY, &hasZoom, &x, &y, + &zoom)); EXPECT_TRUE(hasX); EXPECT_TRUE(hasY); EXPECT_TRUE(hasZoom); @@ -238,13 +243,15 @@ TEST_F(PDFDocTest, GetLocationInPage) { array->SetNewAt(2); array->SetNewAt(3); array->SetNewAt(4); - EXPECT_TRUE(FPDFDest_GetLocationInPage(array.get(), &hasX, &hasY, &hasZoom, - &x, &y, &zoom)); + EXPECT_TRUE(FPDFDest_GetLocationInPage(FPDFDestFromCPDFArray(array.get()), + &hasX, &hasY, &hasZoom, &x, &y, + &zoom)); EXPECT_FALSE(hasX); EXPECT_FALSE(hasY); EXPECT_FALSE(hasZoom); array = pdfium::MakeUnique(); - EXPECT_FALSE(FPDFDest_GetLocationInPage(array.get(), &hasX, &hasY, &hasZoom, - &x, &y, &zoom)); + EXPECT_FALSE(FPDFDest_GetLocationInPage(FPDFDestFromCPDFArray(array.get()), + &hasX, &hasY, &hasZoom, &x, &y, + &zoom)); } diff --git a/fpdfsdk/fpdf_edit_embeddertest.cpp b/fpdfsdk/fpdf_edit_embeddertest.cpp index 0604cdbe71..a20faeba80 100644 --- a/fpdfsdk/fpdf_edit_embeddertest.cpp +++ b/fpdfsdk/fpdf_edit_embeddertest.cpp @@ -995,7 +995,7 @@ TEST_F(FPDFEditEmbeddertest, LoadSimpleType1Font) { ScopedFPDFFont font( FPDFText_LoadFont(document(), data, size, FPDF_FONT_TYPE1, false)); ASSERT_TRUE(font.get()); - CPDF_Font* typed_font = static_cast(font.get()); + CPDF_Font* typed_font = CPDFFontFromFPDFFont(font.get()); EXPECT_TRUE(typed_font->IsType1Font()); CPDF_Dictionary* font_dict = typed_font->GetFontDict(); @@ -1024,7 +1024,7 @@ TEST_F(FPDFEditEmbeddertest, LoadSimpleTrueTypeFont) { ScopedFPDFFont font( FPDFText_LoadFont(document(), data, size, FPDF_FONT_TRUETYPE, false)); ASSERT_TRUE(font.get()); - CPDF_Font* typed_font = static_cast(font.get()); + CPDF_Font* typed_font = CPDFFontFromFPDFFont(font.get()); EXPECT_TRUE(typed_font->IsTrueTypeFont()); CPDF_Dictionary* font_dict = typed_font->GetFontDict(); @@ -1054,7 +1054,7 @@ TEST_F(FPDFEditEmbeddertest, LoadCIDType0Font) { ScopedFPDFFont font( FPDFText_LoadFont(document(), data, size, FPDF_FONT_TYPE1, 1)); ASSERT_TRUE(font.get()); - CPDF_Font* typed_font = static_cast(font.get()); + CPDF_Font* typed_font = CPDFFontFromFPDFFont(font.get()); EXPECT_TRUE(typed_font->IsCIDFont()); // Check font dictionary entries @@ -1096,7 +1096,7 @@ TEST_F(FPDFEditEmbeddertest, LoadCIDType2Font) { ScopedFPDFFont font( FPDFText_LoadFont(document(), data, size, FPDF_FONT_TRUETYPE, 1)); ASSERT_TRUE(font.get()); - CPDF_Font* typed_font = static_cast(font.get()); + CPDF_Font* typed_font = CPDFFontFromFPDFFont(font.get()); EXPECT_TRUE(typed_font->IsCIDFont()); // Check font dictionary entries diff --git a/fpdfsdk/fpdf_editimg.cpp b/fpdfsdk/fpdf_editimg.cpp index f1d90ece2d..9485a75002 100644 --- a/fpdfsdk/fpdf_editimg.cpp +++ b/fpdfsdk/fpdf_editimg.cpp @@ -57,8 +57,10 @@ bool LoadJpegHelper(FPDF_PAGE* pages, if (!image_object || !fileAccess) return false; - RetainPtr pFile = MakeSeekableReadStream(fileAccess); - CPDF_ImageObject* pImgObj = static_cast(image_object); + CPDF_ImageObject* pImgObj = + CPDFPageObjectFromFPDFPageObject(image_object)->AsImage(); + if (!pImgObj) + return false; if (pages) { for (int index = 0; index < nCount; index++) { @@ -68,6 +70,7 @@ bool LoadJpegHelper(FPDF_PAGE* pages, } } + RetainPtr pFile = MakeSeekableReadStream(fileAccess); if (inlineJpeg) pImgObj->GetImage()->SetJpegImageInline(pFile); else @@ -86,7 +89,9 @@ FPDFPageObj_NewImageObj(FPDF_DOCUMENT document) { auto pImageObj = pdfium::MakeUnique(); pImageObj->SetImage(pdfium::MakeRetain(pDoc)); - return pImageObj.release(); + + // Caller takes ownership. + return FPDFPageObjectFromCPDFPageObject(pImageObj.release()); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV @@ -116,7 +121,11 @@ FPDFImageObj_SetMatrix(FPDF_PAGEOBJECT image_object, if (!image_object) return false; - CPDF_ImageObject* pImgObj = static_cast(image_object); + CPDF_ImageObject* pImgObj = + CPDFPageObjectFromFPDFPageObject(image_object)->AsImage(); + if (!pImgObj) + return false; + pImgObj->set_matrix(CFX_Matrix(static_cast(a), static_cast(b), static_cast(c), static_cast(d), static_cast(e), static_cast(f))); @@ -133,13 +142,17 @@ FPDFImageObj_SetBitmap(FPDF_PAGE* pages, if (!image_object || !bitmap || !pages) return false; - CPDF_ImageObject* pImgObj = static_cast(image_object); + CPDF_ImageObject* pImgObj = + CPDFPageObjectFromFPDFPageObject(image_object)->AsImage(); + if (!pImgObj) + return false; + for (int index = 0; index < nCount; index++) { CPDF_Page* pPage = CPDFPageFromFPDFPage(pages[index]); if (pPage) pImgObj->GetImage()->ResetCache(pPage, nullptr); } - RetainPtr holder(CFXBitmapFromFPDFBitmap(bitmap)); + RetainPtr holder(CFXDIBitmapFromFPDFBitmap(bitmap)); pImgObj->GetImage()->SetImage(holder); pImgObj->CalcBoundingBox(); pImgObj->SetDirty(true); @@ -170,7 +183,7 @@ FPDFImageObj_GetBitmap(FPDF_PAGEOBJECT image_object) { else pBitmap = pSource->Clone(nullptr); - return pBitmap.Leak(); + return FPDFBitmapFromCFXDIBitmap(pBitmap.Leak()); } FPDF_EXPORT unsigned long FPDF_CALLCONV diff --git a/fpdfsdk/fpdf_editpage.cpp b/fpdfsdk/fpdf_editpage.cpp index 944dbdc576..0647dc537f 100644 --- a/fpdfsdk/fpdf_editpage.cpp +++ b/fpdfsdk/fpdf_editpage.cpp @@ -54,11 +54,6 @@ static_assert(FPDF_PAGEOBJ_SHADING == CPDF_PageObject::SHADING, static_assert(FPDF_PAGEOBJ_FORM == CPDF_PageObject::FORM, "FPDF_PAGEOBJ_FORM/CPDF_PageObject::FORM mismatch"); -const CPDF_ContentMarkItem* CPDFContentMarkItemFromFPDFPageObjectMark( - FPDF_PAGEOBJECTMARK mark) { - return static_cast(mark); -} - bool IsPageObject(CPDF_Page* pPage) { if (!pPage || !pPage->m_pFormDict || !pPage->m_pFormDict->KeyExist("Type")) return false; @@ -251,7 +246,7 @@ FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV FPDFPage_GetObject(FPDF_PAGE page, if (!IsPageObject(pPage)) return nullptr; - return pPage->GetPageObjectByIndex(index); + return FPDFPageObjectFromCPDFPageObject(pPage->GetPageObjectByIndex(index)); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPage_HasTransparency(FPDF_PAGE page) { @@ -278,15 +273,14 @@ FPDFPageObj_GetMark(FPDF_PAGEOBJECT page_object, unsigned long index) { if (!page_object) return nullptr; - const auto& mark = - CPDFPageObjectFromFPDFPageObject(page_object)->m_ContentMark; - if (!mark.HasRef()) + auto* mark = &CPDFPageObjectFromFPDFPageObject(page_object)->m_ContentMark; + if (!mark->HasRef()) return nullptr; - if (index >= mark.CountItems()) + if (index >= mark->CountItems()) return nullptr; - return static_cast(&mark.GetItem(index)); + return FPDFPageObjectMarkFromCPDFContentMarkItem(&mark->GetItem(index)); } FPDF_EXPORT unsigned long FPDF_CALLCONV diff --git a/fpdfsdk/fpdf_editpath.cpp b/fpdfsdk/fpdf_editpath.cpp index 82c7ca13ef..aca2bebf81 100644 --- a/fpdfsdk/fpdf_editpath.cpp +++ b/fpdfsdk/fpdf_editpath.cpp @@ -42,10 +42,6 @@ CPDF_PathObject* CPDFPathObjectFromFPDFPageObject(FPDF_PAGEOBJECT page_object) { return obj ? obj->AsPath() : nullptr; } -const FX_PATHPOINT* FXPathPointFromFPDFPathSegment(FPDF_PATHSEGMENT segment) { - return static_cast(segment); -} - unsigned int GetAlphaAsUnsignedInt(float alpha) { return static_cast(alpha * 255.f + 0.5f); } @@ -57,7 +53,9 @@ FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV FPDFPageObj_CreateNewPath(float x, auto pPathObj = pdfium::MakeUnique(); pPathObj->m_Path.AppendPoint(CFX_PointF(x, y), FXPT_TYPE::MoveTo, false); pPathObj->DefaultStates(); - return pPathObj.release(); // Caller takes ownership. + + // Caller takes ownership. + return FPDFPageObjectFromCPDFPageObject(pPathObj.release()); } FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV FPDFPageObj_CreateNewRect(float x, @@ -67,7 +65,9 @@ FPDF_EXPORT FPDF_PAGEOBJECT FPDF_CALLCONV FPDFPageObj_CreateNewRect(float x, auto pPathObj = pdfium::MakeUnique(); pPathObj->m_Path.AppendRect(x, y, x + w, y + h); pPathObj->DefaultStates(); - return pPathObj.release(); // Caller takes ownership. + + // Caller takes ownership. + return FPDFPageObjectFromCPDFPageObject(pPathObj.release()); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV @@ -156,7 +156,10 @@ FPDFPath_GetPathSegment(FPDF_PAGEOBJECT path, int index) { return nullptr; const std::vector& points = pPathObj->m_Path.GetPoints(); - return pdfium::IndexInBounds(points, index) ? &points[index] : nullptr; + if (!pdfium::IndexInBounds(points, index)) + return nullptr; + + return FPDFPathSegmentFromFXPathPoint(&points[index]); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFPath_MoveTo(FPDF_PAGEOBJECT path, diff --git a/fpdfsdk/fpdf_edittext.cpp b/fpdfsdk/fpdf_edittext.cpp index 648d1dd5d5..2996a505ee 100644 --- a/fpdfsdk/fpdf_edittext.cpp +++ b/fpdfsdk/fpdf_edittext.cpp @@ -416,12 +416,18 @@ FPDFPageObj_NewTextObj(FPDF_DOCUMENT document, pTextObj->m_TextState.SetFont(pFont); pTextObj->m_TextState.SetFontSize(font_size); pTextObj->DefaultStates(); - return pTextObj.release(); // Caller takes ownership. + + // Caller takes ownership. + return FPDFPageObjectFromCPDFPageObject(pTextObj.release()); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFText_SetText(FPDF_PAGEOBJECT text_object, FPDF_WIDESTRING text) { - auto* pTextObj = static_cast(text_object); + if (!text_object) + return false; + + CPDF_TextObject* pTextObj = + CPDFPageObjectFromFPDFPageObject(text_object)->AsText(); if (!pTextObj) return false; @@ -455,8 +461,9 @@ FPDF_EXPORT FPDF_FONT FPDF_CALLCONV FPDFText_LoadFont(FPDF_DOCUMENT document, if (!pFont->LoadEmbedded(data, size)) return nullptr; - return cid ? LoadCompositeFont(pDoc, std::move(pFont), data, size, font_type) - : LoadSimpleFont(pDoc, std::move(pFont), data, size, font_type); + return FPDFFontFromCPDFFont( + cid ? LoadCompositeFont(pDoc, std::move(pFont), data, size, font_type) + : LoadSimpleFont(pDoc, std::move(pFont), data, size, font_type)); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV @@ -469,7 +476,7 @@ FPDFText_SetFillColor(FPDF_PAGEOBJECT text_object, } FPDF_EXPORT void FPDF_CALLCONV FPDFFont_Close(FPDF_FONT font) { - CPDF_Font* pFont = static_cast(font); + CPDF_Font* pFont = CPDFFontFromFPDFFont(font); if (!pFont) return; @@ -487,7 +494,7 @@ FPDFPageObj_CreateTextObj(FPDF_DOCUMENT document, FPDF_FONT font, float font_size) { CPDF_Document* pDoc = CPDFDocumentFromFPDFDocument(document); - CPDF_Font* pFont = static_cast(font); + CPDF_Font* pFont = CPDFFontFromFPDFFont(font); if (!pDoc || !pFont) return nullptr; @@ -495,5 +502,5 @@ FPDFPageObj_CreateTextObj(FPDF_DOCUMENT document, pTextObj->m_TextState.SetFont(pDoc->LoadFont(pFont->GetFontDict())); pTextObj->m_TextState.SetFontSize(font_size); pTextObj->DefaultStates(); - return pTextObj.release(); + return FPDFPageObjectFromCPDFPageObject(pTextObj.release()); } diff --git a/fpdfsdk/fpdf_formfill.cpp b/fpdfsdk/fpdf_formfill.cpp index b99bd5f40d..280ef62edb 100644 --- a/fpdfsdk/fpdf_formfill.cpp +++ b/fpdfsdk/fpdf_formfill.cpp @@ -157,7 +157,7 @@ void FFLCommon(FPDF_FORMHANDLE hHandle, #ifdef _SKIA_SUPPORT_ pDevice->AttachRecorder(static_cast(recorder)); #endif - RetainPtr holder(CFXBitmapFromFPDFBitmap(bitmap)); + RetainPtr holder(CFXDIBitmapFromFPDFBitmap(bitmap)); pDevice->Attach(holder, false, nullptr, false); { CFX_RenderDevice::StateRestorer restorer(pDevice.get()); diff --git a/fpdfsdk/fpdf_progressive.cpp b/fpdfsdk/fpdf_progressive.cpp index 6ac6686ac8..6d16bce700 100644 --- a/fpdfsdk/fpdf_progressive.cpp +++ b/fpdfsdk/fpdf_progressive.cpp @@ -50,7 +50,7 @@ FPDF_EXPORT int FPDF_CALLCONV FPDF_RenderPageBitmap_Start(FPDF_BITMAP bitmap, CPDF_PageRenderContext* pContext = pOwnedContext.get(); pPage->SetRenderContext(std::move(pOwnedContext)); - RetainPtr pBitmap(CFXBitmapFromFPDFBitmap(bitmap)); + RetainPtr pBitmap(CFXDIBitmapFromFPDFBitmap(bitmap)); auto pOwnedDevice = pdfium::MakeUnique(); CFX_DefaultRenderDevice* pDevice = pOwnedDevice.get(); pContext->m_pDevice = std::move(pOwnedDevice); diff --git a/fpdfsdk/fpdf_searchex.cpp b/fpdfsdk/fpdf_searchex.cpp index 9d48cebf8a..dbc2d2abcd 100644 --- a/fpdfsdk/fpdf_searchex.cpp +++ b/fpdfsdk/fpdf_searchex.cpp @@ -7,19 +7,20 @@ #include "public/fpdf_searchex.h" #include "core/fpdftext/cpdf_textpage.h" +#include "fpdfsdk/cpdfsdk_helpers.h" FPDF_EXPORT int FPDF_CALLCONV FPDFText_GetCharIndexFromTextIndex(FPDF_TEXTPAGE text_page, int nTextIndex) { if (!text_page) return -1; - return static_cast(text_page) - ->CharIndexFromTextIndex(nTextIndex); + return CPDFTextPageFromFPDFTextPage(text_page)->CharIndexFromTextIndex( + nTextIndex); } FPDF_EXPORT int FPDF_CALLCONV FPDFText_GetTextIndexFromCharIndex(FPDF_TEXTPAGE text_page, int nCharIndex) { if (!text_page) return -1; - return static_cast(text_page)->TextIndexFromCharIndex( + return CPDFTextPageFromFPDFTextPage(text_page)->TextIndexFromCharIndex( nCharIndex); } diff --git a/fpdfsdk/fpdf_structtree.cpp b/fpdfsdk/fpdf_structtree.cpp index 98123d94d1..027695e36d 100644 --- a/fpdfsdk/fpdf_structtree.cpp +++ b/fpdfsdk/fpdf_structtree.cpp @@ -14,14 +14,6 @@ namespace { -CPDF_StructTree* ToStructTree(FPDF_STRUCTTREE struct_tree) { - return static_cast(struct_tree); -} - -CPDF_StructElement* ToStructTreeElement(FPDF_STRUCTELEMENT struct_element) { - return static_cast(struct_element); -} - unsigned long WideStringToBuffer(const WideString& str, void* buffer, unsigned long buflen) { @@ -42,19 +34,23 @@ FPDF_StructTree_GetForPage(FPDF_PAGE page) { CPDF_Page* pPage = CPDFPageFromFPDFPage(page); if (!pPage) return nullptr; - return CPDF_StructTree::LoadPage(pPage->m_pDocument.Get(), - pPage->m_pFormDict.Get()) - .release(); + + // Caller takes onwership. + return FPDFStructTreeFromCPDFStructTree( + CPDF_StructTree::LoadPage(pPage->m_pDocument.Get(), + pPage->m_pFormDict.Get()) + .release()); } FPDF_EXPORT void FPDF_CALLCONV FPDF_StructTree_Close(FPDF_STRUCTTREE struct_tree) { - std::unique_ptr(ToStructTree(struct_tree)); + std::unique_ptr( + CPDFStructTreeFromFPDFStructTree(struct_tree)); } FPDF_EXPORT int FPDF_CALLCONV FPDF_StructTree_CountChildren(FPDF_STRUCTTREE struct_tree) { - CPDF_StructTree* tree = ToStructTree(struct_tree); + CPDF_StructTree* tree = CPDFStructTreeFromFPDFStructTree(struct_tree); if (!tree) return -1; @@ -64,19 +60,21 @@ FPDF_StructTree_CountChildren(FPDF_STRUCTTREE struct_tree) { FPDF_EXPORT FPDF_STRUCTELEMENT FPDF_CALLCONV FPDF_StructTree_GetChildAtIndex(FPDF_STRUCTTREE struct_tree, int index) { - CPDF_StructTree* tree = ToStructTree(struct_tree); + CPDF_StructTree* tree = CPDFStructTreeFromFPDFStructTree(struct_tree); if (!tree || index < 0 || static_cast(index) >= tree->CountTopElements()) { return nullptr; } - return tree->GetTopElement(static_cast(index)); + return FPDFStructElementFromCPDFStructElement( + tree->GetTopElement(static_cast(index))); } FPDF_EXPORT unsigned long FPDF_CALLCONV FPDF_StructElement_GetAltText(FPDF_STRUCTELEMENT struct_element, void* buffer, unsigned long buflen) { - CPDF_StructElement* elem = ToStructTreeElement(struct_element); + CPDF_StructElement* elem = + CPDFStructElementFromFPDFStructElement(struct_element); return (elem && elem->GetDict()) ? WideStringToBuffer(elem->GetDict()->GetUnicodeTextFor("Alt"), buffer, buflen) @@ -85,7 +83,8 @@ FPDF_StructElement_GetAltText(FPDF_STRUCTELEMENT struct_element, FPDF_EXPORT int FPDF_CALLCONV FPDF_StructElement_GetMarkedContentID(FPDF_STRUCTELEMENT struct_element) { - CPDF_StructElement* elem = ToStructTreeElement(struct_element); + CPDF_StructElement* elem = + CPDFStructElementFromFPDFStructElement(struct_element); CPDF_Object* p = (elem && elem->GetDict()) ? elem->GetDict()->GetObjectFor("K") : nullptr; return p && p->IsNumber() ? p->GetInteger() : -1; @@ -95,7 +94,8 @@ FPDF_EXPORT unsigned long FPDF_CALLCONV FPDF_StructElement_GetType(FPDF_STRUCTELEMENT struct_element, void* buffer, unsigned long buflen) { - CPDF_StructElement* elem = ToStructTreeElement(struct_element); + CPDF_StructElement* elem = + CPDFStructElementFromFPDFStructElement(struct_element); return elem ? WideStringToBuffer(elem->GetType().UTF8Decode(), buffer, buflen) : 0; } @@ -104,7 +104,8 @@ FPDF_EXPORT unsigned long FPDF_CALLCONV FPDF_StructElement_GetTitle(FPDF_STRUCTELEMENT struct_element, void* buffer, unsigned long buflen) { - CPDF_StructElement* elem = ToStructTreeElement(struct_element); + CPDF_StructElement* elem = + CPDFStructElementFromFPDFStructElement(struct_element); return elem ? WideStringToBuffer(elem->GetTitle().UTF8Decode(), buffer, buflen) : 0; @@ -112,7 +113,8 @@ FPDF_StructElement_GetTitle(FPDF_STRUCTELEMENT struct_element, FPDF_EXPORT int FPDF_CALLCONV FPDF_StructElement_CountChildren(FPDF_STRUCTELEMENT struct_element) { - CPDF_StructElement* elem = ToStructTreeElement(struct_element); + CPDF_StructElement* elem = + CPDFStructElementFromFPDFStructElement(struct_element); if (!elem) return -1; @@ -123,9 +125,11 @@ FPDF_StructElement_CountChildren(FPDF_STRUCTELEMENT struct_element) { FPDF_EXPORT FPDF_STRUCTELEMENT FPDF_CALLCONV FPDF_StructElement_GetChildAtIndex(FPDF_STRUCTELEMENT struct_element, int index) { - CPDF_StructElement* elem = ToStructTreeElement(struct_element); + CPDF_StructElement* elem = + CPDFStructElementFromFPDFStructElement(struct_element); if (!elem || index < 0 || static_cast(index) >= elem->CountKids()) return nullptr; - return elem->GetKidIfElement(static_cast(index)); + return FPDFStructElementFromCPDFStructElement( + elem->GetKidIfElement(static_cast(index))); } diff --git a/fpdfsdk/fpdf_text.cpp b/fpdfsdk/fpdf_text.cpp index c06885a1a7..edca0669ab 100644 --- a/fpdfsdk/fpdf_text.cpp +++ b/fpdfsdk/fpdf_text.cpp @@ -7,6 +7,7 @@ #include "public/fpdf_text.h" #include +#include #include #include "core/fpdfapi/page/cpdf_page.h" @@ -16,6 +17,7 @@ #include "core/fpdftext/cpdf_textpagefind.h" #include "fpdfsdk/cpdfsdk_helpers.h" #include "third_party/base/numerics/safe_conversions.h" +#include "third_party/base/ptr_util.h" #include "third_party/base/stl_util.h" #ifdef PDF_ENABLE_XFA @@ -31,18 +33,6 @@ namespace { constexpr size_t kBytesPerCharacter = sizeof(unsigned short); -CPDF_TextPage* CPDFTextPageFromFPDFTextPage(FPDF_TEXTPAGE text_page) { - return static_cast(text_page); -} - -CPDF_TextPageFind* CPDFTextPageFindFromFPDFSchHandle(FPDF_SCHHANDLE handle) { - return static_cast(handle); -} - -CPDF_LinkExtract* CPDFLinkExtractFromFPDFPageLink(FPDF_PAGELINK link) { - return static_cast(link); -} - } // namespace FPDF_EXPORT FPDF_TEXTPAGE FPDF_CALLCONV FPDFText_LoadPage(FPDF_PAGE page) { @@ -62,7 +52,7 @@ FPDF_EXPORT FPDF_TEXTPAGE FPDF_CALLCONV FPDFText_LoadPage(FPDF_PAGE page) { pPDFPage, viewRef.IsDirectionR2L() ? FPDFText_Direction::Right : FPDFText_Direction::Left); textpage->ParseTextPage(); - return textpage; + return FPDFTextPageFromCPDFTextPage(textpage); } FPDF_EXPORT void FPDF_CALLCONV FPDFText_ClosePage(FPDF_TEXTPAGE text_page) { @@ -269,7 +259,7 @@ FPDFText_FindStart(FPDF_TEXTPAGE text_page, textpageFind->FindFirst( WideString::FromUTF16LE(findwhat, len), flags, start_index >= 0 ? Optional(start_index) : Optional()); - return textpageFind; + return FPDFSchHandleFromCPDFTextPageFind(textpageFind); } FPDF_EXPORT FPDF_BOOL FPDF_CALLCONV FPDFText_FindNext(FPDF_SCHHANDLE handle) { @@ -309,9 +299,9 @@ FPDF_EXPORT void FPDF_CALLCONV FPDFText_FindClose(FPDF_SCHHANDLE handle) { if (!handle) return; - CPDF_TextPageFind* textpageFind = CPDFTextPageFindFromFPDFSchHandle(handle); - delete textpageFind; - handle = nullptr; + // Take ownership back from caller and destroy. + std::unique_ptr textpageFind( + CPDFTextPageFindFromFPDFSchHandle(handle)); } // web link @@ -320,10 +310,12 @@ FPDFLink_LoadWebLinks(FPDF_TEXTPAGE text_page) { if (!text_page) return nullptr; - CPDF_LinkExtract* pageLink = - new CPDF_LinkExtract(CPDFTextPageFromFPDFTextPage(text_page)); + CPDF_TextPage* pPage = CPDFTextPageFromFPDFTextPage(text_page); + auto pageLink = pdfium::MakeUnique(pPage); pageLink->ExtractLinks(); - return pageLink; + + // Caller takes ownership. + return FPDFPageLinkFromCPDFLinkExtract(pageLink.release()); } FPDF_EXPORT int FPDF_CALLCONV FPDFLink_CountWebLinks(FPDF_PAGELINK link_page) { diff --git a/fpdfsdk/fpdf_transformpage.cpp b/fpdfsdk/fpdf_transformpage.cpp index d2d9f8dbc4..6706a18354 100644 --- a/fpdfsdk/fpdf_transformpage.cpp +++ b/fpdfsdk/fpdf_transformpage.cpp @@ -211,12 +211,14 @@ FPDF_EXPORT FPDF_CLIPPATH FPDF_CALLCONV FPDF_CreateClipPath(float left, auto pNewClipPath = pdfium::MakeUnique(); pNewClipPath->AppendPath(Path, FXFILL_ALTERNATE, false); - return pNewClipPath.release(); // Caller takes ownership. + + // Caller takes ownership. + return FPDFClipPathFromCPDFClipPath(pNewClipPath.release()); } FPDF_EXPORT void FPDF_CALLCONV FPDF_DestroyClipPath(FPDF_CLIPPATH clipPath) { // Take ownership back from caller and destroy. - std::unique_ptr(static_cast(clipPath)); + std::unique_ptr(CPDFClipPathFromFPDFClipPath(clipPath)); } void OutputPath(std::ostringstream& buf, CPDF_Path path) { @@ -268,7 +270,7 @@ FPDF_EXPORT void FPDF_CALLCONV FPDFPage_InsertClipPath(FPDF_PAGE page, return; std::ostringstream strClip; - auto* pClipPath = static_cast(clipPath); + CPDF_ClipPath* pClipPath = CPDFClipPathFromFPDFClipPath(clipPath); for (size_t i = 0; i < pClipPath->GetPathCount(); ++i) { CPDF_Path path = pClipPath->GetPath(i); if (path.GetPoints().empty()) { diff --git a/fpdfsdk/fpdf_view.cpp b/fpdfsdk/fpdf_view.cpp index ea12bf9896..a31118ff10 100644 --- a/fpdfsdk/fpdf_view.cpp +++ b/fpdfsdk/fpdf_view.cpp @@ -648,7 +648,7 @@ FPDF_EXPORT void FPDF_CALLCONV FPDF_RenderPageBitmap(FPDF_BITMAP bitmap, CFX_DefaultRenderDevice* pDevice = new CFX_DefaultRenderDevice; pContext->m_pDevice.reset(pDevice); - RetainPtr pBitmap(CFXBitmapFromFPDFBitmap(bitmap)); + RetainPtr pBitmap(CFXDIBitmapFromFPDFBitmap(bitmap)); pDevice->Attach(pBitmap, !!(flags & FPDF_REVERSE_BYTE_ORDER), nullptr, false); FPDF_RenderPage_Retail(pContext, page, start_x, start_y, size_x, size_y, rotate, flags, true, nullptr); @@ -673,13 +673,15 @@ FPDF_RenderPageBitmapWithMatrix(FPDF_BITMAP bitmap, if (!pPage) return; - CPDF_PageRenderContext* pContext = new CPDF_PageRenderContext; - pPage->SetRenderContext(pdfium::WrapUnique(pContext)); + auto pOwnedContext = pdfium::MakeUnique(); + CPDF_PageRenderContext* pContext = pOwnedContext.get(); + pPage->SetRenderContext(std::move(pOwnedContext)); - CFX_DefaultRenderDevice* pDevice = new CFX_DefaultRenderDevice; - pContext->m_pDevice.reset(pDevice); + auto pOwnedDevice = pdfium::MakeUnique(); + CFX_DefaultRenderDevice* pDevice = pOwnedDevice.get(); + pContext->m_pDevice = std::move(pOwnedDevice); - RetainPtr pBitmap(CFXBitmapFromFPDFBitmap(bitmap)); + RetainPtr pBitmap(CFXDIBitmapFromFPDFBitmap(bitmap)); pDevice->Attach(pBitmap, !!(flags & FPDF_REVERSE_BYTE_ORDER), nullptr, false); CFX_FloatRect clipping_rect; @@ -689,7 +691,6 @@ FPDF_RenderPageBitmapWithMatrix(FPDF_BITMAP bitmap, const FX_RECT rect(0, 0, pPage->GetPageWidth(), pPage->GetPageHeight()); CFX_Matrix transform_matrix = pPage->GetDisplayMatrix(rect, 0); - if (matrix) { transform_matrix.Concat(CFX_Matrix(matrix->a, matrix->b, matrix->c, matrix->d, matrix->e, matrix->f)); @@ -828,7 +829,7 @@ FPDF_EXPORT FPDF_BITMAP FPDF_CALLCONV FPDFBitmap_Create(int width, if (!pBitmap->Create(width, height, alpha ? FXDIB_Argb : FXDIB_Rgb32)) return nullptr; - return pBitmap.Leak(); + return FPDFBitmapFromCFXDIBitmap(pBitmap.Leak()); } FPDF_EXPORT FPDF_BITMAP FPDF_CALLCONV FPDFBitmap_CreateEx(int width, @@ -858,14 +859,14 @@ FPDF_EXPORT FPDF_BITMAP FPDF_CALLCONV FPDFBitmap_CreateEx(int width, static_cast(first_scan), stride)) { return nullptr; } - return pBitmap.Leak(); + return FPDFBitmapFromCFXDIBitmap(pBitmap.Leak()); } FPDF_EXPORT int FPDF_CALLCONV FPDFBitmap_GetFormat(FPDF_BITMAP bitmap) { if (!bitmap) return FPDFBitmap_Unknown; - FXDIB_Format format = CFXBitmapFromFPDFBitmap(bitmap)->GetFormat(); + FXDIB_Format format = CFXDIBitmapFromFPDFBitmap(bitmap)->GetFormat(); switch (format) { case FXDIB_8bppRgb: case FXDIB_8bppMask: @@ -891,7 +892,7 @@ FPDF_EXPORT void FPDF_CALLCONV FPDFBitmap_FillRect(FPDF_BITMAP bitmap, return; CFX_DefaultRenderDevice device; - RetainPtr pBitmap(CFXBitmapFromFPDFBitmap(bitmap)); + RetainPtr pBitmap(CFXDIBitmapFromFPDFBitmap(bitmap)); device.Attach(pBitmap, false, nullptr, false); if (!pBitmap->HasAlpha()) color |= 0xFF000000; @@ -899,24 +900,24 @@ FPDF_EXPORT void FPDF_CALLCONV FPDFBitmap_FillRect(FPDF_BITMAP bitmap, } FPDF_EXPORT void* FPDF_CALLCONV FPDFBitmap_GetBuffer(FPDF_BITMAP bitmap) { - return bitmap ? CFXBitmapFromFPDFBitmap(bitmap)->GetBuffer() : nullptr; + return bitmap ? CFXDIBitmapFromFPDFBitmap(bitmap)->GetBuffer() : nullptr; } FPDF_EXPORT int FPDF_CALLCONV FPDFBitmap_GetWidth(FPDF_BITMAP bitmap) { - return bitmap ? CFXBitmapFromFPDFBitmap(bitmap)->GetWidth() : 0; + return bitmap ? CFXDIBitmapFromFPDFBitmap(bitmap)->GetWidth() : 0; } FPDF_EXPORT int FPDF_CALLCONV FPDFBitmap_GetHeight(FPDF_BITMAP bitmap) { - return bitmap ? CFXBitmapFromFPDFBitmap(bitmap)->GetHeight() : 0; + return bitmap ? CFXDIBitmapFromFPDFBitmap(bitmap)->GetHeight() : 0; } FPDF_EXPORT int FPDF_CALLCONV FPDFBitmap_GetStride(FPDF_BITMAP bitmap) { - return bitmap ? CFXBitmapFromFPDFBitmap(bitmap)->GetPitch() : 0; + return bitmap ? CFXDIBitmapFromFPDFBitmap(bitmap)->GetPitch() : 0; } FPDF_EXPORT void FPDF_CALLCONV FPDFBitmap_Destroy(FPDF_BITMAP bitmap) { RetainPtr destroyer; - destroyer.Unleak(CFXBitmapFromFPDFBitmap(bitmap)); + destroyer.Unleak(CFXDIBitmapFromFPDFBitmap(bitmap)); } void FPDF_RenderPage_Retail(CPDF_PageRenderContext* pContext, @@ -996,7 +997,7 @@ FPDF_VIEWERREF_GetPrintPageRange(FPDF_DOCUMENT document) { if (!pDoc) return nullptr; CPDF_ViewerPreferences viewRef(pDoc); - return viewRef.PrintPageRange(); + return FPDFPageRangeFromCPDFArray(viewRef.PrintPageRange()); } FPDF_EXPORT FPDF_DUPLEXTYPE FPDF_CALLCONV @@ -1067,7 +1068,8 @@ FPDF_GetNamedDestByName(FPDF_DOCUMENT document, FPDF_BYTESTRING name) { return nullptr; CPDF_NameTree name_tree(pDoc, "Dests"); - return name_tree.LookupNamedDest(pDoc, PDF_DecodeText(ByteString(name))); + return FPDFDestFromCPDFArray( + name_tree.LookupNamedDest(pDoc, PDF_DecodeText(ByteString(name)))); } #ifdef PDF_ENABLE_XFA @@ -1186,5 +1188,5 @@ FPDF_EXPORT FPDF_DEST FPDF_CALLCONV FPDF_GetNamedDest(FPDF_DOCUMENT document, } else { *buflen = -1; } - return pDestObj; + return FPDFDestFromCPDFArray(pDestObj->AsArray()); } diff --git a/fpdfsdk/fpdfxfa/cpdfxfa_docenvironment.cpp b/fpdfsdk/fpdfxfa/cpdfxfa_docenvironment.cpp index dc6686548b..cc7a8898e8 100644 --- a/fpdfsdk/fpdfxfa/cpdfxfa_docenvironment.cpp +++ b/fpdfsdk/fpdfxfa/cpdfxfa_docenvironment.cpp @@ -266,7 +266,8 @@ bool CPDFXFA_DocEnvironment::PopupMenu(CXFA_FFWidget* hWidget, if (hWidget->CanSelectAll()) menuFlag |= FXFA_MENU_SELECTALL; - return pFormFillEnv->PopupMenu(pPage.Get(), hWidget, menuFlag, ptPopup); + return pFormFillEnv->PopupMenu( + pPage.Get(), FPDFWidgetFromCXFAFFWidget(hWidget), menuFlag, ptPopup); } void CPDFXFA_DocEnvironment::PageViewEvent(CXFA_FFPageView* pPageView, diff --git a/public/fpdfview.h b/public/fpdfview.h index 817da6cda1..f8d6026292 100644 --- a/public/fpdfview.h +++ b/public/fpdfview.h @@ -32,31 +32,31 @@ #define FPDF_OBJECT_NULLOBJ 8 #define FPDF_OBJECT_REFERENCE 9 -// PDF types -typedef void* FPDF_ACTION; -typedef void* FPDF_ANNOTATION; -typedef void* FPDF_ATTACHMENT; -typedef void* FPDF_BITMAP; -typedef void* FPDF_BOOKMARK; -typedef void* FPDF_CLIPPATH; -typedef void* FPDF_DEST; +// PDF types - use incomplete types for type safety. +typedef struct fpdf_action_t__* FPDF_ACTION; +typedef struct fpdf_annotation_t__* FPDF_ANNOTATION; +typedef struct fpdf_attachment_t__* FPDF_ATTACHMENT; +typedef struct fpdf_bitmap_t__* FPDF_BITMAP; +typedef struct fpdf_bookmark_t__* FPDF_BOOKMARK; +typedef struct fpdf_clippath_t__* FPDF_CLIPPATH; +typedef struct fpdf_dest_t__* FPDF_DEST; typedef struct fpdf_document_t__* FPDF_DOCUMENT; -typedef void* FPDF_FONT; -typedef void* FPDF_LINK; +typedef struct fpdf_font_t__* FPDF_FONT; +typedef struct fpdf_link_t__* FPDF_LINK; typedef struct fpdf_page_t__* FPDF_PAGE; -typedef void* FPDF_PAGELINK; -typedef void* FPDF_PAGEOBJECT; // Page object(text, path, etc) -typedef const void* FPDF_PAGEOBJECTMARK; -typedef void* FPDF_PAGERANGE; -typedef void* FPDF_RECORDER; -typedef void* FPDF_SCHHANDLE; -typedef void* FPDF_STRUCTELEMENT; -typedef void* FPDF_STRUCTTREE; -typedef void* FPDF_TEXTPAGE; -typedef const void* FPDF_PATHSEGMENT; +typedef struct fpdf_pagelink_t__* FPDF_PAGELINK; +typedef struct fpdf_pageobject_t__* FPDF_PAGEOBJECT; // (text, path, etc.) +typedef const struct fpdf_pageobjectmark_t__* FPDF_PAGEOBJECTMARK; +typedef struct fpdf_pagerange_t__* FPDF_PAGERANGE; +typedef const struct fpdf_pathsegment_t* FPDF_PATHSEGMENT; +typedef void* FPDF_RECORDER; // Passed into skia. +typedef struct fpdf_schhandle_t__* FPDF_SCHHANDLE; +typedef struct fpdf_structelement_t__* FPDF_STRUCTELEMENT; +typedef struct fpdf_structtree_t__* FPDF_STRUCTTREE; +typedef struct fpdf_textpage_t__* FPDF_TEXTPAGE; #ifdef PDF_ENABLE_XFA -typedef void* FPDF_WIDGET; +typedef struct fpdf_widget_t__* FPDF_WIDGET; #endif // PDF_ENABLE_XFA // Basic data types -- cgit v1.2.3