//---------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop

#include "MainForm.h"
#include "About.h"
#include "GetURL.h"

#include "..\..\..\..\include\ltkey.h"
#include "BrowsFrm.h"
#include "RawParamsDialog.h"

//---------------------------------------------------------------------
#pragma link "LEADMain"
#pragma link "LEADDlgFile"
#pragma link "LEADDlgService"
#pragma link "LEADIsis"
#pragma link "LEADTwain"
#pragma link "LEADDlgImgEffect"
#pragma link "LEADThmb"
#pragma resource "*.dfm"


TMainFrm *MainFrm;
void RegisterAppKey ( HINSTANCE hInstance );
//---------------------------------------------------------------------
__fastcall TMainFrm::TMainFrm(TComponent *Owner)
   : TForm(Owner)
{
}
//---------------------------------------------------------------------

void TMainFrm::UnlockSupport(void)
{
   LEADImage2->UnlockSupport ( L_SUPPORT_DOCUMENT, L_KEY_DOCUMENT );
   LEADImage2->UnlockSupport ( L_SUPPORT_GIFLZW, L_KEY_GIFLZW );
   LEADImage2->UnlockSupport ( L_SUPPORT_TIFLZW, L_KEY_TIFLZW );
   LEADImage2->UnlockSupport ( L_SUPPORT_OCR, L_KEY_OCR );
   LEADImage2->UnlockSupport ( L_SUPPORT_MEDICAL, L_KEY_MEDICAL );
   LEADImage2->UnlockSupport ( L_SUPPORT_VECTOR, L_KEY_VECTOR );
   LEADImage2->UnlockSupport ( L_SUPPORT_MEDICAL_NET, L_KEY_MEDICAL_NET );
   LEADImage2->UnlockSupport ( L_SUPPORT_BARCODES_1D, L_KEY_BARCODES_1D );
   LEADImage2->UnlockSupport ( L_SUPPORT_BARCODES_2D_READ, L_KEY_BARCODES_2D_READ );
   LEADImage2->UnlockSupport ( L_SUPPORT_BARCODES_2D_WRITE, L_KEY_BARCODES_2D_WRITE );
   LEADImage2->UnlockSupport ( L_SUPPORT_BARCODES_PDF_READ, L_KEY_BARCODES_PDF_READ );
   LEADImage2->UnlockSupport ( L_SUPPORT_BARCODES_PDF_WRITE, L_KEY_BARCODES_PDF_WRITE );
   LEADImage2->UnlockSupport ( L_SUPPORT_PDF, L_KEY_PDF );
   LEADImage2->UnlockSupport ( L_SUPPORT_J2K, L_KEY_J2K );
   LEADImage2->UnlockSupport ( L_SUPPORT_CMW, L_KEY_CMW );
   LEADImage2->UnlockSupport ( L_SUPPORT_DICOM, L_KEY_DICOM );
   LEADImage2->UnlockSupport ( L_SUPPORT_EXTGRAY, L_KEY_EXTGRAY );
   LEADImage2->UnlockSupport ( L_SUPPORT_BITONAL, L_KEY_BITONAL );
   LEADImage2->UnlockSupport ( L_SUPPORT_PDF_SAVE, L_KEY_PDF_SAVE );
   LEADImage2->UnlockSupport ( L_SUPPORT_OCR_PDF_OUTPUT, L_KEY_OCR_PDF_OUTPUT );
   LEADImage2->UnlockSupport ( L_SUPPORT_BARCODES_DATAMATRIX_READ, L_KEY_BARCODES_DATAMATRIX_READ );
   LEADImage2->UnlockSupport ( L_SUPPORT_BARCODES_DATAMATRIX_WRITE, L_KEY_BARCODES_DATAMATRIX_WRITE );
   LEADImage2->UnlockSupport ( L_SUPPORT_LTPRO, L_KEY_LTPRO );
   LEADImage2->UnlockSupport ( L_SUPPORT_ABC, L_KEY_ABC );
   LEADImage2->UnlockSupport ( L_SUPPORT_JBIG2, L_KEY_JBIG2 );
   LEADImage2->UnlockSupport ( L_SUPPORT_ABIC_READ, L_KEY_ABIC_READ );
   LEADImage2->UnlockSupport ( L_SUPPORT_ABIC_SAVE, L_KEY_ABIC_SAVE );
   LEADImage2->UnlockSupport ( L_SUPPORT_PDF_READ, L_KEY_PDF_READ );
   LEADImage2->UnlockSupport ( L_SUPPORT_PDF_ADVANCED, L_KEY_PDF_ADVANCED );

}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::FormCreate(TObject *Sender)
{
   L_INT nRet;

   UnlockSupport ( );
   SetClipboardViewer(Handle);
   bUsePaintWhileLoad = false;
   nNumPastes = 1;
   nNumClrMrg = 1;
   PaintDitherVal = pdOrdered;
   bDICOMLoadMsg=true;
   mnuDitheringOrdered1->Checked = true;
   PaintPaletteVal = ppAuto;
   mnuPaintPaletteAuto1->Checked = true;
   mnuBitonalScalingNormal1->Checked = true;
   mnuBitonalScalingFavorBlack1->Checked = false;
   mnuBitonalScalingScaleToGray1->Checked = false;
   BitonalScalingVal = btsNormal;
   PaintScalingVal = psResample;
   TLEADImage *TempBitmap = new TLEADImage(this);
   if (TempBitmap->Paste(PASTE_ISREADY) == 0)
      mnuPaste1->Enabled = false;
   TempBitmap->Free();

   LEADTwain1->EnableAcquirePageEvent= true;
   LEADImage2->Bitmap= 0;
   mnuSortItems1->Enabled=false;
   bDICOMLoadMsg= true;

   LEADTwain1->InitSession ( (int)Handle );
   nRet= LEADDlgService1->InitDialogs ( DLG_INIT_COLOR );
   if ( nRet != SUCCESS )
   {
      ShowMessage ( "Error Initializing Dialogs" );
      Application->Terminate ( );
   }
   RegisterAppKey ( HInstance );

   FRawDialogDisplaied= false;
   FLoadInfoFormat= FILE_RAW;
   FLoadInfoWidth= 2560;
   FLoadInfoHeight= 3500;
   FLoadInfoXRes= 300;
   FLoadInfoYRes= 300;
   FLoadInfoOffset= 0;
   FLoadInfoWhiteOnBlack= false;
   FLoadInfoLSBFirst= false;
   FLoadInfoViewPerspective= TOP_LEFT;
   FLoadInfoColorOrder= LOADINFO_ORDERRGB;
   FLoadInfoBitsPerPixel= 24;
   FLoadInfoPalette= 0;
   FLoadInfoPadding= true;
   FLoadInfoFlags= FLoadInfoViewPerspective + FLoadInfoColorOrder + LOADINFO_PAD4;

   FShowRawFormatDialog= false;
}
//---------------------------------------------------------------------

void __fastcall TMainFrm::FormCloseQuery(TObject *Sender, bool &CanClose)
{
   if(BrowseForm->InBrowsing)
      CanClose = false;
   else
      CanClose = true;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::FormDestroy(TObject *Sender)
{
   LEADTwain1->EndSession ( );
   LEADDlgService1->FreeDialogs ( );
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuFileClick(TObject *Sender)
{
   bool bEnableISIS = MainFrm->LEADIsis1->IsISISAvailable;
   mnuISISSelect1->Enabled = bEnableISIS;
   mnuISISAcquire1->Enabled = bEnableISIS;
   mnuISISAcquireMulti1->Enabled = bEnableISIS;
   mnuPrintStitchedImages1->Enabled = (Printer()->Printers->Count > 0);
}
//---------------------------------------------------------------------------

void TMainFrm::CreateNewChildForm ( AnsiString FileName, int nPage )
{
   TChildImage *newChild = new TChildImage(Parent);
   newChild->SetImageName ( FileName );
   newChild->Refresh();

   try
   {
      newChild->LEADImage1->EnableLoadInfoEvent= true;   
      newChild->LEADImage1->GetFileInfo( FileName, 0);
      int nFormat= newChild->LEADImage1->InfoFormat;
      bool bLoadUseRes= ( ( nFormat == FILE_J2K ) ||
                          ( nFormat == FILE_JP2 ) ||
                          ( nFormat == FILE_CMW ) ||
                          ( nFormat == FILE_PCD ) ||
                          ( nFormat == FILE_FPX ) ||
                          ( nFormat == FILE_JBIG ) ||
                          ( nFormat == FILE_EPSPOSTSCRIPT ) ||
                          ( nFormat == FILE_PSP ));

      newChild->LEADImage1->RasterizeViewMode= LEADDlgFile1->VECTORMISCViewportMode;
      newChild->LEADImage1->RasterizeViewportWidth= LEADDlgFile1->VECTORMISCViewportWidth;
      newChild->LEADImage1->RasterizeViewportHeight= LEADDlgFile1->VECTORMISCViewportHeight;

      if ( ( bLoadUseRes ) && ( mnuPaintWhileLoad1->Checked ) )
      {
         newChild->LEADImage1->SetLoadResolution ( nFormat,
                                                   LEADImage2->BitmapWidth,
                                                   LEADImage2->BitmapHeight );
         newChild->LEADImage1->Load ( FileName, 0, nPage, 1);
      }
      else
      {
         if ( bLoadUseRes )
            newChild->LEADImage1->Bitmap= LEADImage2->Bitmap;
         else
            newChild->LEADImage1->Load(FileName, 0, nPage, -1);
      }
      newChild->LEADImage1->EnableLoadInfoEvent= false;
      DisplayDICOMLoadMsg(newChild->LEADImage1->InfoFormat);
   }
   catch (ELEADImageError* e)
   {
      newChild->Close();
      DisplayErrorMsg ( newChild->LEADImage1->ErrorMsg );
      Screen->Cursor = crDefault;
      return;
   }

   newChild->StatusBarChanged(newChild);
   newChild->Caption = FileName;
   MainFrm->StatusBar->Panels->Items[0]->Text = FileName;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuOpen1Click(TObject *Sender)
{
   L_INT nRet;

   LEADDlgFile1->DlgFileFlags = 0;
   LEADDlgFile1->DialogTitle = "Open A File";
   LEADDlgFile1->PreviewEnabled = true;
   LEADDlgFile1->LoadPasses = 0;
   LEADDlgFile1->LoadRotated = true;
   LEADDlgFile1->LoadCompressed = false;
   LEADDlgFile1->FileName= "";
   LEADDlgFile1->DlgFlags= DLG_OPEN_ENABLESIZING |
                           DLG_OPEN_SHOW_PREVIEW |
                           DLG_OPEN_USEFILESTAMP |
                           DLG_OPEN_SHOW_PROGRESSIVE |
                           DLG_OPEN_SHOW_MULTIPAGE |
                           DLG_OPEN_SHOW_DELPAGE |
                           DLG_OPEN_SHOW_LOADROTATED |
                           DLG_OPEN_SHOW_LOADCOMPRESSED |
                           DLG_OPEN_SHOW_LOADOPTIONS |
                           DLG_OPEN_SHOW_FILEINFO |
                           DLG_OPEN_SHOW_PDFOPTIONS |
                           DLG_OPEN_SHOW_RASTEROPTIONS |
                           DLG_OPEN_SHOW_VECTOROPTIONS |
                           DLG_OPEN_VIEWTOTALPAGES |
                           DLG_OPEN_LOADBITMAP;

   LEADDlgFile1->LEADImage= LEADImage2;
   LEADDlgFile1->EnableMethodErrors = false;
   LEADImage2->EnableLoadInfoEvent= true;
   FShowRawFormatDialog= True;
   nRet= LEADDlgFile1->ShowOpenDlg ( this );
   LEADImage2->EnableLoadInfoEvent= false;
   LEADDlgFile1->EnableMethodErrors = true;
   if(nRet == ERROR_PDF_BAD_INITIALIZATION_FILES)
   {
      if(IDYES == Application->MessageBox("LEADTOOLS PDF plugin is not found, do you want to download the plugin now?",
                                          "Open File",
                                          MB_ICONEXCLAMATION + MB_YESNO))
      {
         ShellExecute(Handle, "open", "http://www.leadtools.com/ReleaseDownloads/v14/LEADTOOLSPDFRuntime.exe",
                      NULL, NULL, SW_SHOWNORMAL);
      }
      return;
   }
   else if(nRet < SUCCESS_DLG_OK)
   {
      DisplayErrorMsg(LEADDlgFile1->ErrorMsg);
      return;
   }
   if ( nRet == SUCCESS_DLG_CANCEL )
      return;

   Screen->Cursor = crHourGlass;

   CreateNewChildForm ( LEADDlgFile1->FileName, LEADDlgFile1->PageNumber );

   Screen->Cursor = crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::btnOpenClick(TObject *Sender)
{
   mnuOpen1->Click();
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuOpenLocation1Click(TObject *Sender)
{
   char * pStr= NULL;
   
   Application->CreateForm(__classid(TURLDlg), &URLDlg);

   if (URLDlg->ShowModal() == IDOK)
   {
      Screen->Cursor = crHourGlass;
      TChildImage *newChild = new TChildImage(this);

      newChild->mnuEdit->Enabled = false;
      newChild->mnuAnimation->Enabled = false;
      newChild->mnuView->Enabled = false;
      newChild->mnuMultiPage->Enabled = false;
      newChild->mnuImage->Enabled = false;
      newChild->mnuColor->Enabled = false;
      newChild->mnuPreferences->Enabled = false;
      newChild->mnuWindow->Enabled = false;

      URLDataPath = URLDlg->URLPath->Text;
      pStr= URLDataPath.c_str();

      while( *pStr== ' ' )
      {
         pStr++;
      }
            
      newChild->ImageName = pStr;
      try
      {
         newChild->LEADImage1->BitmapDataPath = pStr;
      }
      catch (ELEADImageError *e)
      {
         newChild->Close();
         AnsiString msg = "An error occoured in your application.\n Casues by: "+
               newChild->LEADImage1->ErrorMsg;
         Application->MessageBox (msg.c_str(), (char *)"Error! ", MB_OK);
         Screen->Cursor = crDefault;
         return;
      }
      Screen->Cursor = crDefault;
   }
}
//---------------------------------------------------------------------------

void TMainFrm::ConvertBitmap ( )
{
   L_INT nRet;

   LEADDlgFile1->Overwrite= DLG_FILECONVERSION_OVERWRITE_SKIP;
   LEADDlgFile1->UseLogReport= true;
   LEADDlgFile1->RemoveSourceFile= false;
   LEADDlgFile1->ShowFullPath= true;
   LEADDlgFile1->UseOriginalFolder= true;
   LEADDlgFile1->DlgFlags= DLG_FILECONVERSION_SHOW_PREVIEW        +
                           DLG_FILECONVERSION_SHOW_LOADOPTIONS    +
                           DLG_FILECONVERSION_SHOW_FILEINFO       +
                           DLG_FILECONVERSION_SHOW_PREVIEW_PAGES  +
                           DLG_FILECONVERSION_SHOW_RESIZE         +
                           DLG_FILECONVERSION_SHOW_ROTATE         +
                           DLG_FILECONVERSION_SHOW_NAMINGTEMPLATE +
                           DLG_FILECONVERSION_SHOW_OVERWRITE      +
                           DLG_FILECONVERSION_SHOW_OVERWRITE_ALL  +
                           DLG_FILECONVERSION_SHOW_ADD            +
                           DLG_FILECONVERSION_SHOW_ADDFOLDER      +
                           DLG_FILECONVERSION_SHOW_REMOVE         +
                           DLG_FILECONVERSION_SHOW_SELECTALL      +
                           DLG_FILECONVERSION_SHOW_DELETEORIGINAL +
                           DLG_FILECONVERSION_SHOW_NEWFORMATSUPDATES;

   nRet= LEADDlgFile1->ShowFileConversionDlg ( this );
   if ( nRet < SUCCESS )
      DisplayErrorMsg ( "Convert File dialog error" );
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuConvertFile1Click(TObject *Sender)
{
   ConvertBitmap ( );
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuBrowse1Click(TObject *Sender)
{
   mnuInsertImage1->Enabled = true;
   mnuRemoveImage1->Enabled = true;
   LEADDlgFile1->DialogTitle= "Select a Directory To Browse";
   LEADDlgFile1->Filter= "All| *.*";

   L_INT nRet= LEADDlgFile1->ShowGetDirectoryDlg ( this );
   if ( nRet == SUCCESS_DLG_OK )
      BrowseForm->BrowseDir ( LEADDlgFile1->Directory, "*.*" );
   //To Enable Image List sort Items , Ascending And Descending
   mnuSortItems1->Enabled= BrowseForm->Visible;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuTwainSelectSource1Click(TObject *Sender)
{
   L_INT nRet;
   Screen->Cursor = crHourGlass;
   nRet= LEADTwain1->SelectSource ( );
   if ( (nRet != SUCCESS) && (nRet != ERROR_TWAIN_CANCELED) )
   {
      DisplayErrorMsg ( IntToStr(nRet) );
      Screen->Cursor= crDefault;
      return;
   }
   Screen->Cursor = crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuTwainAcquire1Click(TObject *Sender)
{
   Screen->Cursor = crHourGlass;

   L_INT nRet= LEADTwain1->Acquire ( LTWAIN_SHOW_USER_INTERFACE );
   if ( nRet != SUCCESS )
   {
      DisplayErrorMsg ( IntToStr(nRet) );
      Screen->Cursor= crDefault;
      return;
   }
   Screen->Cursor = crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuISISSelect1Click(TObject *Sender)
{
   Screen->Cursor = crHourGlass;
   try
   {
      LEADIsis1->ISISSelect();
   }
   catch (ELEADIsisError *e)
   {
      AnsiString Msg = "An error occured in your application ...,\n" +
         LEADIsis1->ErrorMsg;
      Application->MessageBox (Msg.c_str(),"Error! ",MB_OK);
   }
   Screen->Cursor = crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuISISAcquire1Click(TObject *Sender)
{
   static int Num = 0;
   TChildImage *Child = NULL;
   AnsiString ImageMsg, IsisMsg;

   Screen->Cursor = crHourGlass;
   LEADIsis1->ISISLoadDriver();
   try
   {
      try
      {
         LEADIsis1->ISISAcquire(ISIS_SHOWUI);
         Num++;
         Child = new TChildImage(Application);
         Child->Caption = "ISIS Acquired Image" + IntToStr(Num);
         MainFrm->StatusBar->Panels->Items[0]->Text = Child->Caption;
         Child->LEADImage1->RefBitmap = True;
         Child->LEADImage1->Bitmap = LEADIsis1->Bitmap;
         Child->LEADImage1->RefBitmap = False;
      }
       __finally
      {
         if(Child)
            ImageMsg = "An error occured in your application ...,\nError: " + Child->LEADImage1->ErrorMsg;
         IsisMsg = "An error occured in your application ...,\nError: " + LEADIsis1->ErrorMsg;
         LEADIsis1->ISISUnloadDriver();
         Screen->Cursor = crDefault;
      }
   }
   catch(ELEADImageError *e)
   {
      Application->MessageBox(ImageMsg.c_str(), "Error", MB_OK);
      if(Child)
         Child->Close();
   }
   catch(ELEADIsisError *e)
   {
      Application->MessageBox(IsisMsg.c_str(), "Error", MB_OK);
      if(Child)
         Child->Close();
   }
   catch(Exception *e)
   {
      if(Child)
         Child->Close();
   }
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuISISAcquireMulti1Click(TObject *Sender)
{
   AnsiString Msg;
   int nMaxPages, nCompressionType;
   bool bOneFile;

   Screen->Cursor = crHourGlass;
   LEADDlgFile1->DlgFileFlags= 0;
   LEADDlgFile1->MaxFileTitleSize= 0;

   LEADDlgFile1->DialogTitle= "Select Base Filename";
   LEADDlgFile1->DlgFlags= DLG_SAVE_SHOW_FILEOPTIONS_MULTIPAGE +
                           DLG_SAVE_SHOW_FILEOPTIONS_JBIG2OPTIONS;

   L_INT nRet= LEADDlgFile1->ShowSaveDlg ( this );
   if ( nRet < SUCCESS_DLG_OK )
   {
      Msg= "FileSave dialog failed,\n Error: " + IntToStr(nRet);
      Application->MessageBox(Msg.c_str(), "Error", MB_OK);
      Screen->Cursor= crDefault;
      return;
   }

   if ( nRet == SUCCESS_DLG_CANCEL )
   {
      Screen->Cursor= crDefault;
      return;
   }
   try
   {
      LEADIsis1->ISISLoadDriver();
      // let's set the ScanAhead to 1/2 the max. # of pages the ADF can hold for SPEED 
      LEADIsis1->ISISSetTag(TAG_SCANAHEAD, TAG_SCANAHEAD_YES);
      LEADIsis1->ISISGetTag(TAG_MAXPAGES, nMaxPages);
      LEADIsis1->ISISSetTag(TAG_SCANAHEAD_MAXPAGES, nMaxPages / 2);
      // try setting scanner compression to match file output type 
      switch(LEADDlgFile1->SaveFormat)
      {
         case FILE_CCITT:
            nCompressionType = TAG_COMPRESSION_MG3;
            break;
         case FILE_CCITT_GROUP3_1DIM:
            nCompressionType = TAG_COMPRESSION_G3;
            break;
         case FILE_CCITT_GROUP4:
            nCompressionType = TAG_COMPRESSION_G4;
            break;
         case FILE_TIFLZW:
            nCompressionType = TAG_COMPRESSION_LZW;
            break;
         case FILE_TIF_PACKBITS:
            nCompressionType = TAG_COMPRESSION_32771;
            break;
         default:
            nCompressionType = TAG_COMPRESSION_NONE;
            break;
      }
      LEADIsis1->ISISSetTag(TAG_COMPRESSION, nCompressionType);
      if(LEADDlgFile1->SaveMulti == MULTIPAGE_OPERATION_OVERWRITE ||
         LEADDlgFile1->SaveMulti == MULTIPAGE_OPERATION_APPEND ||
         LEADDlgFile1->SaveMulti == MULTIPAGE_OPERATION_REPLACE ||
         LEADDlgFile1->SaveMulti == MULTIPAGE_OPERATION_INSERT)

         bOneFile = true;
      else //no multipage support
         bOneFile = false;
      LEADIsis1->ISISAcquireMulti(LEADDlgFile1->FileName, ISIS_SHOWUI, LEADDlgFile1->SaveFormat, bOneFile);
      LEADIsis1->ISISUnloadDriver();
   }
   catch(ELEADIsisError *e)
   {
      if(LEADIsis1->Error == ERROR_USER_ABORT)
         Msg = AnsiString("Scanning canceled; ") + IntToStr(LEADIsis1->PagesDiscarded) + " pages Scanned Ahead but aborted!";
      else
         Msg = AnsiString("ISIS Acquire failed,\nError: ") + LEADIsis1->ErrorMsg;
      Application->MessageBox(Msg.c_str(), "Error", MB_OK);
      Screen->Cursor = crDefault;
      return;
   }
   Screen->Cursor = crDefault;
   ShowMessage(AnsiString("Image(s) acquired to file(s): ") + LEADDlgFile1->FileName);
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuFileFormatAssociations1Click(TObject *Sender)
{
   L_INT nRet;

   LEADDlgFile1->Formats= "";
   LEADDlgFile1->ServerAppName= REGISTRYKEY_SERVER_NAME;
   LEADDlgFile1->SelectedExt= "";

   nRet= LEADDlgFile1->ShowFilesAssociationDlg ( this );
   if ( nRet < SUCCESS )
   {
      DisplayErrorMsg ( LEADDlgFile1->ErrorMsg );
   }
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuPrintStitchedImages1Click(TObject *Sender)
{
   L_INT nRet;

   nRet = LoadUserCustomBitmaps ( "Select Images Folder", DLGFILE_CONTROL );
   if ( nRet == SUCCESS )
   {
      LEADDlgFile1->WindowIcon= Image1->Picture->Icon;
      LEADDlgFile1->CommandShow= SW_SHOW;
      LEADDlgFile1->ShowPrintStitchedImagesDlg ( this );
      LEADDlgFile1->DevModeHandle= 0;
      LEADDlgFile1->DevNamesHandle= 0;
   }
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuCaptureScreen1Click(TObject *Sender)
{
   TChildImage *newChild;
   TLEADImage *TempLead;

   Screen->Cursor =crHourGlass;

   TempLead = new TLEADImage(MainFrm);
   TempLead->ParentWindow = Handle;
   TempLead->Capture(0,0,0,Screen->Width,Screen->Height);

   newChild = new TChildImage(MainFrm);
   newChild->Caption = "Desktop";
   MainFrm->StatusBar->Panels->Items[0]->Text ="Desktop";
   newChild->LEADImage1->Bitmap = TempLead->Bitmap;

   TempLead->Free();
   Screen->Cursor = crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuExit1Click(TObject *Sender)
{
   Close();
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuEditClick(TObject *Sender)
{
   TLEADImage *TempBitmap = new TLEADImage(this);
   if (TempBitmap->Paste(PASTE_ISREADY) == 0)
      mnuPaste1->Enabled = false;
   else
      mnuPaste1->Enabled = true;
   TempBitmap->Free();
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuPaste1Click(TObject *Sender)
{
   Screen->Cursor = crHourGlass;

   TLEADImage *TempBitmap = new TLEADImage(this);
   TempBitmap->Visible = false;
   TempBitmap->Parent  = this;
   if (TempBitmap->Paste(PASTE_ISREADY) == 0)
      ShowMessage("Invalid data on the clipboard");
   else
   {
      TChildImage *newChild = new TChildImage(Application);
      newChild->Caption = "ClipBoard Data: " + IntToStr(nNumPastes);
      MainFrm->StatusBar->Panels->Items[0]->Text = newChild->Caption;
      nNumPastes++;
      newChild->LEADImage1->Paste(0);
   }
   TempBitmap->Free();
   Screen->Cursor = crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::btnPasteClick(TObject *Sender)
{
   if (ActiveMDIChild == NULL)
   {
      btnCopy->Enabled = false;
      MainFrm->mnuPaste1Click(this);
   }
   else
      ((TChildImage *)ActiveMDIChild)->mnuPaste1Click(Parent);
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuOptionsStopOnErrors1Click(TObject *Sender)
{
   mnuOptionsStopOnErrors1->Checked = ! mnuOptionsStopOnErrors1->Checked;
   BrowseForm->LEADThumb1->StopOnError = mnuOptionsStopOnErrors1->Checked;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuOptionsIncludeSubDirectory1Click(TObject *Sender)
{
   mnuOptionsIncludeSubDirectory1->Checked = ! mnuOptionsIncludeSubDirectory1->Checked;
   BrowseForm->LEADThumb1->IncludeSubDirectories = mnuOptionsIncludeSubDirectory1->Checked;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuOptionsExpandMultipage1Click(TObject *Sender)
{
   mnuOptionsExpandMultipage1->Checked = ! mnuOptionsExpandMultipage1->Checked;
   BrowseForm->LEADThumb1->ExpandMultipage = mnuOptionsExpandMultipage1->Checked;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuOptionsDisplayText1Click(TObject *Sender)
{
   mnuOptionsDisplayText1->Checked = ! mnuOptionsDisplayText1->Checked;
   BrowseForm->LEADImgList1->DisplayItemText = mnuOptionsDisplayText1->Checked;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuOptionsEnableKeyboard1Click(TObject *Sender)
{
   mnuOptionsEnableKeyboard1->Checked = ! mnuOptionsEnableKeyboard1->Checked;
   BrowseForm->LEADImgList1->EnableKeyboard = mnuOptionsEnableKeyboard1->Checked;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuShowSelectionColor1Click(TObject *Sender)
{
   mnuShowSelectionColor1->Checked = true;
   BrowseForm->LEADImgList1->SelectionStyle = SELECTIONSTYLE_SELECTCOLOR;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuShowSelectionButton1Click(TObject *Sender)
{
   mnuShowSelectionButton1->Checked = true;
   BrowseForm->LEADImgList1->SelectionStyle = SELECTIONSTYLE_PRESSEDBUTTON;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuShowSelectionUseBitmap1Click(TObject *Sender)
{
   mnuShowSelectionUseBitmap1->Checked = true;
   BrowseForm->LEADImgList1->SelectionStyle = SELECTIONSTYLE_USERBITMAP;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuAllowSelectionNone1Click(TObject *Sender)
{
   mnuAllowSelectionNone1->Checked = true;
   BrowseForm->LEADImgList1->AllowSelection = ALLOWSELECTION_NONE;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuAllowSelectionSingle1Click(TObject *Sender)
{
   mnuAllowSelectionSingle1->Checked = true;
   BrowseForm->LEADImgList1->AllowSelection = ALLOWSELECTION_SINGLE;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuAllowSelectionMulti1Click(TObject *Sender)
{
   mnuAllowSelectionMulti1->Checked = true;
   BrowseForm->LEADImgList1->AllowSelection = ALLOWSELECTION_MULTI;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuScrollStyleVertical1Click(TObject *Sender)
{
   mnuScrollStyleVertical1->Checked = true;
   BrowseForm->LEADImgList1->ScrollStyle = SCROLLSTYLE_VERTICAL;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuScrollStyleHorizontal1Click(TObject *Sender)
{
   mnuScrollStyleHorizontal1->Checked = true;
   BrowseForm->LEADImgList1->ScrollStyle = SCROLLSTYLE_HORIZONTAL;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuSortItemsAscending1Click(TObject *Sender)
{
   BrowseForm->SortItems(true);
   mnuSortItemsAscending1->Checked= true;
   mnuSortItemsDescending1->Checked=False;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuSortItemsDescending1Click(TObject *Sender)
{
   BrowseForm->SortItems(false);
   mnuSortItemsAscending1->Checked= false;
   mnuSortItemsDescending1->Checked=true;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuInsertImage1Click(TObject *Sender)
{
   AnsiString Msg;
   LEADDlgFile1->DlgFileFlags = 0;
   LEADDlgFile1->DialogTitle = "Select an Image";
   LEADDlgFile1->PreviewEnabled = true;
   LEADDlgFile1->LoadPasses = 0;
   LEADDlgFile1->LoadRotated = true;
   LEADDlgFile1->LoadCompressed = false;
   LEADDlgFile1->FileName= "";
   LEADDlgFile1->DlgFlags = DLG_OPEN_SHOW_MULTIPAGE +
                            DLG_OPEN_SHOW_LOADROTATED +
                            DLG_OPEN_SHOW_LOADCOMPRESSED +
                            DLG_OPEN_SHOW_FILEINFO +
                            DLG_OPEN_USEFILESTAMP +
                            DLG_OPEN_SHOW_PREVIEW;

   L_INT nRet= LEADDlgFile1->ShowOpenDlg ( this );
   if ( nRet < SUCCESS_DLG_OK )
   {
      DisplayErrorMsg ( IntToStr(nRet) );//LEADDialog1.ErrorMsg );
      return;
   }
   if (nRet == SUCCESS_DLG_CANCEL )
      return;

   LEADImage2->Load ( LEADDlgFile1->FileName, 0, LEADDlgFile1->PageNumber, 1 );
   BrowseForm->AddItem ( LEADImage2->Bitmap, LEADDlgFile1->FileName, LEADDlgFile1->PageNumber );
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuRemoveImage1Click(TObject *Sender)
{
   BrowseForm->DeleteSelectedItems();
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuCalculationsAddBitmaps1Click(TObject *Sender)
{
   L_INT nRet;
   TChildImage* newChild;

   nRet= LoadUserCustomBitmaps ( "Select Images Folder", DLGIMAGEEFX_CONTROL );
   if ( nRet == SUCCESS )
   {
      LEADDlgImgEffect1->DlgFlags= DLG_ADDBITMAPS_SHOW_PREVIEW +
                                   DLG_ADDBITMAPS_SHOW_TOOL_ZOOMLEVEL;
      nRet= LEADDlgImgEffect1->ShowAddBitmapsDlg ( this );
      if ( (nRet == SUCCESS_DLG_OK) && (LEADDlgImgEffect1->SelectedBitmapList != NULL) )
      {
         newChild= new TChildImage (Parent);
         newChild->LEADImage1->AddBitmaps ( LEADDlgImgEffect1->SelectedBitmapList,
                                            LEADDlgImgEffect1->AddBitmapsFlags );
         newChild->Refresh ( );
         newChild->StatusBarChanged(newChild);
         newChild->Caption= "United";
         MainFrm->StatusBar->Panels->Items[0]->Text= "United";
      }
   }
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuCalculationsStitch1Click(TObject *Sender)
{
   L_INT nRet;
   TChildImage* newChild;

   nRet= LoadUserCustomBitmaps ( "Select Images Folder", DLGIMAGEEFX_CONTROL );
   if ( nRet == SUCCESS )
   {
      LEADDlgImgEffect1->DlgFlags= 0;
      LEADDlgImgEffect1->BitmapWidth= 320;
      LEADDlgImgEffect1->BitmapHeight= 200;
      LEADDlgImgEffect1->BitmapBitsPerPixel= 24;
      LEADDlgImgEffect1->Resolution= 72;
      LEADDlgImgEffect1->BackgroundColor= RGB ( 255, 255, 255 );
      nRet= LEADDlgImgEffect1->ShowStitchDlg ( this );
      if ( (nRet == SUCCESS_DLG_EXPORTANDEXIT) && (LEADDlgImgEffect1->StitchBitmap != 0) )
      {
         newChild= new TChildImage (Parent);
         newChild->LEADImage1->Bitmap= LEADDlgImgEffect1->StitchBitmap;
         newChild->Refresh ( );
         newChild->StatusBarChanged(newChild);
         newChild->Caption= "United";
         MainFrm->StatusBar->Panels->Items[0]->Text= "United";
      }
   }
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuDitheringOrdered1Click(TObject *Sender)
{
   if (mnuDitheringOrdered1->Checked == false)
   {
      mnuDitheringOrdered1->Checked = true;
      mnuDitheringErrorDiffusion1->Checked = false;
      PaintDitherVal = pdOrdered;
   }
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuDitheringErrorDiffusion1Click(TObject *Sender)
{
   if (mnuDitheringErrorDiffusion1->Checked == false)
   {
      mnuDitheringErrorDiffusion1->Checked = true;
      mnuDitheringOrdered1->Checked = false;
      PaintDitherVal = pdDiffusion;
   }
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuBitonalScalingNormal1Click(TObject *Sender)
{
   if (mnuBitonalScalingNormal1->Checked == false)
   {
      mnuBitonalScalingNormal1->Checked = true;
      mnuBitonalScalingFavorBlack1->Checked = false;
      mnuBitonalScalingScaleToGray1->Checked = false;
      BitonalScalingVal = btsNormal;
   }
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuBitonalScalingFavorBlack1Click(TObject *Sender)
{
   if (mnuBitonalScalingFavorBlack1->Checked == false)
   {
      mnuBitonalScalingNormal1->Checked = false;
      mnuBitonalScalingFavorBlack1->Checked = true;
      mnuBitonalScalingScaleToGray1->Checked = false;
      BitonalScalingVal = btsFavorBlack;
   }
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuBitonalScalingScaleToGray1Click(TObject *Sender)
{
   if (mnuBitonalScalingScaleToGray1->Checked == false)
   {
      mnuBitonalScalingNormal1->Checked = false;
      mnuBitonalScalingFavorBlack1->Checked = false;
      mnuBitonalScalingScaleToGray1->Checked = true;
      BitonalScalingVal = btsScaleToGray;
   }
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuPaintPaletteAuto1Click(TObject *Sender)
{
   if (mnuPaintPaletteAuto1->Checked == false)
   {
      mnuPaintPaletteAuto1->Checked = true;
      mnuPaintPaletteFixed1->Checked = false;

      (mnuPaintPaletteUseNetscape1->Checked) ? PaintPaletteVal = ppAutoNetscape :
                                               PaintPaletteVal = ppAuto;

      for(int i=0; i<MDIChildCount;i++)
         ((TChildImage *)MDIChildren[i])->LEADImage1->PaintPalette = PaintPaletteVal;
   }
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuPaintPaletteFixed1Click(TObject *Sender)
{
   if (mnuPaintPaletteFixed1->Checked == false)
   {
      mnuPaintPaletteFixed1->Checked = true;
      mnuPaintPaletteAuto1->Checked = false;

      (mnuPaintPaletteUseNetscape1->Checked) ? PaintPaletteVal = ppFixedNetscape :
                                               PaintPaletteVal = ppFixed;

      for(int i=0;i<MDIChildCount;i++)
         ((TChildImage *)MDIChildren[i])->LEADImage1->PaintPalette = PaintPaletteVal;
   }
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuPaintPaletteUseNetscape1Click(TObject *Sender)
{
   mnuPaintPaletteUseNetscape1->Checked = !mnuPaintPaletteUseNetscape1->Checked;

   if (mnuPaintPaletteUseNetscape1->Checked)
   {
      (mnuPaintPaletteFixed1->Checked) ? PaintPaletteVal = ppFixedNetscape :
                                         PaintPaletteVal = ppAutoNetscape;
   }
   else
   {
      (mnuPaintPaletteFixed1->Checked) ? PaintPaletteVal = ppFixed :
                                         PaintPaletteVal = ppAuto;
   }

   for(int i=0;i<MDIChildCount;i++)
      ((TChildImage *)MDIChildren[i])->LEADImage1->PaintPalette = PaintPaletteVal;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuPaintScalingNormal1Click(TObject *Sender)
{
   mnuPaintScalingNormal1->Checked = true;
   PaintScalingVal = psNormal;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuPaintScalingResample1Click(TObject *Sender)
{
   mnuPaintScalingResample1->Checked = true;
   PaintScalingVal = psResample;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuPaintScalingBicubic1Click(TObject *Sender)
{
   mnuPaintScalingBicubic1->Checked = true;
   PaintScalingVal = psBicubic;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuPaintWhileLoad1Click(TObject *Sender)
{
   mnuPaintWhileLoad1->Checked = !mnuPaintWhileLoad1->Checked;
   bUsePaintWhileLoad = mnuPaintWhileLoad1->Checked;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuLEADTOOLSOnTheWeb1Click(TObject *Sender)
{
   Screen->Cursor = crHourGlass;

   ShellExecute(this->Handle,(LPCTSTR)"open",(LPCTSTR)"www.leadtools.com",
      NULL, NULL, SW_SHOWNORMAL);

   Screen->Cursor = crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::mnuAbout1Click(TObject *Sender)
{
   Application->CreateForm(__classid(TAboutDlg), &AboutDlg);
   AboutDlg->ShowModal();
   AboutDlg->Free();
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::btnAboutClick(TObject *Sender)
{
   mnuAbout1->Click();
}
//---------------------------------------------------------------------------

void TMainFrm::DisplayErrorMsg ( AnsiString ErrorMsg )
{
   AnsiString Msg;
   Msg= "An error occured in your application, \n" + ErrorMsg;

   Application->MessageBox( Msg.c_str(), PChar("Error"), MB_OK);
}
//---------------------------------------------------------------------------

void TMainFrm::DisplayDICOMLoadMsg(int nFileFormat)
{
   if (bDICOMLoadMsg)
   {
      switch(nFileFormat)
      {
         case FILE_DICOM_GRAY:
         case FILE_DICOM_COLOR:
         case FILE_DICOM_RLE_GRAY:
         case FILE_DICOM_RLE_COLOR:
         case FILE_DICOM_JPEG_GRAY:
         case FILE_DICOM_JPEG_COLOR:
            bDICOMLoadMsg = FALSE; //only do this one time
            Application->MessageBox("This demo loads raster images stored in DICOM files.\n For full DICOM support, refer to the LEADTOOLS Medical Imaging demos.","DICOM Load Information", MB_OK);
            break;
      }
   }
}
//---------------------------------------------------------------------------
void __fastcall TMainFrm::btnSaveAsClick(TObject *Sender)
{
   if (ActiveMDIChild == NULL)
      btnSaveAs->Enabled = false;
   else
      ((TChildImage *)ActiveMDIChild)->mnuSaveFileAs1->Click();
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::btnCopyClick(TObject *Sender)
{
   if (ActiveMDIChild == NULL)
      btnCopy->Enabled = false;
   else
      ((TChildImage *)ActiveMDIChild)->mnuCopy1->Click();
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::btnPrintClick(TObject *Sender)
{
   if (ActiveMDIChild == NULL)
      btnPrint->Enabled = false;
   else
      ((TChildImage *)ActiveMDIChild)->mnuPrint1->Click();
}
//---------------------------------------------------------------------------

int __fastcall TMainFrm::LEADTwain1AcquirePageEvent(TBitmapHandle Bitmap)
{
   Screen->Cursor = crHourGlass;
   static int Num = 0;
   TChildImage *Child = new TChildImage(Application);
   Num++;
   Child->Caption = "Twain Acquired Image " + IntToStr(Num);
   MainFrm->StatusBar->Panels->Items[0]->Text = Child->Caption;
   Child->LEADImage1->Bitmap = Bitmap;
   Screen->Cursor = crDefault;
   return SUCCESS;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::OnDrawClipBoard(TMessage* msg)
{
   TLEADImage* TempBitmap = new TLEADImage(this);
   if (TempBitmap->Paste(PASTE_ISREADY) == 0)
      MainFrm->btnPaste->Enabled = false;
   else
      MainFrm->btnPaste->Enabled = true;
   TempBitmap->Free();
}
//---------------------------------------------------------------------------

L_INT TMainFrm::LoadUserCustomBitmaps ( AnsiString strDlgTitle, L_UINT uDlgControl )
{
   L_INT i;
   L_INT nRet;
   TLEADImage* TmpLEADImage;

   nImagesCount= 0;
   for ( i= 0; i < DLG_IMAGE_LIST_COUNT; i ++ )
   {
      ImagesNames[i]= "";
   }

   LEADDlgFile1->DialogTitle= strDlgTitle;
   LEADDlgFile1->Filter= "All| *.*";

   nRet= LEADDlgFile1->ShowGetDirectoryDlg ( this );
   if ( nRet == SUCCESS_DLG_OK )
   {
      LEADThumb2->EnableMethodErrors= false;
      LEADThumb2->Filter= "*.*";
      LEADThumb2->LoadStamp= false;
      try
      {
         nRet= LEADThumb2->BrowseDir ( LEADDlgFile1->Directory );
      }
      catch ( ... )
      {
         if ( LEADThumb2->Error != ERROR_USER_ABORT )
         {
            ShowMessage(LEADThumb2->ErrorMsg);
            return nRet;
         }
      }
      if ( (nRet == SUCCESS) || (nRet == ERROR_USER_ABORT) )
      {
         nRet= SUCCESS;
         // Create a temp LEADImage Control.
         TmpLEADImage= new TLEADImage(this);
         // Set The Parent for the Temp LEADImage Control
         TmpLEADImage->Parent= this;
         // Set the Visibility As False.
         TmpLEADImage->Visible= false;

         switch ( uDlgControl )
         {
            case DLGFILE_CONTROL:
            {
               LEADDlgFile1->ItemsCount= nImagesCount;
               for ( i= 0; i < nImagesCount; i ++)
               {
                  LEADDlgFile1->ItemFileName[i]= ImagesNames[i];
                  LEADDlgFile1->ItemDescription[i]= ImagesNames[i];
                  TmpLEADImage->Load ( ImagesNames[i], 0, 1, 1 );
                  LEADDlgFile1->ItemBitmap[i]= TmpLEADImage->Bitmap;
               }
            }
            break;
            
            case DLGIMAGEEFX_CONTROL:
            {
               LEADDlgImgEffect1->ItemsCount= nImagesCount;

               for ( i= 0; i < nImagesCount; i ++)
               {
                  LEADDlgImgEffect1->ItemFileName[i]= ImagesNames[i];
                  LEADDlgImgEffect1->ItemDescription[i]= ImagesNames[i];
                  TmpLEADImage->Load ( ImagesNames[i], 0, 1, 1 );
                  LEADDlgImgEffect1->ItemBitmap[i]= TmpLEADImage->Bitmap;
               }
            }
            break;
         }
         // Free the Temp LEADImage Control.
         TmpLEADImage->Free ( );
      }
   }
   return nRet;
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::LEADThumb2ThumbnailEvent(TObject *Sender,
      TBitmapHandle Bitmap, AnsiString FileName, int nStatusCode,
      int nPercent)
{
   if(nStatusCode == 0)
   {
      if ( nImagesCount >= DLG_IMAGE_LIST_COUNT )
      {
         LEADThumb2->ContinueBrowse= False;
         return;
      }
      ImagesNames[nImagesCount]= FileName;
      nImagesCount++;
   }
   Application->ProcessMessages ( );
   LEADThumb2->ContinueBrowse= True;
}
//---------------------------------------------------------------------------

static L_BOOL CreateStandardServerRegisteryEntry 
( 
   L_CHAR * pszServerName,
   L_CHAR * pszCommand,
   L_CHAR * pszDefaultIcon
)
{
   DWORD dwDispos;
   LONG  lRet;
   HKEY  hKey;
   BOOL  fRet = TRUE;
   
   L_CHAR *szRegisterKey [ REG_KEYS ] =
   {
      "\\shell\\open\\command",
      "\\DefaultIcon"
   };
   
   L_CHAR *szRegisterKeyDefaultValues [ REG_KEYS ] =
   {
      pszCommand,
      pszDefaultIcon
   };

   {// CREATE SERVER NODE
      lRet = RegCreateKeyEx ( HKEY_CLASSES_ROOT, pszServerName, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, &dwDispos );
      
      if ( lRet != ERROR_SUCCESS )
      {
         return FALSE;
      }
      RegCloseKey ( hKey );
   }// CREATE SERVER NODE

   {// CREATE STANDARD SUB NODES & VALUSE

      L_INT k = 0;

      for (; k < REG_KEYS; k++ )
      {
         L_CHAR szKey [ L_MAXPATH * 2 ] = { 0 };
          
         //compose full key
         sprintf ( szKey, TEXT("%s%s"), REGISTRYKEY_SERVER_NAME, szRegisterKey [ k ] );

         // create...
         lRet = RegCreateKeyEx ( HKEY_CLASSES_ROOT, szKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, &dwDispos );
         
         // set default value
         if ( lRet == ERROR_SUCCESS )
         {
            RegSetValueEx ( hKey, TEXT(""), 0, REG_SZ, ( BYTE* CONST ) ( szRegisterKeyDefaultValues [ k ] ), ( lstrlen ( szRegisterKeyDefaultValues [ k ] ) + 1 ) * sizeof ( L_CHAR ) );
         }
         else
         {
            fRet = FALSE;
         }
         // close key handle
         RegCloseKey ( hKey );
      }
   }// CREATE STANDARD SUB NODES & VALUSE

   return fRet;
}
//---------------------------------------------------------------------------
void RegisterAppKey ( HINSTANCE hInstance )
{
   L_CHAR  szFullFileName [L_MAXPATH] = {0};
   L_CHAR  szShortFileName [L_MAXPATH] = {0};
   L_CHAR* pszPathName = NULL;

   {// RETRIEVE PATH NAME
      DWORD dwRet;
      // full file name
      GetModuleFileName ( hInstance, szFullFileName, L_MAXPATH );

      dwRet = GetShortPathName ( szFullFileName,
                                 szShortFileName,
                                 L_MAXPATH );

      if ( ERROR_INVALID_PARAMETER == dwRet )
      {
         pszPathName = szFullFileName;
      }
      else
      {
         pszPathName = szShortFileName;
      }
   }// RETRIEVE PATH NAME

   {// REGISTER [BASIC] SERVER NAME
      L_CHAR szDefaultIcon [L_MAXPATH*2] = {0};
      L_CHAR szOpen [L_MAXPATH*2] = {0};

      // Open STRING
      sprintf ( szOpen, TEXT ("\"%s\" %%1"), pszPathName );

      // default icon
      sprintf ( szDefaultIcon, TEXT("%s"), pszPathName );

      CreateStandardServerRegisteryEntry ( REGISTRYKEY_SERVER_NAME,
                                           szOpen,
                                           szDefaultIcon );
   }// REGISTER [BASIC] SERVER NAME
}
//---------------------------------------------------------------------------

void __fastcall TMainFrm::LEADImage2LoadInfo(TObject *Sender)
{
   if(FShowRawFormatDialog)
   {
      int i;
      int nColors;
      RGBQUAD rgbColor;

      TRawParamsDlg * dlg = new TRawParamsDlg(this);
      if(dlg->ShowModal() == mrOk)
      {
         FLoadInfoFormat= dlg->LoadInfoFormat;

         FLoadInfoWidth= dlg->LoadInfoWidth;
         FLoadInfoHeight= dlg->LoadInfoHeight;
         FLoadInfoXRes= dlg->LoadInfoXRes;
         FLoadInfoYRes= dlg->LoadInfoYRes;
         FLoadInfoBitsPerPixel= dlg->LoadInfoBitsPerPixel;
         FLoadInfoWhiteOnBlack= dlg->LoadInfoWhiteOnBlack;
         FLoadInfoLSBFirst= dlg->LoadInfoLSBFirst;
         FLoadInfoViewPerspective= dlg->LoadInfoViewPerspective;
         FLoadInfoColorOrder= dlg->LoadInfoColorOrder;
         FLoadInfoPalette= dlg->LoadInfoPalette;

         FLoadInfoFlags= 0;

         if(FLoadInfoWhiteOnBlack)
            FLoadInfoFlags= FLoadInfoFlags + LOADINFO_WHITEONBLACK;

         if(FLoadInfoLSBFirst)
            FLoadInfoFlags= FLoadInfoFlags + LOADINFO_LSB;

         FLoadInfoFlags= FLoadInfoFlags + FLoadInfoViewPerspective;
         FLoadInfoFlags= FLoadInfoFlags + FLoadInfoColorOrder;

         if(dlg->LoadInfoPadding)
            FLoadInfoFlags= FLoadInfoFlags + LOADINFO_PAD4;

         FLoadInfoOffset= dlg->LoadInfoOffset;

         // Set the Selected options in the LEADImage control.
         if(((FLoadInfoBitsPerPixel <= 8) && (FLoadInfoFormat == FILE_RAW)) || 
            ((FLoadInfoBitsPerPixel <= 8) && (FLoadInfoFormat == FILE_ABIC)))
         {
            FLoadInfoFlags= FLoadInfoFlags + LOADINFO_PALETTE;
            if(FLoadInfoPalette == 0) //Grayscale Palette
            {
               nColors= 1 <<  FLoadInfoBitsPerPixel;
               for(i= 0; i < nColors; i ++)
               {
                  rgbColor.rgbBlue= ((i * 256) / nColors);
                  rgbColor.rgbGreen= ((i * 256) / nColors);
                  rgbColor.rgbRed= ((i * 256) / nColors);
                  rgbColor.rgbReserved= 0;

                  LEADImage2->UserPalette[i]= RGB(rgbColor.rgbRed,
                                                  rgbColor.rgbGreen,
                                                  rgbColor.rgbBlue);
               }
            }
            else
            { //LEAD Fixed
               LEADImage2->GetFixedPalette(FLoadInfoBitsPerPixel);
            }
         }

         LEADImage2->LoadInfoFormat= FLoadInfoFormat;
         LEADImage2->LoadInfoFlags= FLoadInfoFlags;
         LEADImage2->LoadInfoWidth= FLoadInfoWidth;
         LEADImage2->LoadInfoHeight= FLoadInfoHeight;
         LEADImage2->LoadInfoBits= FLoadInfoBitsPerPixel;
         LEADImage2->LoadInfoXRes= FLoadInfoXRes;
         LEADImage2->LoadInfoYRes= FLoadInfoYRes;
         LEADImage2->LoadInfoOffset= FLoadInfoOffset;

         FShowRawFormatDialog = false;
      }
      dlg->Free();
   }
}
//.End.Of.File---------------------------------------------------------------