From 5110c4743751145c4ae1934cd1d83bc6c55bb43f Mon Sep 17 00:00:00 2001 From: John Abd-El-Malek Date: Sat, 17 May 2014 22:33:34 -0700 Subject: Initial commit. --- core/include/fpdfdoc/fpdf_ap.h | 92 ++ core/include/fpdfdoc/fpdf_doc.h | 1792 ++++++++++++++++++++++++++++++++++++ core/include/fpdfdoc/fpdf_tagged.h | 99 ++ core/include/fpdfdoc/fpdf_vt.h | 444 +++++++++ 4 files changed, 2427 insertions(+) create mode 100644 core/include/fpdfdoc/fpdf_ap.h create mode 100644 core/include/fpdfdoc/fpdf_doc.h create mode 100644 core/include/fpdfdoc/fpdf_tagged.h create mode 100644 core/include/fpdfdoc/fpdf_vt.h (limited to 'core/include/fpdfdoc') diff --git a/core/include/fpdfdoc/fpdf_ap.h b/core/include/fpdfdoc/fpdf_ap.h new file mode 100644 index 0000000000..4b6a371110 --- /dev/null +++ b/core/include/fpdfdoc/fpdf_ap.h @@ -0,0 +1,92 @@ +// 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 + +#define _FPDF_AP_H_ +#include "../fxcrt/fx_basic.h" +#include "../fpdfapi/fpdf_parser.h" +#include "fpdf_vt.h" +class IPVT_FontMap +{ +public: + + virtual CPDF_Font* GetPDFFont(FX_INT32 nFontIndex) = 0; + + virtual CFX_ByteString GetPDFFontAlias(FX_INT32 nFontIndex) = 0; +}; +struct CPVT_Dash { + + CPVT_Dash(FX_INT32 dash, FX_INT32 gap, FX_INT32 phase) : nDash(dash), nGap(gap), nPhase(phase) + {} + + FX_INT32 nDash; + + FX_INT32 nGap; + + FX_INT32 nPhase; +}; +#define CT_TRANSPARENT 0 +#define CT_GRAY 1 +#define CT_RGB 2 +#define CT_CMYK 3 +struct CPVT_Color { + + CPVT_Color(FX_INT32 type = 0, FX_FLOAT color1 = 0.0f, FX_FLOAT color2 = 0.0f, FX_FLOAT color3 = 0.0f, FX_FLOAT color4 = 0.0f) + : nColorType(type), fColor1(color1), fColor2(color2), fColor3(color3), fColor4(color4) + {} + + FX_INT32 nColorType; + FX_FLOAT fColor1; + FX_FLOAT fColor2; + FX_FLOAT fColor3; + FX_FLOAT fColor4; +}; +class CPVT_Provider : public IPDF_VariableText_Provider +{ +public: + + CPVT_Provider(IPVT_FontMap * pFontMap); + + virtual ~CPVT_Provider(); + + FX_INT32 GetCharWidth(FX_INT32 nFontIndex, FX_WORD word, FX_INT32 nWordStyle); + + FX_INT32 GetTypeAscent(FX_INT32 nFontIndex); + + FX_INT32 GetTypeDescent(FX_INT32 nFontIndex); + + FX_INT32 GetWordFontIndex(FX_WORD word, FX_INT32 charset, FX_INT32 nFontIndex); + + FX_BOOL IsLatinWord(FX_WORD word); + + FX_INT32 GetDefaultFontIndex(); +private: + + IPVT_FontMap * m_pFontMap; +}; +#define PBS_SOLID 0 +#define PBS_DASH 1 +#define PBS_BEVELED 2 +#define PBS_INSET 3 +#define PBS_UNDERLINED 4 +class CPVT_GenerateAP +{ +public: + + static FX_BOOL GenerateTextFieldAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict); + + static FX_BOOL GenerateComboBoxAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict); + + static FX_BOOL GenerateListBoxAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict); + + static CFX_ByteString GenerateEditAP(IPVT_FontMap * pFontMap, IPDF_VariableText_Iterator * pIterator, + const CPDF_Point & ptOffset, FX_BOOL bContinuous, FX_WORD SubWord = 0, const CPVT_WordRange * pVisible = NULL); + + static CFX_ByteString GenerateBorderAP(const CPDF_Rect & rect, FX_FLOAT fWidth, + const CPVT_Color & color, const CPVT_Color & crLeftTop, const CPVT_Color & crRightBottom, + FX_INT32 nStyle, const CPVT_Dash & dash); + + static CFX_ByteString GenerateColorAP(const CPVT_Color & color, const FX_BOOL & bFillOrStroke); +}; diff --git a/core/include/fpdfdoc/fpdf_doc.h b/core/include/fpdfdoc/fpdf_doc.h new file mode 100644 index 0000000000..fc19441309 --- /dev/null +++ b/core/include/fpdfdoc/fpdf_doc.h @@ -0,0 +1,1792 @@ +// 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 + +#ifndef _FPDF_DOC_H_ +#define _FPDF_DOC_H_ +#ifndef _FPDF_PARSER_ +#include "../fpdfapi/fpdf_parser.h" +#endif +#ifndef _FPDF_RENDER_ +#include "../fpdfapi/fpdf_render.h" +#endif +class CPDF_Action; +class CPDF_Annot; +class CPDF_AnnotList; +class CPDF_Bookmark; +class CPDF_BookmarkTree; +class CPDF_Dest; +class CPDF_Link; +class CPDF_LinkList; +class CPDF_Metadata; +class CPDF_NameTree; +class CPDF_NumberTree; +class CPDF_TextObject; +class CPDF_ViewerPreferences; +class CPDF_Page; +class CPDF_RenderOptions; +class CXML_Element; +class CPDF_OCContext; +class CPDF_DocJSActions; +class CPDF_ActionFields; +class CPDF_AAction; +class CPDF_FileSpec; +class CPDF_IconFit; +class CPDF_DefaultAppearance; +class CPDF_InterForm; +class CPDF_FormField; +class CPDF_FormNotify; +class CPDF_FormControl; +class CPDF_LWinParam; +class CFieldTree; +class CPDF_ApSettings; +class CPDF_NameTree : public CFX_Object +{ +public: + + CPDF_NameTree(CPDF_Dictionary* pRoot) + { + m_pRoot = pRoot; + } + + CPDF_NameTree(CPDF_Document* pDoc, FX_BSTR category); + + CPDF_Object* LookupValue(int nIndex, CFX_ByteString& csName) const; + + CPDF_Object* LookupValue(const CFX_ByteString& csName) const; + + CPDF_Array* LookupNamedDest(CPDF_Document* pDoc, FX_BSTR sName); + + int GetIndex(const CFX_ByteString& csName) const; + + int GetCount() const; + + + CPDF_Dictionary* GetRoot() const + { + return m_pRoot; + } + +protected: + + CPDF_Dictionary* m_pRoot; +}; +class CPDF_BookmarkTree : public CFX_Object +{ +public: + + CPDF_BookmarkTree(CPDF_Document* pDoc) + { + m_pDocument = pDoc; + } +public: + + + + CPDF_Bookmark GetFirstChild(CPDF_Bookmark parent); + + CPDF_Bookmark GetNextSibling(CPDF_Bookmark bookmark); + + + CPDF_Document* GetDocument() const + { + return m_pDocument; + } +protected: + + CPDF_Document* m_pDocument; +}; +#define PDFBOOKMARK_ITALIC 1 +#define PDFBOOKMARK_BOLD 2 +class CPDF_Bookmark : public CFX_Object +{ +public: + + CPDF_Bookmark(CPDF_Dictionary* pDict = NULL) + { + m_pDict = pDict; + } + + operator CPDF_Dictionary*() const + { + return m_pDict; + } + + + + FX_DWORD GetColorRef(); + + FX_DWORD GetFontStyle(); + + CFX_WideString GetTitle(); + + + + + CPDF_Dest GetDest(CPDF_Document* pDocument); + + CPDF_Action GetAction(); + + + CPDF_Dictionary* m_pDict; +}; +#define PDFZOOM_XYZ 1 +#define PDFZOOM_FITPAGE 2 +#define PDFZOOM_FITHORZ 3 +#define PDFZOOM_FITVERT 4 +#define PDFZOOM_FITRECT 5 +#define PDFZOOM_FITBBOX 6 +#define PDFZOOM_FITBHORZ 7 + +#define PDFZOOM_FITBVERT 8 +class CPDF_Dest : public CFX_Object +{ +public: + + CPDF_Dest(CPDF_Object* pObj = NULL) + { + m_pObj = pObj; + } + + operator CPDF_Object* () const + { + return m_pObj; + } + + CFX_ByteString GetRemoteName(); + + int GetPageIndex(CPDF_Document* pDoc); + + FX_DWORD GetPageObjNum(); + + int GetZoomMode(); + + FX_FLOAT GetParam(int index); + + + CPDF_Object* m_pObj; +}; +class CPDF_OCContext : public CFX_Object, public IPDF_OCContext +{ +public: + + enum UsageType { + View = 0, + Design, + Print, + Export + }; + + CPDF_OCContext(CPDF_Document *pDoc, UsageType eUsageType = View); + + virtual ~CPDF_OCContext(); + + CPDF_Document* GetDocument() const + { + return m_pDocument; + } + + UsageType GetUsageType() const + { + return m_eUsageType; + } + + FX_BOOL CheckOCGVisible(const CPDF_Dictionary *pOCGDict); + + void ResetOCContext(); +protected: + + FX_BOOL LoadOCGStateFromConfig(FX_BSTR csConfig, const CPDF_Dictionary *pOCGDict, FX_BOOL &bValidConfig) const; + + FX_BOOL LoadOCGState(const CPDF_Dictionary *pOCGDict) const; + + FX_BOOL GetOCGVisible(const CPDF_Dictionary *pOCGDict); + + FX_BOOL GetOCGVE(CPDF_Array *pExpression, FX_BOOL bFromConfig, int nLevel = 0); + + FX_BOOL LoadOCMDState(const CPDF_Dictionary *pOCMDDict, FX_BOOL bFromConfig); + + CPDF_Document *m_pDocument; + + UsageType m_eUsageType; + + CFX_MapPtrTemplate m_OCGStates; +}; +class CPDF_LWinParam : public CFX_Object +{ +public: + + CPDF_LWinParam(CPDF_Dictionary* pDict) + { + m_pDict = pDict; + } + + operator CPDF_Dictionary* () const + { + return m_pDict; + } + + inline CFX_ByteString GetFileName() + { + return m_pDict->GetString("F"); + } + + + inline CFX_ByteString GetDefaultDirectory() + { + return m_pDict->GetString("D"); + } + + + inline CFX_ByteString GetOperation() + { + return m_pDict->GetString("O"); + } + + + inline CFX_ByteString GetParameter() + { + return m_pDict->GetString("P"); + } + + CPDF_Dictionary* m_pDict; +}; +class CPDF_ActionFields : public CFX_Object +{ +public: + + CPDF_ActionFields(const CPDF_Action* pAction) + { + m_pAction = (CPDF_Action*)pAction; + } + + operator CPDF_Action*() const + { + return m_pAction; + } + + FX_DWORD GetFieldsCount() const; + + void GetAllFields(CFX_PtrArray& fieldObjects) const; + + CPDF_Object* GetField(FX_DWORD iIndex) const; + + CPDF_Action* m_pAction; +}; + +#define PDFNAMED_NEXTPAGE 1 +#define PDFNAMED_PREVPAGE 2 +#define PDFNAMED_FIRSTPAGE 3 +#define PDFNAMED_LASTPAGE 4 +#define PDFJS_MAXLENGTH 64 +class CPDF_Action : public CFX_Object +{ +public: + + CPDF_Action(CPDF_Dictionary* pDict = NULL) + { + m_pDict = pDict; + } + + operator CPDF_Dictionary* () const + { + return m_pDict; + } + + enum ActionType { + Unknown = 0, + GoTo, + GoToR, + GoToE, + Launch, + Thread, + URI, + Sound, + Movie, + Hide, + Named, + SubmitForm, + ResetForm, + ImportData, + JavaScript, + SetOCGState, + Rendition, + Trans, + GoTo3DView + }; + + CFX_ByteString GetTypeName() const + { + return m_pDict->GetString("S"); + } + + ActionType GetType() const; + + + + CPDF_Dest GetDest(CPDF_Document* pDoc) const; + + + + + + CFX_WideString GetFilePath() const; + + + + + FX_BOOL GetNewWindow() const + { + return m_pDict->GetBoolean("NewWindow"); + } + + + + + CPDF_LWinParam GetWinParam() const; + + + + + CFX_ByteString GetURI(CPDF_Document* pDoc) const; + + + + + FX_BOOL GetMouseMap() const + { + return m_pDict->GetBoolean("IsMap"); + } + + + + + CPDF_ActionFields GetWidgets() const + { + return this; + } + + + + + FX_BOOL GetHideStatus() const + { + return m_pDict->GetBoolean("H", TRUE); + } + + + + + CFX_ByteString GetNamedAction() const + { + return m_pDict->GetString("N"); + } + + + + + FX_DWORD GetFlags() const + { + return m_pDict->GetInteger("Flags"); + } + + + + + CFX_WideString GetJavaScript() const; + + + + + CPDF_Dictionary* GetAnnot() const; + + + + + FX_INT32 GetOperationType() const; + + + + + CPDF_Stream* GetSoundStream() const + { + return m_pDict->GetStream("Sound"); + } + + FX_FLOAT GetVolume() const + { + return m_pDict->GetNumber("Volume"); + } + + FX_BOOL IsSynchronous() const + { + return m_pDict->GetBoolean("Synchronous"); + } + + FX_BOOL IsRepeat() const + { + return m_pDict->GetBoolean("Repeat"); + } + + FX_BOOL IsMixPlay() const + { + return m_pDict->GetBoolean("Mix"); + } + + + + + FX_DWORD GetSubActionsCount() const; + + CPDF_Action GetSubAction(FX_DWORD iIndex) const; + + + CPDF_Dictionary* m_pDict; +}; +class CPDF_AAction : public CFX_Object +{ +public: + + CPDF_AAction(CPDF_Dictionary* pDict = NULL) + { + m_pDict = pDict; + } + + operator CPDF_Dictionary*() const + { + return m_pDict; + } + + enum AActionType { + CursorEnter = 0, + CursorExit, + ButtonDown, + ButtonUp, + GetFocus, + LoseFocus, + PageOpen, + PageClose, + PageVisible, + PageInvisible, + OpenPage, + ClosePage, + KeyStroke, + Format, + Validate, + Calculate, + CloseDocument, + SaveDocument, + DocumentSaved, + PrintDocument, + DocumentPrinted + }; + + FX_BOOL ActionExist(AActionType eType) const; + + CPDF_Action GetAction(AActionType eType) const; + + FX_POSITION GetStartPos() const; + + CPDF_Action GetNextAction(FX_POSITION& pos, AActionType& eType) const; + + CPDF_Dictionary* m_pDict; +}; +class CPDF_DocJSActions : public CFX_Object +{ +public: + CPDF_DocJSActions(CPDF_Document* pDoc); + + + int CountJSActions() const; + + CPDF_Action GetJSAction(int index, CFX_ByteString& csName) const; + + CPDF_Action GetJSAction(const CFX_ByteString& csName) const; + + int FindJSAction(const CFX_ByteString& csName) const; + + + CPDF_Document* GetDocument() const + { + return m_pDocument; + } + +protected: + + CPDF_Document* m_pDocument; +}; +class CPDF_FileSpec : public CFX_Object +{ +public: + + CPDF_FileSpec(); + + CPDF_FileSpec(CPDF_Object *pObj) + { + m_pObj = pObj; + } + + operator CPDF_Object*() const + { + return m_pObj; + } + + FX_BOOL IsURL() const; + + FX_BOOL GetFileName(CFX_WideString &wsFileName) const; + + CPDF_Stream* GetFileStream() const; + + void SetFileName(FX_WSTR wsFileName, FX_BOOL bURL = FALSE); +protected: + + CPDF_Object *m_pObj; +}; +class CPDF_LinkList : public CFX_Object +{ +public: + + CPDF_LinkList(CPDF_Document* pDoc) + { + m_pDocument = pDoc; + } + + ~CPDF_LinkList(); + + CPDF_Link GetLinkAtPoint(CPDF_Page* pPage, FX_FLOAT pdf_x, FX_FLOAT pdf_y); + + int CountLinks(CPDF_Page* pPage); + + CPDF_Link GetLink(CPDF_Page* pPage, int index); + + CPDF_Document* GetDocument() const + { + return m_pDocument; + } +protected: + + CPDF_Document* m_pDocument; + + CFX_MapPtrToPtr m_PageMap; + + CFX_PtrArray* GetPageLinks(CPDF_Page* pPage); + + void LoadPageLinks(CPDF_Page* pPage, CFX_PtrArray* pList); +}; +class CPDF_Link : public CFX_Object +{ +public: + + CPDF_Link(CPDF_Dictionary* pDict = NULL) + { + m_pDict = pDict; + } + + operator CPDF_Dictionary*() const + { + return m_pDict; + } + + CFX_FloatRect GetRect(); + + + + CPDF_Dest GetDest(CPDF_Document* pDoc); + + CPDF_Action GetAction(); + + + CPDF_Dictionary* m_pDict; +}; +#define ANNOTFLAG_INVISIBLE 1 +#define ANNOTFLAG_HIDDEN 2 +#define ANNOTFLAG_PRINT 4 +#define ANNOTFLAG_NOZOOM 8 +#define ANNOTFLAG_NOROTATE 0x10 +#define ANNOTFLAG_NOVIEW 0x20 +#define ANNOTFLAG_READONLY 0x40 +#define ANNOTFLAG_LOCKED 0x80 +#define ANNOTFLAG_TOGGLENOVIEW 0x100 +class CPDF_Annot : public CFX_PrivateData, public CFX_Object +{ +public: + + CPDF_Annot(CPDF_Dictionary* pDict); + + ~CPDF_Annot(); + + CPDF_Dictionary* m_pAnnotDict; + + CFX_ByteString GetSubType() const; + + FX_DWORD GetFlags() const + { + return m_pAnnotDict->GetInteger("F"); + } + + void GetRect(CFX_FloatRect& rect) const; + + enum AppearanceMode { + Normal, + Rollover, + Down + }; + + FX_BOOL DrawAppearance(const CPDF_Page* pPage, CFX_RenderDevice* pDevice, const CFX_AffineMatrix* pUser2Device, + AppearanceMode mode, const CPDF_RenderOptions* pOptions); + + FX_BOOL DrawInContext(const CPDF_Page* pPage, const CPDF_RenderContext* pContext, + const CFX_AffineMatrix* pUser2Device, AppearanceMode mode); + + void ClearCachedAP(); + + + void DrawBorder(CFX_RenderDevice* pDevice, const CFX_AffineMatrix* pUser2Device, + const CPDF_RenderOptions* pOptions); + + CPDF_PageObject* GetBorder(FX_BOOL bPrint, const CPDF_RenderOptions* pOptions); + + + + int CountIRTNotes(); + + CPDF_Annot* GetIRTNote(int index); + + + CPDF_Form* GetAPForm(const CPDF_Page* pPage, AppearanceMode mode); +private: + + CFX_MapPtrToPtr m_APMap; +protected: + friend class CPDF_AnnotList; + + CPDF_AnnotList* m_pList; + + CPDF_Reference* NewAnnotRef(); +}; +class CPDF_AnnotList : public CFX_Object +{ +public: + + CPDF_AnnotList(CPDF_Page* pPage); + + ~CPDF_AnnotList(); + + void GetAnnotMatrix(const CPDF_Dictionary* pAnnotDict, const CFX_Matrix* pUser2Device, CFX_Matrix &matrix) const; + + void GetAnnotRect(const CPDF_Dictionary* pAnnotDict, const CFX_Matrix* pUser2Device, CPDF_Rect &rtAnnot) const; + + void DisplayAnnots(const CPDF_Page* pPage, CFX_RenderDevice* pDevice, + CFX_AffineMatrix* pMatrix, FX_BOOL bShowWidget, + CPDF_RenderOptions* pOptions); + + void DisplayAnnots(const CPDF_Page* pPage, CPDF_RenderContext* pContext, + FX_BOOL bPrinting, CFX_AffineMatrix* pMatrix, FX_BOOL bShowWidget, + CPDF_RenderOptions* pOptions) + { + DisplayAnnots(pPage, NULL, pContext, bPrinting, pMatrix, bShowWidget ? 3 : 1, pOptions, NULL); + } + + void DisplayAnnots(const CPDF_Page* pPage, CPDF_RenderContext* pContext, + FX_BOOL bPrinting, CFX_AffineMatrix* pMatrix, FX_BOOL bShowWidget, + CPDF_RenderOptions* pOptions, FX_RECT *pClipRect) + { + DisplayAnnots(pPage, NULL, pContext, bPrinting, pMatrix, bShowWidget ? 3 : 1, pOptions, pClipRect); + } + + void DisplayAnnots(const CPDF_Page* pPage, CFX_RenderDevice* pDevice, CPDF_RenderContext* pContext, + FX_BOOL bPrinting, CFX_AffineMatrix* pMatrix, FX_DWORD dwAnnotFlags, + CPDF_RenderOptions* pOptions, FX_RECT* pClipRect); + + + + CPDF_Annot* GetAt(int index) + { + return (CPDF_Annot*)m_AnnotList.GetAt(index); + } + + int Count() + { + return m_AnnotList.GetSize(); + } + + int GetIndex(CPDF_Annot* pAnnot); + + + CPDF_Document* GetDocument() const + { + return m_pDocument; + } +protected: + + CFX_PtrArray m_AnnotList; + + CPDF_Dictionary* m_pPageDict; + + CPDF_Document* m_pDocument; + + CFX_PtrArray m_Borders; + + void DisplayPass(const CPDF_Page* pPage, CFX_RenderDevice* pDevice, + CPDF_RenderContext* pContext, FX_BOOL bPrinting, CFX_AffineMatrix* pMatrix, + FX_BOOL bWidget, CPDF_RenderOptions* pOptions, FX_RECT* clip_rect); + friend class CPDF_Annot; +}; +#define COLORTYPE_TRANSPARENT 0 +#define COLORTYPE_GRAY 1 +#define COLORTYPE_RGB 2 +#define COLORTYPE_CMYK 3 +class CPDF_DefaultAppearance : public CFX_Object +{ +public: + + CPDF_DefaultAppearance(const CFX_ByteString& csDA = "") + { + m_csDA = csDA; + } + + CPDF_DefaultAppearance(const CPDF_DefaultAppearance& cDA) + { + m_csDA = (CFX_ByteString)(CPDF_DefaultAppearance&)cDA; + } + + + operator CFX_ByteString() const + { + return m_csDA; + } + + const CPDF_DefaultAppearance& operator =(const CFX_ByteString& csDA) + { + m_csDA = csDA; + return *this; + } + + const CPDF_DefaultAppearance& operator =(const CPDF_DefaultAppearance& cDA) + { + m_csDA = (CFX_ByteString)(CPDF_DefaultAppearance&)cDA; + return *this; + } + + + + FX_BOOL HasFont(); + + CFX_ByteString GetFontString(); + + void GetFont(CFX_ByteString& csFontNameTag, FX_FLOAT& fFontSize); + + + + + FX_BOOL HasColor(FX_BOOL bStrokingOperation = FALSE); + + CFX_ByteString GetColorString(FX_BOOL bStrokingOperation = FALSE); + + void GetColor(int& iColorType, FX_FLOAT fc[4], FX_BOOL bStrokingOperation = FALSE); + + void GetColor(FX_ARGB& color, int& iColorType, FX_BOOL bStrokingOperation = FALSE); + + + + + FX_BOOL HasTextMatrix(); + + CFX_ByteString GetTextMatrixString(); + + CFX_AffineMatrix GetTextMatrix(); + +protected: + + CFX_ByteString m_csDA; +}; +#define FIELDTYPE_UNKNOWN 0 +#define FIELDTYPE_PUSHBUTTON 1 +#define FIELDTYPE_CHECKBOX 2 +#define FIELDTYPE_RADIOBUTTON 3 +#define FIELDTYPE_COMBOBOX 4 +#define FIELDTYPE_LISTBOX 5 +#define FIELDTYPE_TEXTFIELD 6 +#define FIELDTYPE_SIGNATURE 7 +class CPDF_InterForm : public CFX_PrivateData, public CFX_Object +{ +public: + + CPDF_InterForm(CPDF_Document* pDocument, FX_BOOL bUpdateAP); + + ~CPDF_InterForm(); + + + + static void EnableUpdateAP(FX_BOOL bUpdateAP); + + static FX_BOOL UpdatingAPEnabled(); + + + static CFX_ByteString GenerateNewResourceName(const CPDF_Dictionary* pResDict, FX_LPCSTR csType, int iMinLen = 2, FX_LPCSTR csPrefix = ""); + + + + static CPDF_Font* AddSystemDefaultFont(const CPDF_Document* pDocument); + + static CPDF_Font* AddSystemFont(const CPDF_Document* pDocument, CFX_ByteString csFontName, FX_BYTE iCharSet = 1); + + static CPDF_Font* AddSystemFont(const CPDF_Document* pDocument, CFX_WideString csFontName, FX_BYTE iCharSet = 1); + + static CPDF_Font* AddStandardFont(const CPDF_Document* pDocument, CFX_ByteString csFontName); + + static CFX_ByteString GetNativeFont(FX_BYTE iCharSet, FX_LPVOID pLogFont = NULL); + + static CFX_ByteString GetNativeFont(FX_LPVOID pLogFont = NULL); + + static FX_BYTE GetNativeCharSet(); + + static CPDF_Font* AddNativeFont(FX_BYTE iCharSet, const CPDF_Document* pDocument); + + static CPDF_Font* AddNativeFont(const CPDF_Document* pDocument); + + + + + FX_BOOL ValidateFieldName(CFX_WideString& csNewFieldName, int iType); + + FX_BOOL ValidateFieldName(const CPDF_FormField* pField, CFX_WideString& csNewFieldName); + + FX_BOOL ValidateFieldName(const CPDF_FormControl* pControl, CFX_WideString& csNewFieldName); + + + + + FX_DWORD CountFields(const CFX_WideString &csFieldName = L""); + + CPDF_FormField* GetField(FX_DWORD index, const CFX_WideString &csFieldName = L""); + + void GetAllFieldNames(CFX_WideStringArray& allFieldNames); + + FX_BOOL IsValidFormField(const void* pField); + + CPDF_FormField* GetFieldByDict(CPDF_Dictionary* pFieldDict) const; + + + + + FX_DWORD CountControls(CFX_WideString csFieldName = L""); + + CPDF_FormControl* GetControl(FX_DWORD index, CFX_WideString csFieldName = L""); + + FX_BOOL IsValidFormControl(const void* pControl); + + int CountPageControls(CPDF_Page* pPage) const; + + CPDF_FormControl* GetPageControl(CPDF_Page* pPage, int index) const; + + + CPDF_FormControl* GetControlAtPoint(CPDF_Page* pPage, FX_FLOAT pdf_x, FX_FLOAT pdf_y) const; + + CPDF_FormControl* GetControlByDict(CPDF_Dictionary* pWidgetDict) const; + + + + + FX_DWORD CountInternalFields(const CFX_WideString& csFieldName = L"") const; + + CPDF_Dictionary* GetInternalField(FX_DWORD index, const CFX_WideString& csFieldName = L"") const; + + + + + + CPDF_Document* GetDocument() const + { + return m_pDocument; + } + + CPDF_Dictionary* GetFormDict() const + { + return m_pFormDict; + } + + + + + FX_BOOL NeedConstructAP(); + + void NeedConstructAP(FX_BOOL bNeedAP); + + + + + int CountFieldsInCalculationOrder(); + + CPDF_FormField* GetFieldInCalculationOrder(int index); + + int FindFieldInCalculationOrder(const CPDF_FormField* pField); + + + + + FX_DWORD CountFormFonts(); + + CPDF_Font* GetFormFont(FX_DWORD index, CFX_ByteString& csNameTag); + + CPDF_Font* GetFormFont(CFX_ByteString csNameTag); + + CPDF_Font* GetFormFont(CFX_ByteString csFontName, CFX_ByteString& csNameTag); + + CPDF_Font* GetNativeFormFont(FX_BYTE iCharSet, CFX_ByteString& csNameTag); + + CPDF_Font* GetNativeFormFont(CFX_ByteString& csNameTag); + + FX_BOOL FindFormFont(const CPDF_Font* pFont, CFX_ByteString& csNameTag); + + FX_BOOL FindFormFont(CFX_ByteString csFontName, CPDF_Font*& pFont, CFX_ByteString& csNameTag); + + inline FX_BOOL FindFormFont(CFX_WideString csFontName, CPDF_Font*& pFont, CFX_ByteString& csNameTag) + { + return FindFormFont(PDF_EncodeText(csFontName), pFont, csNameTag); + } + + + + + + void AddFormFont(const CPDF_Font* pFont, CFX_ByteString& csNameTag); + + CPDF_Font* AddNativeFormFont(FX_BYTE iCharSet, CFX_ByteString& csNameTag); + + CPDF_Font* AddNativeFormFont(CFX_ByteString& csNameTag); + + void RemoveFormFont(const CPDF_Font* pFont); + + void RemoveFormFont(CFX_ByteString csNameTag); + + + + + CPDF_DefaultAppearance GetDefaultAppearance(); + + CPDF_Font* GetDefaultFormFont(); + + + + int GetFormAlignment(); + + + + + CPDF_FormField* CheckRequiredFields(const CFX_PtrArray *fields = NULL, FX_BOOL bIncludeOrExclude = TRUE) const; + + CFDF_Document* ExportToFDF(FX_WSTR pdf_path, FX_BOOL bSimpleFileSpec = FALSE) const; + + CFDF_Document* ExportToFDF(FX_WSTR pdf_path, CFX_PtrArray& fields, FX_BOOL bIncludeOrExclude = TRUE, FX_BOOL bSimpleFileSpec = FALSE) const; + + FX_BOOL ImportFromFDF(const CFDF_Document* pFDFDoc, FX_BOOL bNotify = FALSE); + + + + + FX_BOOL ResetForm(const CFX_PtrArray& fields, FX_BOOL bIncludeOrExclude = TRUE, FX_BOOL bNotify = FALSE); + + FX_BOOL ResetForm(FX_BOOL bNotify = FALSE); + + void ReloadForm(); + + CPDF_FormNotify* GetFormNotify() const + { + return m_pFormNotify; + } + + void SetFormNotify(const CPDF_FormNotify* pNotify); + + + int GetPageWithWidget(int iCurPage, FX_BOOL bNext); + + + + FX_BOOL IsUpdated() + { + return m_bUpdated; + } + + void ClearUpdatedFlag() + { + m_bUpdated = FALSE; + } + + + FX_BOOL HasXFAForm() const; + + void FixPageFields(const CPDF_Page* pPage); +protected: + + static FX_BOOL m_bUpdateAP; + + void LoadField(CPDF_Dictionary* pFieldDict, int nLevel = 0); + + CPDF_Object* GetFieldAttr(CPDF_Dictionary* pFieldDict, const FX_CHAR* name); + + CPDF_FormField* AddTerminalField(const CPDF_Dictionary* pFieldDict); + + CPDF_FormControl* AddControl(const CPDF_FormField* pField, const CPDF_Dictionary* pWidgetDict); + + void FDF_ImportField(CPDF_Dictionary* pField, const CFX_WideString& parent_name, FX_BOOL bNotify = FALSE, int nLevel = 0); + + FX_BOOL ValidateFieldName(CFX_WideString& csNewFieldName, int iType, const CPDF_FormField* pExcludedField, const CPDF_FormControl* pExcludedControl); + + int CompareFieldName(const CFX_WideString& name1, const CFX_WideString& name2); + + int CompareFieldName(const CFX_ByteString& name1, const CFX_ByteString& name2); + + CPDF_Document* m_pDocument; + + FX_BOOL m_bGenerateAP; + + CPDF_Dictionary* m_pFormDict; + + CFX_MapPtrToPtr m_ControlMap; + + CFieldTree *m_pFieldTree; + + CFX_ByteString m_bsEncoding; + + CPDF_FormNotify* m_pFormNotify; + + FX_BOOL m_bUpdated; + friend class CPDF_FormControl; + friend class CPDF_FormField; +}; +#define FORMFIELD_READONLY 0x01 +#define FORMFIELD_REQUIRED 0x02 +#define FORMFIELD_NOEXPORT 0x04 +#define FORMRADIO_NOTOGGLEOFF 0x100 +#define FORMRADIO_UNISON 0x200 +#define FORMTEXT_MULTILINE 0x100 +#define FORMTEXT_PASSWORD 0x200 +#define FORMTEXT_NOSCROLL 0x400 +#define FORMTEXT_COMB 0x800 +#define FORMCOMBO_EDIT 0x100 +#define FORMLIST_MULTISELECT 0x100 +class CPDF_FormField : public CFX_Object +{ +public: + + enum Type { + Unknown, + PushButton, + RadioButton, + CheckBox, + Text, + RichText, + File, + ListBox, + ComboBox, + Sign + }; + + CFX_WideString GetFullName(); + + Type GetType() + { + return m_Type; + } + + FX_DWORD GetFlags() + { + return m_Flags; + } + + CPDF_InterForm* GetInterForm() const + { + return m_pForm; + } + + CPDF_Dictionary* GetFieldDict() const + { + return m_pDict; + } + + void SetFieldDict(CPDF_Dictionary* pDict) + { + m_pDict = pDict; + } + + FX_BOOL ResetField(FX_BOOL bNotify = FALSE); + + + + int CountControls() + { + return m_ControlList.GetSize(); + } + + CPDF_FormControl* GetControl(int index) + { + return (CPDF_FormControl*)m_ControlList.GetAt(index); + } + + int GetControlIndex(const CPDF_FormControl* pControl); + + + + + int GetFieldType(); + + + + + CPDF_AAction GetAdditionalAction(); + + + + + CFX_WideString GetAlternateName(); + + + + + CFX_WideString GetMappingName(); + + + + + FX_DWORD GetFieldFlags(); + + + + + CFX_ByteString GetDefaultStyle(); + + + + + CFX_WideString GetRichTextString(); + + + + CFX_WideString GetValue(); + + CFX_WideString GetDefaultValue(); + + FX_BOOL SetValue(const CFX_WideString& value, FX_BOOL bNotify = FALSE); + + + + + + int GetMaxLen(); + + + + + int CountSelectedItems(); + + int GetSelectedIndex(int index); + + FX_BOOL ClearSelection(FX_BOOL bNotify = FALSE); + + FX_BOOL IsItemSelected(int index); + + FX_BOOL SetItemSelection(int index, FX_BOOL bSelected, FX_BOOL bNotify = FALSE); + + FX_BOOL IsItemDefaultSelected(int index); + + int GetDefaultSelectedItem(); + + + + + int CountOptions(); + + CFX_WideString GetOptionLabel(int index); + + CFX_WideString GetOptionValue(int index); + + int FindOption(CFX_WideString csOptLabel); + + int FindOptionValue(FX_LPCWSTR csOptValue, int iStartIndex = 0); + + + + + FX_BOOL CheckControl(int iControlIndex, FX_BOOL bChecked, FX_BOOL bNotify = FALSE); + + + + + int GetTopVisibleIndex(); + + + + + int CountSelectedOptions(); + + int GetSelectedOptionIndex(int index); + + FX_BOOL IsOptionSelected(int iOptIndex); + + FX_BOOL SelectOption(int iOptIndex, FX_BOOL bSelected, FX_BOOL bNotify = FALSE); + + FX_BOOL ClearSelectedOptions(FX_BOOL bNotify = FALSE); + + + + + FX_FLOAT GetFontSize() + { + return m_FontSize; + } + + CPDF_Font* GetFont() + { + return m_pFont; + } + +protected: + + CPDF_FormField(CPDF_InterForm* pForm, CPDF_Dictionary* pDict); + + ~CPDF_FormField(); + + CPDF_FormField::Type m_Type; + + FX_DWORD m_Flags; + + CPDF_InterForm* m_pForm; + + CPDF_Dictionary* m_pDict; + + CFX_PtrArray m_ControlList; + friend class CPDF_InterForm; + friend class CPDF_FormControl; + + + + CFX_WideString GetValue(FX_BOOL bDefault); + + FX_BOOL SetValue(const CFX_WideString& value, FX_BOOL bDefault, FX_BOOL bNotify); + + + void SyncFieldFlags(); + + int FindListSel(CPDF_String* str); + + CFX_WideString GetOptionText(int index, int sub_index); + + void LoadDA(); + + void UpdateAP(CPDF_FormControl* pControl); + + + + CFX_WideString GetCheckValue(FX_BOOL bDefault); + + FX_BOOL SetCheckValue(const CFX_WideString& value, FX_BOOL bDefault, FX_BOOL bNotify); + + + FX_FLOAT m_FontSize; + + CPDF_Font* m_pFont; +}; +CPDF_Object* FPDF_GetFieldAttr(CPDF_Dictionary* pFieldDict, const FX_CHAR* name, int nLevel = 0); +class CPDF_IconFit : public CFX_Object +{ +public: + + CPDF_IconFit(CPDF_Dictionary* pDict = NULL) + { + m_pDict = pDict; + } + + operator CPDF_Dictionary*() const + { + return m_pDict; + } + + + + + enum ScaleMethod { + Always = 0, + Bigger, + Smaller, + Never + }; + + ScaleMethod GetScaleMethod(); + + + + + FX_BOOL IsProportionalScale(); + + + + + void GetIconPosition(FX_FLOAT& fLeft, FX_FLOAT& fBottom); + + + + + FX_BOOL GetFittingBounds(); + + + CPDF_Dictionary* m_pDict; +}; + +#define TEXTPOS_CAPTION 0 +#define TEXTPOS_ICON 1 +#define TEXTPOS_BELOW 2 +#define TEXTPOS_ABOVE 3 +#define TEXTPOS_RIGHT 4 +#define TEXTPOS_LEFT 5 +#define TEXTPOS_OVERLAID 6 +class CPDF_FormControl : public CFX_Object +{ +public: + + CPDF_FormField::Type GetType() + { + return m_pField->GetType(); + } + + CPDF_InterForm* GetInterForm() const + { + return m_pForm; + } + + CPDF_FormField* GetField() const + { + return m_pField; + } + + CPDF_Dictionary* GetWidget() const + { + return m_pWidgetDict; + } + + CFX_FloatRect GetRect(); + + void DrawControl(CFX_RenderDevice* pDevice, CFX_AffineMatrix* pMatrix, + CPDF_Page* pPage, CPDF_Annot::AppearanceMode mode, const CPDF_RenderOptions* pOptions = NULL); + + + + CFX_ByteString GetCheckedAPState(); + + CFX_WideString GetExportValue(); + + FX_BOOL IsChecked(); + + FX_BOOL IsDefaultChecked(); + + + + + enum HighlightingMode { + None = 0, + Invert, + Outline, + Push, + Toggle + }; + + HighlightingMode GetHighlightingMode(); + + + + + FX_BOOL HasMKEntry(CFX_ByteString csEntry); + + + + + int GetRotation(); + + + + + inline FX_ARGB GetBorderColor(int& iColorType) + { + return GetColor(iColorType, "BC"); + } + + inline FX_FLOAT GetOriginalBorderColor(int index) + { + return GetOriginalColor(index, "BC"); + } + + inline void GetOriginalBorderColor(int& iColorType, FX_FLOAT fc[4]) + { + GetOriginalColor(iColorType, fc, "BC"); + } + + + + + inline FX_ARGB GetBackgroundColor(int& iColorType) + { + return GetColor(iColorType, "BG"); + } + + inline FX_FLOAT GetOriginalBackgroundColor(int index) + { + return GetOriginalColor(index, "BG"); + } + + inline void GetOriginalBackgroundColor(int& iColorType, FX_FLOAT fc[4]) + { + GetOriginalColor(iColorType, fc, "BG"); + } + + + + + inline CFX_WideString GetNormalCaption() + { + return GetCaption("CA"); + } + + + + + inline CFX_WideString GetRolloverCaption() + { + return GetCaption("RC"); + } + + + + + inline CFX_WideString GetDownCaption() + { + return GetCaption("AC"); + } + + + + + inline CPDF_Stream* GetNormalIcon() + { + return GetIcon("I"); + } + + + + + inline CPDF_Stream* GetRolloverIcon() + { + return GetIcon("RI"); + } + + + + + inline CPDF_Stream* GetDownIcon() + { + return GetIcon("IX"); + } + + + + + CPDF_IconFit GetIconFit(); + + + + + int GetTextPosition(); + + + + + CPDF_Action GetAction(); + + + + + CPDF_AAction GetAdditionalAction(); + + + + + CPDF_DefaultAppearance GetDefaultAppearance(); + + CPDF_Font* GetDefaultControlFont(); + + + + + int GetControlAlignment(); + +protected: + + CPDF_FormControl(CPDF_FormField* pField, CPDF_Dictionary* pWidgetDict); + + CFX_ByteString GetOnStateName(); + + void SetOnStateName(const CFX_ByteString& csOn); + + void CheckControl(FX_BOOL bChecked); + + FX_ARGB GetColor(int& iColorType, CFX_ByteString csEntry); + + FX_FLOAT GetOriginalColor(int index, CFX_ByteString csEntry); + + void GetOriginalColor(int& iColorType, FX_FLOAT fc[4], CFX_ByteString csEntry); + + CFX_WideString GetCaption(CFX_ByteString csEntry); + + CPDF_Stream* GetIcon(CFX_ByteString csEntry); + + CPDF_ApSettings GetMK(FX_BOOL bCreate); + + CPDF_InterForm* m_pForm; + + CPDF_FormField* m_pField; + + CPDF_Dictionary* m_pWidgetDict; + friend class CPDF_InterForm; + friend class CPDF_FormField; +}; +class CPDF_FormNotify : public CFX_Object +{ +public: + + virtual ~CPDF_FormNotify() {} + + virtual int BeforeValueChange(const CPDF_FormField* pField, CFX_WideString& csValue) + { + return 0; + } + + virtual int AfterValueChange(const CPDF_FormField* pField) + { + return 0; + } + + virtual int BeforeSelectionChange(const CPDF_FormField* pField, CFX_WideString& csValue) + { + return 0; + } + + virtual int AfterSelectionChange(const CPDF_FormField* pField) + { + return 0; + } + + virtual int AfterCheckedStatusChange(const CPDF_FormField* pField, const CFX_ByteArray& statusArray) + { + return 0; + } + + virtual int BeforeFormReset(const CPDF_InterForm* pForm) + { + return 0; + } + + virtual int AfterFormReset(const CPDF_InterForm* pForm) + { + return 0; + } + + virtual int BeforeFormImportData(const CPDF_InterForm* pForm) + { + return 0; + } + + virtual int AfterFormImportData(const CPDF_InterForm* pForm) + { + return 0; + } +}; +FX_BOOL FPDF_GenerateAP(CPDF_Document* pDoc, CPDF_Dictionary* pAnnotDict); +class CPDF_PageLabel : public CFX_Object +{ +public: + + CPDF_PageLabel(CPDF_Document* pDocument) + { + m_pDocument = pDocument; + } + + + CFX_WideString GetLabel(int nPage) const; + + FX_INT32 GetPageByLabel(FX_BSTR bsLabel) const; + + + FX_INT32 GetPageByLabel(FX_WSTR wsLabel) const; + +protected: + CPDF_Document* m_pDocument; +}; +class CPDF_Metadata +{ +public: + + CPDF_Metadata(); + + + ~CPDF_Metadata(); + + void LoadDoc(CPDF_Document *pDoc); + + + FX_INT32 GetString(FX_BSTR bsItem, CFX_WideString &wsStr); + + CXML_Element* GetRoot() const; + + CXML_Element* GetRDF() const; + +protected: + FX_LPVOID m_pData; +}; +class CPDF_ViewerPreferences +{ +public: + + CPDF_ViewerPreferences(CPDF_Document *pDoc); + + + ~CPDF_ViewerPreferences(); + + + FX_BOOL IsDirectionR2L() const; + + FX_BOOL PrintScaling() const; + + +protected: + CPDF_Document* m_pDoc; +}; +class CPDF_ApSettings : public CFX_Object +{ +public: + + CPDF_ApSettings(CPDF_Dictionary* pDict = NULL) + { + m_pDict = pDict; + } + + operator CPDF_Dictionary* () const + { + return m_pDict; + } + + FX_BOOL HasMKEntry(FX_BSTR csEntry); + + + + int GetRotation(); + + + + + inline FX_ARGB GetBorderColor(int& iColorType) + { + return GetColor(iColorType, FX_BSTRC("BC")); + } + + inline FX_FLOAT GetOriginalBorderColor(int index) + { + return GetOriginalColor(index, FX_BSTRC("BC")); + } + + inline void GetOriginalBorderColor(int& iColorType, FX_FLOAT fc[4]) + { + GetOriginalColor(iColorType, fc, FX_BSTRC("BC")); + } + + + + + inline FX_ARGB GetBackgroundColor(int& iColorType) + { + return GetColor(iColorType, FX_BSTRC("BG")); + } + + inline FX_FLOAT GetOriginalBackgroundColor(int index) + { + return GetOriginalColor(index, FX_BSTRC("BG")); + } + + inline void GetOriginalBackgroundColor(int& iColorType, FX_FLOAT fc[4]) + { + GetOriginalColor(iColorType, fc, FX_BSTRC("BG")); + } + + + + + inline CFX_WideString GetNormalCaption() + { + return GetCaption(FX_BSTRC("CA")); + } + + + + + inline CFX_WideString GetRolloverCaption() + { + return GetCaption(FX_BSTRC("RC")); + } + + + + + inline CFX_WideString GetDownCaption() + { + return GetCaption(FX_BSTRC("AC")); + } + + + + + inline CPDF_Stream* GetNormalIcon() + { + return GetIcon(FX_BSTRC("I")); + } + + + + + inline CPDF_Stream* GetRolloverIcon() + { + return GetIcon(FX_BSTRC("RI")); + } + + + + + inline CPDF_Stream* GetDownIcon() + { + return GetIcon(FX_BSTRC("IX")); + } + + + + + CPDF_IconFit GetIconFit(); + + + + + int GetTextPosition(); + + CPDF_Dictionary* m_pDict; +protected: + + FX_ARGB GetColor(int& iColorType, FX_BSTR csEntry); + + FX_FLOAT GetOriginalColor(int index, FX_BSTR csEntry); + + void GetOriginalColor(int& iColorType, FX_FLOAT fc[4], FX_BSTR csEntry); + + CFX_WideString GetCaption(FX_BSTR csEntry); + + CPDF_Stream* GetIcon(FX_BSTR csEntry); + friend class CPDF_FormControl; +}; +#endif diff --git a/core/include/fpdfdoc/fpdf_tagged.h b/core/include/fpdfdoc/fpdf_tagged.h new file mode 100644 index 0000000000..a44c26311b --- /dev/null +++ b/core/include/fpdfdoc/fpdf_tagged.h @@ -0,0 +1,99 @@ +// 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 + +#ifndef _FPDF_TAGGED_H_ +#define _FPDF_TAGGED_H_ +class CPDF_StructTree; +class CPDF_StructElement; +struct CPDF_StructKid; +class CPDF_Document; +class CPDF_Page; +class IPDF_ReflowEngine; +class IPDF_ReflowedPage; +class CPDF_StructTree : public CFX_Object +{ +public: + + static CPDF_StructTree* LoadDoc(const CPDF_Document* pDoc); + + static CPDF_StructTree* LoadPage(const CPDF_Document* pDoc, const CPDF_Dictionary* pPageDict); + + virtual ~CPDF_StructTree() {} + + virtual int CountTopElements() const = 0; + + virtual CPDF_StructElement* GetTopElement(int i) const = 0; +}; +struct CPDF_StructKid { + enum { + Invalid, + Element, + PageContent, + StreamContent, + Object + } m_Type; + + union { + struct { + + CPDF_StructElement* m_pElement; + + CPDF_Dictionary* m_pDict; + } m_Element; + struct { + + FX_DWORD m_PageObjNum; + + FX_DWORD m_ContentId; + } m_PageContent; + struct { + + FX_DWORD m_PageObjNum; + + FX_DWORD m_ContentId; + + FX_DWORD m_RefObjNum; + } m_StreamContent; + struct { + + FX_DWORD m_PageObjNum; + + FX_DWORD m_RefObjNum; + } m_Object; + }; +}; +class CPDF_StructElement : public CFX_Object +{ +public: + + virtual CPDF_StructTree* GetTree() const = 0; + + virtual const CFX_ByteString& GetType() const = 0; + + virtual CPDF_StructElement* GetParent() const = 0; + + virtual CPDF_Dictionary * GetDict() const = 0; + + virtual int CountKids() const = 0; + + virtual const CPDF_StructKid& GetKid(int index) const = 0; + + virtual CFX_PtrArray* GetObjectArray() = 0; + + virtual CPDF_Object* GetAttr(FX_BSTR owner, FX_BSTR name, FX_BOOL bInheritable = FALSE, FX_FLOAT fLevel = 0.0F) = 0; + + + + virtual CFX_ByteString GetName(FX_BSTR owner, FX_BSTR name, FX_BSTR default_value, FX_BOOL bInheritable = FALSE, int subindex = -1) = 0; + + virtual FX_ARGB GetColor(FX_BSTR owner, FX_BSTR name, FX_ARGB default_value, FX_BOOL bInheritable = FALSE, int subindex = -1) = 0; + + virtual FX_FLOAT GetNumber(FX_BSTR owner, FX_BSTR name, FX_FLOAT default_value, FX_BOOL bInheritable = FALSE, int subindex = -1) = 0; + + virtual int GetInteger(FX_BSTR owner, FX_BSTR name, int default_value, FX_BOOL bInheritable = FALSE, int subindex = -1) = 0; + +}; +#endif diff --git a/core/include/fpdfdoc/fpdf_vt.h b/core/include/fpdfdoc/fpdf_vt.h new file mode 100644 index 0000000000..e2825c123d --- /dev/null +++ b/core/include/fpdfdoc/fpdf_vt.h @@ -0,0 +1,444 @@ +// 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 + +#ifndef _FPDF_VT_H_ +#define _FPDF_VT_H_ +#include "../fxcrt/fx_basic.h" +#include "../fpdfapi/fpdf_parser.h" +struct CPVT_WordPlace; +struct CPVT_WordRange; +struct CPVT_Word; +struct CPVT_Line; +struct CPVT_Section; +class IPDF_VariableText_Provider; +class IPDF_VariableText_Iterator; +class IPDF_VariableText; +struct CPVT_WordPlace { + + CPVT_WordPlace() : nSecIndex(-1), nLineIndex(-1), nWordIndex(-1) + { + } + + CPVT_WordPlace(FX_INT32 nSecIndex, FX_INT32 nLineIndex, FX_INT32 nWordIndex) + { + this->nSecIndex = nSecIndex; + this->nLineIndex = nLineIndex; + this->nWordIndex = nWordIndex; + } + + void Default() + { + nSecIndex = nLineIndex = nWordIndex = -1; + } + + FX_BOOL operator == (const CPVT_WordPlace & wp) const + { + return wp.nSecIndex == this->nSecIndex && wp.nLineIndex == this->nLineIndex && wp.nWordIndex == this->nWordIndex; + } + + FX_BOOL operator != (const CPVT_WordPlace & wp) const + { + return wp.nSecIndex != this->nSecIndex || wp.nLineIndex != this->nLineIndex || wp.nWordIndex != this->nWordIndex; + } + + inline FX_INT32 WordCmp(const CPVT_WordPlace & wp) const + { + if (this->nSecIndex > wp.nSecIndex) { + return 1; + } + if (this->nSecIndex < wp.nSecIndex) { + return -1; + } + if (this->nLineIndex > wp.nLineIndex) { + return 1; + } + if (this->nLineIndex < wp.nLineIndex) { + return -1; + } + if (this->nWordIndex > wp.nWordIndex) { + return 1; + } + if (this->nWordIndex < wp.nWordIndex) { + return -1; + } + return 0; + } + + inline FX_INT32 LineCmp(const CPVT_WordPlace & wp) const + { + if (this->nSecIndex > wp.nSecIndex) { + return 1; + } + if (this->nSecIndex < wp.nSecIndex) { + return -1; + } + if (this->nLineIndex > wp.nLineIndex) { + return 1; + } + if (this->nLineIndex < wp.nLineIndex) { + return -1; + } + return 0; + } + + inline FX_INT32 SecCmp(const CPVT_WordPlace & wp) const + { + if (this->nSecIndex > wp.nSecIndex) { + return 1; + } + if (this->nSecIndex < wp.nSecIndex) { + return -1; + } + return 0; + } + + FX_INT32 nSecIndex; + + FX_INT32 nLineIndex; + + FX_INT32 nWordIndex; +}; +struct CPVT_WordRange { + + CPVT_WordRange() + { + } + + CPVT_WordRange(const CPVT_WordPlace & begin, const CPVT_WordPlace & end) + { + Set(begin, end); + } + + void Default() + { + BeginPos.Default(); + EndPos.Default(); + } + + void Set(const CPVT_WordPlace & begin, const CPVT_WordPlace & end) + { + this->BeginPos = begin; + this->EndPos = end; + SwapWordPlace(); + } + + void SetBeginPos(const CPVT_WordPlace & begin) + { + this->BeginPos = begin; + SwapWordPlace(); + } + + void SetEndPos(const CPVT_WordPlace & end) + { + this->EndPos = end; + SwapWordPlace(); + } + + FX_BOOL IsExist() const + { + return this->BeginPos != this->EndPos; + } + + FX_BOOL operator != (const CPVT_WordRange & wr) const + { + return wr.BeginPos != this->BeginPos || wr.EndPos != this->EndPos; + } + + void SwapWordPlace() + { + if (BeginPos.WordCmp(EndPos) > 0) { + CPVT_WordPlace place = EndPos; + EndPos = BeginPos; + BeginPos = place; + } + } + + CPVT_WordPlace BeginPos; + + CPVT_WordPlace EndPos; +}; +struct CPVT_SecProps : public CFX_Object { + + CPVT_SecProps() : fLineLeading(0.0f), fLineIndent(0.0f), nAlignment(0) + { + } + + CPVT_SecProps(FX_FLOAT lineLeading, FX_FLOAT lineIndent, FX_INT32 alignment) : + fLineLeading(lineLeading), fLineIndent(lineIndent), nAlignment(alignment) + { + } + + CPVT_SecProps(const CPVT_SecProps & other) : + fLineLeading(other.fLineLeading), fLineIndent(other.fLineIndent), nAlignment(other.nAlignment) + { + } + + FX_FLOAT fLineLeading; + + FX_FLOAT fLineIndent; + + FX_INT32 nAlignment; +}; +struct CPVT_WordProps : public CFX_Object { + + CPVT_WordProps() : nFontIndex(-1), fFontSize(0.0f), dwWordColor(0), nScriptType(0), nWordStyle(0), + fCharSpace(0.0f), nHorzScale(0) + { + } + + CPVT_WordProps(FX_INT32 fontIndex, FX_FLOAT fontSize, FX_COLORREF wordColor = 0, FX_INT32 scriptType = 0, FX_INT32 wordStyle = 0, + FX_FLOAT charSpace = 0, FX_INT32 horzScale = 100) : + nFontIndex(fontIndex), fFontSize(fontSize), dwWordColor(wordColor), nScriptType(scriptType), + nWordStyle(wordStyle), fCharSpace(charSpace), nHorzScale(horzScale) + { + } + + CPVT_WordProps(const CPVT_WordProps & other) : + nFontIndex(other.nFontIndex), fFontSize(other.fFontSize), dwWordColor(other.dwWordColor), + nScriptType(other.nScriptType), nWordStyle(other.nWordStyle), fCharSpace(other.fCharSpace), + nHorzScale(other.nHorzScale) + { + } + + FX_INT32 nFontIndex; + + FX_FLOAT fFontSize; + + FX_COLORREF dwWordColor; + + FX_INT32 nScriptType; + + FX_INT32 nWordStyle; + + FX_FLOAT fCharSpace; + + FX_INT32 nHorzScale; +}; +struct CPVT_Word { + + CPVT_Word() : Word(0), nCharset(0), ptWord(0, 0), fAscent(0.0f), fDescent(0.0f), fWidth(0.0f), + fFontSize(0), WordProps() + { + } + + FX_WORD Word; + + FX_INT32 nCharset; + + CPVT_WordPlace WordPlace; + + CPDF_Point ptWord; + + FX_FLOAT fAscent; + + FX_FLOAT fDescent; + + FX_FLOAT fWidth; + + FX_INT32 nFontIndex; + + FX_FLOAT fFontSize; + + CPVT_WordProps WordProps; +}; +struct CPVT_Line { + + CPVT_Line() : ptLine(0, 0), fLineWidth(0.0f), fLineAscent(0.0f), fLineDescent(0.0f) + { + } + + CPVT_WordPlace lineplace; + + CPVT_WordPlace lineEnd; + + CPDF_Point ptLine; + + FX_FLOAT fLineWidth; + + FX_FLOAT fLineAscent; + + FX_FLOAT fLineDescent; +}; +struct CPVT_Section { + + CPVT_WordPlace secplace; + + CPDF_Rect rcSection; + + CPVT_SecProps SecProps; + + CPVT_WordProps WordProps; +}; +class IPDF_VariableText_Provider +{ +public: + + virtual FX_INT32 GetCharWidth(FX_INT32 nFontIndex, FX_WORD word, FX_INT32 nWordStyle) = 0; + + virtual FX_INT32 GetTypeAscent(FX_INT32 nFontIndex) = 0; + + virtual FX_INT32 GetTypeDescent(FX_INT32 nFontIndex) = 0; + + virtual FX_INT32 GetWordFontIndex(FX_WORD word, FX_INT32 charset, FX_INT32 nFontIndex) = 0; + + virtual FX_BOOL IsLatinWord(FX_WORD word) = 0; + + virtual FX_INT32 GetDefaultFontIndex() = 0; +}; +class IPDF_VariableText_Iterator +{ +public: + + virtual FX_BOOL NextWord() = 0; + + virtual FX_BOOL PrevWord() = 0; + + virtual FX_BOOL NextLine() = 0; + + virtual FX_BOOL PrevLine() = 0; + + virtual FX_BOOL NextSection() = 0; + + virtual FX_BOOL PrevSection() = 0; + + virtual FX_BOOL GetWord(CPVT_Word & word) const = 0; + + virtual FX_BOOL SetWord(const CPVT_Word & word) = 0; + + virtual FX_BOOL GetLine(CPVT_Line & line) const = 0; + + virtual FX_BOOL GetSection(CPVT_Section & section) const = 0; + + virtual FX_BOOL SetSection(const CPVT_Section & section) = 0; + + virtual void SetAt(FX_INT32 nWordIndex) = 0; + + virtual void SetAt(const CPVT_WordPlace & place) = 0; + + virtual const CPVT_WordPlace & GetAt() const = 0; +}; +class IPDF_VariableText +{ +public: + + static IPDF_VariableText* NewVariableText(); + + static void DelVariableText(IPDF_VariableText* pVT); +public: + + virtual IPDF_VariableText_Provider* SetProvider(IPDF_VariableText_Provider * pProvider) = 0; + + virtual IPDF_VariableText_Iterator* GetIterator() = 0; + + virtual void SetPlateRect(const CPDF_Rect & rect) = 0; + + virtual void SetAlignment(FX_INT32 nFormat = 0) = 0; + + virtual void SetPasswordChar(FX_WORD wSubWord = '*') = 0; + + virtual void SetLimitChar(FX_INT32 nLimitChar = 0) = 0; + + virtual void SetCharArray(FX_INT32 nCharArray = 0) = 0; + + virtual void SetCharSpace(FX_FLOAT fCharSpace = 0.0f) = 0; + + virtual void SetHorzScale(FX_INT32 nHorzScale = 100) = 0; + + virtual void SetMultiLine(FX_BOOL bMultiLine = TRUE) = 0; + + virtual void SetAutoReturn(FX_BOOL bAuto = TRUE) = 0; + + virtual void SetAutoFontSize(FX_BOOL bAuto = TRUE) = 0; + + virtual void SetFontSize(FX_FLOAT fFontSize) = 0; + + virtual void SetLineLeading(FX_FLOAT fLineLeading) = 0; + + virtual void SetRichText(FX_BOOL bRichText) = 0; + + virtual void Initialize() = 0; + + virtual FX_BOOL IsValid() const = 0; + + virtual FX_BOOL IsRichText() const = 0; + + virtual void RearrangeAll() = 0; + + virtual void RearrangePart(const CPVT_WordRange & PlaceRange) = 0; + + virtual void ResetAll() = 0; + + virtual void SetText(FX_LPCWSTR text, FX_INT32 charset = 1, const CPVT_SecProps * pSecProps = NULL, + const CPVT_WordProps * pWordProps = NULL) = 0; + + virtual CPVT_WordPlace InsertWord(const CPVT_WordPlace & place, FX_WORD word, FX_INT32 charset = 1, + const CPVT_WordProps * pWordProps = NULL) = 0; + + virtual CPVT_WordPlace InsertSection(const CPVT_WordPlace & place, const CPVT_SecProps * pSecProps = NULL, + const CPVT_WordProps * pWordProps = NULL) = 0; + + virtual CPVT_WordPlace InsertText(const CPVT_WordPlace & place, FX_LPCWSTR text, FX_INT32 charset = 1, + const CPVT_SecProps * pSecProps = NULL, const CPVT_WordProps * pWordProps = NULL) = 0; + + virtual CPVT_WordPlace DeleteWords(const CPVT_WordRange & PlaceRange) = 0; + + virtual CPVT_WordPlace DeleteWord(const CPVT_WordPlace & place) = 0; + + virtual CPVT_WordPlace BackSpaceWord(const CPVT_WordPlace & place) = 0; + + virtual const CPDF_Rect & GetPlateRect() const = 0; + + virtual CPDF_Rect GetContentRect() const = 0; + + virtual FX_INT32 GetTotalWords() const = 0; + + virtual FX_FLOAT GetFontSize() const = 0; + + virtual FX_INT32 GetAlignment() const = 0; + + virtual FX_WORD GetPasswordChar() const = 0; + + virtual FX_INT32 GetCharArray() const = 0; + + virtual FX_INT32 GetLimitChar() const = 0; + + virtual FX_BOOL IsMultiLine() const = 0; + + virtual FX_INT32 GetHorzScale() const = 0; + + virtual FX_FLOAT GetCharSpace() const = 0; + + virtual CPVT_WordPlace GetBeginWordPlace() const = 0; + + virtual CPVT_WordPlace GetEndWordPlace() const = 0; + + virtual CPVT_WordPlace GetPrevWordPlace(const CPVT_WordPlace & place) const = 0; + + virtual CPVT_WordPlace GetNextWordPlace(const CPVT_WordPlace & place) const = 0; + + virtual CPVT_WordPlace SearchWordPlace(const CPDF_Point & point) const = 0; + + virtual CPVT_WordPlace GetUpWordPlace(const CPVT_WordPlace & place, const CPDF_Point & point) const = 0; + + virtual CPVT_WordPlace GetDownWordPlace(const CPVT_WordPlace & place, const CPDF_Point & point) const = 0; + + virtual CPVT_WordPlace GetLineBeginPlace(const CPVT_WordPlace & place) const = 0; + + virtual CPVT_WordPlace GetLineEndPlace(const CPVT_WordPlace & place) const = 0; + + virtual CPVT_WordPlace GetSectionBeginPlace(const CPVT_WordPlace & place) const = 0; + + virtual CPVT_WordPlace GetSectionEndPlace(const CPVT_WordPlace & place) const = 0; + + virtual void UpdateWordPlace(CPVT_WordPlace & place) const = 0; + + virtual CPVT_WordPlace AjustLineHeader(const CPVT_WordPlace & place, FX_BOOL bPrevOrNext) const = 0; + + virtual FX_INT32 WordPlaceToWordIndex(const CPVT_WordPlace & place) const = 0; + + virtual CPVT_WordPlace WordIndexToWordPlace(FX_INT32 index) const = 0; +}; +#endif -- cgit v1.2.3