// Copyright (C) 2003-2026, Foxit Software Inc..
// All Rights Reserved.
//
// http://www.foxitsoftware.com
//
// The following code is copyrighted and contains proprietary information and trade secrets of Foxit Software Inc..
// You cannot distribute any part of Foxit PDF SDK to any third party or general public,
// unless there is a separate license agreement with Foxit Software Inc. which explicitly grants you such rights.
//
// This file contains an example to demonstrate how to use Foxit PDF SDK to verify if a PDF file is PDFA-1a version
// or convert a PDF file to PDFA-1a version.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;

using foxit;
using foxit.common;
//using foxit.common.fxcrt;
using foxit.addon.compliance;

namespace complianceCS
{
    class TextDoc 
    {
        private FileStream mfile_stream;
        public TextDoc(string file_name, FileMode fill_mode)
        {
            mfile_stream = new FileStream(file_name, fill_mode);
        }
        ~TextDoc()
        {
            try
            {
                mfile_stream.Flush();
                mfile_stream.Close();
            }
            catch (System.ObjectDisposedException e)
            {
                string str = e.Message;
            }
            
        }
        public void Write(string contents)
        {
            if (null == contents) return;
            byte[] byte_data = Encoding.Default.GetBytes(contents);
            // Move file pointer to the end of file.
            mfile_stream.Seek(0, SeekOrigin.End);
            mfile_stream.Write(byte_data, 0, byte_data.Length);
            mfile_stream.Flush();
        }
        public string Read()
        {
            int fs_len = (int)mfile_stream.Length;
            byte[] byte_data = new byte[fs_len];
            int r = mfile_stream.Read(byte_data, 0, byte_data.Length);
            string contents = System.Text.Encoding.UTF8.GetString(byte_data);
            return contents;
        }
    };

    class MyComplianceProgressCallback : ProgressCallback
    {
        private TextDoc text_doc_ = null;

        public MyComplianceProgressCallback(string output_txt_file_path)
        {
            this.text_doc_ = new TextDoc(output_txt_file_path, FileMode.Create);
        }

        public override void Release()
        {

        }

        public override void UpdateCurrentStateData(int current_rate, string current_state_string)
        {
            Console.WriteLine("Current rate:{0}", current_rate);

            text_doc_.Write(string.Format("Current rate:{0}, state str:{1}\r\n", current_rate, current_state_string));
            text_doc_.Write("\r\n");
        }

    }

    class compliance
    {
        public static void OutputPDFAFixupData(ResultInformation result_info, string output_txt_path) {
            TextDoc text_doc = new TextDoc(output_txt_path, FileMode.Create);

            int fixup_count = result_info.GetFixupDataCount();
            text_doc.Write(string.Format("== Fixup Data, count:{0} ==\r\n", fixup_count));
            for (int i = 0; i<fixup_count; i++) {
                FixupData fixup_data = result_info.GetFixupData(i);
                text_doc.Write(string.Format("Used count:{0} ==\r\n", fixup_data.used_count));

                text_doc.Write("Name:");
                text_doc.Write(fixup_data.name);
                text_doc.Write("\r\n");

                text_doc.Write("Comment:");
                text_doc.Write(fixup_data.comment);
                text_doc.Write("\r\n");

                text_doc.Write("Reason:");
                uint reason_count = fixup_data.reasons.GetSize();
                if (reason_count < 1) {
                    text_doc.Write("\r\n");
                } else {
                    for (uint z = 0; z<reason_count; z++) {
                        text_doc.Write("\t");
                        text_doc.Write(fixup_data.reasons.GetAt(z));
                        text_doc.Write("\r\n");
                    }
                }

                text_doc.Write(string.Format("State value:{0}\r\n", fixup_data.state));
                text_doc.Write("\r\n");
            }
        }

        public static void OutputPDFAHitData(ResultInformation result_info, string output_txt_path) {
            TextDoc text_doc = new TextDoc(output_txt_path, FileMode.Create);

            int hit_data_count = result_info.GetHitDataCount();
            text_doc.Write(string.Format("== Hit Data, count:{0} ==\r\n", hit_data_count));
            for (int i = 0; i<hit_data_count; i++) {
                HitData hit_data = result_info.GetHitData(i);
                text_doc.Write(string.Format("Triggered count:{0}\r\n", hit_data.triggered_count));

                text_doc.Write("Name:");
                text_doc.Write(hit_data.name);
                text_doc.Write("\r\n");

                text_doc.Write("Comment:");
                text_doc.Write(hit_data.comment);
                text_doc.Write("\r\n");

                text_doc.Write("Trigger value:");
                uint trigger_value_count = hit_data.trigger_values.GetSize();
                if (trigger_value_count < 1) {
                    text_doc.Write("\r\n");
                } else {
                    for (uint z = 0; z<trigger_value_count; z++) {
                        text_doc.Write("\t");
                        text_doc.Write(hit_data.trigger_values.GetAt(z));
                        text_doc.Write("\r\n");
                    }
                }

                text_doc.Write(string.Format("Check severity:{0}\r\nPage index:{1}\r\n", hit_data.severity, hit_data.page_index));

                text_doc.Write("\r\n");
            }
        }


        static void Main(string[] args)
        {
            string input_path = "../input_files/";
            string output_path = "../output_files/compliance/";
            System.IO.Directory.CreateDirectory(output_path);

            string sn = "Rew1vB0TqoMIxX444UcpScARWdhgJpsJfzmyMLR32a0+EgrCjp2NaQ==";
            string key = "8f3g1sFttW8NAgfSNv+BvaJWy4Pp8flcm7ncNDkdvCCO4JwUFbGLyZdujReMaiplbYJwwxam3lr7uHtQaEf0xTSu8j2ZBdrZ8FS4OQkEUjOI9UEGb3Ic0GqmlP9T9OnSItOYqoZZA/OnYg5EaVP+c/ha32nUquOk+5riEdhYgINAZDdgJkPc+YSWsrfixOIROf6t34j3eRcyFnOY0MS7tSXi1AEPE0VZdyu+5bfmBSGvLI+WR5lQ+oOQR5hRGwqf990WEdBelNO7dxhZELVhEZ+/L60PpDf5y9A8qmrY6PiEU8nhqIyLpks0BxeIsYyZ3Cr82jjfbItPGyEARsIVzluBSgVMD4oGjojz8T6wGDEXUbmZH/pra94XAs8wZ28mzbmIEppWnhBqX0c6Ov8iXCfFfUZr4KNuPxMEgk4VOYTMOd70GEjGnylivw18hbn7ZpkWh2Zql+uU2HejvOgn+WHvT0HF9NhK0Xb5vH8aFkgBP92PJx8obIbxBVeeExczxvsqWufuPdXS2sPNIgMYZ2TtvqVVsiUToeGB2FQo09fzZOSH5Vi18u/siyvC3FmjeMf4+OYWPuDPNCcrb21NgcHam7XI8AAoGLTGtLLWR+fxynbBBcg2d2ZPcZ5CMFIfOBHRWCkcA0sDT3cl9nsBppHNJze/jVxHy+lREeQEA/etSIgohTGAWW3ZlpibRXqMxlmVWEPifCubbWTzQ6U54mRMpW2UghH3gvCNFNgdday3Av7EtlIJOdUuiMq3zmmd5J4Jt4C82CKnVewA0DtZ4EEtwRG9IYuLrfpuZlnjBAtoeXRV1lqUZ6BcCe0E3m9jO28sGkALuIeJQ74XG7X8lMC7lMWWQYiYD7D6G9QT6X3qV4vXJwNKRKpYc/rI+amEawTSnDYAMEaYPwtZ0rb/7BL+atsZZaI+ncebdfVfjDJZbCZAc+JnkuNlUn2xrNRuObw8h/G0lm2pNOEJ10S8R4+yplo5B1QmC2dCDhaTaW67QJPqnJPKbVmjw7i6KGBi+CDP3JnAKlOX/YUu8uk56JfeQUuGcQg/KaBMGctnchH2n1i3+oGbibhurQj22+OO66Q6mijKoCRP/QJm5WTGcO4c0iVX0B8dIlai/uv/pGU8Wps9MxysH5ViVIj56LWKuNfy1FNO9+wx4iHYnUxfW0Iccq3YJYAlOBkMv8VZIJl9aTEEFJ626LJEw/UbEBdR9CdlwnylPf4RuNW/lcGYMgq3xNVpp/bzYKwZivvQOFgMdX1tv8D33SHvAm3zrRCU+v94BJXnBi9k25fnKsc705IMwv+I6bueXA+mDnagj1oTqsWXZ0WnPAYI3WUO7sBf7XUH230wfYXnTSVhujJxiEP/2oWqi2813gtQkKwz9N2p6yT8Vsh3+BaAwwDvtOZMJKUFcabTBSL6NoouzmzwItJ4mIboT6KXaef66rs8jCU=";
            // Initialize library
            ErrorCode error_code = Library.Initialize(sn, key);
            if (error_code != ErrorCode.e_ErrSuccess)
            {
                Console.WriteLine("Library Initialize Error: {0}", error_code);
                return;
            }

            try
            {
                string input_file = input_path + "AboutFoxit.pdf";
                // "compliance_resource_folder_path" is the path of compliance resource folder. Please refer to Developer Guide for more details.
                string compliance_resource_folder_path = "";
                // If you use an authorization key for Foxit PDF SDK, please set a valid unlock code string to compliance_engine_unlockcode for ComplianceEngine.
                // If you use an trial key for Foxit PDF SDK, just keep compliance_engine_unlockcode as an empty string.
                string compliance_engine_unlockcode = "";

                if (compliance_resource_folder_path.Length < 1) {
                  Console.WriteLine("compliance_resource_folder_path is still empty. Please set it with a valid path to compliance resource folder path.");
                  return ;
                }
                // Initialize compliance engine.
                error_code = ComplianceEngine.Initialize(compliance_resource_folder_path, compliance_engine_unlockcode);
                if (error_code != ErrorCode.e_ErrSuccess) {
                  switch (error_code) {
                      case ErrorCode.e_ErrInvalidLicense:
                          Console.WriteLine("[Failed] Compliance module is not contained in current Foxit PDF SDK keys.");
                        break;
                    default:
                        Console.WriteLine("[Failed] Fail to initialize compliance engine. Error: {0}", error_code);
                        break;
                  }
                  return ;
                }
                Console.WriteLine("ComplianceEngine is initialized.");

                using (PDFACompliance pdfa_compliance = new PDFACompliance())
                {
                    {
                        // Verify original PDF file.
                        Console.WriteLine("======== PDFACompliance: Verify before convert ========");
                        MyComplianceProgressCallback verify_progress_callback = new MyComplianceProgressCallback(output_path + "0_pdfacompliance_verify_before_convert_progressdata.txt");
                        using (verify_progress_callback) {
                            ResultInformation verify_result_info = pdfa_compliance.Verify(PDFACompliance.Version.e_VersionPDFA1a, input_file, 0, -1, verify_progress_callback);
                            using (verify_result_info) {
                                OutputPDFAHitData(verify_result_info, output_path + "0_pdfacompliance_verify_before_convert_hitdata.txt");
                            }
                        }
                    }

                    string save_pdf_path = output_path + "1_pdfacompliance_convert_to_pdf1a.pdf";
                    {
                        // Convert original PDF file to PDFA-1a version.
                        Console.WriteLine("======== PDFACompliance: Convert ========");
                        MyComplianceProgressCallback convert_progress_callback = new MyComplianceProgressCallback(output_path + "1_1_pdfacompliance_convert_progressdata.txt");
                        using (convert_progress_callback) {
                            ResultInformation convert_result_info = pdfa_compliance.ConvertPDFFile(input_file, save_pdf_path,
                                                                                                   PDFACompliance.Version.e_VersionPDFA1a,
                                                                                                   convert_progress_callback);
                            using (convert_result_info) {
                                OutputPDFAFixupData(convert_result_info, output_path + "1_1_pdfacompliance_convert_pdfa1a_fixupdata.txt");
                                OutputPDFAHitData(convert_result_info, output_path + "1_1_pdfacompliance_convert_pdfa1a_hitdata.txt");
                            }
                        }
                    }

                    {
                        // Verify converted result PDF file, which is not expected to be PDFA-1a compliant as the original did not have accessibility structures.
                        Console.WriteLine("======== PDFACompliance: Verify after convert ========");
                        MyComplianceProgressCallback verify_progress_callback_2 = new MyComplianceProgressCallback(output_path + "1_2_pdfacompliance_verify_after_convert_progressdata.txt");
                        using (verify_progress_callback_2) {
                            ResultInformation verify_result_info_2 = pdfa_compliance.Verify(PDFACompliance.Version.e_VersionPDFA1a, save_pdf_path, 0, -1, verify_progress_callback_2);
                            using (verify_result_info_2) {
                                OutputPDFAHitData(verify_result_info_2, output_path + "1_2_pdfacompliance_verify_after_convert_hitdata.txt");
                            }
                        }
                    }

                    input_file = input_path + "AboutFoxit_Structured.pdf";
                    {
                        // Verify original PDF file.
                        Console.WriteLine("======== PDFACompliance: Verify before convert ========");
                        MyComplianceProgressCallback verify_progress_callback = new MyComplianceProgressCallback(output_path + "2_pdfacompliance_verify_before_convert_progressdata.txt");
                        using (verify_progress_callback)
                        {
                            ResultInformation verify_result_info = pdfa_compliance.Verify(PDFACompliance.Version.e_VersionPDFA1a, input_file, 0, -1, verify_progress_callback);
                            using (verify_result_info)
                            {
                                OutputPDFAHitData(verify_result_info, output_path + "2_pdfacompliance_verify_before_convert_hitdata.txt");
                            }
                        }
                    }

                    save_pdf_path = output_path + "3_pdfacompliance_convert_to_pdf1a.pdf";
                    {
                        // Convert original PDF file to PDFA-1a version.
                        Console.WriteLine("======== PDFACompliance: Convert ========");
                        MyComplianceProgressCallback convert_progress_callback = new MyComplianceProgressCallback(output_path + "3_1_pdfacompliance_convert_progressdata.txt");
                        using (convert_progress_callback)
                        {
                            ResultInformation convert_result_info = pdfa_compliance.ConvertPDFFile(input_file, save_pdf_path,
                                                                                                   PDFACompliance.Version.e_VersionPDFA1a,
                                                                                                   convert_progress_callback);
                            using (convert_result_info)
                            {
                                OutputPDFAFixupData(convert_result_info, output_path + "3_1_pdfacompliance_convert_pdfa1a_fixupdata.txt");
                                OutputPDFAHitData(convert_result_info, output_path + "3_1_pdfacompliance_convert_pdfa1a_hitdata.txt");
                            }
                        }
                    }

                    {
                        // Verify converted result PDF file, which is expected to be PDFA-1a version.
                        Console.WriteLine("======== PDFACompliance: Verify after convert ========");
                        MyComplianceProgressCallback verify_progress_callback_2 = new MyComplianceProgressCallback(output_path + "3_2_pdfacompliance_verify_after_convert_progressdata.txt");
                        using (verify_progress_callback_2)
                        {
                            ResultInformation verify_result_info_2 = pdfa_compliance.Verify(PDFACompliance.Version.e_VersionPDFA1a, save_pdf_path, 0, -1, verify_progress_callback_2);
                            using (verify_result_info_2)
                            {
                                OutputPDFAHitData(verify_result_info_2, output_path + "3_2_pdfacompliance_verify_after_convert_hitdata.txt");
                            }
                        }
                    }

                    using (PDFXCompliance pdfx_compliance = new PDFXCompliance())
                    {
                        {
                            // Verify original PDF file.
                            Console.WriteLine("======== PDFXCompliance: Verify before convert ========");
                            MyComplianceProgressCallback verify_progress_callback = new MyComplianceProgressCallback(output_path + "0_pdfxcompliance_verify_before_convert_progressdata.txt");
                            using (verify_progress_callback)
                            {
                                ResultInformation verify_result_info = pdfx_compliance.Verify(PDFXCompliance.Version.e_VersionPDFX1a, input_file, 0, -1, verify_progress_callback);
                                using (verify_result_info)
                                {
                                    OutputPDFAHitData(verify_result_info, output_path + "0_pdfxcompliance_verify_before_convert_hitdata.txt");
                                }
                            }
                        }

                        save_pdf_path = output_path + "1_pdfxcompliance_convert_to_pdfx1a.pdf";
                        {
                            // Convert original PDF file to PDFX-1a version.
                            Console.WriteLine("======== PDFXCompliance: Convert ========");
                            MyComplianceProgressCallback convert_progress_callback = new MyComplianceProgressCallback(output_path + "1_1_pdfxcompliance_convert_progressdata.txt");
                            using (convert_progress_callback)
                            {
                                ResultInformation convert_result_info = pdfx_compliance.ConvertPDFFile(input_file, save_pdf_path,
                                                                                                       PDFXCompliance.Version.e_VersionPDFX1a,
                                                                                                       ComplianceEngine.ViewOrPrintCondition.e_ViewOrPrintConditionAuto,
                                                                                                       false, false,
                                                                                                       convert_progress_callback);
                                using (convert_result_info)
                                {
                                    OutputPDFAFixupData(convert_result_info, output_path + "1_1_pdfxcompliance_convert_pdfx1a_fixupdata.txt");
                                    OutputPDFAHitData(convert_result_info, output_path + "1_1_pdfxcompliance_convert_pdfx1a_hitdata.txt");
                                }
                            }
                        }

                        {
                            // Verify converted result PDF file, which is not expected to be PDFX-1a compliant as the original did not have accessibility structures.
                            Console.WriteLine("======== PDFXCompliance: Verify after convert ========");
                            MyComplianceProgressCallback verify_progress_callback_2 = new MyComplianceProgressCallback(output_path + "1_2_pdfxcompliance_verify_after_convert_progressdata.txt");
                            using (verify_progress_callback_2)
                            {
                                ResultInformation verify_result_info_2 = pdfx_compliance.Verify(PDFXCompliance.Version.e_VersionPDFX1a, save_pdf_path, 0, -1, verify_progress_callback_2);
                                using (verify_result_info_2)
                                {
                                    OutputPDFAHitData(verify_result_info_2, output_path + "1_2_pdfxcompliance_verify_after_convert_hitdata.txt");
                                }
                            }
                        }

                        input_file = input_path + "AboutFoxit_Structured.pdf";
                        {
                            // Verify original PDF file.
                            Console.WriteLine("======== PDFXCompliance: Verify before convert ========");
                            MyComplianceProgressCallback verify_progress_callback = new MyComplianceProgressCallback(output_path + "2_pdfxcompliance_verify_before_convert_progressdata.txt");
                            using (verify_progress_callback)
                            {
                                ResultInformation verify_result_info = pdfx_compliance.Verify(PDFXCompliance.Version.e_VersionPDFX1a, input_file, 0, -1, verify_progress_callback);
                                using (verify_result_info)
                                {
                                    OutputPDFAHitData(verify_result_info, output_path + "2_pdfxcompliance_verify_before_convert_hitdata.txt");
                                }
                            }
                        }

                        save_pdf_path = output_path + "3_pdfxcompliance_convert_to_pdfx1a.pdf";
                        {
                            // Convert original PDF file to PDFX-1a version.
                            Console.WriteLine("======== PDFXCompliance: Convert ========");
                            MyComplianceProgressCallback convert_progress_callback = new MyComplianceProgressCallback(output_path + "3_1_pdfxcompliance_convert_progressdata.txt");
                            using (convert_progress_callback)
                            {
                                ResultInformation convert_result_info = pdfx_compliance.ConvertPDFFile(input_file, save_pdf_path,
                                                                                                       PDFXCompliance.Version.e_VersionPDFX1a,
                                                                                                       ComplianceEngine.ViewOrPrintCondition.e_ViewOrPrintConditionAuto,
                                                                                                       false, false,
                                                                                                       convert_progress_callback);
                                using (convert_result_info)
                                {
                                    OutputPDFAFixupData(convert_result_info, output_path + "3_1_pdfxcompliance_convert_pdfx1a_fixupdata.txt");
                                    OutputPDFAHitData(convert_result_info, output_path + "3_1_pdfxcompliance_convert_pdfx1a_hitdata.txt");
                                }
                            }
                        }

                        {
                            // Verify converted result PDF file, which is expected to be PDFX-1a version.
                            Console.WriteLine("======== PDFXCompliance: Verify after convert ========");
                            MyComplianceProgressCallback verify_progress_callback_2 = new MyComplianceProgressCallback(output_path + "3_2_pdfxcompliance_verify_after_convert_progressdata.txt");
                            using (verify_progress_callback_2)
                            {
                                ResultInformation verify_result_info_2 = pdfx_compliance.Verify(PDFXCompliance.Version.e_VersionPDFX1a, save_pdf_path, 0, -1, verify_progress_callback_2);
                                using (verify_result_info_2)
                                {
                                    OutputPDFAHitData(verify_result_info_2, output_path + "3_2_pdfxcompliance_verify_after_convert_hitdata.txt");
                                }
                            }
                        }

                    }

                    using (PDFECompliance pdfe_compliance = new PDFECompliance())
                    {
                        {
                            // Verify original PDF file.
                            Console.WriteLine("======== PDFECompliance: Verify before convert ========");
                            MyComplianceProgressCallback verify_progress_callback = new MyComplianceProgressCallback(output_path + "0_pdfecompliance_verify_before_convert_progressdata.txt");
                            using (verify_progress_callback)
                            {
                                ResultInformation verify_result_info = pdfe_compliance.Verify(input_file, 0, -1, PDFECompliance.Version.e_VersionPDFE1, verify_progress_callback);
                                using (verify_result_info)
                                {
                                    OutputPDFAHitData(verify_result_info, output_path + "0_pdfecompliance_verify_before_convert_hitdata.txt");
                                }
                            }
                        }

                        save_pdf_path = output_path + "1_pdfecompliance_convert_to_pdfe1.pdf";
                        {
                            // Convert original PDF file to PDFE-1a version.
                            Console.WriteLine("======== PDFECompliance: Convert ========");
                            MyComplianceProgressCallback convert_progress_callback = new MyComplianceProgressCallback(output_path + "1_1_pdfecompliance_convert_progressdata.txt");
                            using (convert_progress_callback)
                            {
                                ResultInformation convert_result_info = pdfe_compliance.ConvertPDFFile(input_file, save_pdf_path,
                                                                                                       PDFECompliance.Version.e_VersionPDFE1,
                                                                                                       convert_progress_callback);
                                using (convert_result_info)
                                {
                                    OutputPDFAFixupData(convert_result_info, output_path + "1_1_pdfecompliance_convert_pdfe1_fixupdata.txt");
                                    OutputPDFAHitData(convert_result_info, output_path + "1_1_pdfecompliance_convert_pdfe1_hitdata.txt");
                                }
                            }
                        }

                        {
                            // Verify converted result PDF file, which is not expected to be PDFE-1a compliant as the original did not have accessibility structures.
                            Console.WriteLine("======== PDFECompliance: Verify after convert ========");
                            MyComplianceProgressCallback verify_progress_callback_2 = new MyComplianceProgressCallback(output_path + "1_2_pdfecompliance_verify_after_convert_progressdata.txt");
                            using (verify_progress_callback_2)
                            {
                                ResultInformation verify_result_info_2 = pdfe_compliance.Verify(save_pdf_path, 0, -1, PDFECompliance.Version.e_VersionPDFE1, verify_progress_callback_2);
                                using (verify_result_info_2)
                                {
                                    OutputPDFAHitData(verify_result_info_2, output_path + "1_2_pdfecompliance_verify_after_convert_hitdata.txt");
                                }
                            }
                        }

                        input_file = input_path + "AboutFoxit_Structured.pdf";
                        {
                            // Verify original PDF file.
                            Console.WriteLine("======== PDFECompliance: Verify before convert ========");
                            MyComplianceProgressCallback verify_progress_callback = new MyComplianceProgressCallback(output_path + "2_pdfecompliance_verify_before_convert_progressdata.txt");
                            using (verify_progress_callback)
                            {
                                ResultInformation verify_result_info = pdfe_compliance.Verify(input_file, 0, -1, PDFECompliance.Version.e_VersionPDFE1, verify_progress_callback);
                                using (verify_result_info)
                                {
                                    OutputPDFAHitData(verify_result_info, output_path + "2_pdfecompliance_verify_before_convert_hitdata.txt");
                                }
                            }
                        }

                        save_pdf_path = output_path + "3_pdfecompliance_convert_to_pdfe1.pdf";
                        {
                            // Convert original PDF file to PDFE-1a version.
                            Console.WriteLine("======== PDFECompliance: Convert ========");
                            MyComplianceProgressCallback convert_progress_callback = new MyComplianceProgressCallback(output_path + "3_1_pdfecompliance_convert_progressdata.txt");
                            using (convert_progress_callback)
                            {
                                ResultInformation convert_result_info = pdfe_compliance.ConvertPDFFile(input_file, save_pdf_path,
                                                                                                       PDFECompliance.Version.e_VersionPDFE1,
                                                                                                       convert_progress_callback);
                                using (convert_result_info)
                                {
                                    OutputPDFAFixupData(convert_result_info, output_path + "3_1_pdfecompliance_convert_pdfe1_fixupdata.txt");
                                    OutputPDFAHitData(convert_result_info, output_path + "3_1_pdfecompliance_convert_pdfe1_hitdata.txt");
                                }
                            }
                        }

                        {
                            // Verify converted result PDF file, which is expected to be PDFE-1a version.
                            Console.WriteLine("======== PDFECompliance: Verify after convert ========");
                            MyComplianceProgressCallback verify_progress_callback_2 = new MyComplianceProgressCallback(output_path + "3_2_pdfecompliance_verify_after_convert_progressdata.txt");
                            using (verify_progress_callback_2)
                            {
                                ResultInformation verify_result_info_2 = pdfe_compliance.Verify(save_pdf_path, 0, -1, PDFECompliance.Version.e_VersionPDFE1, verify_progress_callback_2);
                                using (verify_result_info_2)
                                {
                                    OutputPDFAHitData(verify_result_info_2, output_path + "3_2_pdfecompliance_verify_after_convert_hitdata.txt");
                                }
                            }
                        }

                    }

                    using (PDFCompliance pdf_compliance = new PDFCompliance())
                    {
                        input_file = input_path + "AF_ImageXObject_FormXObject.pdf";
                        {
                            // Convert original PDF file to PDF-1.4.
                            Console.WriteLine("======== PDFCompliance: Convert ========");
                            MyComplianceProgressCallback convert_progress_callback = new MyComplianceProgressCallback(output_path + "4_pdfcompliance_convert_1_4_progressdata.txt");
                            save_pdf_path = output_path + "4_pdfcompliance_convert_to_1_4.pdf";
                            using (convert_progress_callback)
                            {
                                ResultInformation convert_result_info = pdf_compliance.ConvertPDFFile(input_file, save_pdf_path, 14,
                                                                                                      convert_progress_callback);
                                using (convert_result_info)
                                {
                                    OutputPDFAFixupData(convert_result_info, output_path + "4_pdfcompliance_convert_1_4_fixupdata.txt");
                                    OutputPDFAHitData(convert_result_info, output_path + "4_pdfcompliance_convert_1_4_hitdata.txt");
                                }
                            }
                        }
                        {
                            // Convert original PDF file to PDF-1.7.
                            Console.WriteLine("======== PDFCompliance: Convert ========");
                            MyComplianceProgressCallback convert_progress_callback = new MyComplianceProgressCallback(output_path + "5_pdfcompliance_convert_1_7_progressdata.txt");
                            save_pdf_path = output_path + "5_pdfcompliance_convert_to_1_7.pdf";
                            using (convert_progress_callback)
                            {
                                ResultInformation convert_result_info = pdf_compliance.ConvertPDFFile(input_file, save_pdf_path, 17,
                                                                                                      convert_progress_callback);
                                using (convert_result_info)
                                {
                                    OutputPDFAFixupData(convert_result_info, output_path + "5_pdfcompliance_convert_1_7_fixupdata.txt");
                                    OutputPDFAHitData(convert_result_info, output_path + "5_pdfcompliance_convert_1_7_hitdata.txt");
                                }
                            }
                        }

                    }


                    // Release compliance engine.
                    ComplianceEngine.Release();

                    Console.WriteLine("== End: Compliance demo. ==");
                }
            }
            catch (foxit.PDFException e)
            {
                Console.WriteLine(e.Message);
            }

            Library.Release();
        }
    }
}
