fs_pdflayer.h

浏览该文件的文档.

#ifndef FS_PDFLAYER_H_
#define FS_PDFLAYER_H_

#include "common/fs_common.h"
#include "pdf/graphics/fs_pdfgraphicsobject.h"

namespace foxit {
namespace pdf {
// forward declaration
class PDFDoc;
class PDFPage;
class LayerPrintData;
class LayerNode;
namespace annots {
class AnnotArray;
}

FSDK_DEFINE_ARRAY(LayerNodeArray, LayerNode)


class LayerZoomData FS_FINAL : public Object {
 public:
  LayerZoomData()
      : min_factor(0)
      , max_factor(0) {}

  LayerZoomData(float min_factor, float max_factor) {
    this->min_factor = min_factor;
    this->max_factor = max_factor;
  }

  LayerZoomData(const LayerZoomData& data) {
    min_factor = data.min_factor;
    max_factor = data.max_factor;
  }

  LayerZoomData &operator = (const LayerZoomData& data) {
    min_factor = data.min_factor;
    max_factor = data.max_factor;
    return (*this);
  }

  void Set(float min_factor, float max_factor) {
    this->min_factor = min_factor;
    this->max_factor = max_factor;
  }

  float min_factor;
  float max_factor;
};

class LayerTree FS_FINAL : public Base {
 public:
  typedef enum _UsageState {
    e_StateON = 0x0000,
    e_StateOFF = 0x0001,
    e_StateUnchanged = 0x0002,
    e_StateUndefined = 0x0003
  } UsageState;
  

  explicit LayerTree(const PDFDoc& document);
  LayerTree(const LayerTree& other);
  LayerTree& operator = (const LayerTree& other);

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

  bool IsEmpty() const;

  ~LayerTree();

  bool SetBaseState(UsageState state);

  LayerNode GetRootNode();

  objects::PDFDictionary* GetDict() const;

  objects::PDFArray* GetOCGs() const;

  LayerNodeArray GetOCGsByPageIndex(int page_index);

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

class LayerPrintData FS_FINAL : public Object{
 public:
  LayerPrintData(const String &subtype, LayerTree::UsageState print_state) {
    this->subtype = subtype;
    this->print_state = print_state;
  }

  LayerPrintData()
    :print_state(LayerTree::e_StateUndefined) {
  }

  LayerPrintData(const LayerPrintData& data) {
    subtype = data.subtype;
    print_state = data.print_state;
  }

  LayerPrintData &operator = (const LayerPrintData& data) {
    subtype = data.subtype;
    print_state = data.print_state;
    return (*this);
  }

  void Set(const String &subtype, LayerTree::UsageState print_state) {
    this->subtype = subtype;
    this->print_state = print_state;
  }

  String subtype;

  LayerTree::UsageState print_state;
};

class LayerContext FS_FINAL : public Base {
 public:
  typedef enum _UsageType {
    e_UsageView = 0x0000,
    e_UsageDesign = 0x0001,
    e_UsagePrint = 0x0002,
    e_UsageExport = 0x0003,
    e_UsageZoom = 0x0004
  } UsageType;
  

  explicit LayerContext(const PDFDoc& document, UsageType usage_type);

  LayerContext(const LayerContext& other);
  LayerContext& operator = (const LayerContext& other);

  bool operator == (const LayerContext& other) const;
  bool operator != (const LayerContext& other) const;
  ~LayerContext();
  bool IsEmpty() const;

  PDFDoc GetDocument();
  UsageType GetUsageType();
  bool Reset();
  bool CopyStates(const LayerContext& source_context);
  bool MergeStates(const LayerContext& source_context);
  bool IsVisible(const LayerNode& layer);
  bool SetVisible(const LayerNode& layer, bool is_visible);

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

class LayerNode FS_FINAL : public Base{
 public:
  LayerNode(const LayerNode& other);
  LayerNode& operator = (const LayerNode& other);

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

  bool IsEmpty() const;

  ~LayerNode();

  int GetChildrenCount();
  LayerNode GetChild(int index);
  bool RemoveChild(int index);

  bool MoveTo(LayerNode parent_layer_node, int index);

  LayerNode AddChild(int index, const wchar_t* name, bool has_Layer);

  WString GetName();
  
   bool IsLocked();

  bool HasLayer();

  bool HasIntent(const char* intent);

  bool IsInPage(const PDFPage& page);

  LayerTree::UsageState GetViewUsage();

  LayerTree::UsageState GetExportUsage();

  LayerPrintData GetPrintUsage();

  LayerZoomData GetZoomUsage();

  bool SetName(const wchar_t* name);

  bool SetDefaultVisible(bool is_visible);

  bool SetViewUsage(LayerTree::UsageState state);

  bool SetExportUsage(LayerTree::UsageState state);

  bool SetPrintUsage(const LayerPrintData& data);

  bool SetZoomUsage(const LayerZoomData& data);

  graphics::GraphicsObjectArray GetGraphicsObjects(const PDFPage& page);

  bool AddGraphicsObject(const PDFPage& page, graphics::GraphicsObject* graphicsobject);

  bool RemoveGraphicsObject(graphics::GraphicsObject* graphics_object);

  bool RemoveUsage(LayerContext::UsageType usage_type);

  objects::PDFDictionary* GetDict() const;

  foxit::pdf::annots::AnnotArray GetAnnots();

  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit LayerNode(FS_HANDLE handle =  NULL);
};
}  // namespace pdf
}  // namespace foxit
#endif  // FS_PDFLAYER_H_