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_