// FASTTWNDlg.cpp : implementation file
//

#include "stdafx.h"
#include "FASTTWN.h"
#include "FASTTWNDlg.h"

#include "windowsx.h"

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

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

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

// Dialog Data
   //{{AFX_DATA(CAboutDlg)
   enum { IDD = IDD_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)
   //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CFASTTWNDlg dialog

CFASTTWNDlg::CFASTTWNDlg(CWnd* pParent /*=NULL*/)
   : CDialog(CFASTTWNDlg::IDD, pParent)
{
   //{{AFX_DATA_INIT(CFASTTWNDlg)
   m_uCustomBufferSize = 0;
   m_bUseCustomBuffer = FALSE;
   m_csBaseFName = _T("");
   //}}AFX_DATA_INIT
   // Note that LoadIcon does not require a subsequent DestroyIcon in Win32
   m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);

   m_uTransMode  = L_LTWAIN_BUFFER_MODE;

   m_pnBPP       = NULL;
   m_nAllBPPCount= 0;
   m_nFormat     = FILE_TIF;

   m_pltRasTwain = NULL;
   m_pltRasterIO = NULL;
   m_pltRaster   = NULL;

   m_nSaveFormat = FILE_TIF;
   m_nSaveBPP    = 1;
   m_csSaveFName = "";
   m_nSaveQFactor= 0;
   m_pRasterTwainSink = NULL;
   m_nPageCount = 0;

   memset(m_nMemFormat, 0, sizeof(m_nMemFormat));
   memset(m_bMemMulti, 0, sizeof(m_bMemMulti));
}

void CFASTTWNDlg::DoDataExchange(CDataExchange* pDX)
{
   CDialog::DoDataExchange(pDX);
   //{{AFX_DATA_MAP(CFASTTWNDlg)
   DDX_Control(pDX, IDC_BROWSE_FILE_NAME, m_btnBrowseFName);
   DDX_Control(pDX, IDC_SEL_LEAD_FORMATS, m_btnLTFormats);
   DDX_Control(pDX, IDC_CMB_FILE_FORMAT, m_cmbFileFormats);
   DDX_Control(pDX, IDC_ACQUIRE, m_btnAcquire);
   DDX_Control(pDX, IDC_EDIT_CUSTOM_BUFFER_SIZE, m_EdtCustomBuffer);
   DDX_Control(pDX, IDC_EDIT_BASE_FNAME, m_EdtBaseFName);
   DDX_Control(pDX, IDC_CHK_USE_CUSTOM_BUF_SIZE, m_chkUseBuffer);
   DDX_Text(pDX, IDC_EDIT_CUSTOM_BUFFER_SIZE, m_uCustomBufferSize);
   DDX_Check(pDX, IDC_CHK_USE_CUSTOM_BUF_SIZE, m_bUseCustomBuffer);
   DDX_Text(pDX, IDC_EDIT_BASE_FNAME, m_csBaseFName);
//   DDX_Control(pDX, IDC_LEADRASTERDLG, m_LEADRasterDlg);
   //}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CFASTTWNDlg, CDialog)
   //{{AFX_MSG_MAP(CFASTTWNDlg)
   ON_WM_SYSCOMMAND()
   ON_WM_PAINT()
   ON_WM_QUERYDRAGICON()
   ON_BN_CLICKED(IDC_RADIO_FILE_MODE, OnRadioFileMode)
   ON_BN_CLICKED(IDC_RADIO_MEM_MODE, OnRadioMemMode)
   ON_BN_CLICKED(IDC_RADIO_NTV_MODE, OnRadioNtvMode)
   ON_WM_CREATE()
   ON_WM_DESTROY()
   ON_BN_CLICKED(IDC_ACQUIRE, OnAcquire)
   ON_BN_CLICKED(IDC_SELECT, OnSelect)
   ON_BN_CLICKED(IDC_CHK_USE_CUSTOM_BUF_SIZE, OnChkUseCustomBufSize)
   ON_EN_CHANGE(IDC_EDIT_BASE_FNAME, OnChangeEditBaseFName)
   ON_BN_CLICKED(IDC_NORMAL_ACQUIRE, OnNormalAcquire)
   ON_BN_CLICKED(IDC_SEL_LEAD_FORMATS, OnSelLeadFormats)
   ON_BN_CLICKED(IDC_BROWSE_FILE_NAME, OnBrowseFileName)
   //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CFASTTWNDlg message handlers

BOOL CFASTTWNDlg::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

   /*****************************************************************************/
   GetDlgItem(IDC_RADIO_MEM_MODE)->EnableWindow(m_bEnableTwain);
   GetDlgItem(IDC_RADIO_NTV_MODE)->EnableWindow(m_bEnableTwain);
   GetDlgItem(IDC_RADIO_FILE_MODE)->EnableWindow(m_bEnableTwain);
   GetDlgItem(IDC_CHK_USE_CUSTOM_BUF_SIZE)->EnableWindow(m_bEnableTwain);
   GetDlgItem(IDC_EDIT_CUSTOM_BUFFER_SIZE)->EnableWindow(m_bEnableTwain);
   GetDlgItem(IDC_CMB_FILE_FORMAT)->EnableWindow(m_bEnableTwain);
   GetDlgItem(IDC_EDIT_BASE_FNAME)->EnableWindow(m_bEnableTwain);
   GetDlgItem(IDC_BROWSE_FILE_NAME)->EnableWindow(m_bEnableTwain);
   GetDlgItem(IDC_SEL_LEAD_FORMATS)->EnableWindow(m_bEnableTwain);
   GetDlgItem(IDC_SELECT)->EnableWindow(m_bEnableTwain);
   GetDlgItem(IDC_ACQUIRE)->EnableWindow(m_bEnableTwain);
   GetDlgItem(IDC_NORMAL_ACQUIRE)->EnableWindow(m_bEnableTwain);

   if(m_bEnableTwain)
      CheckTransferMode();
   
   HRESULT hr = ::CoCreateInstance(CLSID_LEADRasterDlgKrn, NULL, CLSCTX_ALL,
            IID_ILEADRasterDlgKrn, (void**)&m_pRasterKrnDlg);
   if (FAILED (hr) || (m_pRasterKrnDlg == NULL))
   {
      m_pRasterKrnDlg ->Release ();
      m_pRasterKrnDlg = NULL;
   }
   m_pRasterKrnDlg->InitDlg(INIT_WITH_COLOR);
   
   m_pRasterFileDlg = NULL;
   hr = ::CoCreateInstance(CLSID_LEADRasterDlgFile, NULL, CLSCTX_ALL,
            IID_ILEADRasterDlgFile, (void**)&m_pRasterFileDlg);
   if (FAILED (hr) || (m_pRasterFileDlg == NULL))
   {
      m_pRasterFileDlg->Release ();
      m_pRasterFileDlg = NULL;
   }   

   m_pRasterFileDlg->PutEnableMethodErrors(FALSE);

   return TRUE;
}

void CFASTTWNDlg::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 CFASTTWNDlg::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 CFASTTWNDlg::OnQueryDragIcon()
{
   return (HCURSOR) m_hIcon;
}

int CFASTTWNDlg::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
   m_bEnableTwain = FALSE;
   if (CDialog::OnCreate(lpCreateStruct) == -1)
      return -1;

   HRESULT hr = CoCreateInstance(CLSID_LEADRaster, NULL, CLSCTX_ALL, IID_ILEADRaster, (void**)&m_pltRaster);
   if (FAILED(hr))
      return -1;

   hr = CoCreateInstance(CLSID_LEADRasterIO, NULL, CLSCTX_ALL, IID_ILEADRasterIO, (void**)&m_pltRasterIO);
   if (FAILED(hr))
   {
      m_pltRaster->Release();
      m_pltRaster = NULL;

      return -1;
   }

   m_pltRaster->UnlockSupport(L_SUPPORT_DOCUMENT, L_KEY_DOCUMENT);
   m_pltRaster->UnlockSupport(L_SUPPORT_GIFLZW, L_KEY_GIFLZW);
   m_pltRaster->UnlockSupport(L_SUPPORT_TIFLZW, L_KEY_TIFLZW);
   m_pltRaster->UnlockSupport(L_SUPPORT_OCR, L_KEY_OCR);
   m_pltRaster->UnlockSupport(L_SUPPORT_MEDICAL, L_KEY_MEDICAL);
   m_pltRaster->UnlockSupport(L_SUPPORT_VECTOR, L_KEY_VECTOR);
   m_pltRaster->UnlockSupport(L_SUPPORT_MEDICAL_NET, L_KEY_MEDICAL_NET);
   m_pltRaster->UnlockSupport(L_SUPPORT_BARCODES_1D, L_KEY_BARCODES_1D);
   m_pltRaster->UnlockSupport(L_SUPPORT_BARCODES_2D_READ, L_KEY_BARCODES_2D_READ);
   m_pltRaster->UnlockSupport(L_SUPPORT_BARCODES_2D_WRITE, L_KEY_BARCODES_2D_WRITE);
   m_pltRaster->UnlockSupport(L_SUPPORT_BARCODES_PDF_READ, L_KEY_BARCODES_PDF_READ);
   m_pltRaster->UnlockSupport(L_SUPPORT_BARCODES_PDF_WRITE, L_KEY_BARCODES_PDF_WRITE);
   m_pltRaster->UnlockSupport(L_SUPPORT_PDF, L_KEY_PDF);
   m_pltRaster->UnlockSupport(L_SUPPORT_J2K, L_KEY_J2K);
   m_pltRaster->UnlockSupport(L_SUPPORT_CMW, L_KEY_CMW);
   m_pltRaster->UnlockSupport(L_SUPPORT_DICOM, L_KEY_DICOM);
   m_pltRaster->UnlockSupport(L_SUPPORT_EXTGRAY, L_KEY_EXTGRAY);
   m_pltRaster->UnlockSupport(L_SUPPORT_BITONAL, L_KEY_BITONAL);

   hr = CoCreateInstance (CLSID_LEADRasterTwain, NULL, CLSCTX_ALL, IID_ILEADRasterTwain, (void **)&m_pltRasTwain);
  
   if (SUCCEEDED(hr))
   {
      m_pltRasTwain->put_ManName(CString("LEAD Technologies, Inc.").AllocSysString());
      m_pltRasTwain->put_ProdFamily(CString("LEAD Twain COM Object").AllocSysString());
      m_pltRasTwain->put_Version(CString("Version 13").AllocSysString());
      m_pltRasTwain->put_AppName(CString("LEADTools Twain test sample").AllocSysString());

      m_pltRasTwain->EnableMethodErrors = FALSE;
      
      if(m_pltRasTwain->IsAvailable((long)GetSafeHwnd()))
      {
         m_pltRasTwain->InitSession((long)m_hWnd);
         m_bEnableTwain = TRUE;
      }
      m_pRasterTwainSink = new CRasterTwainSink;
      m_pRasterTwainSink->m_pDlg = this;

      LPUNKNOWN pUnkSink = m_pRasterTwainSink->GetIDispatch(FALSE);
      AfxConnectionAdvise(m_pltRasTwain, DIID__LEADRasterTwainEvents, pUnkSink, FALSE, &m_dwCookie);

      m_pltRasTwain->UnlockSupport(L_SUPPORT_DOCUMENT, L_KEY_DOCUMENT);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_GIFLZW, L_KEY_GIFLZW);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_TIFLZW, L_KEY_TIFLZW);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_OCR, L_KEY_OCR);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_MEDICAL, L_KEY_MEDICAL);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_VECTOR, L_KEY_VECTOR);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_MEDICAL_NET, L_KEY_MEDICAL_NET);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_BARCODES_1D, L_KEY_BARCODES_1D);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_BARCODES_2D_READ, L_KEY_BARCODES_2D_READ);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_BARCODES_2D_WRITE, L_KEY_BARCODES_2D_WRITE);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_BARCODES_PDF_READ, L_KEY_BARCODES_PDF_READ);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_BARCODES_PDF_WRITE, L_KEY_BARCODES_PDF_WRITE);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_PDF, L_KEY_PDF);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_J2K, L_KEY_J2K);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_CMW, L_KEY_CMW);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_DICOM, L_KEY_DICOM);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_EXTGRAY, L_KEY_EXTGRAY);
      m_pltRasTwain->UnlockSupport(L_SUPPORT_BITONAL, L_KEY_BITONAL);
   }
   else
      return -1;

   m_pltRaster->EnableMethodErrors = FALSE;
   m_pltRasterIO->EnableMethodErrors = FALSE;
   m_pltRasTwain->EnableMethodErrors = FALSE;

   return 0;
}

void CFASTTWNDlg::OnDestroy() 
{
   if (m_pnBPP)
      GlobalFreePtr(m_pnBPP);

   if (m_pltRasTwain)
   {
      LPUNKNOWN pUnkSink = m_pRasterTwainSink->GetIDispatch(FALSE);
      AfxConnectionUnadvise(m_pltRasTwain, DIID__LEADRasterTwainEvents, pUnkSink, FALSE, m_dwCookie); 
      delete m_pRasterTwainSink;
      
      if(m_bEnableTwain)
      {
         m_pltRasTwain->EndSession();
      }
      m_pltRasTwain->Release();
      m_pltRasTwain = NULL;
   }

   if (m_pltRaster)
      m_pltRaster->Release();

   if (m_pltRasterIO)
      m_pltRasterIO->Release();

   if (m_pRasterFileDlg)
      m_pRasterFileDlg->Release ();
    
   m_pRasterKrnDlg->FreeDlg();
   
   if(m_pRasterKrnDlg)
      m_pRasterKrnDlg->Release ();
   
   m_pRasterFileDlg = NULL;

   CDialog::OnDestroy();
}

void CFASTTWNDlg::CheckTransferMode()
{
   short         iRet = 0;
   ICapability * pltICap; 
   int           nValueCount = 0;
   BOOL          bFile=FALSE, bMem=FALSE, bNative=FALSE;
   int           nXfer;
   ILEADRasterVariant * pltRasVar = NULL;
   ValueType     vType;

   HRESULT hr = CoCreateInstance (CLSID_LEADRasterTwainCapability, NULL, CLSCTX_ALL, IID_ICapability, (void **)&pltICap);
   if (FAILED(hr) || !pltICap)
      return;

   pltICap->EnableMethodErrors = FALSE;
   pltICap->Capability = L_ICAP_XFERMECH;
   pltICap->ConType = L_TWON_ENUMERATION;
   iRet = m_pltRasTwain->GetCapability(pltICap, L_LTWAIN_CAPABILITY_GETVALUES);
   if (iRet != 0)
   {
      AfxMessageBox(_TEXT("Error during GetCapability method..."));
      pltICap->Release();
      return;
   }

   switch (pltICap->GetConType())
   {
   case L_TWON_ONEVALUE:
      {
         ICapabilityOneValue * pCapOVal = NULL;

         hr = pltICap->QueryInterface (IID_ICapabilityOneValue, (void **)&pCapOVal);
         if (FAILED (hr) || !pCapOVal)
            return;

         pCapOVal->get_OneValCapValue (&pltRasVar);
         vType = pltRasVar->Type;
         switch (vType)
         {
         case VALUE_SHORT:
         case VALUE_USHORT:
            if (vType == VALUE_SHORT)
               nXfer = pltRasVar->ShortValue;
            else
               nXfer = pltRasVar->LongValue;

            if (nXfer == L_TWSX_FILE)
               bFile = TRUE;

            if (nXfer == L_TWSX_MEMORY)
               bMem = TRUE;

            if (nXfer == L_TWSX_NATIVE)
               bNative = TRUE;
            break;
         default:
            pCapOVal->Release();
            pltRasVar->Release();
            return;
         }

         pCapOVal->Release();
         pltRasVar->Release();
      }
      break;
   case L_TWON_ENUMERATION:
      {
         long nCount=0;
         ICapabilityEnumeration * pCapEnum=NULL;

         hr = pltICap->QueryInterface(IID_ICapabilityEnumeration, (void **)&pCapEnum);
         if (FAILED (hr) || !pCapEnum)
            return;

         pCapEnum->get_EnumNumOfItems(&nCount);
         for (int i=0 ; i<nCount; i++)
         {
            pCapEnum->get_EnumCapValue(i, &pltRasVar);
            vType = pltRasVar->Type;

            switch (vType)
            {
            case VALUE_SHORT:
            case VALUE_USHORT:
               if (vType == VALUE_SHORT)
                  nXfer = pltRasVar->ShortValue;
               else
                  nXfer = pltRasVar->LongValue;

               if (nXfer == L_TWSX_FILE)
                  bFile = TRUE;

               if (nXfer == L_TWSX_MEMORY)
                  bMem = TRUE;

               if (nXfer == L_TWSX_NATIVE)
                  bNative = TRUE;
               break;
            default:
               pCapEnum->Release();
               pltRasVar->Release();
               return;
            }

            pltRasVar->Release();
         }

         pCapEnum->Release ();
      }
      break;
   }

   CWnd * pWnd = GetDlgItem(IDC_RADIO_FILE_MODE);
   pWnd->EnableWindow(bFile);

   pWnd = GetDlgItem(IDC_RADIO_MEM_MODE);
   pWnd->EnableWindow(bMem);

   pWnd = GetDlgItem(IDC_RADIO_NTV_MODE);
   pWnd->EnableWindow(bNative);

   switch (m_uTransMode)
   {
   case L_LTWAIN_FILE_MODE:
      CheckDlgButton(IDC_RADIO_FILE_MODE, TRUE);
      OnRadioFileMode();
      break;
   case L_LTWAIN_BUFFER_MODE:
      CheckDlgButton(IDC_RADIO_MEM_MODE, TRUE);
      OnRadioMemMode();
      break;
   case L_LTWAIN_NATIVE_MODE:
      CheckDlgButton(IDC_RADIO_NTV_MODE, TRUE);
      OnRadioNtvMode();
      break;
   }
   
   OnChangeEditBaseFName();
}

void CFASTTWNDlg::AddScannerFormats(short iFormat, int iIndex)
{
   switch (iFormat)
   {
   case L_TWFF_TIFF:
      m_cmbFileFormats.InsertString(iIndex, _TEXT("TIFF"));
      m_cmbFileFormats.SetItemData(iIndex, FILE_TIF);
      break;
   case L_TWFF_PICT:
      m_cmbFileFormats.InsertString(iIndex, _TEXT("PICT"));
      m_cmbFileFormats.SetItemData(iIndex, FILE_PCT);
      break;
   case L_TWFF_BMP:
      m_cmbFileFormats.InsertString(iIndex, _TEXT("BMP"));
      m_cmbFileFormats.SetItemData(iIndex, FILE_BMP);
      break;
   case L_TWFF_XBM:
      m_cmbFileFormats.InsertString(iIndex, _TEXT("XBM"));
      m_cmbFileFormats.SetItemData(iIndex, FILE_XBM);
      break;
   case L_TWFF_JFIF:
      m_cmbFileFormats.InsertString(iIndex, _TEXT("JFIF"));
      m_cmbFileFormats.SetItemData(iIndex, FILE_JPEG);
      break;
   case L_TWFF_FPX:
      m_cmbFileFormats.InsertString(iIndex, _TEXT("FPX"));
      m_cmbFileFormats.SetItemData(iIndex, FILE_FPX);
   case L_TWFF_TIFFMULTI:
      m_cmbFileFormats.InsertString(iIndex, _TEXT("TIFF MULTI"));
      m_cmbFileFormats.SetItemData(iIndex, FILE_TIF);
      break;
   case L_TWFF_PNG:
      m_cmbFileFormats.InsertString(iIndex, _TEXT("PNG"));
      m_cmbFileFormats.SetItemData(iIndex, FILE_PNG);
      break;
   case L_TWFF_EXIF:
      m_cmbFileFormats.InsertString(iIndex, _TEXT("EXIF"));
      m_cmbFileFormats.SetItemData(iIndex, FILE_EXIF);
      break;
   }
}

void CFASTTWNDlg::OnRadioFileMode()
{
   m_uTransMode = L_LTWAIN_FILE_MODE;
   m_cmbFileFormats.EnableWindow(TRUE);
   m_btnBrowseFName.EnableWindow(TRUE);

   CString csFName;
   m_EdtBaseFName.GetWindowText(csFName);
   m_btnAcquire.EnableWindow(!csFName.IsEmpty());

   // disable other options
   m_chkUseBuffer.EnableWindow(FALSE);
   m_EdtCustomBuffer.EnableWindow(FALSE);
   m_btnLTFormats.EnableWindow(FALSE);

   CheckDlgButton(IDC_RADIO_MEM_MODE, FALSE);
   CheckDlgButton(IDC_RADIO_NTV_MODE, FALSE);

   ICapability * pltICap; 
   int           nValueCount = 0;
   short         iFormat;
   ILEADRasterVariant * pltRasVar = NULL;
   ValueType     vType;

   HRESULT hr = CoCreateInstance (CLSID_LEADRasterTwainCapability, NULL, CLSCTX_ALL, IID_ICapability, (void **)&pltICap);
   if (FAILED(hr) || !pltICap)
   {
      AfxMessageBox(_TEXT("Error, Can't get Scanner supported formats..."));
      return;
   }

   pltICap->EnableMethodErrors = FALSE;
   pltICap->Capability = L_ICAP_IMAGEFILEFORMAT;
   pltICap->ConType = L_TWON_ENUMERATION;
   short iRet = m_pltRasTwain->GetCapability(pltICap, L_LTWAIN_CAPABILITY_GETVALUES);
   if (iRet != 0)
   {
      AfxMessageBox(_TEXT("Error during GetCapability method..."));
      pltICap->Release();
      return;
   }

   switch (pltICap->GetConType())
   {
   case L_TWON_ONEVALUE:
      {
         ICapabilityOneValue * pCapOVal = NULL;

         hr = pltICap->QueryInterface (IID_ICapabilityOneValue, (void **)&pCapOVal);
         if (FAILED (hr) || !pCapOVal)
            return;

         pCapOVal->get_OneValCapValue (&pltRasVar);
         vType = pltRasVar->Type;
         switch (vType)
         {
         case VALUE_SHORT:
         case VALUE_USHORT:
            m_cmbFileFormats.ResetContent();

            if (vType == VALUE_SHORT)
               iFormat = pltRasVar->ShortValue;
            else
               iFormat = (short)pltRasVar->LongValue;

            AddScannerFormats(iFormat, 0);
            break;
         default:
            pltRasVar->Release();
            pCapOVal->Release();
            return;
         }

         m_cmbFileFormats.SetCurSel(0);
         pCapOVal->Release ();
         pltRasVar->Release();
      }
      break;
   case L_TWON_ENUMERATION:
      {
         long nCount=0;
         ICapabilityEnumeration * pCapEnum=NULL;

         hr = pltICap->QueryInterface(IID_ICapabilityEnumeration, (void **)&pCapEnum);
         if (FAILED (hr) || !pCapEnum)
            return;

         pCapEnum->get_EnumNumOfItems(&nCount);
         m_cmbFileFormats.ResetContent();
         for (int i=0 ; i<nCount; i++)
         {
            pCapEnum->get_EnumCapValue (i, &pltRasVar);
            vType = pltRasVar->Type;
            switch (vType)
            {
            case VALUE_SHORT:
            case VALUE_USHORT:
               if (vType == VALUE_SHORT)
                  iFormat = pltRasVar->ShortValue;
               else
                  iFormat = (short)pltRasVar->LongValue;

               AddScannerFormats(iFormat, 0);
               break;
            default:
               pCapEnum->Release();
               pltRasVar->Release();
               return;
            }

            pltRasVar->Release();
         }
         m_cmbFileFormats.SetCurSel(0);
         pCapEnum->Release ();
      }
      break;
   }
}

void CFASTTWNDlg::OnRadioMemMode() 
{
   m_uTransMode = L_LTWAIN_BUFFER_MODE;

   m_chkUseBuffer.EnableWindow(TRUE);
   m_EdtCustomBuffer.EnableWindow(TRUE);
   m_cmbFileFormats.EnableWindow(TRUE);
   m_btnBrowseFName.EnableWindow(TRUE);

   m_bInit = TRUE;
   OnChkUseCustomBufSize();
   m_bInit = FALSE;

   CString csCustomBuffer, csFName;

   csCustomBuffer = _T(" ");

   m_EdtBaseFName.GetWindowText(csFName);
   if (m_bUseCustomBuffer)
      m_EdtCustomBuffer.GetWindowText(csCustomBuffer);

   m_btnAcquire.EnableWindow(!csCustomBuffer.IsEmpty() && !csFName.IsEmpty());
   FillMemoryFormats();

   // disable other options
   m_btnLTFormats.EnableWindow(FALSE);

   CheckDlgButton(IDC_RADIO_FILE_MODE, FALSE);
   CheckDlgButton(IDC_RADIO_NTV_MODE, FALSE);
}

void CFASTTWNDlg::OnRadioNtvMode()
{
   m_uTransMode = L_LTWAIN_NATIVE_MODE;
   m_btnLTFormats.EnableWindow(TRUE);

   CString csFName;
   m_EdtBaseFName.GetWindowText(csFName);
   m_btnAcquire.EnableWindow(!csFName.IsEmpty());

   // disable other options
   m_cmbFileFormats.EnableWindow(FALSE);
   m_chkUseBuffer.EnableWindow(FALSE);

   CString csText;
   m_EdtCustomBuffer.GetWindowText(csText);
   if (csText.IsEmpty())
      m_EdtCustomBuffer.SetWindowText(_TEXT("0"));

   m_EdtCustomBuffer.EnableWindow(FALSE);
   m_btnBrowseFName.EnableWindow(FALSE);

   CheckDlgButton(IDC_RADIO_MEM_MODE, FALSE);
   CheckDlgButton(IDC_RADIO_FILE_MODE, FALSE);
}

void CFASTTWNDlg::OnChkUseCustomBufSize() 
{
   if (!m_bInit)
      m_bUseCustomBuffer = !m_bUseCustomBuffer;

   m_EdtCustomBuffer.EnableWindow(m_bUseCustomBuffer);
}

void CFASTTWNDlg::OnAcquire() 
{
   int  nFormat = FILE_TIF;
   int  nBPP    = 1;
   BOOL bMulti  = TRUE;
   int  nCurSel = 0;

   if (!m_pltRasTwain)
      return;

   UpdateData();

   switch (m_uTransMode)
   {
   case L_LTWAIN_FILE_MODE:
      nFormat = m_cmbFileFormats.GetItemData(m_cmbFileFormats.GetCurSel());
      break;
   case L_LTWAIN_BUFFER_MODE:
      if (m_bUseCustomBuffer && m_uCustomBufferSize == 0)
      {
         AfxMessageBox(_TEXT("Please, enter valid custom buffer size"));
         return;
      }

      nCurSel = m_cmbFileFormats.GetCurSel();

      nBPP    = m_cmbFileFormats.GetItemData(nCurSel);
      bMulti  = m_bMemMulti[nCurSel];
      nFormat = m_nMemFormat[nCurSel];
      break;
   case L_LTWAIN_NATIVE_MODE:
      nFormat = m_nFormat;
      nBPP    = m_nSaveBPP;
      break;
   }

   m_pltRasTwain->FastTransferMode = m_uTransMode;
   m_pltRasTwain->FastFormat       = nFormat;
   m_pltRasTwain->FastBitsPerPixel = nBPP;
   m_pltRasTwain->FastBufferSize   = m_uCustomBufferSize;
   m_pltRasTwain->FastUsePreferredBufferSize = !m_bUseCustomBuffer;
   m_pltRasTwain->EnableAcquireMultiEvent = FALSE;

   BSTR bstrBaseFName = m_csBaseFName.AllocSysString();
   short iRet = m_pltRasTwain->AcquireMulti(bstrBaseFName, L_LTWAIN_SHOW_USER_INTERFACE, bMulti);

   SysFreeString(bstrBaseFName);
   if (iRet == 0)
      AfxMessageBox(_TEXT("Process Completed"));
   else
   {
      CString csErr;

      csErr.Format(_TEXT("AcquireMulti failed, Error = %d\n"), iRet);
      AfxMessageBox(csErr);
   }
}

void CFASTTWNDlg::OnSelect() 
{
   if (!m_pltRasTwain)
      return;

   short iRet = m_pltRasTwain->SelectSource();
   if (iRet != 0)
      return;

   CheckTransferMode();
}

BOOL CFASTTWNDlg::GetScannerBPP()
{
   ICapability * pltICap;
   ILEADRasterVariant * pltRasVar = NULL;
   ValueType vType;

   if (m_pnBPP)
   {
      GlobalFreePtr(m_pnBPP);
      m_pnBPP = NULL;
      m_nAllBPPCount = 0;
   }

   HRESULT hr = CoCreateInstance (CLSID_LEADRasterTwainCapability, NULL, CLSCTX_ALL, IID_ICapability, (void **)&pltICap);
   if (FAILED(hr) || !pltICap)
      return FALSE;

   pltICap->EnableMethodErrors = FALSE;
   pltICap->Capability = L_ICAP_BITDEPTH;
   pltICap->ConType = L_TWON_ENUMERATION;
   short iRet = m_pltRasTwain->GetCapability(pltICap, L_LTWAIN_CAPABILITY_GETVALUES);
   if (iRet != 0)
   {
      AfxMessageBox(_TEXT("Error during GetCapability method..."));
      pltICap->Release();
      return FALSE;
   }

   switch (pltICap->GetConType())
   {
   case L_TWON_ONEVALUE:
      {
         ICapabilityOneValue * pCapOVal = NULL;

         hr = pltICap->QueryInterface (IID_ICapabilityOneValue, (void **)&pCapOVal);
         if (FAILED (hr) || !pCapOVal)
            return FALSE;

         pCapOVal->get_OneValCapValue (&pltRasVar);
         vType = pltRasVar->Type;
         switch (vType)
         {
         case VALUE_SHORT:
         case VALUE_USHORT:
            m_nAllBPPCount = 1;
            m_pnBPP = (int *)GlobalAllocPtr(GHND, sizeof(int));
            if (m_pnBPP)
            {
               if (vType == VALUE_SHORT)
                  m_pnBPP[0] = pltRasVar->ShortValue;
               else
                  m_pnBPP[0] = pltRasVar->LongValue;
            }

            break;
         default:
            pltRasVar->Release();
            pCapOVal->Release();
            return FALSE;
         }

         pltRasVar->Release();
         pCapOVal->Release();
      }
      break;
   case L_TWON_ENUMERATION:
      {
         long nCount=0;
         ICapabilityEnumeration * pCapEnum=NULL;

         hr = pltICap->QueryInterface(IID_ICapabilityEnumeration, (void **)&pCapEnum);
         if (FAILED (hr) || !pCapEnum)
            return FALSE;

         pCapEnum->get_EnumNumOfItems(&nCount);
         m_nAllBPPCount = nCount;
         m_pnBPP = (int *)GlobalAllocPtr(GHND, sizeof(int) * m_nAllBPPCount);
         if (m_pnBPP)
         {
            for (int i=0 ; i<nCount; i++)
            {
               pCapEnum->get_EnumCapValue (i, &pltRasVar);
               vType = pltRasVar->Type;

               switch (vType)
               {
               case VALUE_SHORT:
               case VALUE_USHORT:
                  if (vType == VALUE_SHORT)
                     m_pnBPP[i] = pltRasVar->ShortValue;
                  else
                     m_pnBPP[i] = pltRasVar->LongValue;
                  break;
               default:
                  pltRasVar->Release();
                  pCapEnum->Release();
                  return FALSE;
               }
            }
         }

         pltRasVar->Release();
         pCapEnum->Release();
      }
      break;
   }

   return (m_pnBPP) ? TRUE : FALSE;
}

void CFASTTWNDlg::OnChangeEditBaseFName()
{
   CString csFName;
   m_EdtBaseFName.GetWindowText(csFName);

   m_btnAcquire.EnableWindow(!csFName.IsEmpty());
}

void CFASTTWNDlg::OnNormalAcquire() 
{
   m_pRasterFileDlg->PutEnableMethodErrors(FALSE);

   m_pRasterFileDlg->PutDialogTitle("Save File");
   m_pRasterFileDlg->PutSaveQFactor(2);

   short iRet= m_pRasterFileDlg->ShowSaveDlg((long)this->m_hWnd);

   if (iRet == 0 )
   {
      if(m_pRasterFileDlg->GetDialogStatus() == DLG_OK)
      {      
         m_nSaveFormat = m_pRasterFileDlg->GetSaveFormat();
         m_csSaveFName =(LPCTSTR) m_pRasterFileDlg->FileName;
         m_nSaveBPP = m_pRasterFileDlg->GetSaveBitsPerPixel();
         m_nSaveQFactor = m_pRasterFileDlg->GetSaveQFactor();
      }
      else
         return;
   }
   else
      return;
   
   m_nPageCount = 0;
   iRet = m_pltRasTwain->Acquire(L_LTWAIN_SHOW_USER_INTERFACE);
   if (iRet != 0)
      AfxMessageBox(_TEXT("Error occurred in Acquire method..."));      
}

void CFASTTWNDlg::OnSelLeadFormats() 
{
   m_pRasterFileDlg->PutEnableMethodErrors(FALSE); 
   m_pRasterFileDlg->PutDialogTitle("Save File");
   m_pRasterFileDlg->PutSaveQFactor(2);

   short iRet= m_pRasterFileDlg->ShowSaveDlg((long)this->m_hWnd);
 
   if (iRet == 0)
   {
      if(m_pRasterFileDlg->GetDialogStatus() == DLG_OK)
      {  
         m_csBaseFName = (LPCTSTR)m_pRasterFileDlg->FileName;
         m_nFormat     = m_pRasterFileDlg->GetSaveFormat();
         m_nSaveBPP    = m_pRasterFileDlg->GetSaveBitsPerPixel();
         m_EdtBaseFName.SetWindowText(m_csBaseFName);
      }
   }   
}

void CFASTTWNDlg::FillMemoryFormats()
{
   int nBPP=1, k=0;

   if (!GetScannerBPP())
   {
      m_pnBPP = &nBPP;
      m_nAllBPPCount = 1;
   }

   memset(m_nMemFormat, 0, sizeof(m_nMemFormat));
   memset(m_bMemMulti, 0, sizeof(m_bMemMulti));

   m_cmbFileFormats.ResetContent();
   for(int i=0; i<m_nAllBPPCount; i++)
   {
      switch (m_pnBPP[i])
      {
      case 1:
         nBPP = 1;

         m_cmbFileFormats.AddString(_TEXT("Multipage CCITT G4 TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_FAX_G4;
         m_bMemMulti[k] = TRUE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Singlepage CCITT G4 TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_FAX_G4;
         m_bMemMulti[k] = FALSE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Multipage CCITT G32D TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_FAX_G3_2D;
         m_bMemMulti[k] = TRUE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Singlepage CCITT G32D TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_FAX_G3_2D;
         m_bMemMulti[k] = FALSE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Multipage CCITT G31D TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_FAX_G3_1D;
         m_bMemMulti[k] = TRUE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Singlepage CCITT G31D TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_FAX_G3_1D;
         m_bMemMulti[k] = FALSE;
         k++;

         if (CheckG31DNOEOLCompression())
         {
            m_cmbFileFormats.AddString(_TEXT("Singlepage CCITT G31D NOEOL (FAX)"));
            m_cmbFileFormats.SetItemData(k, nBPP);
            m_nMemFormat[k] = FILE_FAX_G3_1D_NOEOL;
            m_bMemMulti[k] = FALSE;
            k++;
         }

         m_cmbFileFormats.AddString(_TEXT("Singlepage JBIG"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_JBIG;
         m_bMemMulti[k] = FALSE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Multipage Uncompressed 1-bit TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_TIF;
         m_bMemMulti[k] = TRUE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Singlepage Uncompressed 1-bit TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_TIF;
         m_bMemMulti[k] = FALSE;
         k++;
         break;
      case 24:
         nBPP = 24;

         m_cmbFileFormats.AddString(_TEXT("Singlepage JPEG Color 4:1:1"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_JPEG_411;
         m_bMemMulti[k] = FALSE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Singlepage JPEG Color 4:2:2"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_JPEG_422;
         m_bMemMulti[k] = FALSE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Singlepage JPEG Color 4:4:4"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_JPEG;
         m_bMemMulti[k] = FALSE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Multipage Uncompressed 24-bit TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_TIF;
         m_bMemMulti[k] = TRUE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Singlepage Uncompressed 24-bit TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_TIF;
         m_bMemMulti[k] = FALSE;
         k++;
         break;
      case 8:
         nBPP = 8;

         m_cmbFileFormats.AddString(_TEXT("Singlepage JPEG Grayscale 8-bit"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_JPEG;
         m_bMemMulti[k] = FALSE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Multipage Uncompressed 8-bit TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_TIF;
         m_bMemMulti[k] = TRUE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Singlepage Uncompressed 8-bit TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_TIF;
         m_bMemMulti[k] = FALSE;
         k++;
         break;
      case 4:
         nBPP = 4;

         m_cmbFileFormats.AddString(_TEXT("Multipage Uncompressed 4-bit TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_TIF;
         m_bMemMulti[k] = TRUE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Singlepage Uncompressed 4-bit TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_TIF;
         m_bMemMulti[k] = FALSE;
         k++;
         break;
      case 16:
         nBPP = 16;

         m_cmbFileFormats.AddString(_TEXT("Singlepage JPEG Grayscale 16-bit"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_JPEG;
         m_bMemMulti[k] = FALSE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Multipage Uncompressed 16-bit TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_TIF;
         m_bMemMulti[k] = TRUE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Singlepage Uncompressed 16-bit TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_TIF;
         m_bMemMulti[k] = FALSE;
         k++;
         break;
      case 32:
         nBPP = 32;

         m_cmbFileFormats.AddString(_TEXT("Multipage Uncompressed 32-bit TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_TIF;
         m_bMemMulti[k] = TRUE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Singlepage Uncompressed 32-bit TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_TIF;
         m_bMemMulti[k] = FALSE;
         k++;
         break;
      case 48:
         nBPP = 48;

         m_cmbFileFormats.AddString(_TEXT("Multipage Uncompressed 48-bit TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_TIF;
         m_bMemMulti[k] = TRUE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Singlepage Uncompressed 48-bit TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_TIF;
         m_bMemMulti[k] = FALSE;
         k++;
         break;
      case 64:
         nBPP = 64;

         m_cmbFileFormats.AddString(_TEXT("Multipage Uncompressed 64-bit TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_TIF;
         m_bMemMulti[k] = TRUE;
         k++;

         m_cmbFileFormats.AddString(_TEXT("Singlepage Uncompressed 64-bit TIFF"));
         m_cmbFileFormats.SetItemData(k, nBPP);
         m_nMemFormat[k] = FILE_TIF;
         m_bMemMulti[k] = FALSE;
         k++;
         break;
      }
   }

   m_cmbFileFormats.SetCurSel(0);
}

void CFASTTWNDlg::OnBrowseFileName() 
{
   CFileDialog FileDlg(FALSE, NULL, NULL,
                       OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
                       _TEXT("All Files (*.*)|*.*|"));

   if (FileDlg.DoModal() == IDOK)
      m_EdtBaseFName.SetWindowText(FileDlg.GetPathName());
}

void CFASTTWNDlg::GetMultiFileName(CString & csName)
{
   BOOL bMulti = FALSE;
   switch (m_nSaveFormat)
   {
   case FILE_FAX_G4:
   case FILE_FAX_G3_2D:
   case FILE_FAX_G3_1D:
   case FILE_CCITT_GROUP4:
   case FILE_CCITT_GROUP3_2DIM:
   case FILE_CCITT_GROUP3_1DIM:
   case FILE_GIF:
   case FILE_ICA_G3_1D:
   case FILE_ICA_G3_2D:
   case FILE_ICA_G4:
   case FILE_PCX:
   case FILE_TGA:
   case FILE_TIFLZW:
   case FILE_TIFLZW_CMYK:
   case FILE_TIFLZW_YCC:
   case FILE_TIF:
   case FILE_TIF_CMYK:
   case FILE_TIF_YCC:
   case FILE_TIF_PACKBITS:
   case FILE_TIF_PACKBITS_CMYK:
   case FILE_TIF_PACKBITS_YCC:
   case FILE_TIF_CMP:
   case FILE_TIF_JBIG:
   case FILE_TIF_DXF:
   case FILE_TIF_J2K:
   case FILE_TIF_CMW:
   case FILE_TIF_JPEG_422:
   case FILE_TIF_JPEG_411:
   case FILE_WIN_ICO:
   case FILE_WIN_CUR:
   case FILE_IFF_CAT:
   case FILE_FLC:
   case FILE_ANI:
   case FILE_RAS_PDF:
   case FILE_RAS_PDF_G3_1D:
   case FILE_RAS_PDF_G3_2D:
   case FILE_RAS_PDF_G4:
   case FILE_RAS_PDF_JPEG:
   case FILE_RAS_PDF_JPEG_422:
   case FILE_RAS_PDF_JPEG_411:
      bMulti = TRUE;
      break;
   }

   if (!bMulti)
   {
      TCHAR szScanNo[10];
      TCHAR szDrive[_MAX_DRIVE];
      TCHAR szDir[_MAX_DIR];
      TCHAR szFName[_MAX_FNAME];
      TCHAR szExt[_MAX_EXT];

      LPTSTR lptstrFName = csName.GetBuffer(MAX_PATH);

      memset(szDrive, 0, sizeof(szDrive));
      memset(szDir, 0, sizeof(szDir));
      memset(szFName, 0, sizeof(szFName));
      memset(szExt, 0, sizeof(szExt));

      _tsplitpath(m_csSaveFName, szDrive, szDir, szFName, szExt);

      memset(szScanNo, 0, sizeof(szScanNo));
      wsprintf(szScanNo, _TEXT("%d"), m_nPageCount);
      lstrcat(szFName, szScanNo);

      _tmakepath(lptstrFName, szDrive, szDir, szFName, szExt);
      csName.ReleaseBuffer();
   }
   else
      csName = m_csSaveFName;
}

BOOL CFASTTWNDlg::CheckG31DNOEOLCompression()
{
   short         iRet = 0;
   ICapability * pltICap; 
   int           nValueCount = 0;
   BOOL          bCompExist=FALSE;
   int           nCompression;
   ILEADRasterVariant * pltRasVar = NULL;
   ValueType     vType;

   HRESULT hr = CoCreateInstance (CLSID_LEADRasterTwainCapability, NULL, CLSCTX_ALL, IID_ICapability, (void **)&pltICap);
   if (FAILED(hr) || !pltICap)
      return FALSE;

   pltICap->EnableMethodErrors = FALSE;
   pltICap->Capability = L_ICAP_COMPRESSION;
   pltICap->ConType = L_TWON_ENUMERATION;
   iRet = m_pltRasTwain->GetCapability(pltICap, L_LTWAIN_CAPABILITY_GETVALUES);
   if (iRet != 0)
   {
      pltICap->Release();
      return FALSE;
   }

   switch (pltICap->GetConType())
   {
   case L_TWON_ONEVALUE:
      {
         ICapabilityOneValue * pCapOVal = NULL;

         hr = pltICap->QueryInterface (IID_ICapabilityOneValue, (void **)&pCapOVal);
         if (FAILED (hr) || !pCapOVal)
            return FALSE;

         pCapOVal->get_OneValCapValue (&pltRasVar);
         vType = pltRasVar->Type;
         switch (vType)
         {
         case VALUE_SHORT:
         case VALUE_USHORT:
            if (vType == VALUE_SHORT)
               nCompression = pltRasVar->ShortValue;
            else
               nCompression = pltRasVar->LongValue;

            if (nCompression == L_TWCP_GROUP31D)
               bCompExist = TRUE;
            break;
         default:
            pltRasVar->Release();
            pCapOVal->Release();
            return FALSE;
         }

         pltRasVar->Release();
         pCapOVal->Release();
      }
      break;
   case L_TWON_ENUMERATION:
      {
         long nCount=0;
         ICapabilityEnumeration * pCapEnum=NULL;

         hr = pltICap->QueryInterface(IID_ICapabilityEnumeration, (void **)&pCapEnum);
         if (FAILED (hr) || !pCapEnum)
            return FALSE;

         pCapEnum->get_EnumNumOfItems(&nCount);
         for (int i=0 ; i<nCount; i++)
         {
            pCapEnum->get_EnumCapValue (i, &pltRasVar);
            vType = pltRasVar->Type;
            switch (vType)
            {
            case VALUE_SHORT:
            case VALUE_USHORT:
               if (vType == VALUE_SHORT)
                  nCompression = pltRasVar->ShortValue;
               else
                  nCompression = pltRasVar->LongValue;
               if (nCompression == L_TWCP_GROUP31D)
                  bCompExist = TRUE;

               break;
            default:
               pltRasVar->Release();
               pCapEnum->Release();
               return FALSE;
            }

            pltRasVar->Release();
            if (bCompExist)
               break;
         }

         pCapEnum->Release ();
      }
      break;
   }

   return bCompExist;
}