// LEADTemplate.cpp : implementation file
//

#include "stdafx.h"
#include "twain.h"
#include "LEADTemplate.h"

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

/////////////////////////////////////////////////////////////////////////////
// CLEADTemplate dialog

CLEADTemplate::CLEADTemplate(ILEADRasterTwain_D * pRasterTwain, CWnd* pParent /*=NULL*/)
   : CDialog(CLEADTemplate::IDD, pParent)
{
   //{{AFX_DATA_INIT(CLEADTemplate)
	m_csFileName = _T("");
	//}}AFX_DATA_INIT
   m_pRasterTwain = pRasterTwain;
}

void CLEADTemplate::DoDataExchange(CDataExchange* pDX)
{
   CDialog::DoDataExchange(pDX);
   //{{AFX_DATA_MAP(CLEADTemplate)
	DDX_Control(pDX, IDC_COMBO_HALFTONE, m_cmbHalftone);
	DDX_Control(pDX, IDC_COMBO_HIGHLIGHT, m_cmbHighlight);
	DDX_Control(pDX, IDC_COMBO_CONTRAST, m_cmbContrast);
	DDX_Control(pDX, IDC_COMBO_BRIGHTNESS, m_cmbBrightness);
	DDX_Control(pDX, IDC_COMBO_ORIENTATION, m_cmbOrientation);
	DDX_Control(pDX, IDC_COMBO_PIXEL_TYPE, m_cmbPixelType);
	DDX_Control(pDX, IDOK, m_btnOk);
	DDX_Control(pDX, IDC_COMBO_FILE_FORMAT, m_cmbFileFormats);
	DDX_Control(pDX, IDC_COMBO_MEMORY_COMPRESSION, m_cmbCompression);
	DDX_Control(pDX, IDC_BUTTON_FILE_BROWSE, m_btnBrowse);
	DDX_Control(pDX, IDC_EDIT_FILE_NAME, m_txtFileName);
	DDX_Control(pDX, IDC_COMBO_YRESOLUTION, m_cmbYRes);
	DDX_Control(pDX, IDC_COMBO_XRESOLUTION, m_cmbXRes);
	DDX_Control(pDX, IDC_EDIT_FRAME_BOTTOM, m_txtFrameBottom);
	DDX_Control(pDX, IDC_EDIT_FRAME_RIGHT, m_txtFrameRight);
	DDX_Control(pDX, IDC_EDIT_FRAME_TOP, m_txtFrameTop);
	DDX_Control(pDX, IDC_EDIT_FRAME_LEFT, m_txtFrameLeft);
	DDX_Control(pDX, IDC_COMBO_UNIT, m_cmbUnits);
	DDX_Text(pDX, IDC_EDIT_FILE_NAME, m_csFileName);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CLEADTemplate, CDialog)
   //{{AFX_MSG_MAP(CLEADTemplate)
	ON_BN_CLICKED(IDC_RADIO_TRANSFER_FILE, OnRadioTransferFile)
	ON_BN_CLICKED(IDC_RADIO_TRANSFER_MEMORY, OnRadioTransferMemory)
	ON_BN_CLICKED(IDC_RADIO_TRANSFER_NATIVE, OnRadioTransferNative)
	ON_BN_CLICKED(IDC_BUTTON_FILE_BROWSE, OnButtonFileBrowse)
	ON_BN_CLICKED(IDC_BUTTON_TEMPLATE_LOAD, OnButtonTemplateLoad)
	ON_BN_CLICKED(IDC_BUTTON_TEMPLATE_SAVE, OnButtonTemplateSave)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CLEADTemplate message handlers

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

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

void CLEADTemplate::InitTemplateDlg()
{
   /* L_ICAP_UNITS */
   FillUnitsCap();

   /* L_ICAP_FRAMES */
   FillFrameCaps();

   /* L_ICAP_XRESOLUTION - L_ICAP_YRESOLUTION */
   FillXYRes();

   /* L_ICAP_XFERMECH */
   FillTransferMode();

   /* L_ICAP_PIXELTYPE */
   FillPixelType();

   /* L_ICAP_ORIENTATION */
   FillOrientation();

   /* L_ICAP_CONTRAST, L_ICAP_BRIGHTNESS, L_ICAP_HIGHLIGHT */
   FillEffectsCap(L_ICAP_CONTRAST);
   FillEffectsCap(L_ICAP_BRIGHTNESS);
   FillEffectsCap(L_ICAP_HIGHLIGHT);

   /* L_ICAP_HALFTONES */
   FillHalftones();
}

void CLEADTemplate::FillUnitsCap()
{
   ILEADTwainCapability_D * ptwCap = NULL;

   /* L_ICAP_UNITS */
   HRESULT hr = CoCreateInstance(CLSID_LEADTwainCapability_D, NULL, CLSCTX_ALL, IID_ILEADTwainCapability_D, (void**)&ptwCap);
   if (FAILED(hr))
      return;

   ptwCap->EnableMethodErrors = FALSE;
   ptwCap->CapInfo->Capability = L_ICAP_UNITS;
   ptwCap->CapInfo->ConType = L_TWON_ENUMERATION;
   short nRet = m_pRasterTwain->GetCapability2(ptwCap, L_LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != 0)
   {
      /* disable UNITS combo box */
      m_cmbUnits.EnableWindow(FALSE);
      return;
   }

   m_cmbUnits.ResetContent();

   short nContainerType = ptwCap->CapInfo->ConType;
   switch (nContainerType)
   {
   case L_TWON_ENUMERATION:
      {
         int nCount = ptwCap->CapEnum->EnumNumOfItems;
         for (int i=0; i<nCount; i++)
         {
            long item = ptwCap->CapEnum->GetEnumCapValue(i)->LongValue;
            switch (item)
            {
            case L_TWUN_INCHES:
               m_cmbUnits.AddString(TEXT("Inches"));
               break;
            case L_TWUN_CENTIMETERS:
               m_cmbUnits.AddString(TEXT("Centimeters"));
               break;
            case L_TWUN_PICAS:
               m_cmbUnits.AddString(TEXT("Picas"));
               break;
            case L_TWUN_POINTS:
               m_cmbUnits.AddString(TEXT("Points"));
               break;
            case L_TWUN_TWIPS:
               m_cmbUnits.AddString(TEXT("Twips"));
               break;
            case L_TWUN_PIXELS:
               m_cmbUnits.AddString(TEXT("Pixels"));
               break;
            }

            m_cmbUnits.SetItemData(i, item);
         }

         m_cmbUnits.SetCurSel(ptwCap->CapEnum->EnumCurrentIndex);
      }
      break;
   case L_TWON_ONEVALUE:
      {
         long item = ptwCap->CapOneValue->OneValCapValue->LongValue;
         switch (item)
         {
         case L_TWUN_INCHES:
            m_cmbUnits.AddString(TEXT("Inches"));
            break;
         case L_TWUN_CENTIMETERS:
            m_cmbUnits.AddString(TEXT("Centimeters"));
            break;
         case L_TWUN_PICAS:
            m_cmbUnits.AddString(TEXT("Picas"));
            break;
         case L_TWUN_POINTS:
            m_cmbUnits.AddString(TEXT("Points"));
            break;
         case L_TWUN_TWIPS:
            m_cmbUnits.AddString(TEXT("Twips"));
            break;
         case L_TWUN_PIXELS:
            m_cmbUnits.AddString(TEXT("Pixels"));
            break;
         }

         m_cmbUnits.SetItemData(0, item);
         m_cmbUnits.SetCurSel(0);
      }
      break;
   }

   ptwCap->Release();
}

void CLEADTemplate::FillFrameCaps()
{
   ILEADTwainCapability_D * ptwCap = NULL;

   /* L_ICAP_FRAMES */
   HRESULT hr = CoCreateInstance(CLSID_LEADTwainCapability_D, NULL, CLSCTX_ALL, IID_ILEADTwainCapability_D, (void**)&ptwCap);
   if (FAILED(hr))
      return;

   ptwCap->EnableMethodErrors = FALSE;
   ptwCap->CapInfo->Capability = L_ICAP_FRAMES;
   ptwCap->CapInfo->ConType = L_TWON_ONEVALUE;
   short nRet = m_pRasterTwain->GetCapability2(ptwCap, L_LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != 0)
   {
      /* disable FRAME edit boxes */
      m_txtFrameLeft.EnableWindow(FALSE);
      m_txtFrameTop.EnableWindow(FALSE);
      m_txtFrameRight.EnableWindow(FALSE);
      m_txtFrameBottom.EnableWindow(FALSE);
      return;
   }

   short nContainerType = ptwCap->CapInfo->ConType;
   ItwFrame_D * ptwFrame = NULL;
   LPDISPATCH pDisp = NULL;

   switch (nContainerType)
   {
   case L_TWON_ONEVALUE:
      pDisp = ptwCap->CapOneValue->OneValCapValue->GetDispatchValue();
      break;
   case L_TWON_ENUMERATION:
      pDisp = ptwCap->CapEnum->GetEnumCapValue(ptwCap->CapEnum->EnumDefaultIndex)->GetDispatchValue();
      break;
   }

   pDisp->QueryInterface(IID_ItwFrame_D, (void **)&ptwFrame);

   float fLeft = ptwFrame->GetLeftMargin();
   float fTop = ptwFrame->GetTopMargin();
   float fRight = ptwFrame->GetRightMargin();
   float fBottom = ptwFrame->GetBottomMargin();

   CString csText;
   csText.Format(TEXT("%d.%d"), (int)fLeft, (fLeft - (int)fLeft) * 10);
   m_txtFrameLeft.SetWindowText(csText);

   csText.Format(TEXT("%d.%d"), (int)fTop, (fTop - (int)fTop) * 10);
   m_txtFrameTop.SetWindowText(csText);

   csText.Format(TEXT("%d.%d"), (int)fRight, (fRight - (int)fRight) * 10);
   m_txtFrameRight.SetWindowText(csText);

   csText.Format(TEXT("%d.%d"), (int)fBottom, (fBottom - (int)fBottom) * 10);
   m_txtFrameBottom.SetWindowText(csText);

   ptwFrame->Release();
   ptwCap->Release();
}

void CLEADTemplate::FillXYRes()
{
   ILEADTwainCapability_D * ptwCap = NULL;

   /* L_ICAP_XRESOLUTION */

   HRESULT hr = CoCreateInstance(CLSID_LEADTwainCapability_D, NULL, CLSCTX_ALL, IID_ILEADTwainCapability_D, (void**)&ptwCap);
   if (FAILED(hr))
      return;

   ptwCap->EnableMethodErrors = FALSE;
   ptwCap->CapInfo->Capability = L_ICAP_XRESOLUTION;
   ptwCap->CapInfo->ConType = L_TWON_ENUMERATION;
   short nRet = m_pRasterTwain->GetCapability2(ptwCap, L_LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != 0)
   {
      /* disable XResolution combo boxes */
      m_cmbXRes.EnableWindow(FALSE);
      return;
   }

   float fRes;
   CString csText;
   int i;
   short nContainerType = ptwCap->CapInfo->ConType;

   m_cmbXRes.ResetContent();

   switch (nContainerType)
   {
   case L_TWON_ENUMERATION:
      {
         int nCount = ptwCap->CapEnum->EnumNumOfItems;
         for (i=0; i<nCount; i++)
         {
            fRes = ptwCap->CapEnum->GetEnumCapValue(i)->FloatValue;

            csText.Format(TEXT("%d.%d"), (int)fRes, (fRes - (int)fRes) * 10);
            m_cmbXRes.AddString(csText);
            m_cmbXRes.SetItemData(i, (DWORD)fRes);
         }

         m_cmbXRes.SetCurSel(ptwCap->CapEnum->EnumCurrentIndex);
      }
      break;
   case L_TWON_RANGE:
      {
         int nSelIndex = 0;
         i = 0;

         float fMin = ptwCap->CapRange->GetRangeMinimumValue()->FloatValue;
         float fMax = ptwCap->CapRange->GetRangeMaximumValue()->FloatValue;
         float fStep = ptwCap->CapRange->GetRangeStepSize()->FloatValue;
         float fDefault = ptwCap->CapRange->GetRangeDefaultValue()->FloatValue;

         csText.Format(TEXT("%d.%d"), (int)fMin, (fMin - (int)fMin) * 10);

         m_cmbXRes.AddString(csText);
         m_cmbXRes.SetItemData(i, (DWORD)fMin);
         if (fDefault == fMin)
            nSelIndex = i;

         float fVal = fMin + fStep;
         while (fVal < fMax)
         {
            csText.Format(TEXT("%d.%d"), (int)fVal, (fVal - (int)fVal) * 10);

            i++;
            m_cmbXRes.AddString(csText);
            m_cmbXRes.SetItemData(i, (DWORD)fVal);
            if (fDefault == fVal)
               nSelIndex = i;

            fVal = fVal + fStep;
         }

         csText.Format(TEXT("%d.%d"), (int)fMax, (fMax - (int)fMax) * 10);

         i++;
         m_cmbXRes.AddString(csText);
         m_cmbXRes.SetItemData(i, (DWORD)fMax);
         if (fDefault == fMax)
            nSelIndex = i;

         m_cmbXRes.SetCurSel(nSelIndex);
      }
      break;
   case L_TWON_ONEVALUE:
      {
         fRes = ptwCap->CapOneValue->OneValCapValue->FloatValue;

         csText.Format(TEXT("%d.%d"), (int)fRes, (fRes - (int)fRes) * 10);

         m_cmbXRes.AddString(csText);
         m_cmbXRes.SetItemData(0, (DWORD)fRes);
         m_cmbXRes.SetCurSel(0);
      }
      break;
   }

   ptwCap->Release();
   ptwCap = NULL;

   /* L_ICAP_YRESOLUTION */
   hr = CoCreateInstance(CLSID_LEADTwainCapability_D, NULL, CLSCTX_ALL, IID_ILEADTwainCapability_D, (void**)&ptwCap);
   if (FAILED(hr))
      return;

   ptwCap->EnableMethodErrors = FALSE;
   ptwCap->CapInfo->Capability = L_ICAP_YRESOLUTION;
   ptwCap->CapInfo->ConType = L_TWON_ENUMERATION;
   nRet = m_pRasterTwain->GetCapability2(ptwCap, L_LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != 0)
   {
      /* disable YResolution combo boxes */
      m_cmbYRes.EnableWindow(FALSE);
      return;
   }

   nContainerType = ptwCap->CapInfo->ConType;

   m_cmbYRes.ResetContent();

   switch (nContainerType)
   {
   case L_TWON_ENUMERATION:
      {
         int nCount = ptwCap->CapEnum->EnumNumOfItems;
         for (i=0; i<nCount; i++)
         {
            fRes = ptwCap->CapEnum->GetEnumCapValue(i)->FloatValue;

            csText.Format(TEXT("%d.%d"), (int)fRes, (fRes - (int)fRes) * 10);
            m_cmbYRes.AddString(csText);
            m_cmbYRes.SetItemData(i, (DWORD)fRes);
         }

         m_cmbYRes.SetCurSel(ptwCap->CapEnum->EnumCurrentIndex);
      }
      break;
   case L_TWON_RANGE:
      {
         int nSelIndex = 0;
         i = 0;

         float fMin = ptwCap->CapRange->GetRangeMinimumValue()->FloatValue;
         float fMax = ptwCap->CapRange->GetRangeMaximumValue()->FloatValue;
         float fStep = ptwCap->CapRange->GetRangeStepSize()->FloatValue;
         float fDefault = ptwCap->CapRange->GetRangeDefaultValue()->FloatValue;

         csText.Format(TEXT("%d.%d"), (int)fMin, (fMin - (int)fMin) * 10);

         m_cmbYRes.AddString(csText);
         m_cmbYRes.SetItemData(i, (DWORD)fMin);
         if (fDefault == fMin)
            nSelIndex = i;

         float fVal = fMin + fStep;
         while (fVal < fMax)
         {
            csText.Format(TEXT("%d.%d"), (int)fVal, (fVal - (int)fVal) * 10);

            i++;
            m_cmbYRes.AddString(csText);
            m_cmbYRes.SetItemData(i, (DWORD)fVal);
            if (fDefault == fVal)
               nSelIndex = i;

            fVal = fVal + fStep;
         }

         csText.Format(TEXT("%d.%d"), (int)fMax, (fMax - (int)fMax) * 10);

         i++;
         m_cmbYRes.AddString(csText);
         m_cmbYRes.SetItemData(i, (DWORD)fMax);
         if (fDefault == fMax)
            nSelIndex = i;

         m_cmbYRes.SetCurSel(nSelIndex);
      }
      break;
   case L_TWON_ONEVALUE:
      {
         fRes = ptwCap->CapOneValue->OneValCapValue->FloatValue;

         csText.Format(TEXT("%d.%d"), (int)fRes, (fRes - (int)fRes) * 10);

         m_cmbYRes.AddString(csText);
         m_cmbYRes.SetItemData(0, (DWORD)fRes);
         m_cmbYRes.SetCurSel(0);
      }
      break;
   }

   ptwCap->Release();
   ptwCap = NULL;
}

void CLEADTemplate::FillTransferMode()
{
   CWnd * pFileRadio = GetDlgItem(IDC_RADIO_TRANSFER_FILE);
   CWnd * pMemRadio = GetDlgItem(IDC_RADIO_TRANSFER_MEMORY);
   CWnd * pNativeRadio = GetDlgItem(IDC_RADIO_TRANSFER_NATIVE);

   ILEADTwainCapability_D * ptwCap = NULL;

   /* L_ICAP_XFERMECH */

   HRESULT hr = CoCreateInstance(CLSID_LEADTwainCapability_D, NULL, CLSCTX_ALL, IID_ILEADTwainCapability_D, (void**)&ptwCap);
   if (FAILED(hr))
      return;

   ptwCap->EnableMethodErrors = FALSE;
   ptwCap->CapInfo->Capability = L_ICAP_XFERMECH;
   ptwCap->CapInfo->ConType = L_TWON_ENUMERATION;
   short nRet = m_pRasterTwain->GetCapability2(ptwCap, L_LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != 0)
   {
      /* disable all transfer modes controls boxes */
      pFileRadio->EnableWindow(FALSE);
      pMemRadio->EnableWindow(FALSE);
      pNativeRadio->EnableWindow(FALSE);

      m_btnBrowse.EnableWindow(FALSE);
      m_txtFileName.EnableWindow(FALSE);
      m_cmbCompression.EnableWindow(FALSE);
      m_cmbFileFormats.EnableWindow(FALSE);
      return;
   }

   BOOL bFile, bNative, bMemory;
   short nContainerType = ptwCap->CapInfo->ConType;
   switch (nContainerType)
   {
   case L_TWON_ENUMERATION:
      {
         int nCount = ptwCap->CapEnum->EnumNumOfItems;
         for (int i=0; i<nCount; i++)
         {
            long item = ptwCap->CapEnum->GetEnumCapValue(i)->LongValue;
            switch (item)
            {
            case L_TWSX_NATIVE:
               pNativeRadio->EnableWindow();
               bNative = TRUE;
               break;
            case L_TWSX_FILE:
               pFileRadio->EnableWindow();
               bFile = TRUE;
               break;
            case L_TWSX_MEMORY:
               pMemRadio->EnableWindow();
               bMemory = TRUE;
               break;
            }
         }
      }
      break;
   case L_TWON_ONEVALUE:
      {
         long item = ptwCap->CapOneValue->OneValCapValue->LongValue;
         switch (item)
         {
         case L_TWSX_NATIVE:
            pNativeRadio->EnableWindow();
            bNative = TRUE;
            break;
         case L_TWSX_FILE:
            pFileRadio->EnableWindow();
            bFile = TRUE;
            break;
         case L_TWSX_MEMORY:
            pMemRadio->EnableWindow();
            bMemory = TRUE;
            break;
         }
      }
      break;
   }

   if (bFile)
      EnableFileMode();

   if (bMemory)
      EnableMemoryMode();

   if (bNative)
      EnableNativeMode();

   ptwCap->Release();
}

void CLEADTemplate::EnableFileMode()
{
   CTwainApp * pApp = (CTwainApp *)AfxGetApp();
   pApp->m_twXferMech = L_TWSX_FILE;

   /* Enable file options */
   m_txtFileName.EnableWindow();
   m_btnBrowse.EnableWindow();
   m_cmbFileFormats.EnableWindow();

   /* Disable other options */
   m_cmbCompression.EnableWindow(FALSE);

   /* select file radio and deselect others */
   CheckDlgButton(IDC_RADIO_TRANSFER_FILE, TRUE);
   CheckDlgButton(IDC_RADIO_TRANSFER_MEMORY, FALSE);
   CheckDlgButton(IDC_RADIO_TRANSFER_NATIVE, FALSE);

   /* L_ICAP_IMAGEFILEFORMAT */
   FillImageFileFormat();

   CheckOkButton();
}

void CLEADTemplate::FillImageFileFormat()
{
   ILEADTwainCapability_D * ptwCap = NULL;

   /* L_ICAP_IMAGEFILEFORMAT */

   HRESULT hr = CoCreateInstance(CLSID_LEADTwainCapability_D, NULL, CLSCTX_ALL, IID_ILEADTwainCapability_D, (void**)&ptwCap);
   if (FAILED(hr))
      return;

   ptwCap->EnableMethodErrors = FALSE;
   ptwCap->CapInfo->Capability = L_ICAP_IMAGEFILEFORMAT;
   ptwCap->CapInfo->ConType = L_TWON_ENUMERATION;
   short nRet = m_pRasterTwain->GetCapability2(ptwCap, L_LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != 0)
   {
      /* disable all file modes controls */
      m_txtFileName.EnableWindow(FALSE);
      m_btnBrowse.EnableWindow(FALSE);
      m_cmbFileFormats.EnableWindow(FALSE);
      return;
   }

   m_cmbFileFormats.ResetContent();

   short nContainerType = ptwCap->CapInfo->ConType;
   switch (nContainerType)
   {
   case L_TWON_ENUMERATION:
      {
         int nCount = ptwCap->CapEnum->EnumNumOfItems;
         for (int i=0; i<nCount; i++)
         {
            long item = ptwCap->CapEnum->GetEnumCapValue(i)->LongValue;

            switch (item)
            {
            case L_TWFF_TIFF:
               m_cmbFileFormats.AddString(TEXT("TIFF"));
               break;
            case L_TWFF_PICT:
               m_cmbFileFormats.AddString(TEXT("PICT"));
               break;
            case L_TWFF_BMP:
               m_cmbFileFormats.AddString(TEXT("BMP"));
               break;
            case L_TWFF_XBM:
               m_cmbFileFormats.AddString(TEXT("XBM"));
               break;
            case L_TWFF_JFIF:
               m_cmbFileFormats.AddString(TEXT("JFIF"));
               break;
            case L_TWFF_FPX:
               m_cmbFileFormats.AddString(TEXT("FPX"));
               break;
            case L_TWFF_TIFFMULTI:
               m_cmbFileFormats.AddString(TEXT("TIFFMULTI"));
               break;
            case L_TWFF_PNG:
               m_cmbFileFormats.AddString(TEXT("PNG"));
               break;
            case L_TWFF_SPIFF:
               m_cmbFileFormats.AddString(TEXT("SPIFF"));
               break;
            case L_TWFF_EXIF:
               m_cmbFileFormats.AddString(TEXT("EXIF"));
               break;
            }

            m_cmbFileFormats.SetItemData(i, item);
         }

         m_cmbFileFormats.SetCurSel(ptwCap->CapEnum->EnumDefaultIndex);
      }
      break;
   case L_TWON_ONEVALUE:
      {
         long item = ptwCap->CapOneValue->OneValCapValue->LongValue;
         switch (item)
         {
         case L_TWFF_TIFF:
            m_cmbFileFormats.AddString(TEXT("TIFF"));
            break;
         case L_TWFF_PICT:
            m_cmbFileFormats.AddString(TEXT("PICT"));
            break;
         case L_TWFF_BMP:
            m_cmbFileFormats.AddString(TEXT("BMP"));
            break;
         case L_TWFF_XBM:
            m_cmbFileFormats.AddString(TEXT("XBM"));
            break;
         case L_TWFF_JFIF:
            m_cmbFileFormats.AddString(TEXT("JFIF"));
            break;
         case L_TWFF_FPX:
            m_cmbFileFormats.AddString(TEXT("FPX"));
            break;
         case L_TWFF_TIFFMULTI:
            m_cmbFileFormats.AddString(TEXT("TIFFMULTI"));
            break;
         case L_TWFF_PNG:
            m_cmbFileFormats.AddString(TEXT("PNG"));
            break;
         case L_TWFF_SPIFF:
            m_cmbFileFormats.AddString(TEXT("SPIFF"));
            break;
         case L_TWFF_EXIF:
            m_cmbFileFormats.AddString(TEXT("EXIF"));
            break;
         }

         m_cmbFileFormats.SetItemData(0, item);
         m_cmbFileFormats.SetCurSel(0);
      }
      break;
   }

   ptwCap->Release();
}

void CLEADTemplate::EnableMemoryMode()
{
   CTwainApp * pApp = (CTwainApp *)AfxGetApp();
   pApp->m_twXferMech = L_TWSX_MEMORY;

   /* Enable memory options */
   m_cmbCompression.EnableWindow(TRUE);

   /* Disable other options */
   m_txtFileName.EnableWindow(FALSE);
   m_btnBrowse.EnableWindow(FALSE);
   m_cmbFileFormats.EnableWindow(FALSE);

   /* select memory radio and deselect others */
   CheckDlgButton(IDC_RADIO_TRANSFER_MEMORY, TRUE);
   CheckDlgButton(IDC_RADIO_TRANSFER_FILE, FALSE);
   CheckDlgButton(IDC_RADIO_TRANSFER_NATIVE, FALSE);

   /* L_ICAP_COMPRESSION */
   FillCompression();

   CheckOkButton();
}

void CLEADTemplate::FillCompression()
{
   ILEADTwainCapability_D * ptwCap = NULL;

   /* L_ICAP_COMPRESSION */

   HRESULT hr = CoCreateInstance(CLSID_LEADTwainCapability_D, NULL, CLSCTX_ALL, IID_ILEADTwainCapability_D, (void**)&ptwCap);
   if (FAILED(hr))
      return;

   ptwCap->EnableMethodErrors = FALSE;
   ptwCap->CapInfo->Capability = L_ICAP_COMPRESSION;
   ptwCap->CapInfo->ConType = L_TWON_ENUMERATION;
   short nRet = m_pRasterTwain->GetCapability2(ptwCap, L_LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != 0)
   {
      /* disable all memory modes controls */
      m_cmbCompression.EnableWindow(FALSE);
      return;
   }

   m_cmbCompression.ResetContent();

   short nContainerType = ptwCap->CapInfo->ConType;
   switch (nContainerType)
   {
   case L_TWON_ENUMERATION:
      {
         int nCount = ptwCap->CapEnum->EnumNumOfItems;
         for (int i=0; i<nCount; i++)
         {
            long item = ptwCap->CapEnum->GetEnumCapValue(i)->LongValue;

            switch (item)
            {
            case L_TWCP_NONE:
               m_cmbCompression.AddString(TEXT("NONE"));
               break;
            case L_TWCP_PACKBITS:
               m_cmbCompression.AddString(TEXT("PACKBITS"));
               break;
            case L_TWCP_GROUP31D:
               m_cmbCompression.AddString(TEXT("GROUP31D"));
               break;
            case L_TWCP_GROUP31DEOL:
               m_cmbCompression.AddString(TEXT("GROUP31DEOL"));
               break;
            case L_TWCP_GROUP32D:
               m_cmbCompression.AddString(TEXT("GROUP32D"));
               break;
            case L_TWCP_GROUP4:
               m_cmbCompression.AddString(TEXT("GROUP4"));
               break;
            case L_TWCP_JPEG:
               m_cmbCompression.AddString(TEXT("JPEG"));
               break;
            case L_TWCP_LZW:
               m_cmbCompression.AddString(TEXT("LZW"));
               break;
            case L_TWCP_JBIG:
               m_cmbCompression.AddString(TEXT("JBIG"));
               break;
            case L_TWCP_PNG:
               m_cmbCompression.AddString(TEXT("PNG"));
               break;
            case L_TWCP_RLE4:
               m_cmbCompression.AddString(TEXT("RLE4"));
               break;
            case L_TWCP_RLE8:
               m_cmbCompression.AddString(TEXT("RLE8"));
               break;
            case L_TWCP_BITFIELDS:
               m_cmbCompression.AddString(TEXT("BITFIELDS"));
               break;
            }
            m_cmbCompression.SetItemData(i, item);
         }

         m_cmbCompression.SetCurSel(ptwCap->CapEnum->EnumDefaultIndex);
      }
      break;
   case L_TWON_ONEVALUE:
      {
         long item = ptwCap->CapOneValue->OneValCapValue->LongValue;

         switch (item)
         {
         case L_TWCP_NONE:
            m_cmbCompression.AddString(TEXT("NONE"));
            break;
         case L_TWCP_PACKBITS:
            m_cmbCompression.AddString(TEXT("PACKBITS"));
            break;
         case L_TWCP_GROUP31D:
            m_cmbCompression.AddString(TEXT("GROUP31D"));
            break;
         case L_TWCP_GROUP31DEOL:
            m_cmbCompression.AddString(TEXT("GROUP31DEOL"));
            break;
         case L_TWCP_GROUP32D:
            m_cmbCompression.AddString(TEXT("GROUP32D"));
            break;
         case L_TWCP_GROUP4:
            m_cmbCompression.AddString(TEXT("GROUP4"));
            break;
         case L_TWCP_JPEG:
            m_cmbCompression.AddString(TEXT("JPEG"));
            break;
         case L_TWCP_LZW:
            m_cmbCompression.AddString(TEXT("LZW"));
            break;
         case L_TWCP_JBIG:
            m_cmbCompression.AddString(TEXT("JBIG"));
            break;
         case L_TWCP_PNG:
            m_cmbCompression.AddString(TEXT("PNG"));
            break;
         case L_TWCP_RLE4:
            m_cmbCompression.AddString(TEXT("RLE4"));
            break;
         case L_TWCP_RLE8:
            m_cmbCompression.AddString(TEXT("RLE8"));
            break;
         case L_TWCP_BITFIELDS:
            m_cmbCompression.AddString(TEXT("BITFIELDS"));
            break;
         }
         m_cmbCompression.SetItemData(0, item);
         m_cmbCompression.SetCurSel(0);
      }
      break;
   }

   ptwCap->Release();
}

void CLEADTemplate::EnableNativeMode()
{
   CTwainApp * pApp = (CTwainApp *)AfxGetApp();
   pApp->m_twXferMech = L_TWSX_NATIVE;

   /* Disable other options */
   m_cmbCompression.EnableWindow(FALSE);
   m_txtFileName.EnableWindow(FALSE);
   m_btnBrowse.EnableWindow(FALSE);
   m_cmbFileFormats.EnableWindow(FALSE);

   /* select native radio and deselect others */
   CheckDlgButton(IDC_RADIO_TRANSFER_NATIVE, TRUE);
   CheckDlgButton(IDC_RADIO_TRANSFER_FILE, FALSE);
   CheckDlgButton(IDC_RADIO_TRANSFER_MEMORY, FALSE);

   CheckOkButton();
}

void CLEADTemplate::FillPixelType()
{
   ILEADTwainCapability_D * ptwCap = NULL;

   /* L_ICAP_PIXELTYPE */

   HRESULT hr = CoCreateInstance(CLSID_LEADTwainCapability_D, NULL, CLSCTX_ALL, IID_ILEADTwainCapability_D, (void**)&ptwCap);
   if (FAILED(hr))
      return;

   ptwCap->EnableMethodErrors = FALSE;
   ptwCap->CapInfo->Capability = L_ICAP_PIXELTYPE;
   ptwCap->CapInfo->ConType = L_TWON_ENUMERATION;
   short nRet = m_pRasterTwain->GetCapability2(ptwCap, L_LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != 0)
   {
      /* disable pixel type combo box */
      m_cmbPixelType.EnableWindow(FALSE);
      return;
   }

   m_cmbPixelType.ResetContent();

   short nContainerType = ptwCap->CapInfo->ConType;
   switch (nContainerType)
   {
   case L_TWON_ENUMERATION:
      {
         int nCount = ptwCap->CapEnum->EnumNumOfItems;
         for (int i=0; i<nCount; i++)
         {
            long item = ptwCap->CapEnum->GetEnumCapValue(i)->LongValue;

            switch (item)
            {
            case L_TWPT_BW:
               m_cmbPixelType.AddString(TEXT("BW"));
               break;
            case L_TWPT_GRAY:
               m_cmbPixelType.AddString(TEXT("GRAY"));
               break;
            case L_TWPT_RGB:
               m_cmbPixelType.AddString(TEXT("RGB"));
               break;
            case L_TWPT_PALETTE:
               m_cmbPixelType.AddString(TEXT("PALETTE"));
               break;
            case L_TWPT_CMY:
               m_cmbPixelType.AddString(TEXT("CMY"));
               break;
            case L_TWPT_CMYK:
               m_cmbPixelType.AddString(TEXT("CMYK"));
               break;
            case L_TWPT_YUV:
               m_cmbPixelType.AddString(TEXT("YUV"));
               break;
            case L_TWPT_YUVK:
               m_cmbPixelType.AddString(TEXT("YUVK"));
               break;
            case L_TWPT_CIEXYZ:
               m_cmbPixelType.AddString(TEXT("CIEXYZ"));
               break;
            }

            m_cmbPixelType.SetItemData(i, item);
         }

         m_cmbPixelType.SetCurSel(ptwCap->CapEnum->EnumDefaultIndex);
      }
      break;
   case L_TWON_ONEVALUE:
      {
         long item = ptwCap->CapOneValue->OneValCapValue->LongValue;

         switch (item)
         {
         case L_TWPT_BW:
            m_cmbPixelType.AddString(TEXT("BW"));
            break;
         case L_TWPT_GRAY:
            m_cmbPixelType.AddString(TEXT("GRAY"));
            break;
         case L_TWPT_RGB:
            m_cmbPixelType.AddString(TEXT("RGB"));
            break;
         case L_TWPT_PALETTE:
            m_cmbPixelType.AddString(TEXT("PALETTE"));
            break;
         case L_TWPT_CMY:
            m_cmbPixelType.AddString(TEXT("CMY"));
            break;
         case L_TWPT_CMYK:
            m_cmbPixelType.AddString(TEXT("CMYK"));
            break;
         case L_TWPT_YUV:
            m_cmbPixelType.AddString(TEXT("YUV"));
            break;
         case L_TWPT_YUVK:
            m_cmbPixelType.AddString(TEXT("YUVK"));
            break;
         case L_TWPT_CIEXYZ:
            m_cmbPixelType.AddString(TEXT("CIEXYZ"));
            break;
         }

         m_cmbPixelType.SetItemData(0, item);
         m_cmbPixelType.SetCurSel(0);
      }
      break;
   }

   ptwCap->Release();
}

void CLEADTemplate::FillOrientation()
{
   ILEADTwainCapability_D * ptwCap = NULL;

   /* L_ICAP_ORIENTATION */

   HRESULT hr = CoCreateInstance(CLSID_LEADTwainCapability_D, NULL, CLSCTX_ALL, IID_ILEADTwainCapability_D, (void**)&ptwCap);
   if (FAILED(hr))
      return;

   ptwCap->EnableMethodErrors = FALSE;
   ptwCap->CapInfo->Capability = L_ICAP_ORIENTATION;
   ptwCap->CapInfo->ConType = L_TWON_ENUMERATION;
   short nRet = m_pRasterTwain->GetCapability2(ptwCap, L_LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != 0)
   {
      /* disable all orientation combo box */
      m_cmbOrientation.EnableWindow(FALSE);
      return;
   }

   m_cmbOrientation.ResetContent();

   short nContainerType = ptwCap->CapInfo->ConType;
   switch (nContainerType)
   {
   case L_TWON_ENUMERATION:
      {
         int nCount = ptwCap->CapEnum->EnumNumOfItems;
         for (int i=0; i<nCount; i++)
         {
            long item = ptwCap->CapEnum->GetEnumCapValue(i)->LongValue;

            switch (item)
            {
            case L_TWOR_ROT0:
               m_cmbOrientation.AddString(TEXT("ROT0"));
               break;
            case L_TWOR_ROT90:
               m_cmbOrientation.AddString(TEXT("ROT90"));
               break;
            case L_TWOR_ROT180:
               m_cmbOrientation.AddString(TEXT("ROT180"));
               break;
            case L_TWOR_ROT270:
               m_cmbOrientation.AddString(TEXT("ROT270"));
               break;
            }

            m_cmbOrientation.SetItemData(i, item);
         }

         m_cmbOrientation.SetCurSel(ptwCap->CapEnum->EnumDefaultIndex);
      }
      break;
   case L_TWON_ONEVALUE:
      {
         long item = ptwCap->CapOneValue->OneValCapValue->LongValue;

         switch (item)
         {
         case L_TWOR_ROT0:
            m_cmbOrientation.AddString(TEXT("ROT0"));
            break;
         case L_TWOR_ROT90:
            m_cmbOrientation.AddString(TEXT("ROT90"));
            break;
         case L_TWOR_ROT180:
            m_cmbOrientation.AddString(TEXT("ROT180"));
            break;
         case L_TWOR_ROT270:
            m_cmbOrientation.AddString(TEXT("ROT270"));
            break;
         }

         m_cmbOrientation.SetItemData(0, item);
         m_cmbOrientation.SetCurSel(0);
      }
      break;
   }

   ptwCap->Release();
}

void CLEADTemplate::FillEffectsCap(short nCapability)
{
   ILEADTwainCapability_D * ptwCap = NULL;

   /* L_ICAP_CONTRAST, L_ICAP_BRIGHTNESS, L_ICAP_HIGHLIGHT */
   CComboBox  * pTempCombo = NULL;
   switch (nCapability)
   {
   case L_ICAP_CONTRAST:
      pTempCombo = &m_cmbContrast;
      break;
   case L_ICAP_BRIGHTNESS:
      pTempCombo = &m_cmbBrightness;
      break;
   case L_ICAP_HIGHLIGHT:
      pTempCombo = &m_cmbHighlight;
      break;
   }

   HRESULT hr = CoCreateInstance(CLSID_LEADTwainCapability_D, NULL, CLSCTX_ALL, IID_ILEADTwainCapability_D, (void**)&ptwCap);
   if (FAILED(hr))
      return;

   ptwCap->EnableMethodErrors = FALSE;
   ptwCap->CapInfo->Capability = nCapability;
   ptwCap->CapInfo->ConType = L_TWON_ENUMERATION;
   short nRet = m_pRasterTwain->GetCapability2(ptwCap, L_LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != 0)
   {
      /* disable effect combo box */
      pTempCombo->EnableWindow(FALSE);
      return;
   }

   pTempCombo->ResetContent();

   float fTempVal;
   CString csText;
   int i;

   short nContainerType = ptwCap->CapInfo->ConType;
   switch (nContainerType)
   {
   case L_TWON_ENUMERATION:
      {
         int nCount = ptwCap->CapEnum->EnumNumOfItems;
         for (i=0; i<nCount; i++)
         {
            fTempVal = ptwCap->CapEnum->GetEnumCapValue(i)->FloatValue;

            csText.Format(TEXT("%d.%d"), (int)fTempVal, (fTempVal - (int)fTempVal) * 10);
            pTempCombo->AddString(csText);
            pTempCombo->SetItemData(i, (DWORD)fTempVal);
         }

         pTempCombo->SetCurSel(ptwCap->CapEnum->EnumCurrentIndex);
      }
      break;
   case L_TWON_RANGE:
      {
         int nSelIndex = 0;
         i = 0;

         float fMin = ptwCap->CapRange->GetRangeMinimumValue()->FloatValue;
         float fMax = ptwCap->CapRange->GetRangeMaximumValue()->FloatValue;
         float fStep = ptwCap->CapRange->GetRangeStepSize()->FloatValue;
         float fDefault = ptwCap->CapRange->GetRangeDefaultValue()->FloatValue;

         csText.Format(TEXT("%d.%d"), (int)fMin, (fMin - (int)fMin) * 10);

         pTempCombo->AddString(csText);
         pTempCombo->SetItemData(i, (DWORD)fMin);
         if (fDefault == fMin)
            nSelIndex = i;

         float fVal = fMin + fStep;
         while (fVal < fMax)
         {
            csText.Format(TEXT("%d.%d"), (int)fVal, (fVal - (int)fVal) * 10);

            i++;
            pTempCombo->AddString(csText);
            pTempCombo->SetItemData(i, (DWORD)fVal);
            if (fDefault == fVal)
               nSelIndex = i;

            fVal = fVal + fStep;
         }

         csText.Format(TEXT("%d.%d"), (int)fMax, (fMax - (int)fMax) * 10);

         i++;
         pTempCombo->AddString(csText);
         pTempCombo->SetItemData(i, (DWORD)fMax);
         if (fDefault == fMax)
            nSelIndex = i;

         pTempCombo->SetCurSel(nSelIndex);
      }
      break;
   case L_TWON_ONEVALUE:
      {
         fTempVal = ptwCap->CapOneValue->OneValCapValue->FloatValue;

         csText.Format(TEXT("%d.%d"), (int)fTempVal, (fTempVal - (int)fTempVal) * 10);

         pTempCombo->AddString(csText);
         pTempCombo->SetItemData(0, (DWORD)fTempVal);
         pTempCombo->SetCurSel(0);
      }
      break;
   }

   ptwCap->Release();
}

void CLEADTemplate::FillHalftones()
{
   ILEADTwainCapability_D * ptwCap = NULL;

   /* L_ICAP_HALFTONES */

   HRESULT hr = CoCreateInstance(CLSID_LEADTwainCapability_D, NULL, CLSCTX_ALL, IID_ILEADTwainCapability_D, (void**)&ptwCap);
   if (FAILED(hr))
      return;

   ptwCap->EnableMethodErrors = FALSE;
   ptwCap->CapInfo->Capability = L_ICAP_HALFTONES;
   ptwCap->CapInfo->ConType = L_TWON_ENUMERATION;
   short nRet = m_pRasterTwain->GetCapability2(ptwCap, L_LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != 0)
   {
      /* disable halftone combo box */
      m_cmbHalftone.EnableWindow(FALSE);
      return;
   }

   m_cmbHalftone.ResetContent();

   short nContainerType = ptwCap->CapInfo->ConType;
   switch (nContainerType)
   {
   case L_TWON_ENUMERATION:
      {
         int nCount = ptwCap->CapEnum->EnumNumOfItems;
         for (int i=0; i<nCount; i++)
         {
            BSTR bstrHalftone = ptwCap->CapEnum->GetEnumCapValue(i)->GetStringValue();
            CString csHalftone = bstrHalftone;
            m_cmbHalftone.AddString(csHalftone);
         }

         m_cmbHalftone.SetCurSel(ptwCap->CapEnum->EnumCurrentIndex);
      }
      break;
   case L_TWON_ARRAY:
      {
         int nCount = ptwCap->CapArray->ArrayNumOfItems;
         for (int i=0; i<nCount; i++)
         {
            BSTR bstrHalftone = ptwCap->CapArray->GetArrayCapValue(i)->GetStringValue();
            CString csHalftone = bstrHalftone;
            m_cmbHalftone.AddString(csHalftone);
         }

         m_cmbHalftone.SetCurSel(0);
      }
      break;
   case L_TWON_ONEVALUE:
      {
         BSTR bstrHalftone = ptwCap->CapOneValue->OneValCapValue->GetStringValue();
         CString csHalftone = bstrHalftone;
         m_cmbHalftone.AddString(csHalftone);
         m_cmbHalftone.SetCurSel(0);
      }
      break;
   }

   ptwCap->Release();
}

void CLEADTemplate::CheckOkButton()
{
   CString csTextFrameLeft;
   CString csTextFrameTop;
   CString csTextFrameRight;
   CString csTextFrameBottom;
   CString csTextFileName;
   BOOL    bFrameEnabled = TRUE, bFileEnabled = TRUE, bOkEnabled = TRUE;

   bFrameEnabled = m_txtFrameLeft.IsWindowEnabled();
   if (bFrameEnabled)
   {
      m_txtFrameLeft.GetWindowText(csTextFrameLeft);
      m_txtFrameTop.GetWindowText(csTextFrameTop);
      m_txtFrameRight.GetWindowText(csTextFrameRight);
      m_txtFrameBottom.GetWindowText(csTextFrameBottom);

      if (csTextFrameLeft.IsEmpty() ||
          csTextFrameTop.IsEmpty() ||
          csTextFrameRight.IsEmpty() ||
          csTextFrameBottom.IsEmpty())
         bOkEnabled = FALSE;
   }
   else
      bOkEnabled = TRUE;

   bFileEnabled = m_txtFileName.IsWindowEnabled();
   if (bFileEnabled)
   {
      m_txtFileName.GetWindowText(csTextFileName);
      if (csTextFileName.IsEmpty())
         bOkEnabled = FALSE;
   }

   m_btnOk.EnableWindow(bOkEnabled);
}

void CLEADTemplate::OnRadioTransferFile()
{
   EnableFileMode();
}

void CLEADTemplate::OnRadioTransferMemory()
{
   EnableMemoryMode();
}

void CLEADTemplate::OnRadioTransferNative()
{
   EnableNativeMode();
}

void CLEADTemplate::OnButtonFileBrowse()
{
   CFileDialog FileDlg(FALSE, NULL, NULL,
                       OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
                       TEXT("All Files (*.*)|*.*|"));

   if (FileDlg.DoModal() == IDOK)
      m_txtFileName.SetWindowText(FileDlg.GetPathName());

   CheckOkButton();
}

void CLEADTemplate::SetCapabilities()
{
   /* L_ICAP_UNITS */
   SetUnitsCapability();

   /* L_ICAP_FRAMES */
   SetFramesCapability();

   /* L_ICAP_XRESOLUTION - L_ICAP_YRESOLUTION */
   SetXYResCapability();

   /* L_ICAP_XFERMECH */
   SetXferCapability();

   /* L_ICAP_PIXELTYPE */
   SetPixelTypeCapability();

   /* L_ICAP_ORIENTATION */
   SetOrientationCapability();

   /* L_ICAP_CONTRAST, L_ICAP_BRIGHTNESS, L_ICAP_HIGHLIGHT */
   SetContrastCapability();
   SetBrightnessCapability();
   SetHighlightCapability();

   /* L_ICAP_HALFTONES */
   SetHalftonesCapability();
}

void CLEADTemplate::SetUnitsCapability()
{
   /* L_ICAP_UNITS */
   BOOL bEnabled = m_cmbUnits.IsWindowEnabled();
   if (!bEnabled)
      return;

   int nIndex = m_cmbUnits.GetCurSel();
   DWORD dwItemData = m_cmbUnits.GetItemData(nIndex);

   int nRet = MySetCapability(L_ICAP_UNITS, L_TWTY_UINT16, (long)dwItemData);
   if (nRet != 0)
   {
      CString csError;
      csError.Format(TEXT("Error occurred during set L_ICAP_UNITS capability, nRet = %d"), nRet);

      CTwainApp * pApp = (CTwainApp *)AfxGetApp();
      pApp->AddErrorToErrorsList(csError);
   }
}

void CLEADTemplate::SetFramesCapability()
{
   /* L_ICAP_FRAMES */
   BOOL bEnabled = m_txtFrameLeft.IsWindowEnabled();
   if (!bEnabled)
      return;

   ItwFrame_D * ptwFrame = NULL;

   HRESULT hr = CoCreateInstance(CLSID_twFrame_D, NULL, CLSCTX_ALL, IID_ItwFrame_D, (void**)&ptwFrame);
   if (FAILED(hr))
      return;

   CHAR szText[MAX_PATH];

   memset(szText, 0, sizeof(szText));
   ::GetWindowTextA(m_txtFrameLeft.m_hWnd, szText, sizeof(szText));
   float fLeft = (float)atof(szText);

   memset(szText, 0, sizeof(szText));
   ::GetWindowTextA(m_txtFrameTop.m_hWnd, szText, sizeof(szText));
   float fTop = (float)atof(szText);

   memset(szText, 0, sizeof(szText));
   ::GetWindowTextA(m_txtFrameRight.m_hWnd, szText, sizeof(szText));
   float fRight = (float)atof(szText);

   memset(szText, 0, sizeof(szText));
   ::GetWindowTextA(m_txtFrameBottom.m_hWnd, szText, sizeof(szText));
   float fBottom = (float)atof(szText);

   ptwFrame->LeftMargin = fLeft;
   ptwFrame->TopMargin = fTop;
   ptwFrame->RightMargin = fRight;
   ptwFrame->BottomMargin = fBottom;

   int nRet = MySetCapability(L_ICAP_FRAMES, L_TWTY_FRAME, (long)ptwFrame);
   if (nRet != 0)
   {
      CString csError;
      csError.Format(TEXT("Error occurred during set L_ICAP_FRAMES capability, nRet = %d"), nRet);

      CTwainApp * pApp = (CTwainApp *)AfxGetApp();
      pApp->AddErrorToErrorsList(csError);
   }
   ptwFrame->Release();
}

void CLEADTemplate::SetXYResCapability()
{
   /* L_ICAP_XRESOLUTION */
   BOOL bEnabled = m_cmbXRes.IsWindowEnabled();
   if (!bEnabled)
      return;

   float fRes = (float)m_cmbXRes.GetItemData(m_cmbXRes.GetCurSel());

   int nRet = MySetCapability(L_ICAP_XRESOLUTION, L_TWTY_FIX32, (long)fRes);
   if (nRet != 0)
   {
      CString csError;
      csError.Format(TEXT("Error occurred during set L_ICAP_XRESOLUTION capability, nRet = %d"), nRet);

      CTwainApp * pApp = (CTwainApp *)AfxGetApp();
      pApp->AddErrorToErrorsList(csError);
   }

   /* L_ICAP_YRESOLUTION */
   bEnabled = m_cmbYRes.IsWindowEnabled();
   if (!bEnabled)
      return;

   fRes = (float)m_cmbYRes.GetItemData(m_cmbYRes.GetCurSel());

   nRet = MySetCapability(L_ICAP_YRESOLUTION, L_TWTY_FIX32, (long)fRes);
   if (nRet != 0)
   {
      CString csError;
      csError.Format(TEXT("Error occurred during set L_ICAP_YRESOLUTION capability, nRet = %d"), nRet);

      CTwainApp * pApp = (CTwainApp *)AfxGetApp();
      pApp->AddErrorToErrorsList(csError);
   }
}

void CLEADTemplate::SetXferCapability()
{
   /* L_ICAP_XFERMECH */

   CWnd * pNativeRadio = GetDlgItem(IDC_RADIO_TRANSFER_NATIVE);
   CWnd * pFileRadio = GetDlgItem(IDC_RADIO_TRANSFER_FILE);
   CWnd * pMemRadio = GetDlgItem(IDC_RADIO_TRANSFER_MEMORY);

   BOOL bNativeEnabled = pNativeRadio->IsWindowEnabled();
   BOOL bFileEnabled = pFileRadio->IsWindowEnabled();
   BOOL bMemoryEnabled = pMemRadio->IsWindowEnabled();

   if (!bMemoryEnabled && !bFileEnabled && !bNativeEnabled)
      return;

   CTwainApp * pApp = (CTwainApp *)AfxGetApp();
   int nRet = MySetCapability(L_ICAP_XFERMECH, L_TWTY_UINT16, (long)pApp->m_twXferMech);
   if (nRet != 0)
   {
      CString csError;
      csError.Format(TEXT("Error occurred during set L_ICAP_XFERMECH capability, nRet = %d"), nRet);

      pApp->AddErrorToErrorsList(csError);
      return;
   }

   switch (pApp->m_twXferMech)
   {
   case L_TWSX_FILE:
      {
         /* L_ICAP_IMAGEFILEFORMAT */

         DWORD dwData = m_cmbFileFormats.GetItemData(m_cmbFileFormats.GetCurSel());
         int nRet = MySetCapability(L_ICAP_IMAGEFILEFORMAT, L_TWTY_UINT16, (long)dwData);
         if (nRet != 0)
         {
            CString csError;
            csError.Format(TEXT("Error occurred during set L_ICAP_IMAGEFILEFORMAT capability, nRet = %d"), nRet);

            pApp->AddErrorToErrorsList(csError);
         }

         m_pRasterTwain->GetProperties();
         m_pRasterTwain->DataTransfer->ScanFileFormat = (short)dwData;
         m_pRasterTwain->SetProperties();

         UpdateData();
         BSTR bstrFileName = m_csFileName.AllocSysString();
         m_pRasterTwain->put_FileTransferName(bstrFileName);

         SysFreeString(bstrFileName);
      }
      break;
   case L_TWSX_MEMORY:
      {
         /* L_ICAP_COMPRESSION */
         DWORD dwData = m_cmbCompression.GetItemData(m_cmbCompression.GetCurSel());

         nRet = MySetCapability(L_ICAP_COMPRESSION, L_TWTY_UINT16, (long)dwData);
         if (nRet != 0)
         {
            CString csError;
            csError.Format(TEXT("Error occurred during set ICAP_COMPRESSION capability, nRet = %d"), nRet);

            pApp->AddErrorToErrorsList(csError);
         }
      }
      break;
   case L_TWSX_NATIVE:
      /* do nothing */
      break;
   }
}

void CLEADTemplate::SetPixelTypeCapability()
{
   /* L_ICAP_PIXELTYPE */
   BOOL bEnabled = m_cmbPixelType.IsWindowEnabled();
   if (!bEnabled)
      return;

   long lData = (long)m_cmbPixelType.GetItemData(m_cmbPixelType.GetCurSel());

   int nRet = MySetCapability(L_ICAP_PIXELTYPE, L_TWTY_UINT16, (long)lData);
   if (nRet != 0)
   {
      CString csError;
      csError.Format(TEXT("Error occurred during set L_ICAP_PIXELTYPE capability, nRet = %d"), nRet);

      CTwainApp * pApp = (CTwainApp *)AfxGetApp();
      pApp->AddErrorToErrorsList(csError);
   }
}

void CLEADTemplate::SetOrientationCapability()
{
   /* L_ICAP_ORIENTATION */
   BOOL bEnabled = m_cmbOrientation.IsWindowEnabled();
   if (!bEnabled)
      return;

   long lData = (long)m_cmbOrientation.GetItemData(m_cmbOrientation.GetCurSel());

   int nRet = MySetCapability(L_ICAP_ORIENTATION, L_TWTY_UINT16, (long)lData);
   if (nRet != 0)
   {
      CString csError;
      csError.Format(TEXT("Error occurred during set L_ICAP_ORIENTATION capability, nRet = %d"), nRet);

      CTwainApp * pApp = (CTwainApp *)AfxGetApp();
      pApp->AddErrorToErrorsList(csError);
   }
}

void CLEADTemplate::SetContrastCapability()
{
   /* L_ICAP_CONTRAST */
   BOOL bEnabled = m_cmbContrast.IsWindowEnabled();
   if (!bEnabled)
      return;

   float fData = (float)m_cmbContrast.GetItemData(m_cmbContrast.GetCurSel());

   int nRet = MySetCapability(L_ICAP_CONTRAST, L_TWTY_FIX32, (long)fData);
   if (nRet != 0)
   {
      CString csError;
      csError.Format(TEXT("Error occurred during set L_ICAP_CONTRAST capability, nRet = %d"), nRet);

      CTwainApp * pApp = (CTwainApp *)AfxGetApp();
      pApp->AddErrorToErrorsList(csError);
   }
}

void CLEADTemplate::SetBrightnessCapability()
{
   /* L_ICAP_BRIGHTNESS */
   BOOL bEnabled = m_cmbBrightness.IsWindowEnabled();
   if (!bEnabled)
      return;

   float fData = (float)m_cmbBrightness.GetItemData(m_cmbBrightness.GetCurSel());

   int nRet = MySetCapability(L_ICAP_BRIGHTNESS, L_TWTY_FIX32, (long)fData);
   if (nRet != 0)
   {
      CString csError;
      csError.Format(TEXT("Error occurred during set L_ICAP_BRIGHTNESS capability, nRet = %d"), nRet);

      CTwainApp * pApp = (CTwainApp *)AfxGetApp();
      pApp->AddErrorToErrorsList(csError);
   }
}

void CLEADTemplate::SetHighlightCapability()
{
   /* L_ICAP_HIGHLIGHT */
   BOOL bEnabled = m_cmbHighlight.IsWindowEnabled();
   if (!bEnabled)
      return;

   float fData = (float)m_cmbHighlight.GetItemData(m_cmbHighlight.GetCurSel());

   int nRet = MySetCapability(L_ICAP_HIGHLIGHT, L_TWTY_FIX32, (long)fData);
   if (nRet != 0)
   {
      CString csError;
      csError.Format(TEXT("Error occurred during set L_ICAP_HIGHLIGHT capability, nRet = %d"), nRet);

      CTwainApp * pApp = (CTwainApp *)AfxGetApp();
      pApp->AddErrorToErrorsList(csError);
   }
}

void CLEADTemplate::SetHalftonesCapability()
{
   /* L_ICAP_HALFTONES */
   BOOL bEnabled = m_cmbHalftone.IsWindowEnabled();
   if (!bEnabled)
      return;

   CString csData;
   m_cmbHalftone.GetLBText(m_cmbHalftone.GetCurSel(), csData);

   int nRet = MySetCapability(L_ICAP_HALFTONES, L_TWTY_STR32, (long)(LPCTSTR)csData);
   if (nRet != 0)
   {
      CString csError;
      csError.Format(TEXT("Error occurred during set L_ICAP_HALFTONES capability, nRet = %d"), nRet);

      CTwainApp * pApp = (CTwainApp *)AfxGetApp();
      pApp->AddErrorToErrorsList(csError);
   }
}

void CLEADTemplate::OnButtonTemplateLoad() 
{
   CFileDialog FileDlg(TRUE, NULL, NULL,
                       OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
                       TEXT("LEAD Template (*.ltt)|*.ltt|"));

   if (FileDlg.DoModal() == IDOK)
   {
      CString csFileName = FileDlg.GetPathName();
      BSTR bstrFile = csFileName.AllocSysString();
      int nRet = m_pRasterTwain->LoadTemplate(bstrFile);
      SysFreeString(bstrFile);
      if (nRet == 0)
      {
         InitTemplateDlg();

         CString csBuffer;
         csBuffer.Format(TEXT("Template loaded from (%s)"), csFileName);

         MessageBox(csBuffer, TEXT("Template"));
      }
   }
}

void CLEADTemplate::OnButtonTemplateSave() 
{
   CFileDialog FileDlg(FALSE, TEXT("*.ltt"), NULL,
                       OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
                       TEXT("LEAD Template (*.ltt)|*.ltt|"));

   if (FileDlg.DoModal() == IDOK)
   {
      SetCapabilities();
      CString csFileName = FileDlg.GetPathName();
      BSTR bstrFile = csFileName.AllocSysString();
      int nRet = m_pRasterTwain->SaveTemplate(bstrFile);
      SysFreeString(bstrFile);

      if (nRet == 0)
      {
         CString csBuffer;
         csBuffer.Format(TEXT("Template Saved to (%s)"), FileDlg.GetPathName());
         MessageBox(csBuffer, TEXT("Template"));
      }
   }
}

void CLEADTemplate::OnOK() 
{
   SetCapabilities();
   CDialog::OnOK();
}

int CLEADTemplate::MySetCapability(short nCapability, short nItemType, long lCapData)
{
   ILEADTwainCapability_D * ptwCap = NULL;
   ILEADRasterVariant   * pRasVariant = NULL;

   HRESULT hr = CoCreateInstance(CLSID_LEADTwainCapability_D, NULL, CLSCTX_ALL, IID_ILEADTwainCapability_D, (void**)&ptwCap);
   if (FAILED(hr))
      return ERROR_NO_MEMORY;

   hr = CoCreateInstance(CLSID_LEADRasterVariant, NULL, CLSCTX_ALL, IID_ILEADRasterVariant, (void**)&pRasVariant);
   if (FAILED(hr))
   {
      ptwCap->Release();
      return ERROR_NO_MEMORY;
   }

   ptwCap->EnableMethodErrors = FALSE;
   ptwCap->CapInfo->Capability = nCapability;
   ptwCap->CapInfo->ConType = L_TWON_ONEVALUE;

   switch (nItemType)
   {
   case L_TWTY_UINT16:
      {
         pRasVariant->Type = VALUE_USHORT;
         pRasVariant->LongValue = lCapData;
      }
      break;
   case L_TWTY_FIX32:
      {
         pRasVariant->Type = VALUE_FLOAT;
         pRasVariant->FloatValue = (float)lCapData;
      }
      break;
   case L_TWTY_FRAME:
      {
         ItwFrame_D * ptwFrame = (ItwFrame_D *)lCapData;
         pRasVariant->Type = VALUE_DISPATCH;
         pRasVariant->PutDispatchValue(ptwFrame);
      }
      break;
   case L_TWTY_STR32:
      {
         CString csData = (LPCTSTR)lCapData;

         pRasVariant->Type = VALUE_STRING;

         BSTR bstrData = csData.AllocSysString();
         pRasVariant->PutStringValue(bstrData);
         SysFreeString(bstrData);
      }
      break;
   default:
      return ERROR_NO_MEMORY;
   }

   ptwCap->CapOneValue->OneValItemType = nItemType;
   ptwCap->CapOneValue->OneValCapValue = pRasVariant;

   short nRet = m_pRasterTwain->SetCapability2(ptwCap, L_LTWAIN_CAPABILITY_SET);

   pRasVariant->Release();
   ptwCap->Release();
   return nRet;
}