fs_common.h

Go to the documentation of this file.

#ifndef FS_COMMON_H_
#define FS_COMMON_H_

#include "common/fs_basictypes.h"
#include "common/file/fs_file.h"

namespace foxit {
class ActionCallback;
namespace common {
class DocEventCallback;
class FontMapperCallback;
class Color;
}  // namespace common
namespace pdf {
namespace annots {
class IconProviderCallback;
}  // namespace annots
class PDFDoc;
class SignatureCallback;
class SecurityCallback;
class TimeStampCallback;
}  // namespace pdf
namespace addon {
namespace xfa {
class AppProviderCallback;
}  // namespace xfa
}  // namespace addon

namespace common {
typedef enum _Rotation {
  e_Rotation0 = 0,
  e_Rotation90 = 1,
  e_Rotation180 = 2,
  e_Rotation270 = 3,
  e_RotationUnknown = 4
} Rotation;

typedef enum _RotationPointOptions {
  e_RotationPointCenter = 0,
  e_RotationPointLeftTop = 1,
  e_RotationPointRightTop = 2,
  e_RotationPointLeftBottom  = 3,
  e_RotationPointRightBottom  = 4
} RotationPointOptions;

typedef enum _Alignment {
  e_AlignmentLeft = 0,
  e_AlignmentCenter = 1,
  e_AlignmentRight = 2
} Alignment;

typedef enum _FillMode {
  e_FillModeNone  = 0,
  e_FillModeAlternate= 1,
  e_FillModeWinding = 2
} FillMode;

typedef enum _Position {
  e_PosTopLeft = 0,
  e_PosTopCenter = 1,
  e_PosTopRight = 2,
  e_PosCenterLeft = 3,
  e_PosCenter = 4,
  e_PosCenterRight = 5,
  e_PosBottomLeft = 6,
  e_PosBottomCenter = 7,
  e_PosBottomRight = 8
} Position;

typedef enum _ModuleName {
  e_ModuleNameConnectedPDF = 1,
  e_ModuleNameXFA = 2,
  e_ModuleNameRedaction = 3,
  e_ModuleNameRMS = 4,
  e_ModuleNameOCR = 5,
  e_ModuleNameComparison = 6,
  e_ModuleNameCompliance = 7,
  e_ModuleNameOptimizer = 8,
  e_ModuleNameConversion = 9,
  e_ModuleNameLayoutRecognition = 10,
  e_ModuleNameAccessibility = 11,
  e_ModuleNameTableMaker = 12,
  e_ModuleNameDWG2PDF = 13,
  e_ModuleNameAdvEdit = 14,
  e_ModuleNamePDF2Office = 15,
  e_ModuleName3D = 16,
  e_ModuleNameOFD = 17,
  e_ModuleNameOffice2PDF = 18,
  e_ModuleNamePrint2PDF = 19
} ModuleName;

typedef enum _ColorSpaceType {
  e_ColorSpaceInvalid  = 0,
  e_ColorSpaceDeviceGray = 1,
  e_ColorSpaceDeviceRGB = 2,
  e_ColorSpaceDeviceCMYK = 3,
  e_ColorSpaceCalGray = 4,
  e_ColorSpaceCalRGB = 5,
  e_ColorSpaceLab = 6,
  e_ColorSpaceICCBased = 7,
  e_ColorSpaceSeparation = 8,
  e_ColorSpaceDeviceN = 9,
  e_ColorSpaceIndexed = 10,
  e_ColorSpacePattern = 11,
  e_ColorSpaceICCBasedDeviceGray = 12,
  e_ColorSpaceICCBasedDeviceRGB = 13,
  e_ColorSpaceICCBasedDeviceCMYK = 14
} ColorSpaceType;

typedef enum _LocaleID {
  e_LocaleIDUnspecified = 0,
  e_LocaleIDHongKong = 1,
  e_LocaleIDTaiwan = 2,
  e_LocaleIDNetherlands = 3,
  e_LocaleIDFrance = 4,
  e_LocaleIDGermany = 5,
  e_LocaleIDItaly = 6,
  e_LocaleIDKorea = 7,
  e_LocaleIDJapan = 8
} LocaleID;

typedef enum _FileFormatType {
  e_FileFormatTypeFDF = 0,
  e_FileFormatTypeXFDF = 1,
  e_FileFormatTypeHTML = 2,
  e_FileFormatTypeXDP = 3,
  e_FileFormatTypeXML = 4,
  e_FileFormatTypeXFD = 5,
  e_FileFormatTypePDF = 6,
  e_FileFormatTypeTXT = 7
} FileFormatType;


#define CommonDefines foxit::common

class Codec FS_FINAL : public Base {
 public:
  static String Base64Encode(const void* data_buffer, size_t length);

  static String Base64Decode(const void* encoded_data_buffer, size_t length);

  static String FlateCompress(const void* data_buffer, size_t length);

  static String FlateDecompress(const void* compressed_data_buffer, size_t length);
};

class NotifierCallback {
 public:
  virtual void Release() = 0;

  virtual void OnOutOfMemory() = 0;

 protected:
  ~NotifierCallback() {}
};

class Progressive FS_FINAL : public Base {
 public:
  typedef enum _State {
    e_Error = 0,
    e_ToBeContinued = 1,
    e_Finished = 2
  } State;
  
  Progressive(const Progressive& other);
  ~Progressive();

  Progressive& operator = (const Progressive& other);

  State Continue();

  int GetRateOfProgress();

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Progressive(FS_HANDLE handle = NULL);
};
class RenderConfig FS_FINAL : public Object {
 public:
  RenderConfig(int graphics_objs_count_in_one_step) :graphics_objs_count_in_one_step(graphics_objs_count_in_one_step) {}

  RenderConfig():graphics_objs_count_in_one_step(100){}

  RenderConfig& operator = (const RenderConfig& render_config) {
    this->graphics_objs_count_in_one_step = render_config.graphics_objs_count_in_one_step;
    return *this;
  }

  bool operator == (const RenderConfig& render_config) const {
    if (this->graphics_objs_count_in_one_step == render_config.graphics_objs_count_in_one_step)
      return true;
    return false;
  }

  bool operator != (const RenderConfig& render_config) const {
    if (this->graphics_objs_count_in_one_step != render_config.graphics_objs_count_in_one_step)
      return true;
    return false;
  }

  void Set(int graphics_objs_count_in_one_step) {
    this->graphics_objs_count_in_one_step = graphics_objs_count_in_one_step;
  }

  int graphics_objs_count_in_one_step;
};

class Library FS_FINAL : public Object {
 public:
  static ErrorCode Initialize(const char* sn, const char* key);

#if !defined(_SWIG_ANDROID_) && !defined(_SWIG_IOS_) && !defined(_SWIG_JAVA_) && !defined(_SWIG_DOTNET_) && !defined(_SWIG_MACOC_) && !defined(_SWIG_PYTHON_) && !defined(_SWIG_NODEJS_) && !defined(_SWIG_GO_)

#if _FX_OS_ == _FX_IOS_ || _FX_OS_ == _FX_ANDROID_
  static ErrorCode InitializeWithAppName(const char* sn, const char* key, const char* app_name);
#endif
#endif

  static ErrorCode Initialize(const char* sn, const char* key, bool is_optimize_memory, bool enable_js_xfa_threadsafety = false);

  static ErrorCode Reinitialize();

  static void Release();

  static bool HasModuleLicenseRight(common::ModuleName module_name);

  static String GetVersion();

  static bool SetCacheSize(uint32 size);

  static bool EnableJavaScript(bool enable_javascript);

#ifndef __EMSCRIPTEN_RENDER__

  static bool SetAnnotIconProviderCallback(pdf::annots::IconProviderCallback* annot_icon_provider);
#endif

  static bool SetNotifierCallback(NotifierCallback* notifier);

  static bool SetActionCallback(ActionCallback* action_callback);

  static bool SetDocEventCallback(DocEventCallback* callback);

  static bool RegisterSignatureCallback(const char* filter, const char* sub_filter,
                                        pdf::SignatureCallback* signature_callback);

  static void UnregisterSignatureCallback(const char* filter, const char* sub_filter);
    
  static bool RegisterSecurityCallback(const char* filter, pdf::SecurityCallback* callback);

  static bool UnregisterSecurityCallback(const char* filter);

  static bool SetTimeStampCallback(pdf::TimeStampCallback* timestamp_callback);

  #ifndef _FX_NO_XFA_

  static void RegisterXFAAppProviderCallback(addon::xfa::AppProviderCallback* callback);

  #endif

  static void SetRenderTextGamma(float gamma);

  static void* Alloc(size_t size);

  static void Free(void* ptr);

  static void* Realloc(void* ptr, size_t new_size);

  static void SetLogFile(const char* log_file_path);

  static void SetLogFile(const wchar_t* log_file_path);
  
  static void SetLogFile(foxit::common::file::StreamCallback* log_file);
  
  static foxit::ErrorCode FlushLog();

  static bool SetFontMapperCallback(FontMapperCallback* callback);

  static void SetDefaultICCProfilesPath(const wchar_t* icc_profile_folder_path);

  static RenderConfig GetRenderConfig();

  static void SetRenderConfig(const RenderConfig& render_config);

  static void EnableThreadSafety(bool is_enable_thread_safety);

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

  static ErrorCode InitializeOFDEngine(const char* ofd_library_path);

  static void ReleaseOFDEngine();
#endif

  static WString ExecuteJavaScript(const wchar_t* java_script);

  static bool AddExternalFontPath(const wchar_t* font_path);

  static void MatchExternalFontsOnly(bool only_match);

 private:
  Library(const Library&);
  Library& operator = (const Library&);
};
class GraphState FS_FINAL : public Object {
 public:
  typedef enum _LineCapStyle {
    e_LineCapButt  = 0,
    e_LineCapRound= 1,
    e_LineCapSquare = 2
  } LineCapStyle;
  
  typedef enum _LineJoinStyle {
    e_LineJoinMiter = 0,
    e_LineJoinRound = 1,
    e_LineJoinBevel = 2
  } LineJoinStyle;
  

  GraphState(float line_width, LineJoinStyle line_join, float miter_limit,
             LineCapStyle line_cap, float dash_phase, const FloatArray& dashes) {
    this->line_width = line_width;
    this->line_join = line_join;
    this->miter_limit = miter_limit;
    this->line_cap = line_cap;
    this->dash_phase = dash_phase;
    this->dashes = dashes;
  }

  GraphState()
      : line_width(1.0f)
      , line_join(e_LineJoinMiter)
      , miter_limit(10*1.0f)
      , line_cap(e_LineCapButt)
      , dash_phase(0) {}

  GraphState(const GraphState& state) {
    this->line_width = state.line_width;
    this->line_join = state.line_join;
    this->miter_limit = state.miter_limit;
    this->line_cap = state.line_cap;
    this->dash_phase = state.dash_phase;
    this->dashes = state.dashes;
  }

  GraphState& operator = (const GraphState& state) {
    this->line_width = state.line_width;
    this->line_join = state.line_join;
    this->miter_limit = state.miter_limit;
    this->line_cap = state.line_cap;
    this->dash_phase = state.dash_phase;
    this->dashes = state.dashes;
    return *this;
  }

  void Set(float line_width, LineJoinStyle line_join, float miter_limit, LineCapStyle line_cap, float dash_phase,
           const FloatArray& dashes) {
    this->line_width = line_width;
    this->line_join = line_join;
    this->miter_limit = miter_limit;
    this->line_cap = line_cap;
    this->dash_phase = dash_phase;
    this->dashes = dashes;
  }

  float line_width;
  LineJoinStyle line_join;
  float miter_limit;
  LineCapStyle line_cap;

  float dash_phase;

  FloatArray dashes;
};

typedef IFX_Pause PauseCallback;

class DocEventCallback {
 public:
  virtual void Release() = 0;

  virtual void OnDocWillOpen() {}

  virtual void OnDocOpened(const pdf::PDFDoc& document, ErrorCode error_code) {}

  virtual void OnDocWillDestroy(const pdf::PDFDoc& document) {}

  virtual void OnDocWillSave(const pdf::PDFDoc& document) {}

  virtual void OnDocSaved(const pdf::PDFDoc& document, ErrorCode error_code) {}

 protected:
  ~DocEventCallback() {}
};

class Range FS_FINAL : public Base {
 public:
  typedef enum _Filter {
    e_All = 0,
    e_Even = 1,
    e_Odd = 2
  } Filter;
  
  Range();

  explicit Range(int index);

  explicit Range(int start_index, int end_index, Filter filter = e_All);

  Range(const Range& other);

  ~Range();

  Range& operator = (const Range& other);

  bool operator == (const Range& other) const;

  bool operator != (const Range& other) const;

  bool IsEmpty() const;

  void AddSingle( int index );

  void AddSegment( int start_index, int end_index, Filter filter = e_All );

  int GetSegmentCount() const;

  int GetSegmentStart(int segment_index) const;

  int GetSegmentEnd(int segment_index) const;

  void RemoveAll();

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Range(FS_HANDLE handle);
};

class Font FS_FINAL : public Base {
 public:
  typedef enum _Styles {
    e_StyleFixedPitch = 0x0001,
    e_StyleSerif = 0x0002,
    e_StyleSymbolic = 0x0004,
    e_StyleScript = 0x0008,
    e_StyleNonSymbolic = 0x0020,
    e_StyleItalic = 0x0040,
    e_StyleAllCap = 0x10000,
    e_StylesSmallCap = 0x20000,
    e_StylesBold = 0x40000
  } Styles;
  
  typedef enum _Charset {
    e_CharsetANSI = 0,
    e_CharsetDefault = 1,
    e_CharsetSymbol = 2,
    e_CharsetShift_JIS = 128,
    e_CharsetHangeul = 129,
    e_CharsetGB2312 = 134,
    e_CharsetChineseBig5 = 136,
    e_CharsetThai = 222,
    e_CharsetEastEurope = 238,
    e_CharsetRussian = 204,
    e_CharsetGreek = 161,
    e_CharsetTurkish = 162,
    e_CharsetHebrew = 177,
    e_CharsetArabic = 178,
    e_CharsetBaltic = 186
  } Charset;
  
  typedef enum _CIDCharset {
    e_CIDCharsetUnknown = 0,
    e_CIDCharsetGB1 = 1,
    e_CIDCharsetCNS1 = 2,
    e_CIDCharsetJAPAN1 = 3,
    e_CIDCharsetKOREA1 = 4,
    e_CIDCharsetUNICODE = 5
  } CIDCharset;
  
  typedef enum _StandardID {
    e_StdIDCourier = 0,
    e_StdIDCourierB = 1,
    e_StdIDCourierBI = 2,
    e_StdIDCourierI = 3,
    e_StdIDHelvetica = 4,
    e_StdIDHelveticaB = 5,
    e_StdIDHelveticaBI = 6,
    e_StdIDHelveticaI = 7,
    e_StdIDTimes = 8,
    e_StdIDTimesB = 9,
    e_StdIDTimesBI = 10,
    e_StdIDTimesI = 11,
    e_StdIDSymbol = 12,
    e_StdIDZapfDingbats = 13
  } StandardID;
  
  typedef enum _FontTypes {
    e_FontTypeType1 = 1,
    e_FontTypeTrueType = 2,
    e_FontTypeType3 = 3,
    e_FontTypeCIDFont = 4
  } FontTypes;
  
  Font(const wchar_t* name, uint32 styles, Charset charset, int weight);

  explicit Font(StandardID font_id);

  Font(const char* font_file_path, int face_index, Charset charset);

  Font(const wchar_t* font_file_path, int face_index, Charset charset);

  Font(foxit::common::file::StreamCallback* stream);

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Font(FS_HANDLE handle = NULL);

  Font(const Font& other);

  Font& operator = (const Font& other);

  bool operator == (const Font& other) const;

  bool operator != (const Font& other) const;

  bool IsEmpty() const;

  ~Font();

  WString GetName();

  String GetFamilyName();

  bool IsBold() const;

  bool IsItalic() const;

  bool IsEmbedded(const pdf::PDFDoc& document);
  
  bool IsSupportEmbedded(const pdf::PDFDoc& document);

  Font Embed(pdf::PDFDoc document, bool is_add_all_unicodes = true);

  UInt32Array AddUnicodes(const pdf::PDFDoc& document, const UInt32Array& unicode_array);

#ifdef _FONT_GETWOFFDATA_

  String GetWoffData(pdf::PDFDoc document);
#endif
  
  int GetAscent() const;

  int GetDescent() const;

  RectI GetCharBBox(uint32 unicode) const;

  float GetCharWidth(uint32 unicode) const;

  RectI GetCharBBox(foxit::uint32 unicode,const foxit::pdf::PDFDoc& document);
  
  float GetCharWidth(foxit::uint32 unicode,const foxit::pdf::PDFDoc& document);

  foxit::uint32 GetStyles(const pdf::PDFDoc& document);

  CIDCharset GetCIDCharset(const pdf::PDFDoc& document);

  bool IsStandardFont(const pdf::PDFDoc& document);

  StandardID GetStandard14Font(const pdf::PDFDoc& document);

  FontTypes GetFontType(const pdf::PDFDoc& document);

  String GetBaseFontName(const pdf::PDFDoc& document);

  bool IsVertWriting(const pdf::PDFDoc& document);

  String GetEncoding(const pdf::PDFDoc& document);

  bool SetEncoding(const pdf::PDFDoc& document, const char* value);

  bool IsCharSupported(foxit::uint32 unicode, const pdf::PDFDoc& document) const;
};

class FontMapResult FS_FINAL : public Object {
 public:
  FontMapResult() : file_read(NULL), face_index(-1) {}

  FontMapResult(foxit::common::file::ReaderCallback* file_read, int face_index) {
    this->file_read = file_read;
    this->face_index = face_index;
  }

  FontMapResult(const FontMapResult& other) {
    this->file_read = other.file_read;
    this->face_index = other.face_index;
  }

  FontMapResult& operator = (const FontMapResult& other) {
    this->file_read = other.file_read;
    this->face_index = other.face_index;
    return *this;
  }

  bool operator == (const FontMapResult& other) const {
    if (this->file_read != other.file_read || this->face_index != other.face_index)
      return false;
    return true;
  }

  bool operator != (const FontMapResult& other) const {
    return !(*this == other);
  }

  void Set(foxit::common::file::ReaderCallback* file_read, int face_index) {
    this->file_read = file_read;
    this->face_index = face_index;
  }

  foxit::common::file::ReaderCallback* file_read;
  int face_index;
};

class FontMapperCallback {
 public:
  virtual void Release() = 0;

  virtual FontMapResult MapFont(const char* font_name, bool is_truetype, uint32 styles,
                                int weight, int italic_angle, Font::Charset charset) = 0;

  virtual StringArray MapFont(const char* font_family_name, Font::Charset charset,
                              uint32 styles, int weight, int italic_angle) = 0;

 protected:
  ~FontMapperCallback() {}
};

class Path FS_FINAL : public Base {
 public:
  typedef enum _PointType {
    e_TypeMoveTo = 1,
    e_TypeLineTo = 2,
    e_TypeLineToCloseFigure  = 3,
    e_TypeBezierTo = 4,
    e_TypeBezierToCloseFigure = 5
  } PointType;
  
  Path();
  ~Path();
  Path(const Path& other);
  Path& operator=(const Path& other);
  bool operator ==(const Path& other) const;
  bool operator != (const Path& other) const;

  bool IsEmpty() const;

  int GetPointCount();

  PointF GetPoint(int index);

  PointType GetPointType(int index);

  bool SetPoint(int index, const PointF& point, PointType type);

  bool MoveTo(const PointF& point);

  bool LineTo(const PointF& point);

  bool CubicBezierTo(const PointF& point1, const PointF& point2, const PointF& point3);

  bool CloseFigure();

  bool RemovePoint(int index);

  bool AppendRect(const RectF& rect);

  bool AppendEllipse(const RectF& rect);

  void Transform(const Matrix& matrix);
  void Clear();

  void IncreasePointCount(int count);

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Path(FS_HANDLE handle);
};

FSDK_DEFINE_ARRAY(PathArray, Path)


class ColorSpace FS_FINAL : public Base {
 public:
  typedef enum _RenderingIntent {
    e_RenderIntentPerceptual  = 0,
    e_RenderIntentRelColorimetric = 1,
    e_RenderIntentSaturation = 2,
    e_RenderIntentAbsColorimetric = 3
  } RenderingIntent;
  

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit ColorSpace(FS_HANDLE handle);

  ColorSpace(foxit::common::ColorSpaceType type);
  ~ColorSpace();

  ColorSpace(const ColorSpace& other);

  ColorSpace& operator=(const ColorSpace& other);

  bool operator==(const ColorSpace& other) const;

  bool operator!=(const ColorSpace& other) const;

  bool IsEmpty() const;

  int GetComponentCount() const;

  foxit::common::ColorSpaceType GetColorSpaceType() const;

  bool IsSpotColorSpace() const;

  StringArray GetComponentNames() const;

  Color ConvertColor(const Color& color);

  Color ConvertColor(int r_value, int g_value, int b_value);

  Color ConvertColor(int c_value, int m_value, int y_value, int k_value);
};

class Color FS_FINAL : public Base {
 public:
  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Color(FS_HANDLE handle);

  Color();
  explicit Color(const ColorSpace& color_space);
  ~Color();

  Color(const Color& other);

  Color& operator=(const Color& other);

  bool operator==(const Color& other) const;

  bool operator!=(const Color& other) const;

  bool IsEmpty() const;

  ColorSpace GetColorSpace();

  FloatArray GetValue() const;

  void SetValue(const FloatArray& component_array);

  Color ConvertToRGB(ColorSpace::RenderingIntent intent = ColorSpace::e_RenderIntentRelColorimetric) const;

  Color ConvertToCMYK(ColorSpace::RenderingIntent intent = ColorSpace::e_RenderIntentRelColorimetric) const;
};
}  // namespace common
}  // namespace foxit

#endif  // FS_COMMON_H_