fs_render.h

浏览该文件的文档.

#ifndef FS_RENDER_H_
#define FS_RENDER_H_

#include "common/fs_common.h"
#include "common/fs_image.h"
#ifndef __EMSCRIPTEN_RENDER__
#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_
#endif

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

namespace foxit {
namespace pdf {
class PDFPage;
}
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);
#ifndef __EMSCRIPTEN_RENDER__
gressive 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_
#endif

  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);

#ifndef __EMSCRIPTEN_RENDER__

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

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

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

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

  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);
#ifndef __EMSCRIPTEN_RENDER__  

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

  void SetRenderLayer(bool is_render_one_layer);
#endif

  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);

};
}  // namespace common
}  // namespace foxit
#endif  // FS_RENDER_H_