fs_basictypes.h

Go to the documentation of this file.

#ifndef FS_BASIC_TYPES_H_
#define FS_BASIC_TYPES_H_

#include <cstddef>
#include <fstream>
#include <iostream>
#include <string>
#include <memory>
#include <vector>
#include <exception>
#include <cmath>
#include <cfloat>
#include <stdlib.h>
#include <string.h>

#include "common/fxcrt/fx_basic.h"
#include "common/fxcrt/fx_coordinates.h"
#include "common/fxcrt/fx_process.h"

#if defined(_WIN32) || defined(_WIN64)
#include <Windows.h>
#endif  // defined(_WIN32) || defined(_WIN64)

#define FSDK_DEFINE_ARRAY(ArrayName, Type) \
class ArrayName : public Object { \
 public: \
\
  ArrayName(); \
\
  ~ArrayName(); \
\
  ArrayName(const ArrayName& other); \
\
  ArrayName& operator = (const ArrayName& other); \
\
  size_t GetSize() const; \
\
  Type GetAt(size_t index) const; \
\
  Type& operator[](size_t index) const; \
\
  void Add(const Type& element); \
\
  void RemoveAt(size_t index); \
\
  void InsertAt(size_t index, const Type& element); \
\
  void RemoveAll(); \
     \
 private: \
  void* data_; \
};

namespace std {
class exception;
}

inline CFX_ByteString FX_UTF8Encode(const wchar_t* wstr) {
  return ::FX_UTF8Encode((FX_LPCWSTR) wstr, (FX_STRSIZE)FXSYS_wcslen(wstr));
}

inline bool operator==(const char* str1, const CFX_ByteString& str2) {
  return str2.Equal(str1);
}

inline bool operator!=(const char* str1, const CFX_ByteString& str2) {
  return !str2.Equal(str1);
}
inline std::ostream& operator<<(std::ostream& os, const CFX_ByteString& str) {
  return os << (const char*) str;
}

inline std::wostream& operator<<(std::wostream& os, const CFX_WideString& str) {
  return os << (const wchar_t*) str;
}

#ifndef TRUE

#define TRUE true
#endif

#ifndef FALSE

#define FALSE false
#endif

#ifndef NULL

#define NULL ((void*)0)
#endif

namespace foxit {
typedef FX_INT64        int64;
typedef FX_UINT64       uint64;
typedef FX_INT32        int32;
typedef FX_UINT32       uint32;
typedef FX_INT16        int16;
typedef FX_UINT16       uint16;
typedef FX_INT8         int8;
typedef FX_UINT8        uint8;
typedef FX_POSITION     POSITION;
typedef FX_FILESIZE     FILESIZE;
typedef uint32 ARGB;
typedef uint32 RGB;
typedef void* FS_HANDLE;

#if defined(_WIN32) || defined(_WIN64) || defined(__EMSCRIPTEN__)

typedef void* FX_HWND;
#endif

typedef CFX_Object Object;
typedef CFX_WideString WString;
typedef CFX_ByteString String;

FSDK_DEFINE_ARRAY(WStringArray, WString)
FSDK_DEFINE_ARRAY(StringArray, String)

typedef enum _ErrorCode {
  e_ErrSuccess = 0,
  e_ErrFile = 1,
  e_ErrFormat = 2,
  e_ErrPassword = 3,
  e_ErrHandle = 4,
  e_ErrCertificate = 5,
  e_ErrUnknown = 6,
  e_ErrInvalidLicense = 7,
  e_ErrParam = 8,
  e_ErrUnsupported = 9,
  e_ErrOutOfMemory = 10,
  e_ErrSecurityHandler = 11,
  e_ErrNotParsed = 12,
  e_ErrNotFound = 13,
  e_ErrInvalidType = 14,
  e_ErrConflict = 15,
  e_ErrUnknownState = 16,
  e_ErrDataNotReady = 17,
  e_ErrInvalidData = 18,
  e_ErrXFALoadError = 19,
  e_ErrNotLoaded = 20,
  e_ErrInvalidState = 21,
  e_ErrNotCDRM = 22,
  e_ErrCanNotConnectToServer = 23,
  e_ErrInvalidUserToken = 24,
  e_ErrNoRights = 25,
  e_ErrRightsExpired = 26,
  e_ErrDeviceLimitation = 27,
  e_ErrCanNotRemoveSecurityFromServer = 28,
  e_ErrCanNotGetACL = 29,
  e_ErrCanNotSetACL = 30,
  e_ErrIsAlreadyCPDF = 31,
  e_ErrIsAlreadyCDRM = 32,
  e_ErrCanNotUploadDocInfo = 33,
  e_ErrCanNotUploadCDRMInfo = 34,
  e_ErrInvalidWrapper = 35,
  e_ErrCanNotGetClientID = 36,
  e_ErrCanNotGetUserToken = 37,
  e_ErrInvalidACL = 38,
  e_ErrInvalidClientID = 39,
  e_ErrOCREngineNotInit = 40,
  e_ErrDiskFull = 41,
  e_ErrOCRTrialIsEnd = 42,
  e_ErrFilePathNotExist = 43,
  e_ErrComplianceEngineNotInit = 44,
  e_ErrComplianceEngineInvalidUnlockCode = 45,
  e_ErrComplianceEngineInitFailed = 46,
  e_ErrTimeStampServerMgrNotInit = 47,
  e_ErrLTVVerifyModeNotSet = 48,
  e_ErrLTVRevocationCallbackNotSet = 49,
  e_ErrLTVCannotSwitchVersion = 50,
  e_ErrLTVCannotCheckDTS = 51,
  e_ErrLTVCannotLoadDSS = 52,
  e_ErrLTVCannotLoadDTS = 53,
  e_ErrNeedSigned = 54,
  e_ErrComplianceResourceFile = 55,
  e_ErrTimeStampServerMgrNoDefaltServer = 56,
  e_ErrDefaultTimeStampServer = 57,
  e_ErrNoConnectedPDFModuleRight = 58,
  e_ErrNoXFAModuleRight = 59,
  e_ErrNoRedactionModuleRight = 60,
  e_ErrNoRMSModuleRight = 61,
  e_ErrNoOCRModuleRight = 62,
  e_ErrNoComparisonModuleRight = 63,
  e_ErrNoComplianceModuleRight = 64,
  e_ErrNoOptimizerModuleRight = 65,
  e_ErrNoConversionModuleRight = 66,
  e_ErrOfficeComNotInit = 67,
  e_ErrNoMicroOfficeInstalled = 68,
  e_ErrExcelHasNoContent = 69,
  e_ErrNoLayoutRecognitionModuleRight = 70,
  e_ErrWPSEngineNotFound = 71,
  e_ErrLibreofficeEngineNotFound = 72,
  e_ErrNoAccessibilityModuleRight = 73,
  e_ErrODAEngineNotFound = 74,
  e_ErrNoTableMakerModuleRight = 75,
  e_ErrNoDWG2PDFModuleRight = 76,
  e_ErrNoAdvEditModuleRight = 77,
  e_ErrNoPDF2OfficeModuleRight = 78,
  e_ErrURLInBlackList = 79,
  e_ErrOFDEngineNotInit = 80,
  e_ErrNoOFDModuleRight = 81,
  e_ErrNo3DModuleRight = 82,
  e_ErrInvalidRegex = 83,
  e_ErrNoDocumentPermission = 84,
  e_ErrNoOffice2PDFModuleRight = 85,
  e_ErrMIPUPEEngineInitFailed = 86,
  e_ErrMIPProtectionEngineInitFailed = 87,
  e_ErrMIPCreateProtectionHandlerFailed = 88,
  e_ErrMIPGetExtendedLabelInfoByIdFailed = 89,
  e_ErrNoPrint2PDFModuleRight = 90,
  e_ErrResponseDataError = 91,
  e_ErrTimeout = 92,
  e_ErrNoImageObject = 93,
  e_ErrFXOCREngineNotInit = 94
} ErrorCode;


typedef CFX_ArrayTemplate<float> FloatArray;
typedef CFX_ArrayTemplate<int32> Int32Array;

typedef CFX_ArrayTemplate<uint32> UInt32Array;

class Base : public Object {
 public:
  FS_HANDLE Handle() const {
    return handle_;
  }
  virtual ~Base(){}

 protected:
  explicit Base(FS_HANDLE handle = NULL) : handle_(handle) {}
  FS_HANDLE handle_;
};

typedef CFX_Matrix Matrix;
typedef CFX_PointF PointF;
typedef PointF Offset;
typedef CFX_FloatRect RectF;
typedef FX_RECT RectI;
typedef CFX_ArrayTemplate<RectF> RectFArray;
typedef CFX_ArrayTemplate<PointF> PointFArray;

class DateTime : public Object {
 public:
  static DateTime GetUTCTime();
  static DateTime GetLocalTime();

  DateTime(uint16 year, uint16 month, uint16 day,
           uint16 hour, uint16 minute, uint16 second, uint16 milliseconds,
           int16 utc_hour_offset, uint16 utc_minute_offset)
      : year(year)
      , month(month)
      , day(day)
      , hour(hour)
      , minute(minute)
      , second(second)
      , milliseconds(milliseconds)
      , utc_hour_offset(utc_hour_offset)
      , utc_minute_offset(utc_minute_offset) {}

  DateTime()
      : year(0)
      , month(0)
      , day(0)
      , hour(0)
      , minute(0)
      , second(0)
      , milliseconds(0)
      , utc_hour_offset(0)
      , utc_minute_offset(0) {}
  explicit DateTime(const FXCRT_DATETIMEZONE& time);
  DateTime(const DateTime& dt)
      : year(dt.year)
      , month(dt.month)
      , day(dt.day)
      , hour(dt.hour)
      , minute(dt.minute)
      , second(dt.second)
      , milliseconds(dt.milliseconds)
      , utc_hour_offset(dt.utc_hour_offset)
      , utc_minute_offset(dt.utc_minute_offset) {}

  DateTime& operator = (const DateTime& dt) {
    year = dt.year;
    month = dt.month;
    day = dt.day;
    hour = dt.hour;
    minute = dt.minute;
    second = dt.second;
    milliseconds = dt.milliseconds;
    utc_hour_offset = dt.utc_hour_offset;
    utc_minute_offset = dt.utc_minute_offset;
    return *this;
  }
  operator FXCRT_DATETIMEZONE() const;

#if (defined(_WIN32) || defined(_WIN64)) && !defined(SWIG)

  explicit DateTime(const SYSTEMTIME& systime)
      : year(systime.wYear)
      , month(systime.wMonth)
      , day(systime.wDay)
      , hour(systime.wHour)
      , minute(systime.wMinute)
      , second(systime.wSecond)
      , milliseconds(systime.wMilliseconds)
      , utc_hour_offset(0)
      , utc_minute_offset(0) {}

  operator SYSTEMTIME() const;
#endif  // defined(_WIN32) || defined(_WIN64)

  void Set(uint16 year, uint16 month, uint16 day,
           uint16 hour, uint16 minute, uint16 second, uint16 milliseconds,
           int16 utc_hour_offset, uint16 utc_minute_offset) {
    this->year = year;
    this->month = month;
    this->day = day;
    this->hour = hour;
    this->minute = minute;
    this->second = second;
    this->milliseconds = milliseconds;
    this->utc_hour_offset = utc_hour_offset;
    this->utc_minute_offset = utc_minute_offset;
  }

  bool IsValid() const;

  bool operator == (const DateTime& datetime) const;
  bool operator != (const DateTime& datetime) const;
  bool operator > (const DateTime& datetime) const;
  bool operator >= (const DateTime& datetime) const;
  bool operator < (const DateTime& datetime) const;
  bool operator <= (const DateTime& datetime) const;

  DateTime& ToLocalTime();

  DateTime& ToUTCTime();

  uint16 year;
  uint16 month;
  uint16 day;
  uint16 hour;
  uint16 minute;
  uint16 second;
  uint16 milliseconds;
  int16 utc_hour_offset;
  
  uint16 utc_minute_offset;
};

//#if !defined(_SWIG_ANDROID_) && !defined(_SWIG_IOS_)
  
class Exception : public std::exception , public Object {
 public:
  Exception(const char* file_name, int line_number, const char* function_name, ErrorCode error_code);

  Exception(const Exception& exception)
      : error_code_(exception.error_code_)
      , error_message_(exception.error_message_)
      , name_(exception.name_) {}

  Exception& operator = (const Exception& exception) {
    error_code_ = exception.error_code_;
    error_message_ = exception.error_message_;
    return *this;
  }

  ~Exception() throw() {}

  ErrorCode GetErrCode() const {
    return error_code_;
  }

  String GetMessage() const
  {
    return error_message_;
  }

  String GetName() const
  { return name_; }

 private:
  ErrorCode error_code_;
  String error_message_;
  String name_;
};
  
#define throw(Exception)
//#endif  // !defined(_SWIG_ANDROID_) && !defined(_SWIG_IOS_)

#if __cpluscplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1700)
#define FS_FINAL final
#else
#define FS_FINAL 
#endif

#if __cpluscplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)
#define FS_OVERRIDE override
#else
#define FS_OVERRIDE 
#endif

}  // namespace foxit
#endif