fs_render.h

浏览该文件的文档.

#ifndef FS_RENDER_H_
#define FS_RENDER_H_

#include "common/fs_common.h"
#include "common/fs_image.h"
#include "pdf/annots/fs_annot.h"
#include "pdf/fs_pdflayer.h"
#include "pdf/fs_reflowpage.h"
#ifndef _FX_NO_XFA_
#include "addon/xfa/fs_xfa.h"
#endif  // #ifndef _FX_NO_XFA_

#ifdef __APPLE__
#include <CoreGraphics/CoreGraphics.h>
#endif

namespace foxit {
namespace pdf {
class PDFPage;
}
namespace ofd {
class OFDPage;
};
namespace fld {
class FLDPage;
};
namespace common {
class PrintDeviceSettingData FS_FINAL : public Object{
 public:
 typedef enum _OrientationFlag {
   e_Portrait  = 0,
   e_Landscape = 1
 } OrientationFlag;
 
  explicit PrintDeviceSettingData(int device_width, int device_height, RectF device_margin, OrientationFlag orientation , int resolution, uint32 copies)
    : device_width(device_width)
    , device_height(device_height)
    , device_margin(device_margin)
    , orientation(orientation)
    , resolution(resolution)
    , copies(copies){}

  PrintDeviceSettingData()
    : device_width(2479)
    , device_height(3508)
    , orientation(e_Portrait)
    , resolution(300)
    , copies(1) {}

  PrintDeviceSettingData(const PrintDeviceSettingData& settings)
      : device_width(settings.device_width)
      , device_height(settings.device_height)
      , device_margin(settings.device_margin)
      , orientation(settings.orientation)
      , resolution(settings.resolution)
      , copies(settings.copies) {}

  PrintDeviceSettingData& operator = (const PrintDeviceSettingData& settings) {
    device_width = settings.device_width;
    device_height = settings.device_height;
    device_margin = settings.device_margin;
    orientation = settings.orientation;
    resolution = settings.resolution;
    copies = settings.copies;
    return *this;
  }

   void Set(int device_width, int device_height, RectF device_margin, OrientationFlag orientation, int resolution, uint32 copies ) {
     this->device_width = device_width;
     this->device_height = device_height;
     this->device_margin = device_margin;
     this->orientation = orientation;
     this->resolution = resolution;
     this->copies = copies;
   }
    int device_width;
    int device_height;
    RectF device_margin;
    OrientationFlag orientation;
    int resolution;
    uint32 copies;
};

class Renderer FS_FINAL : public Base {
 public:
  typedef enum _ColorMode {
    e_ColorModeNormal = 0,
    e_ColorModeMappingGray = 1,
    e_ColorModeMapping = 2,
    e_ColorModeAlpha = 3,
    e_ColorModeForeground = 4
  } ColorMode;
  
  typedef enum _ContentFlag {
    e_RenderPage = 0x01,
    e_RenderAnnot = 0x02,
    e_RenderHighlight = 0x04,
    e_RenderExceptHighlight = 0x08,
    e_RenderScreen = 0x10
  } ContentFlag;
  
  typedef enum _ColorModeForeground {
    e_ColorModeForegroundText = 0x01,
    e_ColorModeForegroundPath = 0x02,
    e_ColorModeForegroundBlackText = 0x04,
    e_ColorModeForegroundBlackPath = 0x08
  } ColorModeForeground;
  
  #ifdef __APPLE__

  typedef enum _DeviceType {
    e_DeviceDisplay = 1,
    e_DevicePrinter = 2
  }DeviceType;
  #endif

  Renderer(const Bitmap& bitmap, bool is_rgb_order);

  Renderer(const PrintDeviceSettingData& print_param, const wchar_t* dest_file_path);

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

  explicit Renderer(HDC dc);

  Renderer(HDC dc, const wchar_t* printer_driver_name);
#endif

#ifdef __APPLE__

  Renderer(const CGContextRef& context, DeviceType device_type);
#endif

  Renderer(const Renderer& other);
  ~Renderer();

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

  bool IsEmpty() const;

  Progressive StartQuickRender(const pdf::PDFPage& page, const Matrix& matrix, PauseCallback* pause = NULL);

  Progressive StartRender(const pdf::PDFPage& page, const Matrix& matrix, PauseCallback* pause = NULL);

   Progressive StartRenderReflowPage(const pdf::ReflowPage& reflow_page, const Matrix& matrix,
                                    PauseCallback* pause = NULL);

#ifndef _FX_NO_XFA_

  Progressive StartRenderXFAPage(const addon::xfa::XFAPage& xfa_page_view, const Matrix& matrix, bool is_highlight,
                                 PauseCallback* pause = NULL);
#endif  // #ifndef _FX_NO_XFA_

  Progressive StartRenderBitmap(const Bitmap& bitmap, const Matrix& matrix,
                                const RectI* clip_rect = NULL, uint32 interpolation = 0,
                                PauseCallback* pause = NULL);

  Progressive StartRenderBitmap(const Bitmap& bitmap, const Matrix& matrix,
                                const RectI* clip_rect, uint32 interpolation,
                                uint32 alpha, PauseCallback* pause);

  void SetRenderAnnotAppearanceType(foxit::pdf::annots::Annot::AppearanceType ap_type);

  bool RenderAnnot(const pdf::annots::Annot& annot, const Matrix& matrix);

  bool RenderFormControls(const pdf::PDFPage& page, const Matrix& matrix);

  bool RenderGraphicsObject(const pdf::graphics::GraphicsObject* graphics_object, const pdf::PDFPage& page, const Matrix& matrix);

  void SetClipRect(const RectI* clip_rect);

  void ClearClips();

  void SetClipPathFill(const Path& clip_path, const Matrix& matrix, foxit::common::FillMode fill_mode);

  void SetClipPathStroke(const Path& clip_path, const Matrix& matrix, const GraphState* graph_state = NULL);

  void SetRenderContentFlags(uint32 render_content_flags);

  void SetRenderAnnotsForThumbnail(bool is_render_annots_for_thumbnail);

  void SetRenderFormField(bool is_render_formfield);

  void SetRenderSignature(bool is_render_signature);

  void SetLayerContext(const pdf::LayerContext& layer_context);

  void SetRenderLayer(bool is_render_one_layer);

  void SetColorMode(ColorMode color_mode);
  void SetMappingModeColors(ARGB background_color, ARGB foreground_color);

  void SetForegroundColorMode(uint32 foreground_color_mode);

  void SetForegroundColor(ARGB foreground_color);

  void SetClearType(bool is_clear_type);
  void SetPrintTextAsGraphic(bool is_to_print_text_graphic);

  void SetPrintTextAsImage(bool is_to_print_text_image);

  void SetForceDownSample(bool is_to_force_down_sample);

  void SetOverprint(bool is_to_enable_overprint);
  
  void SetJPEGDownSample(bool is_jepg_down_sample);

  void SetJPXDownSample(bool is_jpx_down_sample);

  void EnableForPrint(bool is_render_for_print);

  void SetForceHalftone(bool is_to_force_halftone);

  void SetRenderPathThinLine(bool is_render_path_thin_line);

  void SetRenderTextAntiAliasing(bool is_render_text_antialiasing);

  void SetRenderPathAntiAliasing(bool is_render_path_antialiasing);

  void SetRenderPathFullCovered(bool is_render_path_full_covered);

  void SetRenderImageAntiAliasing(bool is_render_image_antialiasing);

  void SetRenderEnhanceThinLines(bool is_render_enhance_thin_lines);

  void SetRenderSignatureState(bool is_render_signature_state);

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

  void SetScreenDPIScale(float scale);

};

class OFDRenderOption FS_FINAL : public Object {
 public:
  typedef enum _ColorMode {
    e_ColorModeNormal = 0,
    e_ColorModeMappingGray = 1,
    e_ColorModeMapping = 2,
    e_ColorModeAnyColor = 3,
    e_ColorModeRedHead = 4
  } ColorMode;
  
  typedef enum _RenderFlag {
    e_RenderFlagNoDisplayBackgroundTemplatePage = 0x10,
    e_RenderFlagResourceNoCache = 0x20,
    e_RenderFlagPrintSubImage = 0x40,
    e_RenderFlagDisplayThumbnail = 0x80,
    e_RenderFlagProgressiveRending = 0x100,
    e_RenderFlagNoUseFxTextClearType = 0x200,
    e_RenderFlagAnnotNoUseBound = 0x400,
    e_RenderFlagPageNoUseCropBox = 0x800,
    e_RenderFlagPageNoUsePageArea = 0x1000,
    e_RenderFlagRenHanWriting = 0x2000,
    e_RenderFlagPageNoUseFontWeight = 0x4000,
    e_RenderFlagPrintPDF = 0x8000,
    e_RenderFlagPageNoUseClip = 0x10000,
    e_RenderFlagPageUseCacheImage = 0x20000,
    e_WaterMarkDefaultIsBackground = 0x40000,
    e_RenderFlagWaterMarkNotPrint = 0x80000,
    e_RenderFlagCGTransformHasPriority = 0x100000,
    e_RenderFlagBadEmbedFontNoRender = 0x200000
  } RenderFlag;
  

  OFDRenderOption() :
    is_print(false),
    color_mode(OFDRenderOption::e_ColorModeNormal),
    back_color(0xFFFFFFFF),
    fore_color(0xFF000000),
    x_dpi(96),
    y_dpi(96),
    render_flags(0) {};
  explicit OFDRenderOption(bool is_print, ColorMode color_mode, foxit::RGB back_color, foxit::RGB fore_color, int x_dpi, int y_dpi, int render_flags) :
    is_print(is_print),
    color_mode(color_mode),
    back_color(back_color),
    fore_color(fore_color),
    x_dpi(x_dpi),
    y_dpi(y_dpi),
    render_flags(render_flags) {};

  ~OFDRenderOption() {};

  OFDRenderOption(const OFDRenderOption& other) :
    is_print(other.is_print),
    color_mode(other.color_mode),
    back_color(other.back_color),
    fore_color(other.fore_color),
    x_dpi(other.x_dpi),
    y_dpi(other.y_dpi),
    render_flags(other.render_flags) {
  };

  OFDRenderOption& operator = (const OFDRenderOption& other) {
    this->is_print = other.is_print;
    this->color_mode = other.color_mode;
    this->back_color = other.back_color;
    this->fore_color = other.fore_color;
    this->x_dpi = other.x_dpi;
    this->y_dpi = other.y_dpi;
    this->render_flags = other.render_flags;
    return *this;
  }

  void Set(bool is_print, ColorMode color_mode, foxit::RGB back_color, foxit::RGB fore_color, int x_dpi, int y_dpi, int render_flags) {
    this->is_print = is_print;
    this->color_mode = color_mode;
    this->back_color = back_color;
    this->fore_color = fore_color;
    this->x_dpi = x_dpi;
    this->y_dpi = y_dpi;
    this->render_flags = render_flags;
  }

  bool is_print;

  ColorMode color_mode;

  foxit::RGB back_color;

  foxit::RGB fore_color;

  int x_dpi;

  int y_dpi;

  int render_flags;
};

class OFDRender FS_FINAL : public Base {
 public:
  typedef enum _ContentFlag {
    e_RenderPage = 0x01,
    e_RenderStampAnnot = 0x02,
    e_RenderHighlightAnnot = 0x04,
    e_RenderExceptHighlightAnnot = 0x08,
    e_RenderSealAnnot = 0x10,
    e_RenderSealAnnotGray = 0x20
  } ContentFlag;
  

  explicit OFDRender(const Bitmap& bitmap);

  ~OFDRender();

  OFDRender(const OFDRender& other);

  OFDRender& operator = (const OFDRender& other);

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

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

  bool IsEmpty() const;

  Progressive StartRender(const foxit::ofd::OFDPage& page, const Matrix& matrix, PauseCallback* pause = NULL);

  void SetRenderOption(const OFDRenderOption& render_option);

  void SetRenderContentFlags(uint32 render_content_flags);

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

class FLDRenderOption FS_FINAL : public Object {
 public:
  typedef enum _ColorMode {
    e_ColorModeNormal = 0,
    e_ColorModeMappingGray = 1,
    e_ColorModeMapping = 2,
    e_ColorModeAnyColor = 3,
    e_ColorModeRedHead = 4
  } ColorMode;
  

  FLDRenderOption() :
    is_print(false),
    color_mode(FLDRenderOption::e_ColorModeNormal),
    back_color(0xFFFFFFFF),
    fore_color(0xFF000000),
    x_dpi(96),
    y_dpi(96) {};

  explicit FLDRenderOption(bool is_print, ColorMode color_mode, foxit::RGB back_color, foxit::RGB fore_color, int x_dpi, int y_dpi) :
    is_print(is_print),
    color_mode(color_mode),
    back_color(back_color),
    fore_color(fore_color),
    x_dpi(x_dpi),
    y_dpi(y_dpi) {};

  ~FLDRenderOption() {};

  FLDRenderOption(const FLDRenderOption& other) :
    is_print(other.is_print),
    color_mode(other.color_mode),
    back_color(other.back_color),
    fore_color(other.fore_color),
    x_dpi(other.x_dpi),
    y_dpi(other.y_dpi) {
  };

  FLDRenderOption& operator = (const FLDRenderOption& other) {
    this->is_print = other.is_print;
    this->color_mode = other.color_mode;
    this->back_color = other.back_color;
    this->fore_color = other.fore_color;
    this->x_dpi = other.x_dpi;
    this->y_dpi = other.y_dpi;
    return *this;
  }

  void Set(bool is_print, ColorMode color_mode, foxit::RGB back_color, foxit::RGB fore_color, int x_dpi, int y_dpi) {
    this->is_print = is_print;
    this->color_mode = color_mode;
    this->back_color = back_color;
    this->fore_color = fore_color;
    this->x_dpi = x_dpi;
    this->y_dpi = y_dpi;
  }

  bool is_print;

  ColorMode color_mode;

  foxit::RGB back_color;

  foxit::RGB fore_color;

  int x_dpi;

  int y_dpi;
};

class FLDRender FS_FINAL : public Base {
 public:
  explicit FLDRender(const Bitmap& bitmap);

  ~FLDRender();

  FLDRender(const FLDRender& other);

  FLDRender& operator = (const FLDRender& other);

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

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

  bool IsEmpty() const;

  bool Render(const foxit::fld::FLDPage& page, const Matrix& matrix);

  void SetRenderOption(const FLDRenderOption& render_option);

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit FLDRender(FS_HANDLE handle);
};
}  // namespace common
}  // namespace foxit
#endif  // FS_RENDER_H_