//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include <windowsx.h>

#include "LEADTemplateDialog.h"
#include "MainForm.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)

#pragma link "LEADTwain"
#pragma resource "*.dfm"
TLEADTemplateDlg *LEADTemplateDlg;
//---------------------------------------------------------------------------
__fastcall TLEADTemplateDlg::TLEADTemplateDlg(TComponent* Owner)
   : TForm(Owner)
{
}
//---------------------------------------------------------------------------

float Fix32ToFloat (TW_FIX32 * ptwFix)
{
   float Floater = 0;

   Floater = (float)ptwFix->Whole + (float)ptwFix->Frac / (float)65536.0;

   return Floater;
}
//---------------------------------------------------------------------------

TW_FIX32 FloatToFix32 (float Floater)
{
   TW_FIX32 Fix32;
   TW_INT32 Int32 = (TW_INT32)(Floater * 65536.0 + 0.5);
   Fix32.Whole = (TW_INT16) (Int32 >> 16);
   Fix32.Frac = (TW_UINT16) (Int32 & 0x0000FFFFL);

   return Fix32;
}
//---------------------------------------------------------------------------

void __fastcall TLEADTemplateDlg::_rbFileClick(TObject *Sender)
{
   EnableFileMode();
}
//---------------------------------------------------------------------------

void __fastcall TLEADTemplateDlg::_rbMemoryClick(TObject *Sender)
{
   EnableMemoryMode();
}
//---------------------------------------------------------------------------

void __fastcall TLEADTemplateDlg::_rbNativeClick(TObject *Sender)
{
   EnableNativeMode();
}
//---------------------------------------------------------------------------

void __fastcall TLEADTemplateDlg::_btnBrowseClick(TObject *Sender)
{
   _MSSaveDialog->Title= "Save File";
   _MSSaveDialog->Filter= "All files (*.*)|*.*";
   if ( _MSSaveDialog->Execute ( ) )
   {
      _edtFileName->Text= _MSSaveDialog->FileName;
   }
}
//---------------------------------------------------------------------------

void __fastcall TLEADTemplateDlg::_btnOKClick(TObject *Sender)
{
   SetCapabilities();
}
//---------------------------------------------------------------------------


void __fastcall TLEADTemplateDlg::FormCreate(TObject *Sender)
{
   MainFrm->XferMech= TWSX_NATIVE;

   InitializeDialog();
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::InitializeDialog ( )
{
   /* ICAP_UNITS */
   FillUnitsCap();

   /* ICAP_FRAMES */
   FillFrameCaps();

   /* ICAP_XRESOLUTION - ICAP_YRESOLUTION */
   FillXYRes();

   /* ICAP_XFERMECH */
   FillTransferMode();

   /* ICAP_PIXELTYPE */
   FillPixelType();

   /* ICAP_ORIENTATION */
   FillOrientation();

   /* ICAP_CONTRAST, ICAP_BRIGHTNESS, ICAP_HIGHLIGHT */
   FillEffectsCap(ICAP_CONTRAST);
   FillEffectsCap(ICAP_BRIGHTNESS);
   FillEffectsCap(ICAP_HIGHLIGHT);

   /* ICAP_HALFTONES */
   FillHalftones();
}
//---------------------------------------------------------------------------

void __fastcall TLEADTemplateDlg::_edtKeyPress(TObject *Sender,
      char &Key)
{
   if (!((Key >= '0') && (Key <= '9')) && (Key != ' ') && (Key != '\b'))
      Key = NULL;
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::FillUnitsCap()
{
   TW_CAPABILITY   twCap;
   pTW_ENUMERATION pEnum = NULL;
   pTW_ONEVALUE    pOneValue = NULL;
   L_INT           nRet = TWAIN_SUCCESS, i =0;

   /* ICAP_UNITS */
   _cmbUnits->Clear();

   ZeroMemory(&twCap, sizeof(TW_CAPABILITY));
   twCap.Cap = ICAP_UNITS;
   twCap.ConType = TWON_ENUMERATION;
   nRet= MainFrm->_LEADTwain->GetCapability(&twCap, LTWAIN_CAPABILITY_GETVALUES);
   if(nRet != TWAIN_SUCCESS)
   {
      /* disable UNITS combo box */
      _cmbUnits->Enabled= False;
      return;
   }


   switch (twCap.ConType)
   {
   case TWON_ENUMERATION:
      {
         pEnum = (pTW_ENUMERATION)GlobalLock((void*)twCap.hContainer);
         _arrUnits.Length = pEnum->NumItems;         
         for(i=0; i<(L_INT)pEnum->NumItems; i++)
         {
            pTW_UINT8 ptwTemp = GetItemFromEnumeration(pEnum, i);
            TW_UINT16 twItem = (TW_UINT16)*ptwTemp;
            switch (twItem)
            {
            case TWUN_INCHES:
               _cmbUnits->Items->Add("Inches");
               break;
            case TWUN_CENTIMETERS:
               _cmbUnits->Items->Add("Centimeters");
               break;
            case TWUN_PICAS:
               _cmbUnits->Items->Add("Picas");
               break;
            case TWUN_POINTS:
               _cmbUnits->Items->Add("Points");
               break;
            case TWUN_TWIPS:
               _cmbUnits->Items->Add("Twips");
               break;
            case TWUN_PIXELS:
               _cmbUnits->Items->Add("Pixels");
               break;
            }

            _arrUnits[i]= twItem;
         }

         _cmbUnits->ItemIndex= pEnum->CurrentIndex;
      }
      break;

   case TWON_ONEVALUE:
      {
         pOneValue = (pTW_ONEVALUE)GlobalLock((void*)twCap.hContainer);
         _arrUnits.Length = 1;
         pTW_UINT8 ptwTemp = GetItemFromOneValue(pOneValue);
         TW_UINT16 twItem = (TW_UINT16)*ptwTemp;

         switch (twItem)
         {
         case TWUN_INCHES:
            _cmbUnits->Items->Add("Inches");
            break;
         case TWUN_CENTIMETERS:
            _cmbUnits->Items->Add("Centimeters");
            break;
         case TWUN_PICAS:
            _cmbUnits->Items->Add("Picas");
            break;
         case TWUN_POINTS:
            _cmbUnits->Items->Add("Points");
            break;
         case TWUN_TWIPS:
            _cmbUnits->Items->Add("Twips");
            break;
         case TWUN_PIXELS:
            _cmbUnits->Items->Add("Pixels");
            break;
         }

         _arrUnits[0]= twItem;
         _cmbUnits->ItemIndex= 0;
      }
      break;
   }

   GlobalUnlock((void*)twCap.hContainer);
   MainFrm->_LEADTwain->FreeContainer(&twCap);
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::FillFrameCaps()
{
   TW_CAPABILITY   twCap;
   pTW_ONEVALUE    pOneValue = NULL;
   pTW_ENUMERATION pEnum = NULL;
   pTW_FRAME       pFrame = NULL;
   L_INT           nRet = TWAIN_SUCCESS;

   /* ICAP_FRAMES */

   /* ICAP_FRAMES */
   ZeroMemory(&twCap, sizeof(TW_CAPABILITY));
   twCap.Cap= ICAP_FRAMES;
   twCap.ConType= TWON_ONEVALUE;
   nRet= MainFrm->_LEADTwain->GetCapability(&twCap, LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != TWAIN_SUCCESS)
   {
      /* disable FRAME edit boxes */
      _edtLeft->Enabled= false;
      _edtTop->Enabled= false;
      _edtRight->Enabled= false;
      _edtBottom->Enabled= false;
      return;
   }

   pTW_UINT8 ptwTemp = NULL;
   switch (twCap.ConType)
   {
   case TWON_ONEVALUE:
      {
         pOneValue = (pTW_ONEVALUE)GlobalLock((void*)twCap.hContainer);
         ptwTemp = GetItemFromOneValue(pOneValue);
         pFrame = (pTW_FRAME)ptwTemp;
      }
      break;
   case TWON_ENUMERATION:
      {
         pEnum = (pTW_ENUMERATION)GlobalLock((void*)twCap.hContainer);
         ptwTemp = GetItemFromEnumeration(pEnum, pEnum->CurrentIndex);
         pFrame = (pTW_FRAME)ptwTemp;
      }
      break;
   }

   float fLeft = Fix32ToFloat(&pFrame->Left);
   float fTop = Fix32ToFloat(&pFrame->Top);
   float fRight = Fix32ToFloat(&pFrame->Right);
   float fBottom = Fix32ToFloat(&pFrame->Bottom);

   _edtLeft->Text= IntToStr((L_INT)fLeft) + "." + IntToStr((int)((fLeft- (L_INT)fLeft) * 10));
   _edtTop->Text= IntToStr((L_INT)fTop) + "." + IntToStr((int)((fTop - (L_INT)fTop) * 10));
   _edtRight->Text= IntToStr((L_INT)fRight) + "." + IntToStr((int)((fRight - (L_INT)fRight) * 10));
   _edtBottom->Text= IntToStr((L_INT)fBottom) + "." + IntToStr((int)((fBottom - (L_INT)fBottom) * 10));

   GlobalUnlock((void*)twCap.hContainer);
   MainFrm->_LEADTwain->FreeContainer(&twCap);
}
//---------------------------------------------------------------------------

pTW_UINT8 TLEADTemplateDlg::GetItemFromEnumeration(pTW_ENUMERATION ptwEnum, L_INT nIndex)
{
   if (nIndex < 0 || nIndex >= (L_INT)ptwEnum->NumItems)
      return 0;

   switch (ptwEnum->ItemType)
   {
   case TWTY_INT8:
      {
         pTW_INT8 ptwItem = (pTW_INT8)ptwEnum->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_INT16:
      {
         pTW_INT16 ptwItem = (pTW_INT16)ptwEnum->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_INT32:
      {
         pTW_INT32 ptwItem = (pTW_INT32)ptwEnum->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_UINT8:
      {
         pTW_UINT8 ptwItem = (pTW_UINT8)ptwEnum->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_UINT16:
      {
         pTW_UINT16 ptwItem = (pTW_UINT16)ptwEnum->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_UINT32:
      {
         pTW_UINT32 ptwItem = (pTW_UINT32)ptwEnum->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_BOOL:
      {
         pTW_BOOL ptwItem = (pTW_BOOL)ptwEnum->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_FIX32:
      {
         pTW_FIX32 ptwItem = (pTW_FIX32)&ptwEnum->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_FRAME:
      {
         pTW_FRAME ptwItem = (pTW_FRAME)&ptwEnum->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_STR32:
      {
         pTW_STR32 ptwItem = (pTW_STR32)&ptwEnum->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_STR64:
      {
         pTW_STR64 ptwItem = (pTW_STR64)&ptwEnum->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_STR128:
      {
         pTW_STR128 ptwItem = (pTW_STR128)&ptwEnum->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_STR255:
      {
         pTW_STR255 ptwItem = (pTW_STR255)&ptwEnum->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_STR1024:
      {
         pTW_STR1024 ptwItem = (pTW_STR1024)&ptwEnum->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_UNI512:
      {
         pTW_UNI512 ptwItem = (pTW_UNI512)&ptwEnum->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }
   }

   return 0;
}
//---------------------------------------------------------------------------

pTW_UINT8 TLEADTemplateDlg::GetItemFromOneValue(pTW_ONEVALUE ptwOneValue)
{
   switch (ptwOneValue->ItemType)
   {
   case TWTY_INT8:
      {
         pTW_INT8 ptwItem = (pTW_INT8)&ptwOneValue->Item;
         return (pTW_UINT8)ptwItem;
      }

   case TWTY_INT16:
      {
         pTW_INT16 ptwItem = (pTW_INT16)&ptwOneValue->Item;
         return (pTW_UINT8)ptwItem;
      }

   case TWTY_INT32:
      {
         pTW_INT32 ptwItem = (pTW_INT32)&ptwOneValue->Item;
         return (pTW_UINT8)ptwItem;
      }

   case TWTY_UINT8:
      {
         pTW_UINT8 ptwItem = (pTW_UINT8)&ptwOneValue->Item;
         return (pTW_UINT8)ptwItem;
      }

   case TWTY_UINT16:
      {
         pTW_UINT16 ptwItem = (pTW_UINT16)&ptwOneValue->Item;
         return (pTW_UINT8)ptwItem;
      }

   case TWTY_UINT32:
      {
         pTW_UINT32 ptwItem = (pTW_UINT32)&ptwOneValue->Item;
         return (pTW_UINT8)ptwItem;
      }

   case TWTY_BOOL:
      {
         pTW_BOOL ptwItem = (pTW_BOOL)&ptwOneValue->Item;
         return (pTW_UINT8)ptwItem;
      }

   case TWTY_FIX32:
      {
         pTW_FIX32 ptwItem = (pTW_FIX32)&ptwOneValue->Item;
         return (pTW_UINT8)ptwItem;
      }

   case TWTY_FRAME:
      {
         pTW_FRAME ptwItem = (pTW_FRAME)&ptwOneValue->Item;
         return (pTW_UINT8)ptwItem;
      }

   case TWTY_STR32:
      {
         pTW_STR32 ptwItem = (pTW_STR32)&ptwOneValue->Item;
         return (pTW_UINT8)ptwItem;
      }

   case TWTY_STR64:
      {
         pTW_STR64 ptwItem = (pTW_STR64)&ptwOneValue->Item;
         return (pTW_UINT8)ptwItem;
      }

   case TWTY_STR128:
      {
         pTW_STR128 ptwItem = (pTW_STR128)&ptwOneValue->Item;
         return (pTW_UINT8)ptwItem;
      }

   case TWTY_STR255:
      {
         pTW_STR255 ptwItem = (pTW_STR255)&ptwOneValue->Item;
         return (pTW_UINT8)ptwItem;
      }

   case TWTY_STR1024:
      {
         pTW_STR1024 ptwItem = (pTW_STR1024)&ptwOneValue->Item;
         return (pTW_UINT8)ptwItem;
      }

   case TWTY_UNI512:
      {
         pTW_UNI512 ptwItem = (pTW_UNI512)&ptwOneValue->Item;
         return (pTW_UINT8)ptwItem;
      }
   }

   return 0;
}
//---------------------------------------------------------------------------

pTW_UINT8 TLEADTemplateDlg::GetItemFromArray(pTW_ARRAY ptwArray, L_INT nIndex)
{
   if (nIndex < 0 || nIndex >= (L_INT)ptwArray->NumItems)
      return 0;

   switch (ptwArray->ItemType)
   {
   case TWTY_INT8:
      {
         pTW_INT8 ptwItem = (pTW_INT8)ptwArray->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_INT16:
      {
         pTW_INT16 ptwItem = (pTW_INT16)ptwArray->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_INT32:
      {
         pTW_INT32 ptwItem = (pTW_INT32)ptwArray->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_UINT8:
      {
         pTW_UINT8 ptwItem = (pTW_UINT8)ptwArray->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_UINT16:
      {
         pTW_UINT16 ptwItem = (pTW_UINT16)ptwArray->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_UINT32:
      {
         pTW_UINT32 ptwItem = (pTW_UINT32)ptwArray->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_BOOL:
      {
         pTW_BOOL ptwItem = (pTW_BOOL)ptwArray->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_FIX32:
      {
         pTW_FIX32 ptwItem = (pTW_FIX32)&ptwArray->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_FRAME:
      {
         pTW_FRAME ptwItem = (pTW_FRAME)&ptwArray->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_STR32:
      {
         pTW_STR32 ptwItem = (pTW_STR32)&ptwArray->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_STR64:
      {
         pTW_STR64 ptwItem = (pTW_STR64)&ptwArray->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_STR128:
      {
         pTW_STR128 ptwItem = (pTW_STR128)&ptwArray->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_STR255:
      {
         pTW_STR255 ptwItem = (pTW_STR255)&ptwArray->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_STR1024:
      {
         pTW_STR1024 ptwItem = (pTW_STR1024)&ptwArray->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }

   case TWTY_UNI512:
      {
         pTW_UNI512 ptwItem = (pTW_UNI512)&ptwArray->ItemList;
         return (pTW_UINT8)&ptwItem[nIndex];
      }
   }

   return 0;
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::FillXYRes()
{
   TW_CAPABILITY   twCap;
   pTW_ENUMERATION pEnum = NULL;
   pTW_RANGE       pRange = NULL;
   pTW_ONEVALUE    pOneValue = NULL;
   L_INT           nRet = TWAIN_SUCCESS, i=0;
   FLOAT           fRes;
   AnsiString      strVal;
   pTW_UINT8       ptwTemp = NULL;
   pTW_FIX32       ptwItem = NULL;

   /* ICAP_XRESOLUTION */
   /* ICAP_XRESOLUTION */
   _cmbXResolution->Clear();

   ZeroMemory(&twCap, sizeof(TW_CAPABILITY));
   twCap.Cap= ICAP_XRESOLUTION;
   twCap.ConType= TWON_ENUMERATION;
   nRet= MainFrm->_LEADTwain->GetCapability(&twCap, LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != TWAIN_SUCCESS)
   {
      /* disable XResolution combo boxes */
      _cmbXResolution->Enabled= false;
   }
   else
   {
      switch (twCap.ConType)
      {
      case TWON_ENUMERATION:
         {
            pEnum = (pTW_ENUMERATION)GlobalLock((void*)twCap.hContainer);

            for (i=0; i<(L_INT)pEnum->NumItems; i++)
            {
               ptwTemp = GetItemFromEnumeration(pEnum, i);
               ptwItem = (pTW_FIX32)ptwTemp;

               fRes = Fix32ToFloat(&ptwItem[i]);

               strVal= IntToStr((L_INT)fRes) + "." + IntToStr((int)((fRes - (L_INT)fRes) * 10));

               _cmbXResolution->Items->Add(strVal);
            }
            _cmbXResolution->ItemIndex= pEnum->CurrentIndex;
         }
         break;

      case TWON_RANGE:
         {
            L_INT nSelIndex = 0;
            
            pRange = (pTW_RANGE)GlobalLock((void*)twCap.hContainer);

            pTW_FIX32 ptwMin = (pTW_FIX32)&pRange->MinValue;
            pTW_FIX32 ptwMax = (pTW_FIX32)&pRange->MaxValue;
            pTW_FIX32 ptwStep = (pTW_FIX32)&pRange->StepSize;
            pTW_FIX32 ptwDefault = (pTW_FIX32)&pRange->DefaultValue;

            float fMin = Fix32ToFloat(ptwMin);
            float fMax = Fix32ToFloat(ptwMax);
            float fStep = Fix32ToFloat(ptwStep);
            float fDefault = Fix32ToFloat(ptwDefault);

            strVal= IntToStr((L_INT)fMin) + "." + IntToStr((int)((fMin - (L_INT)fMin) * 10));

            i=0;

            _cmbXResolution->Items->Add(strVal);

            if(fDefault == fMin)
               nSelIndex = i;

            float fVal = fMin + fStep;
            while (fVal < fMax)
            {
               strVal= IntToStr((L_INT)fVal) + "." + IntToStr((int)((fVal - (L_INT)fVal) * 10));

               i++;
               _cmbXResolution->Items->Add(strVal);

               if (fDefault == fVal)
                  nSelIndex = i;

               fVal = fVal + fStep;
            }

            strVal= IntToStr((L_INT)fMax) + "." + IntToStr((int)((fMax - (L_INT)fMax) * 10));

            i++;
            _cmbXResolution->Items->Add(strVal);

            if (fDefault == fMax)
               nSelIndex = i;

            _cmbXResolution->ItemIndex= nSelIndex;
         }
         break;

      case TWON_ONEVALUE:
         {
            pOneValue = (pTW_ONEVALUE)GlobalLock((void*)twCap.hContainer);

            ptwTemp = GetItemFromOneValue(pOneValue);
            ptwItem = (pTW_FIX32)ptwTemp;

            fRes = Fix32ToFloat(&ptwItem[i]);

            strVal= IntToStr((L_INT)fRes) + "." + IntToStr((int)((fRes - (L_INT)fRes) * 10));

            _cmbXResolution->Items->Add(strVal);
            _cmbXResolution->ItemIndex= 0;
         }
         break;
      }

      GlobalUnlock((void*)twCap.hContainer);
      MainFrm->_LEADTwain->FreeContainer(&twCap);
      
   }

   /* ICAP_YRESOLUTION */

   _cmbYResolution->Clear();

   ZeroMemory(&twCap, sizeof(TW_CAPABILITY));
   twCap.Cap = ICAP_YRESOLUTION;
   twCap.ConType = TWON_ENUMERATION;
   nRet= MainFrm->_LEADTwain->GetCapability(&twCap, LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != TWAIN_SUCCESS)
   {
      /* disable YResolution combo boxes */
      _cmbYResolution->Enabled= False;
      return;
   }

   switch (twCap.ConType)
   {
   case TWON_ENUMERATION:
      {
         pEnum = (pTW_ENUMERATION)GlobalLock((void*)twCap.hContainer);

         for (i=0; i<(L_INT)pEnum->NumItems; i++)
         {
            ptwTemp = GetItemFromEnumeration(pEnum, i);
            ptwItem = (pTW_FIX32)ptwTemp;

            fRes = Fix32ToFloat(&ptwItem[i]);

            strVal= IntToStr((int)fRes) + "." + IntToStr((int)((fRes - (L_INT)fRes) * 10));

            _cmbYResolution->Items->Add(strVal);
         }

         _cmbYResolution->ItemIndex= pEnum->CurrentIndex;
      }
      break;

   case TWON_RANGE:
      {
         L_INT nSelIndex = 0;
         i = 0;
         pRange = (pTW_RANGE)GlobalLock((void*)twCap.hContainer);

         pTW_FIX32 ptwMin = (pTW_FIX32)&pRange->MinValue;
         pTW_FIX32 ptwMax = (pTW_FIX32)&pRange->MaxValue;
         pTW_FIX32 ptwStep = (pTW_FIX32)&pRange->StepSize;
         pTW_FIX32 ptwDefault = (pTW_FIX32)&pRange->DefaultValue;

         float fMin = Fix32ToFloat(ptwMin);
         float fMax = Fix32ToFloat(ptwMax);
         float fStep = Fix32ToFloat(ptwStep);
         float fDefault = Fix32ToFloat(ptwDefault);

         strVal= IntToStr((int)fMin) + "." + IntToStr((int)((fMin - (L_INT)fMin) * 10));

         i=0;

         _cmbYResolution->Items->Add(strVal);

         if (fDefault == fMin)
            nSelIndex = i;

         float fVal = fMin + fStep;
         while (fVal < fMax)
         {
            strVal= IntToStr((int)fVal) + "." + IntToStr((int)((fVal - (L_INT)fVal) * 10));

            i++;
            _cmbYResolution->Items->Add(strVal);

            if (fDefault == fVal)
               nSelIndex = i;

            fVal = fVal + fStep;
         }

         strVal= IntToStr((int)fMax) + "." + IntToStr((int)((fMax - (L_INT)fMax) * 10));

         i++;
         _cmbYResolution->Items->Add(strVal);

         if (fDefault == fMax)
            nSelIndex = i;

         _cmbYResolution->ItemIndex= nSelIndex;
      }
      break;
   case TWON_ONEVALUE:
      {
         pOneValue = (pTW_ONEVALUE)GlobalLock((void*)twCap.hContainer);

         ptwTemp = GetItemFromOneValue(pOneValue);
         ptwItem = (pTW_FIX32)ptwTemp;

         fRes = Fix32ToFloat(&ptwItem[i]);

         strVal= IntToStr((int)fRes) + "." + IntToStr((int)((fRes - (L_INT)fRes) * 10));

         _cmbYResolution->Items->Add(strVal);

         _cmbYResolution->ItemIndex= 0;
      }
      break;
   }

   GlobalUnlock((void*)twCap.hContainer);
   MainFrm->_LEADTwain->FreeContainer(&twCap);
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::FillTransferMode()
{
   TW_CAPABILITY   twCap;
   pTW_ENUMERATION pEnum = NULL;
   pTW_ONEVALUE    pOneValue = NULL;
   L_INT           nRet = TWAIN_SUCCESS, i=0;
   bool            bFile, bNative, bMemory;

   /* ICAP_XFERMECH */

   bFile = bNative = bMemory = false;

   _rbFile->Enabled= False;
   _rbMemory->Enabled= False;
   _rbNative->Enabled= False;

   ZeroMemory(&twCap, sizeof(TW_CAPABILITY));
   twCap.Cap= ICAP_XFERMECH;
   twCap.ConType= TWON_ENUMERATION;
   nRet= MainFrm->_LEADTwain->GetCapability(&twCap, LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != TWAIN_SUCCESS)
   {
      /* disable all transfer modes controls boxes */
      _edtFileName->Enabled= false;
      _btnBrowse->Enabled= false;
      _cmbFormat->Enabled= false;
      _cmbCompression->Enabled= false;
      return;
   }

   pTW_UINT8 ptwTemp = NULL;
   TW_UINT16 twItem;

   switch (twCap.ConType)
   {
   case TWON_ENUMERATION:
      {
         pEnum = (pTW_ENUMERATION)GlobalLock((void*)twCap.hContainer);
         for(i=0; i<(L_INT)pEnum->NumItems; i++)
         {
            ptwTemp = GetItemFromEnumeration(pEnum, i);
            twItem = (TW_UINT16)*ptwTemp;
            switch (twItem)
            {
            case TWSX_NATIVE:
               _rbNative->Enabled= True;
               bNative = TRUE;
               break;
            case TWSX_FILE:
               _rbFile->Enabled= True;
               bFile = TRUE;
               break;
            case TWSX_MEMORY:
               _rbMemory->Enabled= True;
               bMemory = TRUE;
               break;
            }
         }
      }
      break;
      
   case TWON_ONEVALUE:
      {
         pOneValue = (pTW_ONEVALUE)GlobalLock((void*)twCap.hContainer);

         ptwTemp = GetItemFromOneValue(pOneValue);
         twItem = (TW_UINT16)*ptwTemp;
         switch (twItem)
         {
         case TWSX_NATIVE:
            _rbNative->Enabled= True;
            bNative = TRUE;
            break;
         case TWSX_FILE:
            _rbFile->Enabled= True;
            bFile = TRUE;
            break;
         case TWSX_MEMORY:
            _rbMemory->Enabled= True;
            bMemory = TRUE;
            break;
         }
      }
      break;
   }

   GlobalUnlock((void*)twCap.hContainer);
   MainFrm->_LEADTwain->FreeContainer(&twCap);

   if (bFile)
      EnableFileMode();

   if (bMemory)
      EnableMemoryMode();

   if (bNative)
      EnableNativeMode();
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::EnableFileMode()
{
   MainFrm->XferMech= TWSX_FILE;

   /* Enable file options */
   _edtFileName->Enabled= True;
   _btnBrowse->Enabled= True;
   _cmbFormat->Enabled= True;

   /* Disable other options */
   _cmbCompression->Enabled= False;

   /* select file radio and deselect others */
   _rbFile->Checked= true;
   _rbMemory->Checked= false;
   _rbNative->Checked= false;

   /* ICAP_IMAGEFILEFORMAT */
   FillImageFileFormat();

   CheckOKButton();
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::EnableMemoryMode()
{
   MainFrm->XferMech= TWSX_MEMORY;

   /* Enable memory options */
   _cmbCompression->Enabled= True;

   /* Disable other options */
   _edtFileName->Enabled= False;
   _btnBrowse->Enabled= False;
   _cmbFormat->Enabled= False;

   /* select memory radio and deselect others */
   _rbFile->Checked= false;
   _rbMemory->Checked= true;
   _rbNative->Checked= false;

   /* ICAP_COMPRESSION */
   FillCompression();

   CheckOKButton();
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::EnableNativeMode()
{
   MainFrm->XferMech= TWSX_NATIVE;

   /* Disable other options */
   _edtFileName->Enabled= false;
   _btnBrowse->Enabled= false;
   _cmbFormat->Enabled= false;
   _cmbCompression->Enabled= false;

   /* select native radio and deselect others */
   _rbFile->Checked= false;
   _rbMemory->Checked= false;
   _rbNative->Checked= true;

   CheckOKButton();
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::FillImageFileFormat()
{
   TW_CAPABILITY   twCap;
   pTW_ENUMERATION pEnum = NULL;
   pTW_ONEVALUE    pOneValue = NULL;
   L_INT           nRet = TWAIN_SUCCESS, i=0;

   /* ICAP_IMAGEFILEFORMAT */
   ZeroMemory(&twCap, sizeof(TW_CAPABILITY));
   twCap.Cap= ICAP_IMAGEFILEFORMAT;
   twCap.ConType= TWON_ENUMERATION;
   nRet= MainFrm->_LEADTwain->GetCapability(&twCap, LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != TWAIN_SUCCESS)
   {
      /* disable all file modes controls */
      _edtFileName->Enabled= false;
      _btnBrowse->Enabled= false;
      _cmbFormat->Enabled= false;
      return;
   }

   pTW_UINT8 ptwTemp = NULL;
   TW_UINT16 twItem;

   _cmbFormat->Clear();

   switch (twCap.ConType)
   {
   case TWON_ENUMERATION:
      {
         pEnum = (pTW_ENUMERATION)GlobalLock((void*)twCap.hContainer);
         _arrFormat.Length = pEnum->NumItems;
         
         for(i=0; i<(L_INT)pEnum->NumItems; i++)
         {
            ptwTemp = GetItemFromEnumeration(pEnum, i);
            twItem = (TW_UINT16)*ptwTemp;

            switch (twItem)
            {
            case TWFF_TIFF:
               _cmbFormat->Items->Add("TIFF");
               break;
            case TWFF_PICT:
               _cmbFormat->Items->Add("PICT");
               break;
            case TWFF_BMP:
               _cmbFormat->Items->Add("BMP");
               break;
            case TWFF_XBM:
               _cmbFormat->Items->Add("XBM");
               break;
            case TWFF_JFIF:
               _cmbFormat->Items->Add("JFIF");
               break;
            case TWFF_FPX:
               _cmbFormat->Items->Add("FPX");
               break;
            case TWFF_TIFFMULTI:
               _cmbFormat->Items->Add("TIFFMULTI");
               break;
            case TWFF_PNG:
               _cmbFormat->Items->Add("PNG");
               break;
            case TWFF_SPIFF:
               _cmbFormat->Items->Add("SPIFF");
               break;
            case TWFF_EXIF:
               _cmbFormat->Items->Add("EXIF");
               break;
            }

            _arrFormat[i]= twItem;
         }

         _cmbFormat->ItemIndex= pEnum->CurrentIndex;
      }
      break;
   case TWON_ONEVALUE:
      {
         pOneValue = (pTW_ONEVALUE)GlobalLock((void*)twCap.hContainer);
         ptwTemp = GetItemFromOneValue(pOneValue);
         twItem = (TW_UINT16)*ptwTemp;

         _arrFormat.Length = 1;

         switch (twItem)
         {
         case TWFF_TIFF:
            _cmbFormat->Items->Add("TIFF");
            break;
         case TWFF_PICT:
            _cmbFormat->Items->Add("PICT");
            break;
         case TWFF_BMP:
            _cmbFormat->Items->Add("BMP");
            break;
         case TWFF_XBM:
            _cmbFormat->Items->Add("XBM");
            break;
         case TWFF_JFIF:
            _cmbFormat->Items->Add("JFIF");
            break;
         case TWFF_FPX:
            _cmbFormat->Items->Add("FPX");
            break;
         case TWFF_TIFFMULTI:
            _cmbFormat->Items->Add("TIFFMULTI");
            break;
         case TWFF_PNG:
            _cmbFormat->Items->Add("PNG");
            break;
         case TWFF_SPIFF:
            _cmbFormat->Items->Add("SPIFF");
            break;
         case TWFF_EXIF:
            _cmbFormat->Items->Add("EXIF");
            break;
         }

         _arrFormat[0]= twItem;
         _cmbFormat->ItemIndex= 0;
      }
      break;
   }

   GlobalUnlock((void*)twCap.hContainer);
   MainFrm->_LEADTwain->FreeContainer(&twCap);
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::CheckOKButton()
{
   bool bOkEnabled;

   bOkEnabled= True;
   if(_edtLeft->Enabled)
   {
      if((_edtLeft->Text == "") || (_edtTop->Text == "") ||
         (_edtRight->Text == "") || (_edtBottom->Text == ""))
         bOkEnabled= false;
   }

   if(_edtFileName->Enabled)
   {
      if(_edtFileName->Text == "")
         bOkEnabled= false;
   }

   _btnOK->Enabled= bOkEnabled;
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::FillCompression()
{
   TW_CAPABILITY   twCap;
   pTW_ENUMERATION pEnum = NULL;
   pTW_ONEVALUE    pOneValue = NULL;
   L_INT           nRet = TWAIN_SUCCESS, i=0;

   /* ICAP_COMPRESSION */

   ZeroMemory(&twCap, sizeof(TW_CAPABILITY));
   twCap.Cap= ICAP_COMPRESSION;
   twCap.ConType= TWON_ENUMERATION;
   nRet= MainFrm->_LEADTwain->GetCapability(&twCap, LTWAIN_CAPABILITY_GETVALUES);
   if(nRet != TWAIN_SUCCESS)
   {
      /* disable all memory modes controls */
      _cmbCompression->Enabled= false;
      return;
   }

   pTW_UINT8 ptwTemp = NULL;
   TW_UINT16 twItem;

   _cmbCompression->Clear();
   
   switch (twCap.ConType)
   {
   case TWON_ENUMERATION:
      {
         pEnum = (pTW_ENUMERATION)GlobalLock((void*)twCap.hContainer);
         _arrCompression.Length = pEnum->NumItems;
         for(i=0; i<(L_INT)pEnum->NumItems; i++)
         {
            ptwTemp = GetItemFromEnumeration(pEnum, i);
            twItem = (TW_UINT16)*ptwTemp;
            switch (twItem)
            {
            case TWCP_NONE:
               _cmbCompression->Items->Add("NONE");
               break;
            case TWCP_PACKBITS:
               _cmbCompression->Items->Add("PACKBITS");
               break;
            case TWCP_GROUP31D:
               _cmbCompression->Items->Add("GROUP31D");
               break;
            case TWCP_GROUP31DEOL:
               _cmbCompression->Items->Add("GROUP31DEOL");
               break;
            case TWCP_GROUP32D:
               _cmbCompression->Items->Add("GROUP32D");
               break;
            case TWCP_GROUP4:
               _cmbCompression->Items->Add("GROUP4");
               break;
            case TWCP_JPEG:
               _cmbCompression->Items->Add("JPEG");
               break;
            case TWCP_LZW:
               _cmbCompression->Items->Add("LZW");
               break;
            case TWCP_JBIG:
               _cmbCompression->Items->Add("JBIG");
               break;
            case TWCP_PNG:
               _cmbCompression->Items->Add("PNG");
               break;
            case TWCP_RLE4:
               _cmbCompression->Items->Add("RLE4");
               break;
            case TWCP_RLE8:
               _cmbCompression->Items->Add("RLE8");
               break;
            case TWCP_BITFIELDS:
               _cmbCompression->Items->Add("BITFIELDS");
               break;
            }

            _arrCompression[i]= twItem;
         }

         _cmbCompression->ItemIndex= pEnum->CurrentIndex;
      }
      break;

   case TWON_ONEVALUE:
      {
         pOneValue = (pTW_ONEVALUE)GlobalLock((void*)twCap.hContainer);
         _arrCompression.Length = 1;
         ptwTemp = GetItemFromOneValue(pOneValue);
         twItem = (TW_UINT16)*ptwTemp;

         switch (twItem)
         {
         case TWCP_NONE:
            _cmbCompression->Items->Add("NONE");
            break;
         case TWCP_PACKBITS:
            _cmbCompression->Items->Add("PACKBITS");
            break;
         case TWCP_GROUP31D:
            _cmbCompression->Items->Add("GROUP31D");
            break;
         case TWCP_GROUP31DEOL:
            _cmbCompression->Items->Add("GROUP31DEOL");
            break;
         case TWCP_GROUP32D:
            _cmbCompression->Items->Add("GROUP32D");
            break;
         case TWCP_GROUP4:
            _cmbCompression->Items->Add("GROUP4");
            break;
         case TWCP_JPEG:
            _cmbCompression->Items->Add("JPEG");
            break;
         case TWCP_LZW:
            _cmbCompression->Items->Add("LZW");
            break;
         case TWCP_JBIG:
            _cmbCompression->Items->Add("JBIG");
            break;
         case TWCP_PNG:
            _cmbCompression->Items->Add("PNG");
            break;
         case TWCP_RLE4:
            _cmbCompression->Items->Add("RLE4");
            break;
         case TWCP_RLE8:
            _cmbCompression->Items->Add("RLE8");
            break;
         case TWCP_BITFIELDS:
            _cmbCompression->Items->Add("BITFIELDS");
            break;
         }

         _arrCompression[0]= twItem;
         _cmbCompression->ItemIndex= 0;
      }
      break;
   }

   GlobalUnlock((void*)twCap.hContainer);
   MainFrm->_LEADTwain->FreeContainer(&twCap);
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::FillPixelType()
{
   TW_CAPABILITY   twCap;
   pTW_ENUMERATION pEnum = NULL;
   pTW_ONEVALUE    pOneValue = NULL;
   L_INT           nRet = TWAIN_SUCCESS, i=0;

   /* ICAP_PIXELTYPE */
   ZeroMemory(&twCap, sizeof(TW_CAPABILITY));
   twCap.Cap= ICAP_PIXELTYPE;
   twCap.ConType= TWON_ENUMERATION;
   nRet= MainFrm->_LEADTwain->GetCapability(&twCap, LTWAIN_CAPABILITY_GETVALUES);
   if(nRet != TWAIN_SUCCESS)
   {
      /* disable pixel type combo box */
      _cmbPixelType->Enabled= False;
      return;
   }

   pTW_UINT8 ptwTemp = NULL;
   TW_UINT16 twItem;

   _cmbPixelType->Clear();
   
   switch (twCap.ConType)
   {
   case TWON_ENUMERATION:
      {
         pEnum = (pTW_ENUMERATION)GlobalLock((void*)twCap.hContainer);
         _arrPixelType.Length = pEnum->NumItems;
         for(i=0; i<(L_INT)pEnum->NumItems; i++)
         {
            ptwTemp = GetItemFromEnumeration(pEnum, i);
            twItem = (TW_UINT16)*ptwTemp;
            switch (twItem)
            {
            case TWPT_BW:
               _cmbPixelType->Items->Add("BW");
               break;
            case TWPT_GRAY:
               _cmbPixelType->Items->Add("GRAY");
               break;
            case TWPT_RGB:
               _cmbPixelType->Items->Add("RGB");
               break;
            case TWPT_PALETTE:
               _cmbPixelType->Items->Add("PALETTE");
               break;
            case TWPT_CMY:
               _cmbPixelType->Items->Add("CMY");
               break;
            case TWPT_CMYK:
               _cmbPixelType->Items->Add("CMYK");
               break;
            case TWPT_YUV:
               _cmbPixelType->Items->Add("YUV");
               break;
            case TWPT_YUVK:
               _cmbPixelType->Items->Add("YUVK");
               break;
            case TWPT_CIEXYZ:
               _cmbPixelType->Items->Add("CIEXYZ");
               break;
            }

            _arrPixelType[i]= twItem;
         }

         _cmbPixelType->ItemIndex= pEnum->CurrentIndex;
      }
      break;

   case TWON_ONEVALUE:
      {
         pOneValue = (pTW_ONEVALUE)GlobalLock((void*)twCap.hContainer);
         _arrPixelType.Length = 1;
         ptwTemp = GetItemFromOneValue(pOneValue);
         twItem = (TW_UINT16)*ptwTemp;

         switch (twItem)
         {
         case TWPT_BW:
            _cmbPixelType->Items->Add("BW");
            break;
         case TWPT_GRAY:
            _cmbPixelType->Items->Add("GRAY");
            break;
         case TWPT_RGB:
            _cmbPixelType->Items->Add("RGB");
            break;
         case TWPT_PALETTE:
            _cmbPixelType->Items->Add("PALETTE");
            break;
         case TWPT_CMY:
            _cmbPixelType->Items->Add("CMY");
            break;
         case TWPT_CMYK:
            _cmbPixelType->Items->Add("CMYK");
            break;
         case TWPT_YUV:
            _cmbPixelType->Items->Add("YUV");
            break;
         case TWPT_YUVK:
            _cmbPixelType->Items->Add("YUVK");
            break;
         case TWPT_CIEXYZ:
            _cmbPixelType->Items->Add("CIEXYZ");
            break;
         }

         _arrPixelType[0]= twItem;
         _cmbPixelType->ItemIndex= 0;
      }
      break;
   }

   GlobalUnlock((void*)twCap.hContainer);
   MainFrm->_LEADTwain->FreeContainer(&twCap);
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::FillOrientation()
{
   TW_CAPABILITY   twCap;
   pTW_ENUMERATION pEnum = NULL;
   pTW_ONEVALUE    pOneValue = NULL;
   L_INT           nRet = TWAIN_SUCCESS, i=0;

   /* ICAP_ORIENTATION */   
   ZeroMemory(&twCap, sizeof(TW_CAPABILITY));
   twCap.Cap= ICAP_ORIENTATION;
   twCap.ConType= TWON_ENUMERATION;
   nRet= MainFrm->_LEADTwain->GetCapability(&twCap, LTWAIN_CAPABILITY_GETVALUES);
   if(nRet != TWAIN_SUCCESS)
   {
      /* disable all orientation combo box */
      _cmbOrientation->Enabled= false;
      return;
   }

   pTW_UINT8 ptwTemp = NULL;
   TW_UINT16 twItem;

   _cmbOrientation->Clear();
   
   switch (twCap.ConType)
   {
   case TWON_ENUMERATION:
      {
         pEnum = (pTW_ENUMERATION)GlobalLock((void*)twCap.hContainer);
         _arrOrientation.Length = pEnum->NumItems;
         for(i=0; i<(L_INT)pEnum->NumItems; i++)
         {
            ptwTemp = GetItemFromEnumeration(pEnum, i);
            twItem = (TW_UINT16)*ptwTemp;
            switch (twItem)
            {
            case TWOR_ROT0:
               _cmbOrientation->Items->Add("ROT0");
               break;
            case TWOR_ROT90:
               _cmbOrientation->Items->Add("ROT90");
               break;
            case TWOR_ROT180:
               _cmbOrientation->Items->Add("ROT180");
               break;
            case TWOR_ROT270:
               _cmbOrientation->Items->Add("ROT270");
               break;
            }

            _arrOrientation[i]= twItem;
         }

         _cmbOrientation->ItemIndex= pEnum->CurrentIndex;
      }
      break;

   case TWON_ONEVALUE:
      {
         pOneValue = (pTW_ONEVALUE)GlobalLock((void*)twCap.hContainer);
         _arrOrientation.Length = 1;
         ptwTemp = GetItemFromOneValue(pOneValue);
         twItem = (TW_UINT16)*ptwTemp;

         switch (twItem)
         {
         case TWOR_ROT0:
            _cmbOrientation->Items->Add("ROT0");
            break;
         case TWOR_ROT90:
            _cmbOrientation->Items->Add("ROT90");
            break;
         case TWOR_ROT180:
            _cmbOrientation->Items->Add("ROT180");
            break;
         case TWOR_ROT270:
            _cmbOrientation->Items->Add("ROT270");
            break;
         }

         _arrOrientation[0]= twItem;
         _cmbOrientation->ItemIndex= 0;
      }
      break;
   }

   GlobalUnlock((void*)twCap.hContainer);
   MainFrm->_LEADTwain->FreeContainer(&twCap);
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::FillEffectsCap(TW_UINT16 Capability)
{
   TW_CAPABILITY   twCap;
   pTW_ENUMERATION pEnum = NULL;
   pTW_RANGE       pRange = NULL;
   pTW_ONEVALUE    pOneValue = NULL;
   L_INT           nRet = TWAIN_SUCCESS, i=0;
   FLOAT           fRes;
   AnsiString      strVal;
   pTW_UINT8       ptwTemp = NULL;
   pTW_FIX32       ptwItem = NULL;

   TComboBox * cmbItem = NULL;
   /* ICAP_CONTRAST, ICAP_BRIGHTNESS, ICAP_HIGHLIGHT */
   switch (Capability)
   {
   case ICAP_CONTRAST:
      cmbItem= _cmbContrast;
      break;
   case ICAP_BRIGHTNESS:
      cmbItem= _cmbBrightness;
      break;
   case ICAP_HIGHLIGHT:
      cmbItem= _cmbHighlight;
      break;
   }

   cmbItem->Clear();

   ZeroMemory(&twCap, sizeof(TW_CAPABILITY));
   twCap.Cap= Capability;
   twCap.ConType= TWON_ENUMERATION;
   nRet= MainFrm->_LEADTwain->GetCapability(&twCap, LTWAIN_CAPABILITY_GETVALUES);
   if(nRet != TWAIN_SUCCESS)
   {
      /* disable effect combo box */
      cmbItem->Enabled= false;
      return;
   }

   switch (twCap.ConType)
   {
   case TWON_ENUMERATION:
      {
         pEnum = (pTW_ENUMERATION)GlobalLock((void*)twCap.hContainer);

         for (i=0; i<(L_INT)pEnum->NumItems; i++)
         {
            ptwTemp = GetItemFromEnumeration(pEnum, i);
            ptwItem = (pTW_FIX32)ptwTemp;

            fRes = Fix32ToFloat(&ptwItem[i]);

            strVal= IntToStr((int)fRes) + "." + IntToStr((int)((fRes - (int)fRes) * 10));

            cmbItem->Items->Add(strVal);
         }
         cmbItem->ItemIndex= pEnum->CurrentIndex;
      }
      break;

   case TWON_RANGE:
      {
         L_INT nSelIndex = 0;
         i = 0;
         pRange = (pTW_RANGE)GlobalLock((void*)twCap.hContainer);

         pTW_FIX32 ptwMin = (pTW_FIX32)&pRange->MinValue;
         pTW_FIX32 ptwMax = (pTW_FIX32)&pRange->MaxValue;
         pTW_FIX32 ptwStep = (pTW_FIX32)&pRange->StepSize;
         pTW_FIX32 ptwDefault = (pTW_FIX32)&pRange->DefaultValue;

         float fMin = Fix32ToFloat(ptwMin);
         float fMax = Fix32ToFloat(ptwMax);
         float fStep = Fix32ToFloat(ptwStep);
         float fDefault = Fix32ToFloat(ptwDefault);

         strVal= IntToStr((int)fMin) + "." + IntToStr((int)((fMin - (int)fMin) * 10));

         i=0;
         cmbItem->Items->Add(strVal);

         if (fDefault == fMin)
            nSelIndex = i;

         float fVal = fMin + fStep;
         while (fVal < fMax)
         {
            strVal= IntToStr((int)fVal) + "." + IntToStr((int)((fVal - (int)fVal) * 10));

            i++;
            cmbItem->Items->Add(strVal);

            if (fDefault == fVal)
               nSelIndex = i;

            fVal = fVal + fStep;
         }

         strVal= IntToStr((int)fMax) + "." + IntToStr((int)((fMax - (int)fMax) * 10));

         i++;
         cmbItem->Items->Add(strVal);

         if (fDefault == fMax)
            nSelIndex = i;

         cmbItem->ItemIndex= nSelIndex;
      }
      break;
   case TWON_ONEVALUE:
      {
         pOneValue = (pTW_ONEVALUE)GlobalLock((void*)twCap.hContainer);

         ptwTemp = GetItemFromOneValue(pOneValue);
         ptwItem = (pTW_FIX32)ptwTemp;

         fRes = Fix32ToFloat(&ptwItem[i]);

         strVal= IntToStr((int)fRes) + "." + IntToStr((int)((fRes - (int)fRes) * 10));

         cmbItem->Items->Add(strVal);
         cmbItem->ItemIndex= 0;
      }
      break;
   }

   GlobalUnlock((void*)twCap.hContainer);
   MainFrm->_LEADTwain->FreeContainer(&twCap);
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::FillHalftones()
{
   TW_CAPABILITY   twCap;
   pTW_ENUMERATION pEnum = NULL;
   pTW_ARRAY       pArray = NULL;
   pTW_ONEVALUE    pOneValue = NULL;
   L_INT           nRet = TWAIN_SUCCESS, i=0;
   pTW_UINT8       ptwTemp = NULL;
   pTW_STR32       ptwItem = NULL;

   /* ICAP_HALFTONES */
   _cmbHalftone->Clear();

   ZeroMemory(&twCap, sizeof(TW_CAPABILITY));
   twCap.Cap= ICAP_HALFTONES;
   twCap.ConType= TWON_ENUMERATION;
   nRet= MainFrm->_LEADTwain->GetCapability(&twCap, LTWAIN_CAPABILITY_GETVALUES);
   if (nRet != TWAIN_SUCCESS)
   {
      /* disable halftone combo box */
      _cmbHalftone->Enabled= False;
      return;
   }

   switch (twCap.ConType)
   {
   case TWON_ENUMERATION:
      {
         pEnum = (pTW_ENUMERATION)GlobalLock((void*)twCap.hContainer);

         for (i=0; i<(L_INT)pEnum->NumItems; i++)
         {
            ptwTemp = GetItemFromEnumeration(pEnum, i);
            ptwItem = (pTW_STR32)ptwTemp;

            _cmbHalftone->Items->Add(ptwItem);
         }

         _cmbHalftone->ItemIndex= pEnum->CurrentIndex;
      }
      break;
   case TWON_ARRAY:
      {
         pArray = (pTW_ARRAY)GlobalLock((void*)twCap.hContainer);

         for (i=0; i<(L_INT)pArray->NumItems; i++)
         {
            ptwTemp = GetItemFromArray(pArray, i);
            ptwItem = (pTW_STR32)ptwTemp;

            _cmbHalftone->Items->Add(ptwItem);
         }

         _cmbHalftone->ItemIndex= 0;
      }
      break;
   case TWON_ONEVALUE:
      {
         pOneValue = (pTW_ONEVALUE)GlobalLock((void*)twCap.hContainer);

         ptwTemp = GetItemFromOneValue(pOneValue);
         ptwItem = (pTW_STR32)ptwTemp;

         _cmbHalftone->Items->Add(ptwItem);
         _cmbHalftone->ItemIndex= 0;
      }
      break;
   }

   GlobalUnlock((void*)twCap.hContainer);
   MainFrm->_LEADTwain->FreeContainer(&twCap);
}
//---------------------------------------------------------------------------

void __fastcall TLEADTemplateDlg::_edtChange(TObject *Sender)
{
   CheckOKButton();
}
//---------------------------------------------------------------------------

bool TLEADTemplateDlg::SetCapabilities()
{
   /* ICAP_UNITS */
   SetUnitsCapability();

   /* ICAP_FRAMES */
   SetFramesCapability();

   /* ICAP_XRESOLUTION - ICAP_YRESOLUTION */
   SetXYResCapability();

   /* ICAP_XFERMECH */
   SetXferCapability();

   /* ICAP_PIXELTYPE */
   SetPixelTypeCapability();

   /* ICAP_ORIENTATION */
   SetOrientationCapability();

   /* ICAP_CONTRAST, ICAP_BRIGHTNESS, ICAP_HIGHLIGHT */
   SetContrastCapability();
   SetBrightnessCapability();
   SetHighlightCapability();

   /* ICAP_HALFTONES */
   SetHalftonesCapability();

   return true;
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::SetUnitsCapability()
{
   L_INT nRet;
   DWORD dwItemData;

   /* ICAP_UNITS */
   if(!_cmbUnits->Enabled)
      return;

   dwItemData= _arrUnits[_cmbUnits->ItemIndex];

   nRet= MySetCapability(ICAP_UNITS, TWTY_UINT16, TW_UINT16(dwItemData));
   if(nRet != SUCCESS)
   {
      MainFrm->AddErrorToErrorList("Error occurred during set ICAP_UNITS capability, nRet = " + IntToStr(nRet));
   }
}
//---------------------------------------------------------------------------

L_INT TLEADTemplateDlg::MySetCapability(TW_UINT16 Capability, TW_UINT16 ItemType, TW_UINT32 ItemValue)
{
   TW_CAPABILITY twCap;
   pTW_ONEVALUE pOneValue;
   L_INT nRet;

   ZeroMemory(&twCap, sizeof(TW_CAPABILITY));

   twCap.Cap= Capability;
   twCap.ConType= TWON_ONEVALUE;
   twCap.hContainer= (TW_HANDLE)GlobalAlloc(GHND, sizeof(pTW_ONEVALUE));
   if(twCap.hContainer == 0)
   {
      return ERROR_NO_MEMORY;
   }

   pOneValue= (pTW_ONEVALUE)GlobalLock((void*)twCap.hContainer);
   pOneValue->ItemType= ItemType;
   pOneValue->Item= ItemValue;
   GlobalUnlock((void*)twCap.hContainer);

   nRet= MainFrm->_LEADTwain->SetCapability(&twCap, LTWAIN_CAPABILITY_SET);
   return nRet;
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::SetFramesCapability()
{
   TW_CAPABILITY twCap;
   pTW_ONEVALUE pOneValue;
   L_INT nRet;
   float fValue;
   TW_FIX32 twFixLeft;
   TW_FIX32 twFixTop;
   TW_FIX32 twFixRight;
   TW_FIX32 twFixBottom;
   TW_FRAME twFrame;

   /* ICAP_FRAMES */
   if(! _edtLeft->Enabled)
      return;

   fValue= StrToFloat(_edtLeft->Text);
   twFixLeft= FloatToFix32(fValue);

   fValue= StrToFloat(_edtTop->Text);
   twFixTop= FloatToFix32(fValue);

   fValue= StrToFloat(_edtRight->Text);
   twFixRight= FloatToFix32(fValue);

   fValue= StrToFloat(_edtBottom->Text);
   twFixBottom= FloatToFix32(fValue);

   twFrame.Left= twFixLeft;
   twFrame.Top= twFixTop;
   twFrame.Right= twFixRight;
   twFrame.Bottom= twFixBottom;

   ZeroMemory(&twCap, sizeof(TW_CAPABILITY));
   twCap.Cap= ICAP_FRAMES;
   twCap.ConType= TWON_ONEVALUE;
   twCap.hContainer= (TW_HANDLE)GlobalAlloc(GHND, sizeof(pTW_ONEVALUE) + sizeof(TW_FRAME));
   if(!twCap.hContainer)
      return;

   pOneValue= (pTW_ONEVALUE)GlobalLock((void*)twCap.hContainer);
   pOneValue->ItemType= TWTY_FRAME;
   pOneValue->Item= TW_UINT32(&twFrame);
   GlobalUnlock((void*)twCap.hContainer);

   nRet= MainFrm->_LEADTwain->SetCapability(&twCap, LTWAIN_CAPABILITY_SET);
   if(nRet != SUCCESS)
   {
      MainFrm->AddErrorToErrorList("Error occurred during set ICAP_FRAMES capability, nRet= " + IntToStr(nRet));
   }
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::SetXYResCapability()
{
   L_INT nRet;
   float fValue;
   TW_FIX32 twFix;

   /* ICAP_XRESOLUTION */

   if(!_cmbXResolution->Enabled)
   {
      fValue= StrToFloat(_cmbXResolution->Text);
      twFix= FloatToFix32(fValue);

      nRet= SetFix32Capability(ICAP_XRESOLUTION, &twFix);
      if(nRet != SUCCESS)
      {
         MainFrm->AddErrorToErrorList("Error occurred during set ICAP_XRESOLUTION capability, nRet = " + IntToStr(nRet));
      }
   }

   /* ICAP_YRESOLUTION */
   if(! _cmbYResolution->Enabled)
      return;

   fValue= StrToFloat(_cmbYResolution->Text);
   twFix= FloatToFix32(fValue);

   nRet= SetFix32Capability(ICAP_YRESOLUTION, &twFix);
   if(nRet != SUCCESS)
   {
      MainFrm->AddErrorToErrorList("Error occurred during set ICAP_YRESOLUTION capability, nRet = " + IntToStr(nRet));
   }
}
//---------------------------------------------------------------------------

L_INT TLEADTemplateDlg::SetFix32Capability(TW_UINT16 Capability, pTW_FIX32 ptwFix)
{
   TW_CAPABILITY twCap;
   pTW_ONEVALUE pOneValue;
   L_INT nRet;

   ZeroMemory(&twCap, sizeof(TW_CAPABILITY));
   twCap.Cap= Capability;
   twCap.ConType= TWON_ONEVALUE;
   twCap.hContainer= TW_HANDLE(GlobalAlloc(GHND, sizeof(pTW_ONEVALUE) + sizeof(TW_FIX32)));
   if(!twCap.hContainer)
   {
      return ERROR_NO_MEMORY;
   }

   pOneValue= (pTW_ONEVALUE)GlobalLock((void*)twCap.hContainer);
   pOneValue->ItemType= TWTY_FIX32;
   pOneValue->Item= TW_UINT32(ptwFix);
   GlobalUnlock((void*)twCap.hContainer);

   nRet= MainFrm->_LEADTwain->SetCapability(&twCap, LTWAIN_CAPABILITY_SET);
   return nRet;
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::SetXferCapability()
{
   L_INT nRet;
   DWORD dwItemData;
   TW_UINT16 nFileFormat;
   LTWAINPROPERTIES twProps;

   if(! _rbFile->Enabled && !_rbMemory->Enabled && !_rbNative->Enabled)
      return;

   /* ICAP_XFERMECH */
   nRet= MySetCapability(ICAP_XFERMECH, TWTY_UINT16, TW_UINT16(MainFrm->XferMech));
   if(nRet != SUCCESS)
   {
      MainFrm->AddErrorToErrorList("Error occurred during set ICAP_XFERMECH capability, nRet = " + IntToStr(nRet));
      return;
   }

   switch (MainFrm->XferMech)
   {
      case TWSX_FILE:
      {
         /* ICAP_IMAGEFILEFORMAT */
         dwItemData= _arrFormat[_cmbFormat->ItemIndex];
         nFileFormat= TW_UINT16(dwItemData);

         nRet= MySetCapability(ICAP_IMAGEFILEFORMAT, TWTY_UINT16, nFileFormat);
         if (nRet != SUCCESS)
         {
            MainFrm->AddErrorToErrorList("Error occurred during set ICAP_IMAGEFILEFORMAT capability, nRet = " + IntToStr(nRet));
         }

         ZeroMemory(&twProps, sizeof(LTWAINPROPERTIES));

         twProps.ImageRes.uStructSize= sizeof(IMAGERESOLUTION);
         twProps.DataTransfer.uStructSize= sizeof(DATATRANSFER);
         twProps.ImageEff.uStructSize= sizeof(IMAGEEFFECTS);

         /* Get the current properties of the selected twain source */
         nRet= MainFrm->_LEADTwain->GetProperties(&twProps, LTWAIN_PROPERTIES_GETCURRENT);
         if(nRet != SUCCESS)
         {
            MainFrm->AddErrorToErrorList("Error occurred during set ICAP_IMAGEFILEFORMAT capability, nRet = " + IntToStr(nRet));
         }
         else
         {
            /* Change transfer mode to File and pass file name and format */

            twProps.DataTransfer.nTransferMode= MainFrm->XferMech;
            StrCopy(twProps.DataTransfer.szFileName, _edtFileName->Text.c_str());
            twProps.DataTransfer.nScanFileFormat= nFileFormat;
            twProps.uStructSize= sizeof(LTWAINPROPERTIES);

            /* Set the new properties */
            nRet= MainFrm->_LEADTwain->SetProperties(&twProps, LTWAIN_PROPERTIES_SET);
            if(nRet != SUCCESS)
            {
               MainFrm->AddErrorToErrorList("Error occurred during set ICAP_IMAGEFILEFORMAT capability, nRet = " + IntToStr(nRet));
            }
         }
      }
      break;

      case TWSX_MEMORY:
      {
         /* ICAP_COMPRESSION */
         dwItemData= _arrCompression[_cmbCompression->ItemIndex];

         nRet= MySetCapability(ICAP_COMPRESSION, TWTY_UINT16, TW_UINT16(dwItemData));
         if(nRet != SUCCESS)
         {
            MainFrm->AddErrorToErrorList("Error occurred during set ICAP_COMPRESSION capability, nRet = " + IntToStr(nRet));
         }
      }
      break;

   case TWSX_NATIVE:
      /* do nothing */
      break;
   }
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::SetPixelTypeCapability()
{
   L_INT nRet;
   DWORD dwItemData;
   L_INT nBPP;

   /* ICAP_PIXELTYPE */
   if(!_cmbPixelType->Enabled)
      return;

   dwItemData= _arrPixelType[_cmbPixelType->ItemIndex];

   nRet= MySetCapability(ICAP_PIXELTYPE, TWTY_UINT16, dwItemData);
   if(nRet != SUCCESS)
   {
      MainFrm->AddErrorToErrorList("Error occurred during set ICAP_PIXELTYPE capability, nRet = " + IntToStr(nRet));
   }

   nBPP= 0;
   dwItemData= TWPT_RGB;
   switch (dwItemData)
   {
      case TWPT_BW:
         nBPP= 1;
      break;

      TWPT_GRAY:
         nBPP= 8;
      break;

      TWPT_RGB:
         nBPP= 24;
      break;

      TWPT_PALETTE:
         nBPP= 8;
      break;
   }

   nRet= MySetCapability(ICAP_BITDEPTH, TWTY_UINT16, nBPP);
   if(nRet != SUCCESS)
   {
      MainFrm->AddErrorToErrorList("Error occurred during set ICAP_BITDEPTH capability, nRet= " + IntToStr(nRet));
   }
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::SetOrientationCapability()
{
   L_INT nRet;
   DWORD dwItemData;

   /* ICAP_ORIENTATION */
   if(!_cmbOrientation->Enabled)
      return;

   dwItemData= _arrOrientation[_cmbOrientation->ItemIndex];

   nRet= MySetCapability(ICAP_ORIENTATION, TWTY_UINT16, dwItemData);
   if(nRet != SUCCESS)
   {
      MainFrm->AddErrorToErrorList("Error occurred during set ICAP_ORIENTATION capability, nRet= " + IntToStr(nRet));
   }
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::SetContrastCapability()
{
   L_INT nRet;
   float fValue;
   TW_FIX32 twFix;

   /* ICAP_CONTRAST */
   if(!_cmbContrast->Enabled)
      return;

   fValue= StrToFloat(_cmbContrast->Text);
   twFix= FloatToFix32(fValue);

   nRet= SetFix32Capability(ICAP_CONTRAST, &twFix);
   if (nRet != SUCCESS)
   {
      MainFrm->AddErrorToErrorList("Error occurred during set ICAP_CONTRAST capability, nRet= " + IntToStr(nRet));
   }
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::SetBrightnessCapability()
{
   L_INT nRet;
   float fValue;
   TW_FIX32 twFix;

   /* ICAP_BRIGHTNESS */
   if(!_cmbBrightness->Enabled)
      return;

   fValue= StrToFloat(_cmbBrightness->Text);
   twFix= FloatToFix32(fValue);

   nRet= SetFix32Capability(ICAP_BRIGHTNESS, &twFix);
   if (nRet != SUCCESS)
   {
      MainFrm->AddErrorToErrorList("Error occurred during set ICAP_BRIGHTNESS capability, nRet= " + IntToStr(nRet));
   }
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::SetHighlightCapability()
{
   L_INT nRet;
   float fValue;
   TW_FIX32 twFix;

   /* ICAP_HIGHLIGHT */
   if(!_cmbHighlight->Enabled)
      return;

   fValue= StrToFloat(_cmbHighlight->Text);
   twFix= FloatToFix32(fValue);

   nRet= SetFix32Capability(ICAP_HIGHLIGHT, &twFix);
   if (nRet != SUCCESS)
   {
      MainFrm->AddErrorToErrorList("Error occurred during set ICAP_HIGHLIGHT capability, nRet= " + IntToStr(nRet));
   }
}
//---------------------------------------------------------------------------

void TLEADTemplateDlg::SetHalftonesCapability()
{
   L_INT nRet;
   TW_STR32 szItem;
   TW_UINT32 twItem;

   /* ICAP_HALFTONES */
   if(!_cmbHalftone->Enabled)
      return;

   StrCopy(szItem, _cmbHalftone->Text.c_str());

   twItem= TW_UINT32(&szItem);
   nRet= MySetCapability(ICAP_HALFTONES, TWTY_STR32, twItem);
   if(nRet != SUCCESS)
   {
      MainFrm->AddErrorToErrorList("Error occurred during set ICAP_HALFTONES capability, nRet= " + IntToStr(nRet));
   }
}
//---------------------------------------------------------------------------

void __fastcall TLEADTemplateDlg::_btnLoadClick(TObject *Sender)
{
   L_INT nRet;

   _MSOpenDialog->Title= "Load Template";
   _MSOpenDialog->DefaultExt= "ltt";
   _MSOpenDialog->Filter= "LEAD Template(*.ltt)|*.ltt|All Files(*.*)|*.*";
   if(_MSOpenDialog->Execute())
   {
      // load template...
      nRet= LoadTemplateFile(_MSOpenDialog->FileName);
      if(nRet == TWAIN_SUCCESS)
      {
         ShowMessage("Template Loaded From " + _MSOpenDialog->FileName);
      }
   }
}
//---------------------------------------------------------------------------

L_INT TLEADTemplateDlg::LoadTemplateFile(AnsiString strFileName)
{
   L_INT nRet;
   L_UINT i;
   L_UINT uCapsCount;
   pTW_CAPABILITY pCap;
   HTWAINTEMPLATEFILE hTempFile;

   nRet= MainFrm->_LEADTwain->OpenTemplateFile(&hTempFile, strFileName, LTWAIN_TEMPLATE_OPEN_READ);
   if(nRet == SUCCESS)
   {
      uCapsCount= 0;
      pCap= NULL;

      nRet= MainFrm->_LEADTwain->GetNumOfCapsInFile(hTempFile, &uCapsCount);
      if (nRet == SUCCESS)
      {
         for (i= 0; i < uCapsCount; i ++)
         {
            nRet= MainFrm->_LEADTwain->GetCapabilityFromFile(hTempFile, &pCap, i);
            if(nRet == SUCCESS)
            {
               nRet= MainFrm->_LEADTwain->SetCapability(pCap, LTWAIN_CAPABILITY_SET);

               if(pCap)
               {
                  GlobalFree((void*)pCap->hContainer);
                  GlobalFreePtr(pCap);
               }
            }
         }
      }

      MainFrm->_LEADTwain->CloseTemplateFile(hTempFile);
      InitializeDialog();
   }

   if(nRet != SUCCESS)
   {
      MainFrm->AddErrorToErrorList("Error occurred during load template file, nRet= " + IntToStr(nRet));
   }

   return nRet;
}

void __fastcall TLEADTemplateDlg::_btnSaveClick(TObject *Sender)
{
   L_INT nRet;

   _MSSaveDialog->Title= "Save Template File";
   _MSSaveDialog->Filter= "Template Files(*.ltt)|*.ltt|All Files(*.*)|*.*";
   _MSSaveDialog->DefaultExt= "ltt";
   if(_MSSaveDialog->Execute())
   {
      // save template...
      nRet= SaveTemplateFile(_MSSaveDialog->FileName);
      if(nRet == TWAIN_SUCCESS)
      {
         ShowMessage("Template Saved to " + _MSSaveDialog->FileName);
      }
   }
}
//---------------------------------------------------------------------------

HTWAINTEMPLATEFILE hTempFile;

L_INT TLEADTemplateDlg::SaveTemplateFile(AnsiString strFileName)
{
   L_INT nRet;

   SetCapabilities();

   hTempFile= 0;

   nRet= MainFrm->_LEADTwain->OpenTemplateFile(&hTempFile, strFileName, LTWAIN_TEMPLATE_OPEN_WRITE);
   if(nRet == SUCCESS)
   {
      MainFrm->_LEADTwain->OnEnumCapabilityEvent= LEADSaveCaps;
      nRet= MainFrm->_LEADTwain->EnumCapabilities(LTWAIN_CAPABILITY_GETCURRENT);

      MainFrm->_LEADTwain->CloseTemplateFile(hTempFile);
   }

   if(nRet != SUCCESS)
   {
      MainFrm->AddErrorToErrorList("Error occurred during save template file, nRet = " + IntToStr(nRet));
   }

   return nRet;
}
//---------------------------------------------------------------------------

L_INT __fastcall TLEADTemplateDlg::LEADSaveCaps(L_UINT uCap, pTW_CAPABILITY pCapability)
{
   L_INT nRet;

   nRet= MainFrm->_LEADTwain->AddCapabilityToFile(hTempFile, pCapability);
   if(nRet != SUCCESS)
   {
      MainFrm->AddErrorToErrorList("Error occurred during save capability to template file, nRet = " + IntToStr(nRet));
   }

   return TWAIN_SUCCESS;
}

//-End.Of.File.--------------------------------------------------------------