// PdfCompBatchDlg.cpp : implementation file
//

#include "stdafx.h"
#include "resource.h"
#include "options.h"
#include "PdfCompBatch.h"
#include "PdfCompBatchDlg.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


#ifdef UNICODE
   #define strprintf swprintf
#else
   #define strprintf sprintf
#endif

L_VOID PDFCompError(HWND hwnd, L_INT nCode, L_TCHAR* pTitle, L_TCHAR* pFilename);
L_INT  PDFCompMessageBox (HWND hWnd, L_TCHAR* pCaption, UINT wType, L_TCHAR* pFormat,...);


#define PDFSETTINGS_AUTO         TEXT("Auto Select")
#define PDFSETTINGS_NOISY        TEXT("Noisy Image")
#define PDFSETTINGS_SCANNED      TEXT("Scanned Image")
#define PDFSETTINGS_PRINTED      TEXT("Printed Image")
#define PDFSETTINGS_COMPUTERGEN  TEXT("Computer Generated Image")
#define PDFSETTINGS_PHOTOS       TEXT("Photo")
#define PDFSETTINGS_USERDDEFINED TEXT("User Defined")
#define PDFSETTINGS_MAX 6


#define PDFSIMGQUALITY_AUTO         TEXT("Auto Select")
#define PDFSIMGQUALITY_POOR         TEXT("Poor Quality")
#define PDFSIMGQUALITY_AVG          TEXT("Average Quality")
#define PDFSIMGQUALITY_GOOD         TEXT("Good Quality")
#define PDFSIMGQUALITY_EXCELLENT    TEXT("Excellent Quality")
#define PDFSIMGQUALITY_USERDDEFINED TEXT("User Defined")
#define PDFSIMGQUALITY_MAX 5

/////////////////////////////////////////////////////////////////////////////
// CAboutDlg dialog used for App About

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// Dialog Data
	//{{AFX_DATA(CAboutDlg)
	enum { IDD = IDS_ABOUTBOX };
	//}}AFX_DATA

	// ClassWizard generated virtual function overrides
	//{{AFX_VIRTUAL(CAboutDlg)
	protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support
	//}}AFX_VIRTUAL

// Implementation
protected:
	//{{AFX_MSG(CAboutDlg)
	//}}AFX_MSG
	DECLARE_MESSAGE_MAP()
};

CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
	//{{AFX_DATA_INIT(CAboutDlg)
	//}}AFX_DATA_INIT
}

void CAboutDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CAboutDlg)
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
	//{{AFX_MSG_MAP(CAboutDlg)
		// No message handlers
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CPdfCompBatchDlg dialog

CPdfCompBatchDlg::CPdfCompBatchDlg(CWnd* pParent /*=NULL*/)
	: CDialog(CPdfCompBatchDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CPdfCompBatchDlg)
	m_edtnCleanSize = 0;
	m_edtnColorThreshold = 0;
	m_edtnBGThreshold = 0;
	m_edtnComThreshold = 0;
	m_edtnSegmentQlty = 0;   
	m_strStatus = _T("");
	//}}AFX_DATA_INIT
	// Note that LoadIcon does not require a subsequent DestroyIcon in Win32
	m_hIcon = AfxGetApp()->LoadIcon(IDI_ICON1);



   L_DlgInit(DLG_INIT_COLOR);
}

CPdfCompBatchDlg::~CPdfCompBatchDlg()
{
   L_DlgFree();
}

void CPdfCompBatchDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CPdfCompBatchDlg)
	DDX_Control(pDX, IDBTN_OPTIONS, m_btnOptions);
	DDX_Control(pDX, IDBTN_ABORT, m_btnAbort);
	DDX_Control(pDX, IDBTN_ADDFILE, m_btnAddFile);
	DDX_Control(pDX, IDBTN_REMOVEFILE, m_btnRemove);
	DDX_Control(pDX, IDBTN_ADDFOLDER, m_btnAddFolder);
	DDX_Control(pDX, IDC_PROGRESS2, m_Progress);
	DDX_Control(pDX, IDBTN_RUN, m_btnRun);
	DDX_Control(pDX, IDEDT_SEGQLTYVALUE, m_edtSegmentQlty);
	DDX_Control(pDX, IDEDT_BGTHRESHOLDVALUE, m_edtBGThreshold);
	DDX_Control(pDX, IDEDT_COMTHRESHOLDVALUE, m_edtComThreshold);
	DDX_Control(pDX, IDEDT_COLORTHRESHOLDVALUE, m_edtColorThreshold);
	DDX_Control(pDX, IDEDT_CLEANSIZEVALUE, m_edtCleanSize);
	DDX_Control(pDX, IDCMB_OUTPROFILES, m_cmbOutputProfile);
	DDX_Control(pDX, IDCMB_INPROFILES, m_cmbInputProfile);
	DDX_Control(pDX, IDEDT_SINGLE, m_edtSingle);
	DDX_Control(pDX, IDEDT_SEPARATE, m_edtSeparate);
	DDX_Control(pDX, IDBTN_SINGLEBROWSE, m_btnSingleBrowse);
	DDX_Control(pDX, IDBTN_SEPBROWSE, m_btnSepBrowse);
	DDX_Control(pDX, IDLST_FILESLIST, m_lstFilesList);
	DDX_Text(pDX, IDEDT_CLEANSIZEVALUE, m_edtnCleanSize);
	DDV_MinMaxInt(pDX, m_edtnCleanSize, 0, 10);
	DDX_Text(pDX, IDEDT_COLORTHRESHOLDVALUE, m_edtnColorThreshold);
	DDV_MinMaxInt(pDX, m_edtnColorThreshold, 0, 100);
	DDX_Text(pDX, IDEDT_BGTHRESHOLDVALUE, m_edtnBGThreshold);
	DDV_MinMaxInt(pDX, m_edtnBGThreshold, 0, 100);
	DDX_Text(pDX, IDEDT_COMTHRESHOLDVALUE, m_edtnComThreshold);
	DDV_MinMaxInt(pDX, m_edtnComThreshold, 0, 300);
	DDX_Text(pDX, IDEDT_SEGQLTYVALUE, m_edtnSegmentQlty);
	DDV_MinMaxInt(pDX, m_edtnSegmentQlty, 0, 100);
	DDX_Text(pDX, IDC_STATUS, m_strStatus);
   DDX_Control(pDX, IDRBTN_SEPARATE, m_rbtnSeperate);
   DDX_Control(pDX, IDRBTN_SINGLE, m_rbtnSingle);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CPdfCompBatchDlg, CDialog)
	//{{AFX_MSG_MAP(CPdfCompBatchDlg)
	ON_WM_SYSCOMMAND()
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDBTN_ADDFILE, OnAddfile)
	ON_BN_CLICKED(IDBTN_ADDFOLDER, OnAddFolder)
	ON_BN_CLICKED(IDBTN_REMOVEFILE, OnRemovefile)
	ON_BN_CLICKED(IDRBTN_SEPARATE, OnSeparate)
	ON_BN_CLICKED(IDRBTN_SINGLE, OnSingle)		
	ON_BN_CLICKED(IDBTN_SINGLEBROWSE, OnSinglebrowse)
	ON_BN_CLICKED(IDBTN_SEPBROWSE, OnSepbrowse)
	ON_CBN_SELCHANGE(IDCMB_INPROFILES, OnSelchangeInprofiles)
	ON_CBN_SELCHANGE(IDCMB_OUTPROFILES, OnSelchangeOutprofiles)
	ON_BN_CLICKED(IDBTN_RUN, OnRun)
	ON_EN_CHANGE(IDEDT_CLEANSIZEVALUE, OnChangeCleansizevalue)
	ON_EN_CHANGE(IDEDT_BGTHRESHOLDVALUE, OnChangeBgthresholdvalue)
	ON_EN_CHANGE(IDEDT_COMTHRESHOLDVALUE, OnChangeComthresholdvalue)
	ON_EN_CHANGE(IDEDT_SEGQLTYVALUE, OnChangeSegqltyvalue)
	ON_EN_CHANGE(IDEDT_COLORTHRESHOLDVALUE, OnChangeColorthresholdvalue)
	ON_EN_CHANGE(IDEDT_SINGLE, OnChangeSingle)
	ON_EN_CHANGE(IDEDT_SEPARATE, OnChangeSeparate)
	ON_BN_CLICKED(IDBTN_ABORT, OnAbort)
	ON_NOTIFY(LVN_KEYDOWN, IDLST_FILESLIST, OnKeydownFileslist)
	ON_WM_CLOSE()
	ON_BN_CLICKED(IDBTN_OPTIONS, OnOptions)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CPdfCompBatchDlg message handlers

BOOL CPdfCompBatchDlg::OnInitDialog()
{
	CDialog::OnInitDialog();

	// Add "About..." menu item to system menu.

	// IDM_ABOUTBOX must be in the system command range.
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		CString strAboutMenu;
		strAboutMenu.LoadString(IDS_ABOUTBOX);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon
	
	// TODO: Add extra initialization here

   UNLOCKSUPPORT();

   m_lstFilesList.SetExtendedStyle( LVS_EX_GRIDLINES | LVS_EX_FULLROWSELECT | LVS_EX_TRACKSELECT );
   m_lstFilesList.InsertColumn(0, _T("File Name"), LVCFMT_CENTER, 250);   
   m_lstFilesList.InsertColumn(1, _T("Status"), LVCFMT_CENTER, 75);   

   CheckDlgButton(IDRBTN_SINGLE, TRUE);
   m_bSingleFile = TRUE;
   m_btnSepBrowse.EnableWindow(FALSE);     
   m_edtSeparate.EnableWindow(FALSE);

   m_strStatus = "Idle";
   m_bInProcess = FALSE;
   m_bAbortProcess = FALSE;
   m_bCancelProcess = FALSE;

   /****************Init Input Profile ***********************/
   m_cmbInputProfile.InsertString(0,PDFSETTINGS_AUTO);
   m_cmbInputProfile.InsertString(1,PDFSETTINGS_NOISY);
   m_cmbInputProfile.InsertString(2,PDFSETTINGS_SCANNED);
   m_cmbInputProfile.InsertString(3,PDFSETTINGS_PRINTED);
   m_cmbInputProfile.InsertString(4,PDFSETTINGS_COMPUTERGEN);
   m_cmbInputProfile.InsertString(5,PDFSETTINGS_PHOTOS);
   m_cmbInputProfile.InsertString(6,PDFSETTINGS_USERDDEFINED);
   m_cmbInputProfile.SetCurSel(0);
   SetInputProfile();


   /****************Init Output Profile ***********************/
   m_cmbOutputProfile.InsertString(0,PDFSIMGQUALITY_AUTO);
   m_cmbOutputProfile.InsertString(1,PDFSIMGQUALITY_POOR);
   m_cmbOutputProfile.InsertString(2,PDFSIMGQUALITY_AVG);
   m_cmbOutputProfile.InsertString(3,PDFSIMGQUALITY_GOOD);
   m_cmbOutputProfile.InsertString(4,PDFSIMGQUALITY_EXCELLENT);
   m_cmbOutputProfile.InsertString(5,PDFSIMGQUALITY_USERDDEFINED);   
   m_cmbOutputProfile.SetCurSel(0);
   SetOutputProfile();
   
   
   /****************Init Edit Ctrl ***********************/
   m_edtCleanSize.EnableWindow(FALSE);
   m_edtColorThreshold.EnableWindow(FALSE);
   m_edtBGThreshold.EnableWindow(FALSE);
   m_edtComThreshold.EnableWindow(FALSE);
   m_edtSegmentQlty.EnableWindow(FALSE);
   

   /****************Check Run Button Status ***********************/
   CheckRunStatus();

   UpdateData( FALSE );

   m_bFirstPdfLoaded = TRUE;


   FILEPDFOPTIONS PDFOption;

   L_GetPDFOptions(&PDFOption, sizeof(FILEPDFOPTIONS));
   PDFOption.nXResolution = 150;
   PDFOption.nYResolution = 150;
   L_SetPDFOptions(&PDFOption);
   	
	return TRUE;  // return TRUE  unless you set the focus to a control
}

void CPdfCompBatchDlg::OnSysCommand(UINT nID, LPARAM lParam)
{
	if ((nID & 0xFFF0) == IDM_ABOUTBOX)
	{
		CAboutDlg dlgAbout;
		dlgAbout.DoModal();
	}
	else
	{
		CDialog::OnSysCommand(nID, lParam);
	}
}

// If you add a minimize button to your dialog, you will need the code below
//  to draw the icon.  For MFC applications using the document/view model,
//  this is automatically done for you by the framework.

void CPdfCompBatchDlg::OnPaint() 
{
	if (IsIconic())
	{
		CPaintDC dc(this); // device context for painting

		SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(), 0);

		// Center icon in client rectangle
		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		// Draw the icon
		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialog::OnPaint();
	}
}

// The system calls this to obtain the cursor to display while the user drags
//  the minimized window.
HCURSOR CPdfCompBatchDlg::OnQueryDragIcon()
{
	return (HCURSOR) m_hIcon;
}

void CPdfCompBatchDlg::OnAddfile() 
{
   OPENFILENAME  OpenFileName;
   OPENDLGPARAMS DlgParams ;
   L_INT i;
   L_INT           nRet ;


   /**************** Init Open Dialog ***********************/

   memset ( &OpenFileName, 0, sizeof ( OPENFILENAME ) ) ;
   memset ( &DlgParams, 0, sizeof ( OPENDLGPARAMS ) ) ;

   OpenFileName.lStructSize       = sizeof(OPENFILENAME);
   OpenFileName.lpstrInitialDir   = NULL;
   OpenFileName.Flags             = OFN_EXPLORER | 
                                    OFN_ALLOWMULTISELECT ;

   DlgParams.uStructSize = sizeof ( OPENDLGPARAMS ) ;
   DlgParams.uDlgFlags = DLG_OPEN_SHOW_LOADROTATED     |
                         DLG_OPEN_SHOW_LOADCOMPRESSED  |
                         DLG_OPEN_SHOW_FILEINFO        |
                         DLG_OPEN_SHOW_PREVIEW;

   nRet = L_DlgOpen ( NULL, &OpenFileName, &DlgParams );
   if ( SUCCESS_DLG_OK == nRet )
   {
      m_bFirstPdfLoaded = TRUE;
      
      for(i=0; i<DlgParams.nNumOfFiles; i++)
      {
         m_lstFilesList.InsertItem(m_lstFilesList.GetItemCount(), DlgParams.pFileData[i].szFileName);
      }
      
   }
   else if(SUCCESS_DLG_CANCEL != nRet)
   {
      PDFCompError(NULL,nRet,TEXT("Add File"), TEXT(""));
   }

   CheckRunStatus();


   /****************Free Open Dialog Data***********************/

   for ( i = 0 ; i < DlgParams.nNumOfFiles ; i++ )
   {
      if( DlgParams.pFileData )
      {      
         if ( NULL != DlgParams.pFileData [ i ].pBitmap )
         {
            if ( DlgParams.pFileData [ i ].pBitmap->Flags.Allocated )
            {
               L_FreeBitmap ( DlgParams.pFileData [ i ].pBitmap ) ;
            }

            GlobalFree ( DlgParams.pFileData [ i ].pBitmap ) ;
         }

         if ( NULL != DlgParams.pFileData [ i ].pThumbnail )
         {
            if ( DlgParams.pFileData [ i ].pThumbnail->Flags.Allocated )
            {
               L_FreeBitmap ( DlgParams.pFileData [ i ].pThumbnail ) ;
            }

            GlobalFree ( DlgParams.pFileData [ i ].pThumbnail ) ;
         }

         if ( NULL != DlgParams.pFileData [ i ].pFileInfo )
         {
            GlobalFree ( DlgParams.pFileData [ i ].pFileInfo ) ;
         }

         if ( NULL != DlgParams.pFileData [ i ].FileOptions.pOptions )
         {
            GlobalFree ( DlgParams.pFileData [ i ].FileOptions.pOptions ) ;
         }
      }
   }

   if ( NULL != DlgParams.pFileData )
   {
      GlobalFree ( DlgParams.pFileData ) ;
   }

	
}

void CPdfCompBatchDlg::OnAddFolder() 
{
   BROWSEINFO   BrowseInfo ;
   LPITEMIDLIST pResult ;
   TCHAR        szPath [ MAX_PATH ] = _T ( "" ) ;
   CString      strTitle ;
   CStringArray AddFilesArray ;

   /**************** Init Browse Dialog ***********************/
   ZeroMemory ( &BrowseInfo, sizeof ( BROWSEINFO ) ) ;

   BrowseInfo.hwndOwner = m_hWnd ;
   BrowseInfo.pidlRoot  = NULL ;
   BrowseInfo.iImage    = 0 ;
   BrowseInfo.lpfn      = NULL ; 
   BrowseInfo.lpszTitle = strTitle;
   BrowseInfo.ulFlags   = 0 ;   

   pResult = ::SHBrowseForFolder ( &BrowseInfo ) ;

   

   /**************** Get Files name in the Folder ***********************/
   if ( NULL != pResult )
   {
      CString strFolderName;

      ::SHGetPathFromIDList ( pResult, szPath ) ;      
      strFolderName = szPath;

      WIN32_FIND_DATA FindData ;
      HANDLE          hFindFile ;
      CString         strSearchFolder ;


      strSearchFolder = strFolderName ;
      strSearchFolder +=  _T("\\*")  ;

      hFindFile = ::FindFirstFile ( strSearchFolder, &FindData ) ;

      if ( INVALID_HANDLE_VALUE != hFindFile )
      {
         m_bFirstPdfLoaded = TRUE;
         while ( ::FindNextFile ( hFindFile, &FindData ) )
         {
            if ( ( FILE_ATTRIBUTE_DIRECTORY & FindData.dwFileAttributes ) != FILE_ATTRIBUTE_DIRECTORY )
            {
               if ( ( FILE_ATTRIBUTE_ENCRYPTED & FindData.dwFileAttributes ) != FILE_ATTRIBUTE_ENCRYPTED &&
                    ( FILE_ATTRIBUTE_REPARSE_POINT & FindData.dwFileAttributes ) != FILE_ATTRIBUTE_REPARSE_POINT &&
                    ( FILE_ATTRIBUTE_SPARSE_FILE & FindData.dwFileAttributes ) != FILE_ATTRIBUTE_SPARSE_FILE )
               {
                  CString  strFullFileName ;
                  strFullFileName = strFolderName + _T("\\") + FindData.cFileName ;

                  L_TCHAR FileName[MAX_PATH];

                  lstrcpy(FileName, strFullFileName.GetBuffer(strFullFileName.GetLength()));
                  
                  m_lstFilesList.InsertItem(m_lstFilesList.GetItemCount(),strFullFileName.GetBuffer(MAX_PATH));
               }
            }
         }
      }
   }

   

   CheckRunStatus();
	
}

void CPdfCompBatchDlg::OnRemovefile() 
{   
   L_INT nSelection    = 0 ;
   L_INT nSelCount     = 0 ;
   L_INT nNewSelection = -1 ;


   nSelCount = m_lstFilesList.GetSelectedCount ( ) ;

   if(nSelCount > 0)
   {   
      if(nSelCount > 1)
      {
         L_INT nSelItemIndex = -1 ;
         L_INT i             = 0 ;
         CUIntArray   DeleteIndexsArray ;

         DeleteIndexsArray.RemoveAll ( ) ;

         nSelItemIndex = m_lstFilesList.GetNextItem ( -1, LVIS_SELECTED ) ;

         nNewSelection = nSelItemIndex ;

         while ( ( i < nSelCount ) && ( nSelItemIndex >= 0 ) )
         {
            DeleteIndexsArray.Add ( nSelItemIndex ) ;

            nSelItemIndex = m_lstFilesList.GetNextItem ( nSelItemIndex, 
                                                      LVIS_SELECTED ) ;      

            i++ ;
         }

         for ( L_INT j = ( DeleteIndexsArray.GetSize ( ) - 1 ) ; j >= 0 ; j-- )
         {
            m_lstFilesList.DeleteItem(DeleteIndexsArray [ j ]) ;
         }
      }
      else
      {
         nSelection = m_lstFilesList.GetNextItem ( -1, LVIS_SELECTED ) ;
         
         if ( 0 <= nSelection ) 
         {
            m_lstFilesList.DeleteItem( nSelection ) ;
         } 

         nNewSelection = nSelection ;
       }
   }

   m_lstFilesList.SetItemState ( nNewSelection,
                               LVIS_SELECTED | LVIS_FOCUSED, 
                               LVIS_SELECTED | LVIS_FOCUSED );


   CheckRunStatus();
}


void CPdfCompBatchDlg::OnSeparate() 
{
   
   m_edtSeparate.GetWindowText(m_strOutPutPath);   
	m_btnSingleBrowse.EnableWindow(FALSE);      
   m_edtSingle.EnableWindow(FALSE);
   m_btnSepBrowse.EnableWindow(TRUE);   
   m_edtSeparate.EnableWindow(TRUE); 
   m_bSingleFile = FALSE;	
   CheckRunStatus();
}

void CPdfCompBatchDlg::OnSingle() 
{
   m_edtSingle.GetWindowText(m_strOutPutPath);   
	m_btnSepBrowse.EnableWindow(FALSE);    
   m_edtSeparate.EnableWindow(FALSE);   
   m_btnSingleBrowse.EnableWindow(TRUE);   
   m_edtSingle.EnableWindow(TRUE);
   m_bSingleFile = TRUE;	
   CheckRunStatus();
}

void CPdfCompBatchDlg::OnSepbrowse() 
{
	BROWSEINFO   BrowseInfo ;
   LPITEMIDLIST pResult ;
   TCHAR        szPath [ MAX_PATH ] = _T ( "" ) ;
   CString      strTitle ;
   CStringArray AddFilesArray ;

   /**************** Init Browsee Dialog ***********************/
   
   ZeroMemory ( &BrowseInfo, sizeof ( BROWSEINFO ) ) ;

   BrowseInfo.hwndOwner = m_hWnd ;
   BrowseInfo.pidlRoot  = NULL ;
   BrowseInfo.iImage    = 0 ;
   BrowseInfo.lpfn      = NULL ; 
   BrowseInfo.lpszTitle = strTitle.GetBuffer ( strTitle.GetLength ( ) ) ;
   BrowseInfo.ulFlags   = 0 ;   

   pResult = ::SHBrowseForFolder ( &BrowseInfo ) ;

   if ( NULL != pResult )
   {
      CString strFolderName;

      ::SHGetPathFromIDList ( pResult, szPath ) ;
      strFolderName = szPath;
      m_edtSeparate.SetWindowText(strFolderName);
      m_strOutPutPath = strFolderName;
   }
}

void CPdfCompBatchDlg::OnSinglebrowse() 
{
   L_INT                nRet;
   OPENFILENAME         OpenFileName;
   SAVEDLGPARAMS        FSParm;
   L_TCHAR              szOpenFileFilter[] = TEXT("ALL\0")TEXT("*.*\0")TEXT("PDF\0")TEXT("*.pdf\0");
   L_TCHAR              szFileName[MAX_PATH];   
   FILESAVEFORMAT       Formats[1];
   FILESAVEFORMATBPP    MrcSub[1] =      {sizeof(FILESAVEFORMATBPP),24, DLG_FF_SAVE_SUB_PDF1_UNCOMPRESSED};
   
   SET_SIZE(&Formats[0]);
   Formats[0].nFormat            = DLG_FF_SAVE_PDF;
   Formats[0].nBppCount          = 1;
   Formats[0].pFileSaveFormatBpp = MrcSub;

   memset(&OpenFileName, 0, sizeof(OPENFILENAME));
   memset(&FSParm, 0, sizeof(SAVEDLGPARAMS));
   memset(szFileName, 0, sizeof(szFileName));
 
   OpenFileName.lStructSize   = sizeof(OPENFILENAME);
   OpenFileName.lpstrFile     = szFileName;
   OpenFileName.nMaxFile      = MAX_PATH;
   OpenFileName.Flags         = OFN_OVERWRITEPROMPT;
   OpenFileName.lpstrFilter   = szOpenFileFilter;
   OpenFileName.lpstrTitle    = TEXT("Save as PDF");
   OpenFileName.nFilterIndex  = 0;

   FSParm.pFileFormats = Formats;
   FSParm.uFileFormatsCount = 1;
   SET_SIZE(&FSParm);
   FSParm.nQFactor      = 2;
   FSParm.nPageNumber   = 1;
   FSParm.uSaveMulti    = TRUE;
   
   
   nRet = L_DlgSave(NULL, &OpenFileName, &FSParm);   

   if(nRet == SUCCESS_DLG_OK)
   {
      m_edtSingle.SetWindowText(FSParm.szFileName);	
      m_strOutPutPath = FSParm.szFileName;
   }
}

L_VOID CPdfCompBatchDlg::OnSelchangeInprofiles() 
{
   CheckRunStatus();
 
   /**************** Check if it User Profile ***********************/
   if(m_cmbInputProfile.GetCurSel() == 6)
   {   
      m_edtCleanSize.EnableWindow(TRUE);   
      m_edtBGThreshold.EnableWindow(TRUE);
      m_edtComThreshold.EnableWindow(TRUE);
   }
   else
   {  
      SetInputProfile();
      /*
      
      */
   }
}

void CPdfCompBatchDlg::SetInputProfile()
{
   switch(m_cmbInputProfile.GetCurSel()) 
   {
      case 0:
         m_edtBGThreshold.SetWindowText(_T("15")); 
         m_edtComThreshold.SetWindowText(_T("100"));
         m_edtCleanSize.SetWindowText(_T("7"));            
   	   break;
      case 1:
         m_edtBGThreshold.SetWindowText(_T("25")); 
         m_edtComThreshold.SetWindowText(_T("125"));
         m_edtCleanSize.SetWindowText(_T("10"));   
   	   break;
      case 2:
         m_edtBGThreshold.SetWindowText(_T("15")); 
         m_edtComThreshold.SetWindowText(_T("125"));
         m_edtCleanSize.SetWindowText(_T("8"));   
   	   break;
      case 3:
         m_edtBGThreshold.SetWindowText(_T("10")); 
         m_edtComThreshold.SetWindowText(_T("100"));
         m_edtCleanSize.SetWindowText(_T("7"));   
   	   break;
      case 4:
         m_edtBGThreshold.SetWindowText(_T("10")); 
         m_edtComThreshold.SetWindowText(_T("75"));
         m_edtCleanSize.SetWindowText(_T("3"));   
   	   break;
      case 5:
         m_edtBGThreshold.SetWindowText(_T("0")); 
         m_edtComThreshold.SetWindowText(_T("75"));
         m_edtCleanSize.SetWindowText(_T("3"));   
   	   break;      
   }


   m_edtCleanSize.EnableWindow(FALSE);   
   m_edtBGThreshold.EnableWindow(FALSE);
   m_edtComThreshold.EnableWindow(FALSE);
   
   UpdateData();
}

void CPdfCompBatchDlg::SetOutputProfile()
{
   switch(m_cmbOutputProfile.GetCurSel()) 
   {
      case 0:
         m_edtSegmentQlty.SetWindowText(_T("50"));
         m_edtColorThreshold.SetWindowText(_T("25"));      
   	   break;
      case 1:
         m_edtSegmentQlty.SetWindowText(_T("0"));
         m_edtColorThreshold.SetWindowText(_T("30"));       
   	   break;
      case 2:
         m_edtSegmentQlty.SetWindowText(_T("50"));
         m_edtColorThreshold.SetWindowText(_T("25"));      
   	   break;
      case 3:
         m_edtSegmentQlty.SetWindowText(_T("75"));
         m_edtColorThreshold.SetWindowText(_T("25"));      
   	   break;
      case 4:
         m_edtSegmentQlty.SetWindowText(_T("100"));
         m_edtColorThreshold.SetWindowText(_T("25"));      
   	   break;      
   }
   
   m_edtColorThreshold.EnableWindow(FALSE);   
   m_edtSegmentQlty.EnableWindow(FALSE);

   UpdateData();
}

void CPdfCompBatchDlg::OnSelchangeOutprofiles() 
{
   /**************** Check if it User Profile ***********************/
   if(m_cmbOutputProfile.GetCurSel() == 5)
   {   
      m_edtColorThreshold.EnableWindow(TRUE);
      m_edtSegmentQlty.EnableWindow(TRUE);
   }
   else
   {
      SetOutputProfile();      
   }
}


L_INT L_EXPORT PdfCompImageCallBack( LCPDF_HANDLE hDocument, L_INT nPage, LPSEGMENTINFO pSegment, L_VOID* pUserData )
{ 
   CPdfCompBatchDlg  *pMyDialog;

   pMyDialog = (CPdfCompBatchDlg *)pUserData;
   if( pMyDialog->m_nCurPage != nPage )
   {
      pMyDialog->m_Progress.StepIt();
      pMyDialog->m_nCurPage = nPage;      
   }
   

   return SUCCESS;
}

int CPdfCompBatchDlg::OnRun() 
{
   L_INT nRet;
   BITMAPHANDLE hBitmap;
   LCPDF_HANDLE hDocument;
   PDFCOMPOPTIONS PDFOptions;


   /**************** Update Data on all Ctrl in Main Dialog ***********************/
   nRet = UpdateData();   
   if(!nRet)
      return 0;

   m_btnRun.ShowWindow(SW_HIDE);
   m_btnAbort.ShowWindow(SW_SHOW);
   m_btnAbort.UpdateWindow();   
   m_nCurPage = 0; 
   
   /**************** Init PDFOptions Struct ***********************/
   memset(&PDFOptions,0,sizeof(PDFCOMPOPTIONS));
   PDFOptions.uStructSize = sizeof(PDFCOMPOPTIONS);

   switch(m_cmbInputProfile.GetCurSel()) 
   {

      case 0:
         PDFOptions.imageQuality = PDFCOMP_IMAGEQUALITY_UNKNOWN;
         break;
      case 1:         
         PDFOptions.imageQuality = PDFCOMP_IMAGEQUALITY_NOISY;
   	   break;
      case 2:
         PDFOptions.imageQuality = PDFCOMP_IMAGEQUALITY_SCANNED;
   	   break;
      case 3:
         PDFOptions.imageQuality = PDFCOMP_IMAGEQUALITY_PRINTED;
   	   break;
      case 4:
         PDFOptions.imageQuality = PDFCOMP_IMAGEQUALITY_COMPUTER_GENERATED;
   	   break;
      case 5:
         PDFOptions.imageQuality = PDFCOMP_IMAGEQUALITY_PHOTO;
   	   break;
    
   	  
      case 6:
         PDFOptions.imageQuality = PDFCOMP_IMAGEQUALITY_USER;
         PDFOptions.uCleanSize = m_edtnCleanSize;
         PDFOptions.uBackGroundThreshold = m_edtnBGThreshold;
         PDFOptions.uCombineThreshold = m_edtnComThreshold;
   	   break;
   }

   switch(m_cmbOutputProfile.GetCurSel()) 
   {

      case 0:
         PDFOptions.outputQuality = PDFCOMP_OUTPUTQUALITY_AUTO;
   	   break;

      case 1:         
         PDFOptions.outputQuality = PDFCOMP_OUTPUTQUALITY_POOR;
   	   break;
      case 2:
         PDFOptions.outputQuality = PDFCOMP_OUTPUTQUALITY_AVERAGE;
   	   break;
      case 3:
         PDFOptions.outputQuality = PDFCOMP_OUTPUTQUALITY_GOOD;
   	   break;
      case 4:
         PDFOptions.outputQuality = PDFCOMP_OUTPUTQUALITY_EXCELLENT;
   	   break;
        
      case 5:
         PDFOptions.outputQuality = PDFCOMP_OUTPUTQUALITY_USER;
         PDFOptions.uSegmentQuality = m_edtnSegmentQlty;
         PDFOptions.uColorThreshold = m_edtnColorThreshold;         
   	   break;
   }

   L_TCHAR strOutFile[MAX_PATH];
   L_TCHAR strInputFile[MAX_PATH];      
   L_INT nInputFiles;
   
   nInputFiles = m_lstFilesList.GetItemCount();

   /**************** Init the Progress Bar ***********************/
   for( L_INT i = m_lstFilesList.GetItemCount( ) - 1 ; i >= 0 ; i--)      
   {
      m_lstFilesList.SetItemText( i, 1, TEXT("") );
      m_lstFilesList.Update(i);
   }
   m_Progress.SetRange(0,nInputFiles);
   m_Progress.SetPos(0);
   m_Progress.SetStep(1);
   m_bInProcess = TRUE;

   DisableALL();      
   
   if(m_bSingleFile)
   {
      if(m_bCancelProcess )
      {
         return 0;
      }
      
      lstrcpy(strOutFile,m_strOutPutPath);     

      /**************** Init Pdf Compressor ***********************/
      nRet = L_PdfCompInit(&hDocument,(pPDFCOMP_IMAGECALLBACK)PdfCompImageCallBack, this );
      if(nRet != SUCCESS)
      {
         EnableALL();
         DisplayLEADError(nRet);
         return nRet;
      }

      PDFCOMPRESSION pdfComp;

      pdfComp.uStructSize = sizeof( pdfComp );
      pdfComp.dwFlags = PDFCOMP_1BITCOMPTYPE_ENABLED | PDFCOMP_2BITCOMPTYPE_ENABLED | PDFCOMP_PICTURECOMPTYPE_ENABLED;
      pdfComp.comp1Bit = (PDFCOMP_1BITCOMPTYPE)m_AdvancedOptions.m_n1Bit;
      pdfComp.comp2Bit = (PDFCOMP_2BITCOMPTYPE)m_AdvancedOptions.m_n2Bit;
      pdfComp.compPicture = (PDFCOMP_PICTURECOMPTYPE)m_AdvancedOptions.m_nPict;
      pdfComp.nQFactor = m_AdvancedOptions.m_nQFactor;         

      nRet = L_PdfCompSetCompression( hDocument, &pdfComp );
      if(nRet != SUCCESS)
      {
         L_PdfCompFree( hDocument );
         EnableALL();
         DisplayLEADError(nRet);
         return nRet;
      }

      PDFOptions.dwFlags |= m_AdvancedOptions.m_nSeg;
      if( FALSE == m_AdvancedOptions.m_bCheckBackground )
         PDFOptions.dwFlags |= PDFCOMP_WITHOUT_BACKGROUND;



      for( i = 0; i<nInputFiles; i++)
      {         
         if(m_bAbortProcess)
         {
            EnableALL();
            MessageBox(TEXT("Process Aborted"));
            m_Progress.SetPos(0);
            L_PdfCompFree(hDocument);
            m_bAbortProcess = FALSE;
            return 0;
         }
         m_lstFilesList.GetItemText(i,0,strInputFile,MAX_PATH);

         m_strStatus = "Processing file: ";
         m_strStatus += strInputFile;
         UpdateData( FALSE );
         
         /**************** Load the input file ***********************/
         FILEINFO FileInfo;
         nRet = L_FileInfo(strInputFile, &FileInfo, sizeof(FILEINFO), FILEINFO_TOTALPAGES, NULL);
         if(nRet != SUCCESS)
         {
            m_Progress.SetPos(0);
            m_Progress.StepIt();            
            m_lstFilesList.SetItemText( i, 1, TEXT("Failed!") );
            m_lstFilesList.Update(i);
            continue;            
         }
         
         if(FileInfo.Format == FILE_RAS_PDF)
         {
            if(m_bFirstPdfLoaded)
            {
               FILEPDFOPTIONS PDFOption;
               L_GetPDFOptions(&PDFOption, sizeof(FILEPDFOPTIONS));

               CPDFDPIOptions DPIOptions;            
               DPIOptions.m_nXResolution = PDFOption.nXResolution;
               DPIOptions.m_nYResolution = PDFOption.nYResolution;

               if( IDOK == DPIOptions.DoModal() )
               {
                  PDFOption.nXResolution = DPIOptions.m_nXResolution;
                  PDFOption.nYResolution = DPIOptions.m_nYResolution;
                   
                  L_SetPDFOptions( &PDFOption );
                  m_bFirstPdfLoaded = FALSE;
               }
            }
         }    

         LOADFILEOPTION LoadOptions;
         nRet = L_GetDefaultLoadFileOption(&LoadOptions, sizeof(LOADFILEOPTION));
         if(nRet != SUCCESS)
         {
            m_Progress.SetPos(0);
            m_Progress.StepIt();            
            m_lstFilesList.SetItemText( i, 1, TEXT("Failed!") );
            m_lstFilesList.Update(i);
            continue;            
         }   
         
         for(L_INT nPageNumber = 0 ; nPageNumber < FileInfo.TotalPages; nPageNumber++)
         {   
            LoadOptions.PageNumber = nPageNumber + 1;
            
            nRet = L_LoadBitmap(strInputFile, &hBitmap,sizeof(BITMAPHANDLE),0,ORDER_BGRORGRAY,&LoadOptions,NULL);
            if(nRet != SUCCESS)
            {
               if(nRet == ERROR_PDF_BAD_INITIALIZATION_FILES)
               {
                  if( IDYES == MessageBox ( TEXT("LEADTOOLS PDF plugin is not found, do you want to download the plugin now?"),
                                         TEXT("Open File"),MB_ICONEXCLAMATION | MB_YESNO))
                  {
                     ShellExecute(m_hWnd, TEXT("open"), TEXT("http://www.leadtools.com/ReleaseDownloads/v14/LEADTOOLSPDFRuntime.exe"), 
                                  NULL, NULL, SW_SHOWNORMAL);
                  }
               }
               m_Progress.SetPos(0);
               m_Progress.StepIt();            
               m_lstFilesList.SetItemText( i, 1, TEXT("Failed!") );
               m_lstFilesList.Update(i);
               continue;            
            }         

            /**************** send the input file to Pdf Compressor ***********************/
            nRet = L_PdfCompInsertMRC(hDocument,&hBitmap,&PDFOptions);
            if(nRet != SUCCESS)
            {
               m_Progress.SetPos(0);
               EnableALL();
               DisplayLEADError(nRet);
               L_PdfCompFree(hDocument);
               return nRet;
            }

            m_lstFilesList.SetItemText( i, 1, TEXT("SUCCESS!") );
            m_lstFilesList.Update(i);
         }
         
         
         WaitForAppIdle();
      }
      
      /**************** Write Pdf Compressor Data to output file ***********************/
      nRet = L_PdfCompWrite(hDocument,strOutFile);
      if(nRet != SUCCESS)
      {
         m_Progress.SetPos(0);
         EnableALL();
         DisplayLEADError(nRet);
         L_PdfCompFree(hDocument);
         return nRet;
      }
      
      L_PdfCompFree(hDocument);
   }
   else
   {
      for(L_INT i=0; i<nInputFiles; i++)
      {
         if(m_bCancelProcess )
         {
            return 0;
         }
         if(m_bAbortProcess)
         {
            EnableALL();
            MessageBox(TEXT("Process Aborted"));            
            m_Progress.SetPos(0);
            m_bAbortProcess = FALSE;
            return 0;
         }

         lstrcpy(strOutFile,m_strOutPutPath);
         L_INT nLen = lstrlen(strOutFile);
         if(lstrcmp(&strOutFile[nLen-1], _T("\\")) == 0)
            strOutFile[nLen-1] = 0;

         m_lstFilesList.GetItemText(i,0,strInputFile,MAX_PATH);

         CString Tmp = strInputFile;
         CString File ;
         L_INT     nStringLength = 0 ;

         nStringLength = Tmp.ReverseFind('\\');
         nStringLength = Tmp.GetLength ( ) - nStringLength ;
         Tmp = Tmp.Right(nStringLength);

         nStringLength = Tmp.ReverseFind ( '.' ) ;
         File = Tmp.Left( nStringLength );
         lstrcat (strOutFile , File.GetBuffer(File.GetLength()));
         lstrcat(strOutFile ,_T(".pdf"));


         /**************** Init Pdf Compressor ***********************/
         nRet = L_PdfCompInit(&hDocument,(pPDFCOMP_IMAGECALLBACK)PdfCompImageCallBack, this );
         if(nRet != SUCCESS)
         {
            m_Progress.SetPos(0);
            EnableALL();
            DisplayLEADError(nRet);
            return nRet;
         }

         
         PDFCOMPRESSION pdfComp;

         pdfComp.uStructSize = sizeof( pdfComp );
         pdfComp.dwFlags = PDFCOMP_1BITCOMPTYPE_ENABLED | PDFCOMP_2BITCOMPTYPE_ENABLED | PDFCOMP_PICTURECOMPTYPE_ENABLED;
         pdfComp.comp1Bit = (PDFCOMP_1BITCOMPTYPE)m_AdvancedOptions.m_n1Bit;
         pdfComp.comp2Bit = (PDFCOMP_2BITCOMPTYPE)m_AdvancedOptions.m_n2Bit;
         pdfComp.compPicture = (PDFCOMP_PICTURECOMPTYPE)m_AdvancedOptions.m_nPict;
         pdfComp.nQFactor = m_AdvancedOptions.m_nQFactor;            

         nRet = L_PdfCompSetCompression( hDocument, &pdfComp );
         if(nRet != SUCCESS)
         {
            L_PdfCompFree( hDocument );
            m_Progress.SetPos(0);
            EnableALL();
            DisplayLEADError(nRet);
            return nRet;
         }

         PDFOptions.dwFlags |= m_AdvancedOptions.m_nSeg;
         if( FALSE == m_AdvancedOptions.m_bCheckBackground )
            PDFOptions.dwFlags |= PDFCOMP_WITHOUT_BACKGROUND;
         


         m_strStatus = "Processing file: ";
         m_strStatus += strInputFile;
         UpdateData( FALSE );
         

         FILEINFO FileInfo;
         nRet = L_FileInfo(strInputFile, &FileInfo, sizeof(FILEINFO), FILEINFO_TOTALPAGES, NULL);
         if(nRet != SUCCESS)
         {
            m_Progress.SetPos(0);
            m_Progress.StepIt();            
            m_lstFilesList.SetItemText( i, 1, TEXT("Failed!") );
            m_lstFilesList.Update(i);
            continue;            
         } 

         if(FileInfo.Format == FILE_RAS_PDF)
         {
            if(m_bFirstPdfLoaded)
            {
               FILEPDFOPTIONS PDFOption;
               L_GetPDFOptions(&PDFOption, sizeof(FILEPDFOPTIONS));

               CPDFDPIOptions DPIOptions;            
               DPIOptions.m_nXResolution = PDFOption.nXResolution;
               DPIOptions.m_nYResolution = PDFOption.nYResolution;

               if( IDOK == DPIOptions.DoModal() )
               {
                  PDFOption.nXResolution = DPIOptions.m_nXResolution;
                  PDFOption.nYResolution = DPIOptions.m_nYResolution;
                   
                  L_SetPDFOptions( &PDFOption );
                  m_bFirstPdfLoaded = FALSE;
               }
            }
         }

         LOADFILEOPTION LoadOptions;
         nRet = L_GetDefaultLoadFileOption(&LoadOptions, sizeof(LOADFILEOPTION));
         if(nRet != SUCCESS)
         {
            m_Progress.SetPos(0);
            m_Progress.StepIt();            
            m_lstFilesList.SetItemText( i, 1, TEXT("Failed!") );
            m_lstFilesList.Update(i);
            continue;            
         }   
         
         for(L_INT nPageNumber = 0 ; nPageNumber < FileInfo.TotalPages; nPageNumber++)
         {   
            LoadOptions.PageNumber = nPageNumber + 1;
         /**************** Load the input file ***********************/
            nRet = L_LoadBitmap(strInputFile, &hBitmap,sizeof(BITMAPHANDLE),0,ORDER_BGRORGRAY,&LoadOptions,NULL);
            if(nRet != SUCCESS)
            { 
               if(nRet == ERROR_PDF_BAD_INITIALIZATION_FILES)
               {
                  if( IDYES == MessageBox ( TEXT("LEADTOOLS PDF plugin is not found, do you want to download the plugin now?"),
                                         TEXT("Open File"),MB_ICONEXCLAMATION | MB_YESNO))
                  {
                     ShellExecute(m_hWnd, TEXT("open"), TEXT("http://www.leadtools.com/ReleaseDownloads/v14/LEADTOOLSPDFRuntime.exe"), 
                                  NULL, NULL, SW_SHOWNORMAL);
                  }
               }
               m_Progress.SetPos(0);
               m_lstFilesList.SetItemText( i, 1, TEXT("Failed!") );
               m_lstFilesList.Update(i);
               m_Progress.StepIt();            
               continue;
            }

            /**************** send the input file to Pdf Compressor ***********************/
            nRet = L_PdfCompInsertMRC(hDocument,&hBitmap,&PDFOptions);
            if(nRet != SUCCESS)
            {
               m_Progress.SetPos(0);
               EnableALL();
               DisplayLEADError(nRet);
               L_PdfCompFree(hDocument);
               return nRet;
            }
         }
         /**************** Write Pdf Compressor Data to output file ***********************/
         nRet = L_PdfCompWrite(hDocument,strOutFile);
         if(nRet != SUCCESS)
         {            
            m_Progress.SetPos(0);
            EnableALL();
            DisplayLEADError(nRet);
            L_PdfCompFree(hDocument);            
            return nRet;
         }
         
         m_lstFilesList.SetItemText( i, 1, TEXT("SUCCESS!") );
         m_lstFilesList.Update(i);
      
         L_PdfCompFree(hDocument);
         m_nCurPage = 0;
         
         WaitForAppIdle();
      }

   }   

   
   m_bInProcess = FALSE;      
   EnableALL();
   m_Progress.SetPos(0);
   m_strStatus = "Idle";   
   UpdateData( FALSE );

   if(m_bAbortProcess)
   {
      MessageBox(TEXT("Process Aborted"));      
      m_bAbortProcess = FALSE;
   }
   
   return 0;
}

void CPdfCompBatchDlg::OnChangeCleansizevalue() 
{
   CheckRunStatus();
}

void CPdfCompBatchDlg::CheckRunStatus()
{
   CString csValue1;
   m_edtCleanSize.GetWindowText(csValue1);
   CString csValue2;
   m_edtBGThreshold.GetWindowText(csValue2);
   CString csValue3;
   m_edtColorThreshold.GetWindowText(csValue3);
   CString csValue4;
   m_edtComThreshold.GetWindowText(csValue4);
   CString csValue5;
   m_edtSegmentQlty.GetWindowText(csValue5);

   L_BOOL bEdt;
   if(m_bSingleFile)
   {   
      CString csValue6;
      m_edtSingle.GetWindowText(csValue6);
      bEdt = !csValue6.IsEmpty();
   }
   else
   {
      CString csValue7;
      m_edtSeparate.GetWindowText(csValue7);
      bEdt = !csValue7.IsEmpty();
   }
   
   m_btnRun.EnableWindow((!csValue1.IsEmpty() 
          && !csValue2.IsEmpty() 
          && !csValue3.IsEmpty()
          && !csValue4.IsEmpty()
          &&  !csValue5.IsEmpty())&&
          m_lstFilesList.GetItemCount() &&
          bEdt);
}

void CPdfCompBatchDlg::OnChangeBgthresholdvalue() 
{
	CheckRunStatus();
}

void CPdfCompBatchDlg::OnChangeComthresholdvalue() 
{
   CheckRunStatus();
}

void CPdfCompBatchDlg::OnChangeSegqltyvalue() 
{
   CheckRunStatus();
}

void CPdfCompBatchDlg::OnChangeColorthresholdvalue() 
{
   CheckRunStatus();
}

void CPdfCompBatchDlg::OnChangeSingle() 
{
   CheckRunStatus();
   m_edtSingle.GetWindowText(m_strOutPutPath);
}

void CPdfCompBatchDlg::OnChangeSeparate() 
{
   CheckRunStatus();	
   m_edtSeparate.GetWindowText(m_strOutPutPath);
}


L_INT CPdfCompBatchDlg::DisplayLEADError(L_INT nCode)
{
   CString str;
   
   if((nCode == SUCCESS || nCode == ERROR_USER_ABORT))   
      nCode = 0;   
   if(ERROR_FILE_OPEN == nCode)
   {      
      MessageBox(TEXT("Couldn't save the file, the file in use"));      
   }
   else if(nCode)
   {
      str.Format(TEXT("A LEADTOOLS error has occured.\nCODE = %d"), nCode);
      MessageBox(str);
   }
   return(nCode);
}

L_VOID CPdfCompBatchDlg::DisableALL(L_VOID)
{
   m_edtBGThreshold.EnableWindow(FALSE);
   m_edtCleanSize.EnableWindow(FALSE);
   m_edtColorThreshold.EnableWindow(FALSE);
   m_edtComThreshold.EnableWindow(FALSE);
   m_edtSegmentQlty.EnableWindow(FALSE);
   m_edtSeparate.EnableWindow(FALSE);
   m_edtSingle.EnableWindow(FALSE);
   m_cmbInputProfile.EnableWindow(FALSE);   
   m_cmbOutputProfile.EnableWindow(FALSE);
   m_btnRun.EnableWindow(FALSE);
   m_btnSepBrowse.EnableWindow(FALSE);
   m_btnSingleBrowse.EnableWindow(FALSE);
   m_btnAddFile.EnableWindow(FALSE);
   m_btnAddFolder.EnableWindow(FALSE);
   m_btnOptions.EnableWindow(FALSE);
   m_btnRemove.EnableWindow(FALSE);
   m_rbtnSeperate.EnableWindow(FALSE);
   m_rbtnSingle.EnableWindow(FALSE);
   UpdateWindow();

}

L_VOID CPdfCompBatchDlg::EnableALL(L_VOID)
{
   m_btnAbort.ShowWindow(SW_HIDE);
   m_btnRun.ShowWindow(SW_SHOW);
   m_btnRun.UpdateWindow();

   if(m_cmbOutputProfile.GetCurSel() == 5)
   {   
      m_edtColorThreshold.EnableWindow(TRUE);
      m_edtSegmentQlty.EnableWindow(TRUE);
   }

   if(m_cmbInputProfile.GetCurSel() == 6)
   {   
      m_edtCleanSize.EnableWindow(TRUE);   
      m_edtBGThreshold.EnableWindow(TRUE);
      m_edtComThreshold.EnableWindow(TRUE);
   }
   
   
   if(m_bSingleFile)
   {
      m_edtSingle.EnableWindow(TRUE);
      m_btnSingleBrowse.EnableWindow(TRUE);            

   }
   else
   {
      m_edtSeparate.EnableWindow(TRUE);   
      m_btnSepBrowse.EnableWindow(TRUE);      
   }

   m_rbtnSeperate.EnableWindow(TRUE);      
   m_rbtnSingle.EnableWindow(TRUE);
   m_cmbInputProfile.EnableWindow(TRUE);
   m_cmbOutputProfile.EnableWindow(TRUE);
   m_btnRun.EnableWindow(TRUE);
   m_btnAddFile.EnableWindow(TRUE);
   m_btnAddFolder.EnableWindow(TRUE);
   m_btnRemove.EnableWindow(TRUE);
   m_btnOptions.EnableWindow(TRUE);

   UpdateWindow();
}

void CPdfCompBatchDlg::OnAbort() 
{
	m_bAbortProcess = TRUE;
	
}


void CPdfCompBatchDlg::WaitForAppIdle ( ) 
{
   MSG msg ;
   
   
   while ( AfxIsValidAddress ( AfxGetApp ( ), sizeof ( CWinApp ) ) && 
           ::PeekMessage ( &msg, NULL, NULL, NULL, PM_NOREMOVE ) ) 
   {
      AfxGetApp ( )->PumpMessage ( ) ;
   }

}

void CPdfCompBatchDlg::OnKeydownFileslist(NMHDR* pNMHDR, LRESULT* pResult) 
{
	LV_KEYDOWN* pLVKeyDow = (LV_KEYDOWN*)pNMHDR;

   if(VK_DELETE == pLVKeyDow->wVKey)
   {
      CPdfCompBatchDlg::OnRemovefile() ;
   }
	
	*pResult = 0;
}



void CPdfCompBatchDlg::OnClose() 
{
	m_bCancelProcess = TRUE;
	
	CDialog::OnClose();
}

void CPdfCompBatchDlg::OnOptions() 
{
   m_AdvancedOptions.DoModal();   	
}



L_VOID PDFCompError(HWND hwnd, L_INT nCode, L_TCHAR* pTitle, L_TCHAR* pFilename)
{
   L_TCHAR ErrorBuf[1024];
   switch (nCode)
   {
   case ERROR_NO_MEMORY:
      strprintf (ErrorBuf, TEXT("Not enough memory available!"));
      break;
   case ERROR_NO_BITMAP:
      strprintf (ErrorBuf, TEXT("Invalid bitmap handle!"));
      break;
   case ERROR_MEMORY_TOO_LOW:
      strprintf (ErrorBuf, TEXT("Not enough memory available!"));
      break;
   case ERROR_FILE_LSEEK:
      strprintf (ErrorBuf, TEXT("Error seeking to position!"));
      break;
   case ERROR_FILE_WRITE:
      strprintf (ErrorBuf, TEXT("Error writing file!"));
      break;
   case ERROR_FILE_GONE:
      strprintf (ErrorBuf, TEXT("File not present - abort!"));
      break;
   case ERROR_FILE_READ:
      strprintf (ErrorBuf, TEXT("Error reading file!"));
      break;
   case ERROR_INV_FILENAME:
      strprintf (ErrorBuf, TEXT("Invalid filename specified!"));
      break;
   case ERROR_FILE_FORMAT:
      strprintf (ErrorBuf, TEXT("Invalid file format!"));
      break;
   case ERROR_FILENOTFOUND:
      strprintf (ErrorBuf, TEXT("File not found!"));
      break;
   case ERROR_INV_RANGE:
      strprintf (ErrorBuf, TEXT("Invalid width/height!"));
      break;
   case ERROR_IMAGE_TYPE:
      strprintf (ErrorBuf, TEXT("Image format recognized, but sub-type not supported!"));
      break;
   case ERROR_INV_PARAMETER:
      strprintf (ErrorBuf, TEXT("Invalid parameter!"));
      break;
   case ERROR_FILE_OPEN:
      strprintf (ErrorBuf, TEXT("Not able to open file!"));
      break;
   case ERROR_UNKNOWN_COMP:
      strprintf (ErrorBuf, TEXT("Unknown compression format!"));
      break;
   case ERROR_FEATURE_NOT_SUPPORTED:
      strprintf (ErrorBuf, TEXT("Feature not supported!"));
      break;
   case ERROR_NOT_256_COLOR:
      strprintf (ErrorBuf, TEXT("VGA card only supports 256 colors (8 bit)!"));
      break;
   case ERROR_PRINTER:
      strprintf (ErrorBuf, TEXT("Printer error!"));
      break;
   case ERROR_CRC_CHECK:
      strprintf (ErrorBuf, TEXT("Data CRC check error!"));
      break;
   case ERROR_QFACTOR:
      strprintf (ErrorBuf, TEXT("Invalid QFactor specified!"));
      break;
   case ERROR_TARGAINSTALL:
      strprintf (ErrorBuf, TEXT("TARGA not installed!"));
      break;
   case ERROR_OUTPUTTYPE:
      strprintf (ErrorBuf, TEXT("Invalid compression format!"));
      break;
   case ERROR_XORIGIN:
      strprintf (ErrorBuf, TEXT("X origin specified invalid!"));
      break;
   case ERROR_YORIGIN:
      strprintf (ErrorBuf, TEXT("Y origin specified invalid!"));
      break;
   case ERROR_VIDEOTYPE:
      strprintf (ErrorBuf, TEXT("Invalid video mode!"));
      break;
   case ERROR_BITPERPIXEL:
      strprintf (ErrorBuf, TEXT("Invalid bits/pixel!"));
      break;
   case ERROR_WINDOWSIZE:
      strprintf (ErrorBuf, TEXT("Invalid window size!"));
      break;
   case ERROR_NORMAL_ABORT:
      strprintf (ErrorBuf, TEXT("Escape key pressed!"));
      break;
   case ERROR_NO_STAMP:
      strprintf (ErrorBuf, TEXT("Stamp not found!"));
      break;
   case ERROR_G3CODE_INVALID:
      strprintf (ErrorBuf, TEXT("Invalid group 3 data!"));
      break;
   case ERROR_G3CODE_EOF:
   case ERROR_G3CODE_EOL:
      strprintf (ErrorBuf, TEXT("Group3 code end of code!"));
      break;
   case ERROR_PREMATURE_EOF:
      strprintf (ErrorBuf, TEXT("Premature EOF at scanline!"));
      break;
   case ERROR_PREMATURE_EOL:
   case ERROR_UNCOMP_EOF:
   case ERROR_ACT_INCOMP:
   case ERROR_BAD_DECODE_STATE:
      strprintf (ErrorBuf, TEXT("Premature end-of-line code!"));
      break;
   case ERROR_VERSION_NUMBER:
      strprintf (ErrorBuf, TEXT("Bad version number!"));
      break;
   case ERROR_TWAIN_NODSM:
      strprintf (ErrorBuf, TEXT("Source manager not found!"));
      break;
   case ERROR_TWAIN_BUMMER:
      strprintf (ErrorBuf, TEXT("Failure due to unknown causes!"));
      break;
   case ERROR_TWAIN_LOWMEMORY:
      strprintf (ErrorBuf, TEXT("Not enough memory to perform operation!"));
      break;
   case ERROR_TWAIN_NODS:
      strprintf (ErrorBuf, TEXT("No Data Source!"));
      break;
   case ERROR_TWAIN_MAXCONNECTIONS:
      strprintf (ErrorBuf, TEXT("DS is connected to max possible apps!"));
      break;
   case ERROR_TWAIN_OPERATIONERROR:
      strprintf (ErrorBuf, TEXT("DS or DSM reported error, app shouldn't!"));
      break;
   case ERROR_TWAIN_BADCAP:
      strprintf (ErrorBuf, TEXT("Unknown capability!"));
      break;
   case ERROR_TWAIN_BADPROTOCOL:
      strprintf (ErrorBuf, TEXT("Unrecognized MSG DG DAT combination!"));
      break;
   case ERROR_TWAIN_BADVALUE:
      strprintf (ErrorBuf, TEXT("Data parameter out of range!"));
      break;
   case ERROR_TWAIN_SEQERROR:
      strprintf (ErrorBuf, TEXT("DG DAT MSG out of expected sequence!"));
      break;
   case ERROR_TWAIN_BADDEST:
      strprintf (ErrorBuf, TEXT("Unknown destination App/Src in DSM_Entry!"));
      break;
   case ERROR_NOT_ENOUGH_IMAGES:
      strprintf (ErrorBuf, TEXT("Not enough images to complete the process!"));
      break;
   case ERROR_IMAGE_EMPTY:
      strprintf (ErrorBuf, TEXT("Image is empty!"));
      break;
   case ERROR_NO_CHANGE:
      strprintf (ErrorBuf, TEXT("The image hasn't changed!"));
      break;
   case ERROR_LZW_LOCKED:
      strprintf (ErrorBuf, TEXT("LZW capability is required to load/save this file!"));
      break;
   case ERROR_DOCUMENT_NOT_ENABLED:
      strprintf (ErrorBuf, TEXT("Express capability is required to use this function!"));
      break;
   case ERROR_MEDICAL_NOT_ENABLED:
      strprintf (ErrorBuf, TEXT("Medical Express capability is required to use this function!"));
      break;
   case ERROR_JBIG_NOT_ENABLED:
      strprintf (ErrorBuf, TEXT("JBIG capability is required to use this function!"));
      break;
   case ERROR_FPX_FILE_IN_USE:
      strprintf (ErrorBuf, TEXT("Error accessing file. The file is probably already open!"));
      break;

   case ERROR_USER_ABORT:
   case SUCCESS_DLG_CANCEL:
      return;
      break;
  
   default:
      if(nCode >= ERROR_FPX_INVALID_FORMAT_ERROR && nCode <= ERROR_FPX_INVALID_TILE)
         strprintf (ErrorBuf, TEXT("Internal FlashPix error!"));
      else
         strprintf (ErrorBuf, TEXT("Internal or Unrecognized Error!"));
      break;
   }

   PDFCompMessageBox (hwnd, pTitle, MB_ICONEXCLAMATION | MB_OK,
    TEXT("%s\nLEADTOOLS DLL Error (%d)\n%s"), pFilename, nCode, ErrorBuf);

   return;
}





L_INT PDFCompMessageBox (HWND hWnd, L_TCHAR* pCaption, UINT wType, L_TCHAR* pFormat,...)
{
   L_TCHAR szText[256];

   va_list ap;
   va_start (ap, pFormat);

   wvsprintf (szText, pFormat, ap);

   va_end (ap);
   return (MessageBox (hWnd, szText, pCaption, wType));
}