Allow building non-XFA (master) on the XFA branch.

public/fpdfview.h

 // 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
 
 // NOTE: External docs refer to this file as "fpdfview.h", so do not rename
 // despite lack of consitency with other public files.
 
 #ifndef PUBLIC_FPDFVIEW_H_
 #define PUBLIC_FPDFVIEW_H_
 
 #if defined(_WIN32) && !defined(__WINDOWS__)
 #include <windows.h>
 #endif
 
+#ifdef PDF_ENABLE_XFA
 //  TODO: remove the #define when XFA is officially in pdfium
 #define PDF_USE_XFA
-
-// Data types
-typedef void* FPDF_MODULEMGR;
+#endif  // PDF_ENABLE_XFA
 
 // PDF types
+typedef void* FPDF_ACTION;
+typedef void* FPDF_BITMAP;
+typedef void* FPDF_BOOKMARK;
+typedef void* FPDF_CLIPPATH;
+typedef void* FPDF_DEST;
+typedef void* FPDF_DOCSCHHANDLE;
 typedef void* FPDF_DOCUMENT;
+typedef void* FPDF_FONT;
+typedef void* FPDF_HMODULE;
+typedef void* FPDF_LINK;
+typedef void* FPDF_MODULEMGR;
 typedef void* FPDF_PAGE;
+typedef void* FPDF_PAGELINK;
+typedef void* FPDF_PAGEOBJECT;  // Page object(text, path, etc)
+typedef void* FPDF_PAGERANGE;
+typedef void* FPDF_PATH;
+typedef void* FPDF_SCHHANDLE;
+typedef void* FPDF_TEXTPAGE;
+
+#ifdef PDF_ENABLE_XFA
+typedef void* FPDF_STRINGHANDLE;
 typedef void* FPDF_WIDGET;
-typedef void* FPDF_STRINGHANDLE;
-typedef void* FPDF_PAGEOBJECT;  // Page object(text, path, etc)
-typedef void* FPDF_PATH;
-typedef void* FPDF_CLIPPATH;
-typedef void* FPDF_BITMAP;
-typedef void* FPDF_FONT;
-typedef void* FPDF_TEXTPAGE;
-typedef void* FPDF_SCHHANDLE;
-typedef void* FPDF_PAGELINK;
-typedef void* FPDF_HMODULE;
-typedef void* FPDF_DOCSCHHANDLE;
-typedef void* FPDF_BOOKMARK;
-typedef void* FPDF_DEST;
-typedef void* FPDF_ACTION;
-typedef void* FPDF_LINK;
-typedef void* FPDF_PAGERANGE;
+#endif  // PDF_ENABLE_XFA
 
 // Basic data types
-typedef void* FPDF_LPVOID;
-typedef void const* FPDF_LPCVOID;
-typedef int FPDF_RESULT;
 typedef int FPDF_BOOL;
 typedef int FPDF_ERROR;
 typedef unsigned long FPDF_DWORD;
 typedef float FS_FLOAT;
 
+#ifdef PDF_ENABLE_XFA
+typedef void* FPDF_LPVOID;
+typedef void const* FPDF_LPCVOID;
+typedef char const* FPDF_LPCSTR;
+typedef int FPDF_RESULT;
+#endif
+
 // Duplex types
 typedef enum _FPDF_DUPLEXTYPE_ {
   DuplexUndefined = 0,
   Simplex,
   DuplexFlipShortEdge,
   DuplexFlipLongEdge
 } FPDF_DUPLEXTYPE;
 
 // String types
 typedef unsigned short FPDF_WCHAR;
 typedef unsigned char const* FPDF_LPCBYTE;
-typedef char const* FPDF_LPCSTR;
 
 // FPDFSDK may use three types of strings: byte string, wide string (UTF-16LE
 // encoded), and platform dependent string
 typedef const char* FPDF_BYTESTRING;
 
 // FPDFSDK always uses UTF-16LE encoded wide strings, each character uses 2
 // bytes (except surrogation), with the low byte first.
 typedef const unsigned short* FPDF_WIDESTRING;
 
-#ifndef _FPDF_DEF_STR_
-#define _FPDF_DEF_STR_
+#ifdef PDF_ENABLE_XFA
 // Structure for a byte string.
 // Note, a byte string commonly means a UTF-16LE formated string.
 typedef struct _FPDF_BSTR {
   // String buffer.
   char* str;
   // Length of the string, in bytes.
   int len;
 } FPDF_BSTR;
-
-#endif
+#endif  // PDF_ENABLE_XFA
 
 // For Windows programmers: In most cases it's OK to treat FPDF_WIDESTRING as a
 // Windows unicode string, however, special care needs to be taken if you
 // expect to process Unicode larger than 0xffff.
 //
 // For Linux/Unix programmers: most compiler/library environments use 4 bytes
 // for a Unicode character, and you have to convert between FPDF_WIDESTRING and
 // system wide string by yourself.
-
 #ifdef _WIN32_WCE
 typedef const unsigned short* FPDF_STRING;
 #else
 typedef const char* FPDF_STRING;
 #endif
 
 // Matrix for transformation.
 typedef struct _FS_MATRIX_ {
   float a;
   float b;
@@ skipping 110 matching lines @@
 // Parameters:
 //          file_path -  Path to the PDF file (including extension).
 //          password  -  A string used as the password for the PDF file.
 //                       If no password is needed, empty or NULL can be used.
 // Return value:
 //          A handle to the loaded document, or NULL on failure.
 // Comments:
 //          Loaded document can be closed by FPDF_CloseDocument().
 //          If this function fails, you can use FPDF_GetLastError() to retrieve
 //          the reason why it failed.
-// Notes:
-//          The application should call FPDF_LoadXFA function after PDF
-//          document loaded to support XFA fields in fpdfformfill.h file.
 DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_LoadDocument(FPDF_STRING file_path,
                                                   FPDF_BYTESTRING password);
 
 // Function: FPDF_LoadMemDocument
 //          Open and load a PDF document from memory.
 // Parameters:
 //          data_buf    -   Pointer to a buffer containing the PDF document.
 //          size        -   Number of bytes in the PDF document.
 //          password    -   A string used as the password for the PDF file.
 //                          If no password is needed, empty or NULL can be used.
 // Return value:
 //          A handle to the loaded document, or NULL on failure.
 // Comments:
 //          The memory buffer must remain valid when the document is open.
 //          The loaded document can be closed by FPDF_CloseDocument.
 //          If this function fails, you can use FPDF_GetLastError() to retrieve
 //          the reason why it failed.
 // Notes:
-//          The application should call FPDF_LoadXFA function after the
-//          document is loaded to support form fields.
+//          If PDFium is built with the XFA module, the application should call
+//          FPDF_LoadXFA() function after the PDF document loaded to support XFA
+//          fields defined in the fpdfformfill.h file.
 DLLEXPORT FPDF_DOCUMENT STDCALL FPDF_LoadMemDocument(const void* data_buf,
                                                      int size,
                                                      FPDF_BYTESTRING password);
 
 // Structure for custom file access.
 typedef struct {
   // File length, in bytes.
   unsigned long m_FileLen;
 
   // A function pointer for getting a block of data from a specific position.
   // Position is specified by byte offset from the beginning of the file.
   // The position and size will never go out of range of the file length.
   // It may be possible for FPDFSDK to call this function multiple times for
   // the same position.
   // Return value: should be non-zero if successful, zero for error.
   int (*m_GetBlock)(void* param,
                     unsigned long position,
                     unsigned char* pBuf,
                     unsigned long size);
 
   // A custom pointer for all implementation specific data.  This pointer will
   // be used as the first parameter to the m_GetBlock callback.
   void* m_Param;
 } FPDF_FILEACCESS;
 
+#ifdef PDF_ENABLE_XFA
 /**
  * @brief Structure for file reading or writing (I/O).
  *
  * @note This is a handler and should be implemented by callers.
  */
 typedef struct _FPDF_FILEHANDLER {
   /**
    * @brief User-defined data.
    * @note Callers can use this field to track controls.
    */
@@ skipping 59 matching lines @@
    *
    * @param[in]   clientData  Pointer to user-defined data.
    * @param[in]   size        New size of file stream, in bytes.
    *
    * @return 0 for success, other value for failure.
    */
   FPDF_RESULT (*Truncate)(FPDF_LPVOID clientData, FPDF_DWORD size);
 
 } FPDF_FILEHANDLER, *FPDF_LPFILEHANDLER;
 
+#endif
 // Function: FPDF_LoadCustomDocument
 //          Load PDF document from a custom access descriptor.
 // Parameters:
 //          pFileAccess -   A structure for accessing the file.
 //          password    -   Optional password for decrypting the PDF file.
 // Return value:
 //          A handle to the loaded document, or NULL on failure.
 // Comments:
 //          The application must keep the file resources valid until the PDF
 //          document is closed.
 //
 //          The loaded document can be closed with FPDF_CloseDocument.
 // Notes:
-//          The application should call the FPDF_LoadXFA function after the
-//          document is loaded to support form fields.
+//          If PDFium is built with the XFA module, the application should call
+//          FPDF_LoadXFA() function after the PDF document loaded to support XFA
+//          fields defined in the fpdfformfill.h file.
 DLLEXPORT FPDF_DOCUMENT STDCALL
 FPDF_LoadCustomDocument(FPDF_FILEACCESS* pFileAccess, FPDF_BYTESTRING password);
 
 // Function: FPDF_GetFileVersion
 //          Get the file version of the given PDF document.
 // Parameters:
 //          doc         -   Handle to a document.
 //          fileVersion -   The PDF file version. File version: 14 for 1.4, 15
 //                          for 1.5, ...
 // Return value:
 //          True if succeeds, false otherwise.
 // Comments:
 //          If the document was created by FPDF_CreateNewDocument,
 //          then this function will always fail.
 DLLEXPORT FPDF_BOOL STDCALL FPDF_GetFileVersion(FPDF_DOCUMENT doc,
                                                 int* fileVersion);
 
 #define FPDF_ERR_SUCCESS 0    // No error.
 #define FPDF_ERR_UNKNOWN 1    // Unknown error.
 #define FPDF_ERR_FILE 2       // File not found or could not be opened.
 #define FPDF_ERR_FORMAT 3     // File not in PDF format or corrupted.
 #define FPDF_ERR_PASSWORD 4   // Password required or incorrect password.
 #define FPDF_ERR_SECURITY 5   // Unsupported security scheme.
 #define FPDF_ERR_PAGE 6       // Page not found or content error.
+#ifdef PDF_ENABLE_XFA
 #define FPDF_ERR_XFALOAD 7    // Load XFA error.
 #define FPDF_ERR_XFALAYOUT 8  // Layout XFA error.
+#endif  // PDF_ENABLE_XFA
 
 // Function: FPDF_GetLastError
 //          Get last error code when a function fails.
 // Parameters:
 //          None.
 // Return value:
 //          A 32-bit integer indicating error code as defined above.
 // Comments:
 //          If the previous SDK call succeeded, the return value of this
 //          function is not defined.
@@ skipping 502 matching lines @@
 //            2) Second time pass in allocated |buffer| and buflen to retrieve
 //               |buffer|, which should be used as wchar_t*.
 //
 //         If buflen is not sufficiently large, it will be set to -1 upon
 //         return.
 DLLEXPORT FPDF_DEST STDCALL FPDF_GetNamedDest(FPDF_DOCUMENT document,
                                               int index,
                                               void* buffer,
                                               long* buflen);
 
+#ifdef PDF_ENABLE_XFA
 // Function: FPDF_BStr_Init
 //          Helper function to initialize a byte string.
 DLLEXPORT FPDF_RESULT STDCALL FPDF_BStr_Init(FPDF_BSTR* str);
 
 // Function: FPDF_BStr_Set
 //          Helper function to set string data.
 DLLEXPORT FPDF_RESULT STDCALL FPDF_BStr_Set(FPDF_BSTR* str,
                                             FPDF_LPCSTR bstr,
                                             int length);
 
 // Function: FPDF_BStr_Clear
 //          Helper function to clear a byte string.
 DLLEXPORT FPDF_RESULT STDCALL FPDF_BStr_Clear(FPDF_BSTR* str);
+#endif  // PDF_ENABLE_XFA
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif  // PUBLIC_FPDFVIEW_H_