// 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)
   virtual BOOL OnInitDialog();
   //}}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()

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

   VERSIONINFO VerInfo;
   L_TCHAR     szBuffer[1024];

   L_VersionInfo (&VerInfo,sizeof(VerInfo));
   
   wsprintf(szBuffer, TEXT("LEAD Product: %hs\nVersion %d.%d\nDate: %hs\nTime: %hs"),
           (L_TCHAR L_FAR *)VerInfo.Product,
           VerInfo.MajorNumber,
           VerInfo.MinorNumber,
           (L_TCHAR L_FAR *)VerInfo.Date,
           (L_TCHAR L_FAR *)VerInfo.Time);

   GetDlgItem(IDC_STATIC_VERSIONINFO)->SetWindowText(szBuffer);

   return TRUE;  // return TRUE unless you set the focus to a control
                 // EXCEPTION: OCX Property Pages should return FALSE
}

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

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

   m_hSession = NULL;
   m_bStartNegs = FALSE;
   m_uTransMode = LTWAIN_BUFFER_MODE;

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

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

   memset(m_nMemFormat, 0, sizeof(m_nMemFormat));
   memset(m_bMemMulti, 0, sizeof(m_bMemMulti));
   L_DlgInit(DLG_INIT_COLOR);
}
CFASTTWNDlg::~CFASTTWNDlg()
{
   L_DlgFree();
}

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_CHK_USE_CUSTOM_BUF_SIZE, m_chkUseBuffer);
   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_Text(pDX, IDC_EDIT_CUSTOM_BUFFER_SIZE, m_uCustomBufferSize);
   DDX_Text(pDX, IDC_EDIT_BASE_FNAME, m_csBaseFName);
   DDX_Check(pDX, IDC_CHK_USE_CUSTOM_BUF_SIZE, m_bUseCustomBuffer);
   //}}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
/*****************************************************************************/

   CheckTransferMode();
   return TRUE;  // return TRUE  unless you set the focus to a control
}

void CFASTTWNDlg::CheckTransferMode()
{
   L_INT             nRet = SUCCESS;
   TW_CAPABILITY     twCap;
   TW_ONEVALUE     * pOneValue = NULL;
   TW_ENUMERATION  * pEnum = NULL;
   TW_UINT16       * pValue = NULL;
   L_INT             nValueCount = 0;
   L_BOOL            bFile=FALSE, bMem=FALSE, bNative=FALSE;

   nRet = L_TwainStartCapsNeg(m_hSession);
   if (nRet != SUCCESS)
      return;

   m_bStartNegs = TRUE;

   twCap.Cap = ICAP_XFERMECH;
   twCap.ConType = TWON_ENUMERATION;
   twCap.hContainer = NULL;
   nRet = L_TwainGetCapability (m_hSession, &twCap, LTWAIN_CAPABILITY_GETVALUES);

   switch (twCap.ConType)
   {
   case TWON_ONEVALUE:
      if (twCap.hContainer)
      {
         pOneValue = (TW_ONEVALUE *)GlobalLock(twCap.hContainer);
         if (pOneValue)
         {
            nValueCount = 1;
            pValue = (TW_UINT16 *)&pOneValue->Item;
         }
      }
      break;
   case TWON_ENUMERATION:
      if (twCap.hContainer)
      {
         pEnum = (TW_ENUMERATION *)GlobalLock(twCap.hContainer);
         if (pEnum)
         {
            nValueCount = pEnum->NumItems;
            pValue = (TW_UINT16 *)pEnum->ItemList;
         }
      }
      break;
   }

   for (int i=0; i<nValueCount; i++)
   {
      if (pValue[i] == TWSX_FILE)
         bFile = TRUE;
      if (pValue[i] == TWSX_MEMORY)
         bMem = TRUE;
      if (pValue[i] == TWSX_NATIVE)
         bNative = TRUE;
   }

   if (pEnum || pOneValue)
   {
      GlobalUnlock (twCap.hContainer);
      GlobalFree (twCap.hContainer);
   }

   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 LTWAIN_FILE_MODE:
         CheckDlgButton(IDC_RADIO_FILE_MODE, TRUE);
         OnRadioFileMode();
         break;
      case LTWAIN_BUFFER_MODE:
         CheckDlgButton(IDC_RADIO_MEM_MODE, TRUE);
         OnRadioMemMode();
         break;
      case LTWAIN_NATIVE_MODE:
         CheckDlgButton(IDC_RADIO_NTV_MODE, TRUE);
         OnRadioNtvMode();
         break;
   }

   OnChangeEditBaseFName();
   L_TwainEndCapsNeg(m_hSession);
   m_bStartNegs = FALSE;
}

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) 
{
   if (CDialog::OnCreate(lpCreateStruct) == -1)
      return -1;

   APPLICATIONDATA AppData;

   AppData.hWnd = m_hWnd;                                            // Window handle of an application, may not be NULL
   lstrcpy (AppData.szManufacturerName, TEXT("LEAD Technologies, Inc."));   // Application manufacturer name
   lstrcpy (AppData.szAppProductFamily, TEXT("LEAD Test Applications"));    // Application product family
   lstrcpy (AppData.szVersionInfo, TEXT("Version 13.0"));                   // Application version info
   lstrcpy (AppData.szAppName, TEXT("Fast TWAIN Test Application"));        // Application Name
   AppData.uStructSize = sizeof(APPLICATIONDATA);

   // initialize the twain session to use other lead twain functions
   L_INT nRet = L_TwainInitSession (&m_hSession, &AppData);
   if (nRet != SUCCESS)
      return -1;

   return 0;
}

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

   if (m_hSession)
      L_TwainEndSession(&m_hSession);

   CDialog::OnDestroy();
}

void CFASTTWNDlg::FillFileFormats()
{
   // Get the available supported image file fomrats
   TW_CAPABILITY twCap;
   TW_UINT16   * pValue = NULL;
   L_INT         nValueCount=0;
   L_INT         nRet;

   twCap.Cap        = ICAP_IMAGEFILEFORMAT;
   twCap.ConType    = TWON_ENUMERATION;
   twCap.hContainer = NULL;

   if (m_bStartNegs)
      L_TwainEndCapsNeg(m_hSession);

   nRet = L_TwainStartCapsNeg(m_hSession);
   if (nRet != SUCCESS)
      return;

   m_bStartNegs = TRUE;

   nRet = L_TwainGetCapability (m_hSession, &twCap, LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != SUCCESS)
   {
      AfxMessageBox(TEXT("Error, Can't get Scanner supported formats..."));
      return;
   }

   switch (twCap.ConType)
   {
   case TWON_ONEVALUE:
      {
         TW_ONEVALUE * pOneValue = NULL;
         if (twCap.hContainer)
         {
            pOneValue = (TW_ONEVALUE *)GlobalLock(twCap.hContainer);
            pValue = (TW_UINT16 *)&pOneValue->Item;
            nValueCount = 1;
         }
      }
      break;
   case TWON_ENUMERATION:
      {
         TW_ENUMERATION * pEnum = NULL;
         if (twCap.hContainer)
         {
            pEnum = (TW_ENUMERATION *)GlobalLock(twCap.hContainer);
            pValue = (TW_UINT16 *)pEnum->ItemList;
            nValueCount = pEnum->NumItems;
         }
      }
   }

   m_cmbFileFormats.ResetContent();
   for(int i=0; i<nValueCount; i++)
   {
      switch (pValue[i])
      {
      case TWFF_TIFF:
         m_cmbFileFormats.AddString(TEXT("TIFF"));
         m_cmbFileFormats.SetItemData(i, FILE_TIF);
         break;
      case TWFF_PICT:
         m_cmbFileFormats.AddString(TEXT("PICT"));
         m_cmbFileFormats.SetItemData(i, FILE_PCT);
         break;
      case TWFF_BMP:
         m_cmbFileFormats.AddString(TEXT("BMP"));
         m_cmbFileFormats.SetItemData(i, FILE_BMP);
         break;
      case TWFF_XBM:
         m_cmbFileFormats.AddString(TEXT("XBM"));
         m_cmbFileFormats.SetItemData(i, FILE_XBM);
         break;
      case TWFF_JFIF:
         m_cmbFileFormats.AddString(TEXT("JPEG"));
         m_cmbFileFormats.SetItemData(i, FILE_JPEG);
         break;
      case TWFF_FPX:
         m_cmbFileFormats.AddString(TEXT("FPX"));
         m_cmbFileFormats.SetItemData(i, FILE_FPX);
      case TWFF_TIFFMULTI:
         m_cmbFileFormats.AddString(TEXT("TIFF MULTI"));
         m_cmbFileFormats.SetItemData(i, FILE_TIF);
         break;
      case TWFF_PNG:
         m_cmbFileFormats.AddString(TEXT("PNG"));
         m_cmbFileFormats.SetItemData(i, FILE_PNG);
         break;
      case TWFF_EXIF:
         m_cmbFileFormats.AddString(TEXT("EXIF"));
         m_cmbFileFormats.SetItemData(i, FILE_EXIF);
         break;
      }
   }

   if (pValue)
   {
      GlobalUnlock (twCap.hContainer);
      GlobalFree (twCap.hContainer);
   }

   m_cmbFileFormats.SetCurSel(0);

   L_TwainEndCapsNeg(m_hSession);
   m_bStartNegs = FALSE;
}

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

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

   FillFileFormats();

   // 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);
}

void CFASTTWNDlg::OnRadioMemMode()
{
   m_uTransMode = 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 = 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() 
{
   L_INT    nFormat = FILE_TIF;
   L_INT    nBPP    = 1;
   L_BOOL   bMulti  = TRUE;
   L_INT    nCurSel = 0;

   if (!m_hSession)
      return;
   
   if (m_bStartNegs)
   {
      L_TwainEndCapsNeg(m_hSession);
      m_bStartNegs = FALSE;
   }

   CString csCustomBuffer;
   m_EdtCustomBuffer.GetWindowText(csCustomBuffer);
   if (csCustomBuffer.IsEmpty())
      m_EdtCustomBuffer.SetWindowText(TEXT("0"));

   UpdateData();

   switch (m_uTransMode)
   {
   case LTWAIN_FILE_MODE:
      nFormat = m_cmbFileFormats.GetItemData(m_cmbFileFormats.GetCurSel());
      break;
   case 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 LTWAIN_NATIVE_MODE:
      nFormat = m_nSaveFormat;
      nBPP    = m_nSaveBPP;
      break;
   }

   L_INT nRet = L_TwainAcquireMulti(m_hSession,
                                    (L_TCHAR *)(LPCTSTR)m_csBaseFName,
                                    LTWAIN_SHOW_USER_INTERFACE,
                                    m_uTransMode,
                                    nFormat,
                                    nBPP,
                                    bMulti,
                                    m_uCustomBufferSize, 
                                    !m_bUseCustomBuffer,
                                    NULL, NULL);

   if (nRet == SUCCESS)
      AfxMessageBox(TEXT("Process Completed"));
   else
   {
      if (nRet == ERROR_TWAIN_CANCELED)
         return;

      CString csErr;

      csErr.Format(TEXT("L_TwainAcquireMulti failed, Error = %d\n"), nRet);
      AfxMessageBox(csErr);
   }
}

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

   L_INT nRet = L_TwainSelectSource(m_hSession, NULL);
   if (nRet != SUCCESS && nRet != ERROR_TWAIN_CANCELED)
   {
      AfxMessageBox(TEXT("Error during select Twain source..."));
      return;
   }

   CheckTransferMode();
}

L_BOOL CFASTTWNDlg::GetScannerBPP()
{
   L_INT           nRet=TWAIN_SUCCESS;
   L_BOOL          bRet=TRUE;
   TW_CAPABILITY   twCap;
   pTW_ONEVALUE    pOneVal=NULL;
   pTW_ENUMERATION pEnum  =NULL;
   TW_UINT16     * pValue = NULL;

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

   // Get the available supported Bits Per Pixel
   twCap.Cap = ICAP_BITDEPTH;
   twCap.ConType = TWON_ENUMERATION;
   twCap.hContainer = NULL;

   nRet = L_TwainGetCapability(m_hSession, &twCap, LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != TWAIN_SUCCESS)
      return FALSE;

   switch (twCap.ConType)
   {
   case TWON_ONEVALUE:
      if (twCap.hContainer)
      {
         pOneVal = (TW_ONEVALUE *)GlobalLock(twCap.hContainer);
         if (pOneVal && (pOneVal->ItemType == TWTY_UINT16 || pOneVal->ItemType == TWTY_INT16))
         {
            pValue = (TW_UINT16 *)&pOneVal->Item;
            m_nAllBPPCount = 1;
         }
         else
            bRet = FALSE;
      }
      else
         bRet = FALSE;
      break;
   case TWON_ENUMERATION:
      if (twCap.hContainer)
      {
         pEnum = (TW_ENUMERATION *)GlobalLock(twCap.hContainer);
         if (pEnum && (pEnum->ItemType == TWTY_UINT16 || pEnum->ItemType == TWTY_INT16))
         {
            pValue = (TW_UINT16 *)pEnum->ItemList;
            m_nAllBPPCount = pEnum->NumItems;
         }
         else
            bRet = FALSE;
      }
      else
         bRet = FALSE;
   }

   if (bRet)
   {
      m_pnBPP = (L_INT *)GlobalAllocPtr(GHND, sizeof(L_INT) * m_nAllBPPCount);
      if (m_pnBPP)
      {
         for(int i=0; i<m_nAllBPPCount; i++)
            m_pnBPP[i] = pValue[i];
      }
      else
         bRet = FALSE;
   }

   if (pValue)
   {
      GlobalUnlock (twCap.hContainer);
      GlobalFree (twCap.hContainer);
   }

   return bRet;
}

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

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

L_INT EXT_CALLBACK TwainAcquireCB(HTWAINSESSION hSession, pBITMAPHANDLE pBitmap, L_VOID * pUserData)
{
   CFASTTWNDlg * pDlg = (CFASTTWNDlg *)pUserData;
   if (!pDlg)
      return 0;

   CString csFName;
   pDlg->m_nPageCount++;

   pDlg->GetMultiFileName(csFName);

   L_SaveFile((L_TCHAR L_FAR *)(LPCTSTR)csFName,
              pBitmap,
              pDlg->m_nSaveFormat,
              pDlg->m_nSaveBPP, 
              pDlg->m_nSaveQFactor,
              SAVEFILE_MULTIPAGE, NULL, NULL, NULL);

   return SUCCESS;
}

void CFASTTWNDlg::OnNormalAcquire() 
{
   OPENFILENAME  SaveFileName;
   SAVEDLGPARAMS FSParm;
   L_INT         nRet;

   memset(&SaveFileName, 0, sizeof(OPENFILENAME));
   memset(&FSParm, 0, sizeof(SAVEDLGPARAMS));

   FSParm.uStructSize  = sizeof(SAVEDLGPARAMS);
   FSParm.nQFactor     = 2;
   FSParm.uDlgFlags    = DLG_SAVE_SHOW_FILEOPTIONS_MULTIPAGE       |
                         DLG_SAVE_SHOW_FILEOPTIONS_PROGRESSIVE     |
                         DLG_SAVE_SHOW_FILEOPTIONS_QFACTOR         |
                         DLG_SAVE_SHOW_FILEOPTIONS_BASICJ2KOPTIONS |
                         DLG_SAVE_SHOW_FILEOPTIONS_J2KOPTIONS      |
                         DLG_SAVE_SHOW_FILEOPTIONS_STAMP;

   FSParm.nPageNumber = 1;
   FSParm.uSaveMulti = FALSE;

   SaveFileName.lStructSize       = sizeof(OPENFILENAME);
   SaveFileName.lpstrInitialDir   = NULL;
   SaveFileName.lpstrTitle        = TEXT("Save As");


   nRet = L_DlgSave (m_hWnd, &SaveFileName, &FSParm);
   if (nRet == SUCCESS_DLG_OK)
   {
      m_csSaveFName = FSParm.szFileName;
      m_nSaveFormat = FSParm.nFormat;
      m_nSaveBPP    = FSParm.nBitsPerPixel;
      m_nSaveQFactor= FSParm.nQFactor;

      if((FSParm.nFormat == FILE_J2K)||
         (FSParm.nFormat == FILE_JP2)||
         (FSParm.nFormat == FILE_CMW)||
         (FSParm.nFormat == FILE_TIF_J2K)||
         (FSParm.nFormat == FILE_TIF_CMW))
      {
         L_SetJ2KOptions(&FSParm.FileJ2KOptions);
      }
   }
   else
      return;

   m_nPageCount = 0;
   nRet = L_TwainAcquire(m_hSession, NULL, 0,TwainAcquireCB, LTWAIN_SHOW_USER_INTERFACE, NULL, this);
   if (nRet != SUCCESS)
      AfxMessageBox(TEXT("Error occurred in L_TwainAcquire..."));
}

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

   if (!GetScannerBPP())
   {
      m_pnBPP = (L_INT *)GlobalAllocPtr(GHND, sizeof(L_INT));
      m_pnBPP[0] = nBPP;
      m_nAllBPPCount = 1;
   }

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

   m_cmbFileFormats.ResetContent();
   for(L_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_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::OnSelLEADFormats() 
{
   OPENFILENAME  SaveFileName;
   SAVEDLGPARAMS FSParm;
   L_INT         nRet;

   memset(&SaveFileName, 0, sizeof(OPENFILENAME));
   memset(&FSParm, 0, sizeof(SAVEDLGPARAMS));

   FSParm.uStructSize  = sizeof(SAVEDLGPARAMS);
   FSParm.nQFactor     = 2;
   FSParm.uDlgFlags    = DLG_SAVE_SHOW_FILEOPTIONS_MULTIPAGE       |
                         DLG_SAVE_SHOW_FILEOPTIONS_PROGRESSIVE     |
                         DLG_SAVE_SHOW_FILEOPTIONS_QFACTOR         |
                         DLG_SAVE_SHOW_FILEOPTIONS_BASICJ2KOPTIONS |
                         DLG_SAVE_SHOW_FILEOPTIONS_J2KOPTIONS      |
                         DLG_SAVE_SHOW_FILEOPTIONS_STAMP;

   FSParm.nPageNumber = 1;
   FSParm.uSaveMulti = FALSE;

   SaveFileName.lStructSize       = sizeof(OPENFILENAME);
   SaveFileName.lpstrInitialDir   = NULL;
   SaveFileName.lpstrTitle        = TEXT("Save As");


   nRet = L_DlgSave (m_hWnd, &SaveFileName, &FSParm);
   if (nRet == SUCCESS_DLG_OK)
   {
      m_csBaseFName = FSParm.szFileName;
      m_nSaveFormat = FSParm.nFormat;
      m_nSaveBPP    = FSParm.nBitsPerPixel;
      m_EdtBaseFName.SetWindowText(m_csBaseFName);

      if((FSParm.nFormat == FILE_J2K)||
         (FSParm.nFormat == FILE_JP2)||
         (FSParm.nFormat == FILE_CMW)||
         (FSParm.nFormat == FILE_TIF_J2K)||
         (FSParm.nFormat == FILE_TIF_CMW))
      {
         L_SetJ2KOptions(&FSParm.FileJ2KOptions);
      }
   }
}

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)
{
   L_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)
   {
      L_TCHAR szScanNo[10];
      L_TCHAR szDrive[_MAX_DRIVE];
      L_TCHAR szDir[_MAX_DIR];
      L_TCHAR szFName[_MAX_FNAME];
      L_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;
}

L_BOOL CFASTTWNDlg::CheckG31DNOEOLCompression()
{
   L_INT             nRet = SUCCESS;
   TW_CAPABILITY     twCap;
   TW_ONEVALUE     * pOneValue = NULL;
   TW_ENUMERATION  * pEnum = NULL;
   TW_UINT16       * pValue = NULL;
   L_INT             nValueCount = 0;
   L_BOOL            bCompExist = FALSE;

   nRet = L_TwainStartCapsNeg(m_hSession);
   if (nRet != SUCCESS)
      return FALSE;

   m_bStartNegs = TRUE;

   twCap.Cap = ICAP_COMPRESSION;
   twCap.ConType = TWON_ENUMERATION;
   twCap.hContainer = NULL;
   nRet = L_TwainGetCapability (m_hSession, &twCap, LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != SUCCESS)
      return FALSE;

   switch (twCap.ConType)
   {
   case TWON_ONEVALUE:
      if (twCap.hContainer)
      {
         pOneValue = (TW_ONEVALUE *)GlobalLock(twCap.hContainer);
         if (pOneValue)
         {
            nValueCount = 1;
            pValue = (TW_UINT16 *)&pOneValue->Item;
         }
      }
      break;
   case TWON_ENUMERATION:
      if (twCap.hContainer)
      {
         pEnum = (TW_ENUMERATION *)GlobalLock(twCap.hContainer);
         if (pEnum)
         {
            nValueCount = pEnum->NumItems;
            pValue = (TW_UINT16 *)pEnum->ItemList;
         }
      }
      break;
   }

   for (int i=0; i<nValueCount; i++)
   {
      if (pValue[i] == TWCP_GROUP31D)
      {
         bCompExist = TRUE;
         break;
      }
   }

   if (pEnum || pOneValue)
   {
      GlobalUnlock (twCap.hContainer);
      GlobalFree (twCap.hContainer);
   }

   return bCompExist;
}