fs_compliancecommon.h

浏览该文件的文档.

 
#ifndef FS_COMPLIANCEENGINE_H_
#define FS_COMPLIANCEENGINE_H_
 
#include "common/fs_common.h"
 
namespace foxit {
namespace addon {
namespace compliance {
class ResultInformation;
class ProgressCallback;
class PreflightSettingData;
class PreflightReportSettingData;
class Preflight;
 
class ComplianceEngine FS_FINAL : public Object{
 public:
  typedef enum _ViewOrPrintCondition {
    e_ViewOrPrintConditionAuto = 0,
    e_ViewOrPrintConditionCoatedGRACoL2006 = 1,
    e_ViewOrPrintConditionISOCoatedv2ECI = 2,
    e_ViewOrPrintConditionJapanColor2001Coated = 3,
    e_ViewOrPrintConditionPSOCoatedv3ECI = 4
  } ViewOrPrintCondition;
  
 
  static ErrorCode Initialize(const wchar_t* compliance_resource_folder_path, const char* compliance_engine_unlockcode);
 
  static void Release();
 
#if !defined(_MAC_JAVA_)
 
  static ErrorCode InitializeThreadContext();
 
  static void ReleaseThreadContext();
#endif
 
   static void SetTempFolderPath(const wchar_t* temp_folder_path);
 
   static void EnableHandleTransparency(bool enable_handle_transparency);
 
   static void SetLanguage(const char* language);
};
 
class ProgressCallback {
 public:
  virtual void Release() = 0;
 
  virtual void UpdateCurrentStateData(int current_rate, const WString& current_state_string) = 0;
 
 protected:
  ~ProgressCallback() {}
};
 
class PreflightSettingData  FS_FINAL : public Object{
 public:
  typedef enum _LibraryType {
    e_LibraryTypeFoxit = 0,
    e_LibraryTypePDFStandards = 1,
    e_LibraryTypePrepressColorTransparency = 2
  } LibraryType;
  
  typedef enum _OperateType {
    e_OperateTypeProfiles = 0,
    e_OperateTypeSingleChecks = 1,
    e_OperateTypeSingleFixups = 2
  } OperateType;
  
 
  PreflightSettingData()
    : preflight_key(L"")
    , operate_type(e_OperateTypeProfiles)
    , src_pdf_path(L"")
    , saved_pdf_path(L"")
    , first_page_index(0)
    , last_page_index(-1) {}
 
  PreflightSettingData(const wchar_t* preflight_key, OperateType operate_type, const wchar_t* src_pdf_path, const wchar_t* saved_pdf_path,
    int first_page_index, int last_page_index) {
    this->preflight_key = preflight_key;
    this->operate_type = operate_type;
    this->src_pdf_path = src_pdf_path;
    this->saved_pdf_path = saved_pdf_path;
    this->first_page_index = first_page_index;
    this->last_page_index = last_page_index;
  }
 
  PreflightSettingData &operator = (const PreflightSettingData& data) {
    preflight_key = data.preflight_key;
    operate_type = data.operate_type;
    src_pdf_path = data.src_pdf_path;
    saved_pdf_path = data.saved_pdf_path;
    first_page_index = data.first_page_index;
    last_page_index = data.last_page_index;
    return (*this);
  }
 
  WString preflight_key;
 
  OperateType operate_type;
 
  WString src_pdf_path;
 
  WString saved_pdf_path;
 
  int first_page_index;
 
  int last_page_index;
};
 
class PreflightReportSettingData  FS_FINAL : public Object{
 public:
  typedef enum _ReportFileFormatType {
    e_ReportFileFormatTypePdf = 0,
    e_ReportFileFormatTypeXml = 1,
    e_ReportFileFormatTypeTxt = 2,
    e_ReportFileFormatTypeHtml = 3
  } ReportFileFormatType;
  
  typedef enum _ProblemsHighlightMethod {
    e_ProblemsHighlightMethodTransparentMasks = 0,
    e_ProblemsHighlightMethodLayers = 1
  } ProblemsHighlightMethod;
  
    
  PreflightReportSettingData()
    : report_file_format_type(e_ReportFileFormatTypePdf)
    , to_generate_overview(true)
    , to_highlight_problems(true)
    , problems_highlight_method(e_ProblemsHighlightMethodTransparentMasks)
    , report_file_path(L"") {}
 
  PreflightReportSettingData(ReportFileFormatType report_file_format_type, bool to_generate_overview, bool to_highlight_problems,
    ProblemsHighlightMethod problem_highlight_method, const wchar_t* report_file_path) {
    this->report_file_format_type = report_file_format_type;
    this->to_generate_overview = to_generate_overview;
    this->to_highlight_problems = to_highlight_problems;
    this->problems_highlight_method = problem_highlight_method;
    this->report_file_path = report_file_path;
  }
 
  PreflightReportSettingData &operator = (const PreflightReportSettingData& data) {
    report_file_format_type = data.report_file_format_type;
    to_generate_overview = data.to_generate_overview;
    to_highlight_problems = data.to_highlight_problems;
    problems_highlight_method = data.problems_highlight_method;
    report_file_path = data.report_file_path;
    return (*this);
  }
 
  ReportFileFormatType report_file_format_type;
 
  bool to_generate_overview;
 
  bool to_highlight_problems;
 
  ProblemsHighlightMethod problems_highlight_method;
 
  WString report_file_path;
};
 
class Preflight FS_FINAL : public Base {
 public:
  Preflight();
 
  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit Preflight(FS_HANDLE handle);
 
  ~Preflight();
 
  Preflight(const Preflight& other);
 
  Preflight& operator = (const Preflight& other);
 
  bool operator == (const Preflight& other) const;
 
  bool operator != (const Preflight& other) const;
 
  bool IsEmpty() const;
 
  StringArray GetGroupNamesArray(const PreflightSettingData::LibraryType& library_type, const PreflightSettingData::OperateType& operate_type);
 
  StringArray GetItemKeysArray(const String& group_name);
 
  void Analyze(const PreflightSettingData& preflight_setting_data, ProgressCallback* progress_callback = NULL);
  
  void AnalyzeAndFixup(const PreflightSettingData& preflight_setting_data, ProgressCallback* progress_callback = NULL);
 
  bool GenerateReport(const PreflightReportSettingData& preflight_report_setting_data, ProgressCallback* progress_callback = NULL);
 
  bool CanFixup(const String& item_key);
};
 
class FixupData : public Object {
 public:
  typedef enum _FixupState {
    e_FixupStateSuccess = 0,
    e_FixupStateFailure = 1,
    e_FixupStateNotRequired = 2
  } FixupState;
  
 
  FixupData()
    : used_count(0)
    , state(e_FixupStateNotRequired) {}
 
  FixupData(const FixupData& other)
      : used_count(other.used_count)
      , state(other.state)
      , name(other.name)
      , comment(other.comment)
      , reasons(other.reasons) {}
 
  FixupData& operator = (const FixupData& other) {
    used_count = other.used_count;
    state = other.state;
    name = other.name;
    comment = other.comment;
    reasons = other.reasons;
    return *this;
  }
 
  bool operator == (const FixupData& other) const {
    bool is_equal = (used_count == other.used_count && state == other.state &&
                     name == other.name && comment == other.comment);
    if (is_equal) {
      for (int i=0; i<(int)reasons.GetSize(); i++) {
        if (reasons[i] != other.reasons[i]) {
          is_equal = false;
          break;
        }
      }
    }
    return is_equal;
  }
 
  bool operator != (const FixupData& other) const  {
    return !((*this) == other);
  }
 
  uint32 used_count;
  FixupState state;
  WString name;
  WString comment;
  WStringArray reasons;
};
 
class HitData : public Object {
 public:
  typedef enum _CheckSeverity {
    e_CheckSeverityInfo = 1,
    e_CheckSeverityWarning = 2,
    e_CheckSeverityError = 3
  } CheckSeverity;
  
 
  HitData()
    : triggered_count(0)
    , severity(e_CheckSeverityInfo)
    , page_index(-1){}
 
  HitData(const HitData& other)
      : triggered_count(other.triggered_count)
      , severity(other.severity)
      , name(other.name)
      , comment(other.comment)
      , trigger_values(other.trigger_values)
      , page_index(other.page_index) {}
 
  HitData& operator = (const HitData& other) {
    triggered_count = other.triggered_count;
    severity = other.severity;
    name = other.name;
    comment = other.comment;
    trigger_values = other.trigger_values;
    page_index = other.page_index;
    return *this;
  }
 
  bool operator == (const HitData& other) const {
    bool is_equal = (triggered_count == other.triggered_count && severity == other.severity &&
                     name == other.name && comment == other.comment && page_index == other.page_index);
    if (is_equal) {
      for (int i=0; i<(int)trigger_values.GetSize(); i++) {
        if (trigger_values[i] != other.trigger_values[i]) {
          is_equal = false;
          break;
        }
      }
    }
    return is_equal;
  }
 
  bool operator != (const HitData& other) const  {
    return !((*this) == other);
  }
 
  uint32 triggered_count;
  CheckSeverity severity;
  WString name;
  WString comment;
  WStringArray trigger_values;
  int page_index;
};
 
class ResultInformation FS_FINAL : public Base {
 public:
  ResultInformation();
  // User is strongly recommended NOT to use this method; otherwise unknown situation may occur.
  explicit ResultInformation(FS_HANDLE handle);
  ~ResultInformation();
  ResultInformation(const ResultInformation& other);
 
  ResultInformation& operator = (const ResultInformation& other);
  bool operator == (const ResultInformation& other) const;
 
  bool operator != (const ResultInformation& other) const;
 
  bool IsEmpty() const;
 
  int GetFixupDataCount() const;
  FixupData GetFixupData(int index) const;
 
  int GetHitDataCount() const;
 
  HitData GetHitData(int index) const;
};
}  // namespace compliance/**
}  // namespace addon
}  // namespace foxit
 
#endif  // FS_COMPLIANCEENGINE_H_