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

#include "MainForm.h"
#include "ChildImg.h"
#include "CreatAni.h"
#include "AniSet.h"
#include "FrmSet.h"
#include "GetValue.h"
#include "Info.h"
#include "ClrMrg.h"

#include <printers.hpp>
#include "BrowsFrm.h"
//---------------------------------------------------------------------
#pragma link "LEADDlgEffect"
#pragma link "LEADDlgColor"
#pragma link "LEADDlgImage"
#pragma link "LEADDlgImgEffect"
#pragma link "LEADDlgImgDoc"
#pragma link "LEADDlgFile"
#pragma link "LEADDlgWeb"
#pragma link "LEADThmb"
#pragma resource "*.dfm"

#include "..\..\..\..\include\ltkey.h"

#define UNID   "3E512560-C349-11D2-86CD-006008786A2B"
bool bDICOMSaveMsg;
L_INT nImagesCount;
AnsiString ImagesNames[ DLG_IMAGE_LIST_COUNT ];
L_INT g_nAnimationWidth;
L_INT g_nAnimationHeight;
L_INT g_bUseAnimationWidthHeight;

//---------------------------------------------------------------------
__fastcall TChildImage::TChildImage(TComponent *Owner)
: TForm(Owner)
{
}
//---------------------------------------------------------------------

void __fastcall TChildImage::FormCreate(TObject *Sender)
{
   LEADImage1->AutoFloater= false;
   LEADImage1->RgnFrameType= m_RgnFrame= ftAnimated;
   m_fFloaterMoving= false;

   ImageName=UNID;
   nZoomFactor=100;
   ViewNormalProc ();

   LEADImage1->HScrollStep= 1000;
   LEADImage1->VScrollStep= 1000;
   m_oldWindowState=WindowState;

   /* Initialize paint effects, patterns and gradients */
   // paint effect

   efxEffectDelay= LEADDlgEffect1->Delay;
   efxEffectGrain= LEADDlgEffect1->Grain;
   efxPaintEffect= LEADDlgEffect1->Effect;
   efxPaintMaxPasses= LEADDlgEffect1->MaxPass;
   efxWandColor= (TColor)LEADDlgEffect1->WandColor;
   efxWandSize= LEADDlgEffect1->WandThickness;
   // transition(pattern)
   ptnEffectDelay= LEADDlgEffect1->Delay;
   ptnEffectGrain= LEADDlgEffect1->Grain;
   ptnPaintMaxPasses= LEADDlgEffect1->MaxPass;
   ptnPatternBackColor= (TColor)LEADDlgEffect1->BackColor;
   ptnPatternForeColor= (TColor)LEADDlgEffect1->ForeColor;
   ptnPatternStyle= LEADDlgEffect1->PatternStyle;
   ptnTransitionStyle= LEADDlgEffect1->TransitionStyle;
   
   ptnTransitionEffect= LEADDlgEffect1->Effect;
   ptnTransparentColor= (TColor)LEADDlgEffect1->TransparentColor;
   ptnUseTransparentColor= LEADDlgEffect1->Transparent;
   ptnWandColor= (TColor)LEADDlgEffect1->WandColor;
   ptnWandSize= LEADDlgEffect1->WandThickness;
   // gradient
   grdEffectDelay= LEADDlgEffect1->Delay;
   grdGradientEndColor= (TColor)LEADDlgEffect1->EndColor;
   grdGradientStartColor= (TColor)LEADDlgEffect1->StartColor;
   grdGradientSteps= LEADDlgEffect1->GradientSteps;
   grdGradientStyle= LEADDlgEffect1->GradientStyle;
   mnuSortItems1->Enabled= false;
   bDICOMSaveMsg= true;

   LEADDlgColor1->LEADDlgService= MainFrm->LEADDlgService1;
   LEADDlgImage1->LEADDlgService= MainFrm->LEADDlgService1;
   LEADDlgEffect1->LEADDlgService= MainFrm->LEADDlgService1;
   LEADDlgImgEffect1->LEADDlgService= MainFrm->LEADDlgService1;
   LEADDlgImgDoc1->LEADDlgService= MainFrm->LEADDlgService1;

   nImagesCount= 0;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::FormActivate(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   if(Visible == true)
   {
      mnuPaintPaletteAuto1->Checked= MainFrm->mnuPaintPaletteAuto1->Checked;
      mnuPaintPaletteFixed1->Checked= MainFrm->mnuPaintPaletteFixed1->Checked;
      mnuPaintPaletteUseNetscape1->Checked= MainFrm->mnuPaintPaletteUseNetscape1->Checked;
      mnuDitheringOrdered1->Checked= MainFrm->mnuDitheringOrdered1->Checked;
      mnuDitheringErrorDiffusion1->Checked= MainFrm->mnuDitheringErrorDiffusion1->Checked;
      mnuBitonalScalingNormal1->Checked= MainFrm->mnuBitonalScalingNormal1->Checked;
      mnuBitonalScalingFavorBlack1->Checked= MainFrm->mnuBitonalScalingFavorBlack1->Checked;
      mnuBitonalScalingScaleToGray1->Checked= MainFrm->mnuBitonalScalingScaleToGray1->Checked;
      mnuPaintScalingNormal1->Checked= MainFrm->mnuPaintScalingNormal1->Checked;
      mnuPaintScalingResample1->Checked= MainFrm->mnuPaintScalingResample1->Checked;
      mnuPaintScalingBicubic1->Checked= MainFrm->mnuPaintScalingBicubic1->Checked;
      mnuPaintWhileLoad1->Checked= MainFrm->mnuPaintWhileLoad1->Checked;

      if(WindowState != wsNormal)
         mnuSnapWindowToImage1->Enabled= false;
      else
         mnuSnapWindowToImage1->Enabled= true;
         
      LEADImage1->PaintPalette= MainFrm->PaintPaletteVal;
      LEADImage1->PaintDither= MainFrm->PaintDitherVal;
      LEADImage1->BitonalScaling= MainFrm->BitonalScalingVal;
      LEADImage1->PaintScaling= MainFrm->PaintScalingVal;
      LEADImage1->PaintWhileLoad= MainFrm->bUsePaintWhileLoad;

      StatusBarChanged(this);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::FormShow(TObject *Sender)
{
   StatusBarChanged(this);
   UpdateMenuItems ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::FormResize(TObject *Sender)
{
   Screen->Cursor= crHourGlass;
   if(WindowState != wsNormal)
      mnuSnapWindowToImage1->Enabled= false;
   else
      mnuSnapWindowToImage1->Enabled= true;

   if(mnuPanWindow1->Checked)
   {
      if(WindowState == wsMinimized)
         LEADImage1->ShowPanWin(false);
      if(m_oldWindowState == wsMinimized)
         LEADImage1->ShowPanWin(true);
   }
   m_oldWindowState=WindowState;
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::FormCloseQuery(TObject *Sender,
      bool &CanClose)
{
   if(LEADImage1->ReadyState == rsLoading)
      CanClose= false;
}
//---------------------------------------------------------------------------
void __fastcall TChildImage::FormClose(TObject *Sender, TCloseAction &Action)
{
   Action= caFree;
}
//---------------------------------------------------------------------

void __fastcall TChildImage::FormDestroy(TObject *Sender)
{
   if(MainFrm->MDIChildCount >= 1)
   {
      if(MainFrm->MDIChildCount == 1)
      {
         MainFrm->StatusBar->Panels->Items[0]->Text ="";
         MainFrm->StatusBar->Panels->Items[1]->Text ="";
         MainFrm->StatusBar->Panels->Items[2]->Text ="";
         MainFrm->StatusBar->Panels->Items[3]->Text ="";
         MainFrm->StatusBar->Panels->Items[4]->Text ="";
         MainFrm->StatusBar->Panels->Items[5]->Text ="";
      }
      BorderIcons=BorderIcons - (TBorderIcons()<< biSystemMenu);
      MainFrm->btnSaveAs->Enabled= (MainFrm->MDIChildCount > 1);
      MainFrm->btnCopy->Enabled= (MainFrm->MDIChildCount > 1);
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuFileClick(TObject *Sender)
{
   if(LEADImage1->AnimationEnable || LEADImage1->ReadyState == rsLoading)
   {
      mnuSaveFileAs1->Enabled= false;
      mnuPrint1->Enabled= false;
      mnuColorMerge1->Enabled= false;
   }
   else
   {
      mnuSaveFileAs1->Enabled= true;
      mnuPrint1->Enabled= true;
      mnuColorMerge1->Enabled= true;
   }
   bool bEnableISIS= MainFrm->LEADIsis1->IsISISAvailable;
   mnuISISSelect1->Enabled=bEnableISIS;
   mnuISISAcquire1->Enabled=bEnableISIS;
   mnuISISAcquireMulti1->Enabled=bEnableISIS;
   mnuPrintPreview1->Enabled = (Printer()->Printers->Count > 0);
   mnuPrintStitchedImages1->Enabled = (Printer()->Printers->Count > 0);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuOpen1Click(TObject *Sender)
{
   MainFrm->mnuOpen1->Click ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuOpenLocation1Click(TObject *Sender)
{
   MainFrm->mnuOpenLocation1->Click ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSaveFileAs1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   LEADDlgFile1->DialogTitle= "Save A File";
   LEADDlgFile1->MaxFileTitleSize= 0;
   LEADDlgFile1->MaxFileSize= 0;
   LEADDlgFile1->DlgFileFlags= 0;
   LEADDlgFile1->FileName= "";
   LEADDlgFile1->DlgFlags= DLG_SAVE_ENABLESIZING +
                           DLG_SAVE_SHOW_FILEOPTIONS_MULTIPAGE +
                           DLG_SAVE_SHOW_FILEOPTIONS_PROGRESSIVE +
                           DLG_SAVE_SHOW_FILEOPTIONS_QFACTOR +
                           DLG_SAVE_SHOW_FILEOPTIONS_STAMP +
                           DLG_SAVE_SHOW_FILEOPTIONS_BASICJ2KOPTIONS +
                           DLG_SAVE_SHOW_FILEOPTIONS_J2KOPTIONS +
                           DLG_SAVE_SHOW_FILEOPTIONS_JBIG2OPTIONS;
   LEADDlgFile1->LEADImage= LEADImage1;
   int nRet= LEADDlgFile1->ShowSaveDlg (this);
   if(nRet < SUCCESS_DLG_OK)
   {
      AnsiString Msg= "FileSave dialog failed,\n Error: " + IntToStr(nRet);
      Application->MessageBox(Msg.c_str(), "Error", MB_OK);
   }
   if(nRet == SUCCESS_DLG_OK)
   {
      SetJ2KOptions();
      if(LEADDlgFile1->SaveWithStamp)
      {
         LEADImage1->SaveWithStamp(LEADDlgFile1->FileName,
                                   LEADDlgFile1->SaveFormat,
                                   LEADDlgFile1->SaveBitsPerPixel,
                                   LEADDlgFile1->SaveQFactor,
                                   LEADDlgFile1->SaveStampWidth,
                                   LEADDlgFile1->SaveStampHeight,
                                   LEADDlgFile1->SaveStampBits);
      }
      else
      {
         LEADImage1->JBIG2SaveFlags = LEADDlgFile1->SaveJBIG2SaveFlags;
         LEADImage1->JBIG2TemplateType = LEADDlgFile1->SaveJBIG2TemplateType;
         LEADImage1->JBIG2GBATX1 = LEADDlgFile1->SaveJBIG2GBATY1;
         LEADImage1->JBIG2GBATY1 = LEADDlgFile1->SaveJBIG2GBATY1;
         LEADImage1->JBIG2GBATX2 = LEADDlgFile1->SaveJBIG2GBATX2;
         LEADImage1->JBIG2GBATY2 = LEADDlgFile1->SaveJBIG2GBATY2;
         LEADImage1->JBIG2GBATX3 = LEADDlgFile1->SaveJBIG2GBATX3;
         LEADImage1->JBIG2GBATY3 = LEADDlgFile1->SaveJBIG2GBATY3;
         LEADImage1->JBIG2GBATX4 = LEADDlgFile1->SaveJBIG2GBATX4;
         LEADImage1->JBIG2GBATY4 = LEADDlgFile1->SaveJBIG2GBATY4;
         LEADImage1->Save(LEADDlgFile1->FileName,
                          LEADDlgFile1->SaveFormat,
                          LEADDlgFile1->SaveBitsPerPixel,
                          LEADDlgFile1->SaveQFactor,
                          LEADDlgFile1->SaveMulti);
      }
      DisplayDICOMSaveMsg(LEADDlgFile1->SaveFormat);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuConvertFile1Click(TObject *Sender)
{
   MainFrm->mnuConvertFile1Click (Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuBrowse1Click(TObject *Sender)
{
     MainFrm->mnuBrowse1Click(Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuClose1Click(TObject *Sender)
{
   Close ();
}
//---------------------------------------------------------------------------

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

   Application->CreateForm(__classid(TColorMergeDlg), &ColorMergeDlg);
   if(ColorMergeDlg->ShowModal () == mrOk)
   {
      TChildImage *Child[4];

      TChildImage *newChild=new TChildImage(MainFrm);
      newChild->Caption ="Color Merge" + IntToStr(MainFrm->nNumClrMrg);
      MainFrm->nNumClrMrg++;

      Child[0]=(TChildImage *)ColorMergeDlg->GetBitmapList ()->Items
                   [ColorMergeDlg->ComboBox1->ItemIndex];
      Child[1]=(TChildImage *)ColorMergeDlg->GetBitmapList ()->Items
                   [ColorMergeDlg->ComboBox2->ItemIndex];
      Child[2]=(TChildImage *)ColorMergeDlg->GetBitmapList ()->Items
                   [ColorMergeDlg->ComboBox3->ItemIndex];
      Child[3]=(TChildImage *)ColorMergeDlg->GetBitmapList ()->Items
                   [ColorMergeDlg->ComboBox4->ItemIndex];

      for (int i=0;i<4;i++)
         newChild->LEADImage1->ColorPlanes[i]=Child[i]->LEADImage1->Bitmap;

      newChild->LEADImage1->ColorMerge(ColorMergeDlg->GetColorSpace ());
      StatusBarChanged(newChild);
   }
   ColorMergeDlg->Free ();
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuTwainSelectSource1Click(TObject *Sender)
{
   MainFrm->mnuTwainSelectSource1->Click ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuTwainAcquire1Click(TObject *Sender)
{
   MainFrm->mnuTwainAcquire1->Click ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuISISSelect1Click(TObject *Sender)
{
   MainFrm->mnuISISSelect1->Click ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuISISAcquire1Click(TObject *Sender)
{
   MainFrm->mnuISISAcquire1->Click ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuISISAcquireMulti1Click(TObject *Sender)
{
   MainFrm->mnuISISAcquireMulti1->Click ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuWebTunerJPEG1Click(TObject *Sender)
{
   LEADDlgWeb1->DlgFlags= DLG_JPEGWEBTUNER_SHOW_PREVIEW +
                          DLG_JPEGWEBTUNER_SHOW_EXPORT +
                          DLG_JPEGWEBTUNER_SHOW_INFORMATION +
                          DLG_JPEGWEBTUNER_SHOW_TOOL_ZOOMLEVEL +
                          DLG_JPEGWEBTUNER_SHOW_OPTIONS +
                          DLG_JPEGWEBTUNER_SHOW_SAVETHUMBNAIL;

   LEADDlgWeb1->LEADImage= LEADImage1;
   LEADDlgWeb1->ShowJPEGWebTunerDlg (this);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuWebTunerPNG1Click(TObject *Sender)
{
   LEADDlgWeb1->DlgFlags= DLG_PNGWEBTUNER_SHOW_PREVIEW +
                          DLG_PNGWEBTUNER_SHOW_EXPORT +
                          DLG_PNGWEBTUNER_SHOW_INFORMATION +
                          DLG_PNGWEBTUNER_SHOW_TOOL_ZOOMLEVEL +
                          DLG_PNGWEBTUNER_SHOW_TOOL_COLORPICKER +
                          DLG_PNGWEBTUNER_SHOW_TRANSPARENCY +
                          DLG_PNGWEBTUNER_SHOW_ADDWINDOWCOLOR;

   LEADDlgWeb1->LEADImage= LEADImage1;
   LEADDlgWeb1->ShowPNGWebTunerDlg (this);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuWebTunerGIF1Click(TObject *Sender)
{
   LEADDlgWeb1->DlgFlags= DLG_GIFWEBTUNER_SHOW_PREVIEW +
                          DLG_GIFWEBTUNER_SHOW_EXPORT +
                          DLG_GIFWEBTUNER_SHOW_INFORMATION +
                          DLG_GIFWEBTUNER_SHOW_TOOL_ZOOMLEVEL +
                          DLG_GIFWEBTUNER_SHOW_TOOL_COLORPICKER +
                          DLG_GIFWEBTUNER_SHOW_TRANSPARENCY +
                          DLG_GIFWEBTUNER_SHOW_OPTIONS +
                          DLG_GIFWEBTUNER_SHOW_ADDWINDOWCOLOR ;

   LEADDlgWeb1->LEADImage= LEADImage1;
   LEADDlgWeb1->ShowGIFWebTunerDlg (this);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuHTMLMapCreator1Click(TObject *Sender)
{
   LEADDlgWeb1->LEADImage= LEADImage1;
   LEADDlgWeb1->ShowHTMLMapperDlg (this);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuFileFormatAssociations1Click(TObject *Sender)
{
   MainFrm->mnuFileFormatAssociations1Click (Sender);  
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuPrint1Click(TObject *Sender)
{
   if(PrinterSetupDialog1->Execute () == true)
   {
      Screen->Cursor=crHourGlass;
      try
      {
         Printer ()->BeginDoc ();
         Printer ()->Title="LEAD Image";
         int nWidth =(LEADImage1->BitmapWidth * GetDeviceCaps(Printer ()->Handle,LOGPIXELSX)) / (float)LEADImage1->BitmapXRes;
         int nHeight=(LEADImage1->BitmapHeight* GetDeviceCaps(Printer ()->Handle,LOGPIXELSY)) / (float)LEADImage1->BitmapYRes;

         LEADImage1->Render((int)Printer ()->Handle, 1, 1, nWidth, nHeight);
         Printer ()->EndDoc ();
      }
      catch (const Exception &E)
      {
         MainFrm->DisplayErrorMsg (E.Message);
      }
      Screen->Cursor =crDefault;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuPrintPreview1Click(TObject *Sender)
{
   LEADDlgFile1->LEADImage= LEADImage1;
   LEADDlgFile1->WindowIcon= MainFrm->Image1->Picture->Icon;
   LEADDlgFile1->CommandShow= SW_SHOW;
   LEADDlgFile1->ShowPrintPreviewDlg (this);
   LEADDlgFile1->DevModeHandle= 0;
   LEADDlgFile1->DevNamesHandle= 0;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuPrintStitchedImages1Click(TObject *Sender)
{
   MainFrm->mnuPrintStitchedImages1Click (this);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuCaptureScreen1Click(TObject *Sender)
{
   MainFrm->mnuCaptureScreen1->Click ();
}
//---------------------------------------------------------------------------

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

   Application->CreateForm(__classid(TDlgInfo), &DlgInfo);
   DlgInfo->ListView1->Items->Item[0]->SubItems[0].Text= Caption;

   AnsiString FormatName=GetFormatName(LEADImage1->InfoFormat);
   if(FormatName != "NOT SUPPORTED")
      DlgInfo->ListView1->Items->Item[1]->SubItems[0].Text= FormatName;
   else
      DlgInfo->ListView1->Items->Item[1]->SubItems[0].Text=IntToStr(LEADImage1->InfoFormat);

   DlgInfo->ListView1->Items->Item[2]->SubItems[0].Text=IntToStr(LEADImage1->BitmapWidth);
   DlgInfo->ListView1->Items->Item[3]->SubItems[0].Text=IntToStr(LEADImage1->BitmapHeight);
   DlgInfo->ListView1->Items->Item[4]->SubItems[0].Text=IntToStr(LEADImage1->BitmapBits);

   if(!LEADImage1->InfoSizeDisk)
      DlgInfo->ListView1->Items->Item[5]->SubItems[0].Text="File Not Saved";
   else
      DlgInfo->ListView1->Items->Item[5]->SubItems[0].Text=IntToStr(LEADImage1->InfoSizeDisk);
   if(LEADImage1->InfoSizeMem == 0)
      DlgInfo->ListView1->Items->Item[6]->SubItems[0].Text="File Not Saved";
   else
      DlgInfo->ListView1->Items->Item[6]->SubItems[0].Text=IntToStr(LEADImage1->InfoSizeMem);

   DlgInfo->ListView1->Items->Item[7]->SubItems[0].Text= LEADImage1->InfoCompress;
   DlgInfo->ShowModal ();
   DlgInfo->Free ();
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuExit1Click(TObject *Sender)
{
   MainFrm->mnuExit1->Click ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuEditClick(TObject *Sender)
{
   if(LEADImage1->Paste(PASTE_ISREADY) == 0)
      mnuPaste1->Enabled= false;
   else
      mnuPaste1->Enabled= true;

   if(LEADImage1->HasRgn == true)
      mnuSelectRegionCancelRegion1->Enabled= true;
   else
      mnuSelectRegionCancelRegion1->Enabled= false;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuCopy1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         MainFrm->LEADImage2->Copy(COPY_DIB + COPY_DDB + COPY_PALETTE);
         FinishRgnProcessing ();
      }
      else
         LEADImage1->Copy(COPY_DIB + COPY_DDB + COPY_PALETTE);
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

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

   if(LEADImage1->Paste(PASTE_ISREADY) == 0)
      ShowMessage("Invalid data on the clipboard");
   else
   {
      TChildImage *newChild=new TChildImage(Application);
      newChild->Caption="ClipBoard Data: " + IntToStr(MainFrm->nNumPastes);
      MainFrm->nNumPastes++;
      StatusBarChanged(newChild);
      newChild->LEADImage1->Paste(0);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSelectRegion1Click(TObject *Sender)
{
   mnuSelectRegionRect1->Checked= (LEADImage1->RgnMarkingMode == mmRectangle);
   mnuSelectRegionEllipse1->Checked= (LEADImage1->RgnMarkingMode == mmEllipse);
   mnuSelectRegionRndRect1->Checked= (LEADImage1->RgnMarkingMode == mmRoundRect);
   mnuSelectRegionFreeHand1->Checked= (LEADImage1->RgnMarkingMode == mmFreeHand);
   mnuSelectRegionNone1->Checked= (LEADImage1->RgnMarkingMode == mmNone);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSelectRegionNone1Click(TObject *Sender)
{
   LEADImage1->RgnMarkingMode= mmNone;
   m_RgnMarkingMode= mmNone;
   LEADImage1->Cursor=crDefault;
   if(LEADBkgrnd->Bitmap) //restore background
   {
      LEADImage1->Combine(0, 0, LEADImage1->BitmapWidth, LEADImage1->BitmapHeight,
         LEADBkgrnd->Bitmap, 0, 0, CB_OP_ADD + CB_DST_0);
      LEADBkgrnd->Bitmap=0;
   }
   LEADImage1->Floater=0;
   LEADImage1->FreeRgn ();
   LEADImage1->Repaint ();   
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSelectRegionRect1Click(TObject *Sender)
{
   LEADImage1->RgnMarkingMode= mmRectangle;
   m_RgnMarkingMode= mmRectangle;
   
   LEADImage1->Cursor=crCross;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSelectRegionEllipse1Click(TObject *Sender)
{
   LEADImage1->RgnMarkingMode= mmEllipse;
   m_RgnMarkingMode= mmEllipse;
   LEADImage1->Cursor=crCross;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSelectRegionRndRect1Click(TObject *Sender)
{
   LEADImage1->RgnMarkingMode= mmRoundRect;
   m_RgnMarkingMode= mmRoundRect;
   LEADImage1->Cursor=crCross;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSelectRegionFreeHand1Click(TObject *Sender)
{
   LEADImage1->RgnMarkingMode= mmFreeHand;
   m_RgnMarkingMode= mmFreeHand;
   
   LEADImage1->Cursor=crCross;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSelectRegionCancelRegion1Click(TObject *Sender)
{
   if(LEADBkgrnd->Bitmap) //restore background
   {
      LEADImage1->Combine(0, 0, LEADImage1->BitmapWidth, LEADImage1->BitmapHeight,
         LEADBkgrnd->Bitmap, 0, 0, CB_OP_ADD + CB_DST_0);
      LEADBkgrnd->Bitmap=0;
   }
   LEADImage1->Floater=0;
   LEADImage1->FreeRgn ();
   LEADImage1->ForceRepaint ();
   StatusBarChanged(this);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSelectRegionFrame1Click(TObject *Sender)
{
   mnuSelectRegionFrameWithoutFrame1->Checked= (LEADImage1->RgnFrameType == ftNone);
   mnuSelectRegionFrameStaticFrame1->Checked= (LEADImage1->RgnFrameType == ftStatic);
   mnuSelectRegionFrameAnimatedFrame1->Checked= (LEADImage1->RgnFrameType == ftAnimated);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSelectRegionFrameAnimatedFrame1Click(TObject *Sender)
{
   LEADImage1->RgnFrameType= m_RgnFrame= ftAnimated;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSelectRegionFrameStaticFrame1Click(TObject *Sender)
{
   LEADImage1->RgnFrameType= m_RgnFrame= ftStatic;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSelectRegionFrameWithoutFrame1Click(TObject *Sender)
{
   LEADImage1->RgnFrameType= m_RgnFrame= ftNone;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuAnimationClick(TObject *Sender)
{
   if(LEADImage1->BitmapListIndex > 0)
   {
      mnuPreviousFrame1->Enabled= true;
      mnuFirstFrame1->Enabled= true;
   }
   else
   {
      mnuPreviousFrame1->Enabled= false;
      mnuFirstFrame1->Enabled= false;
   }

   if(LEADImage1->BitmapListIndex < (LEADImage1->BitmapListCount - 1))
   {
      mnuNextFrame1->Enabled= true;
      mnuLastFrame1->Enabled= true;
   }
   else
   {
      mnuNextFrame1->Enabled= false;
      mnuLastFrame1->Enabled= false;
   }

   if(LEADImage1->InfoAnimation)
      mnuPlay1->Enabled= true;
   else
      mnuPlay1->Enabled= false;

   if(((TChildImage*)(MainFrm->ActiveMDIChild))->LEADImage1->BitmapListCount == 1)
   {
      mnuAnimationSettings1->Enabled= false;
      mnuFrameSettings1->Enabled= false;
      mnuOptimizeColors1->Enabled= false;
      mnuLoop1->Enabled= false;
      mnuPlay1->Enabled= false;
   }
   else
   {
      mnuCreate1->Enabled= true;
      mnuAnimationSettings1->Enabled= true;
      mnuFrameSettings1->Enabled= true;
      mnuOptimizeColors1->Enabled= true;
      mnuLoop1->Enabled= true;
      mnuPlay1->Enabled= true;
   }
   if(((TChildImage*)(MainFrm->ActiveMDIChild))->LEADImage1->AnimationEnable)
   {
      mnuCreate1->Enabled= false;
      mnuAnimationSettings1->Enabled= false;
      mnuFrameSettings1->Enabled= false;
      mnuOptimizeColors1->Enabled= false;
      mnuNextFrame1->Enabled= false;
      mnuLastFrame1->Enabled= false;
      mnuPreviousFrame1->Enabled= false;
      mnuFirstFrame1->Enabled= false;
   }

   if(GetImageName () == UNID)
      mnuOptimizeColors1->Enabled= false;

   mnuLoop1->Checked= LEADImage1->AnimationLoop;
   mnuPlay1->Checked= LEADImage1->AnimationEnable;
   mnuOptimizeColors1->Enabled= ((((TChildImage*)(MainFrm->ActiveMDIChild))->LEADImage1->BitmapListCount > 1) &&
                                (!((TChildImage*)(MainFrm->ActiveMDIChild))->LEADImage1->AnimationEnable));

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

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

   Application->CreateForm(__classid(TDlgAni), &DlgAni);
   if(DlgAni->ShowModal () == mrOk)
   {
      TChildImage *newChild=new TChildImage(MainFrm);
      newChild->Caption="Animation";
      TList *List=DlgAni->GetDstList ();
      for(int i=0; i< List->Count; i++)
      {
         TChildImage *TmpChild;

         TmpChild=(TChildImage *)List->Items[i];
         TmpChild->LEADImage1->BitmapDelay=1000;
         if(TmpChild->LEADImage1->Floater && TmpChild->LEADBkgrnd->Bitmap)
            newChild->LEADImage1->InsertBitmapListItem(LST_APPEND, TmpChild->LEADBkgrnd->Bitmap);
         else
            newChild->LEADImage1->InsertBitmapListItem(LST_APPEND, TmpChild->LEADImage1->Bitmap);
         newChild->LEADImage1->BitmapListIndex=i;
         newChild->LEADImage1->FreeRgn ();
      }
      StatusBarChanged(newChild);
   }
   DlgAni->Free ();
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuFirstFrame1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   PasteFloater ();
   LEADImage1->BitmapListIndex=0;
   LEADImage1->ForceRepaint ();
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuPreviousFrame1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   PasteFloater ();
   LEADImage1->BitmapListIndex= LEADImage1->BitmapListIndex - 1;
   LEADImage1->ForceRepaint ();
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuNextFrame1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   PasteFloater ();
   LEADImage1->BitmapListIndex= LEADImage1->BitmapListIndex + 1;
   LEADImage1->ForceRepaint ();
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuLastFrame1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   PasteFloater ();
   LEADImage1->BitmapListIndex=(LEADImage1->BitmapListCount - 1);
   LEADImage1->ForceRepaint ();
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

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

   Application->CreateForm(__classid(TAnimSet), &AnimSet);
   AnimSet->ShowModal ();
   if(AnimSet->ModalResult == mrOk)
   {
      g_nAnimationWidth= StrToInt(AnimSet->Text3->Text);
      g_nAnimationHeight= StrToInt(AnimSet->Text4->Text);
      g_bUseAnimationWidthHeight= true;
   }
   AnimSet->Free ();
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

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

   Application->CreateForm(__classid(TFrameSet), &FrameSet);
   FrameSet->ShowModal ();
   FrameSet->Free ();
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuOptimizeColors1Click(TObject *Sender)
{
   L_INT nRet;
   AnsiString Msg;

   LEADDlgColor1->LEADImage= LEADImage1;

   LEADDlgColor1->BitsPerPixel= LEADImage1->AnimationBitsPerPixel;
   LEADDlgColor1->DlgFlagsEx= DLG_COLORRES_SHOW_BITALL +
                              DLG_COLORRES_SHOW_DITHER_ALL +
                              DLG_COLORRES_SHOW_PAL_ALL;

   LEADDlgColor1->DlgFlags= DLG_COLORRES_SHOW_ORDER;

   nRet= LEADDlgColor1->ShowColorResDlg (this);
   if(nRet < SUCCESS_DLG_OK)
   {
      Msg= "ColorRes failed, \n Caused By: " + IntToStr(nRet) + "\n";
      Application->MessageBox(Msg.c_str (),PChar("Error"),MB_OK);
      return;
   }

   if(nRet == SUCCESS_DLG_CANCEL)
      return;

   Screen->Cursor=crHourGlass;
   if(LEADDlgColor1->BitsPerPixel > 8)
   {
      try
      {
         LEADImage1->ColorResList (LEADDlgColor1->BitsPerPixel,
                                    LEADDlgColor1->PaletteFlags,
                                    LEADDlgColor1->DitherFlags,
                                    0);
      }
      catch (const Exception &E)
      {
         MainFrm->DisplayErrorMsg (E.Message);
      }
   }
   else
   {
      int nColors=1 << LEADDlgColor1->BitsPerPixel;
      for (UINT i= 0; i < LEADDlgColor1->UserPaletteColorsCount; i ++)
      {
         LEADImage1->UserPalette[i]= LEADDlgColor1->UserPaletteColors[i];
      }
      if(((LEADDlgColor1->PaletteFlags & CRF_FIXEDPALETTE) != 0) && (nColors > 2))
      {
         TColor crBack;
         if(LEADImage1->AnimationBackColor >= 0x1000000)
            crBack= LEADImage1->AnimationPalette[LEADImage1->AnimationBackColor & 0xFF];
         else
            crBack = LEADImage1->AnimationBackColor;

         try
         {
            LEADImage1->ColorResList (LEADDlgColor1->BitsPerPixel,
                                       LEADDlgColor1->PaletteFlags,
                                       LEADDlgColor1->DitherFlags,
                                       LEADDlgColor1->UserPaletteColorsCount);
         }
         catch (const Exception &E)
         {
            MainFrm->DisplayErrorMsg (E.Message);
            return;
         }

         LEADImage1->AnimationPalette[nColors - 1]=crBack;
         LEADImage1->AnimationBackColor=(TColor)(0x1000000 + (nColors - 1));
         for(int i=0; i< (int)LEADImage1->BitmapListCount; i++)
         {
            LEADImage1->BitmapListIndex=i;
            LEADImage1->BitmapPalette[nColors - 1]=crBack;
         }
         LEADImage1->BitmapListIndex=0;
      }
      else
      {
         try
         {
            LEADImage1->ColorResList (LEADDlgColor1->BitsPerPixel,
                                       LEADDlgColor1->PaletteFlags,
                                       LEADDlgColor1->DitherFlags,
                                       LEADDlgColor1->UserPaletteColorsCount);
         }
         catch (const Exception &E)
         {
            Screen->Cursor=crDefault;
            return;
         }
      }
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuLoop1Click(TObject *Sender)
{
   LEADImage1->AnimationLoop=!LEADImage1->AnimationLoop;
   mnuLoop1->Checked= LEADImage1->AnimationLoop;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuPlay1Click(TObject *Sender)
{
   int nCurrentBitmap;
   int nOldIndex;
   int nWidth, nHeight;

   if(! LEADImage1->AnimationEnable)
   {
      // Create a temp LEADImage Control.
      TLEADImage * TempLEADImage= new TLEADImage (this);
      // Set the Visibility As false.
      TempLEADImage->Visible= false;
      // Set The Parent for the Temp LEADImage Control
      TempLEADImage->Parent= this;

      // Get the Old Bitmap Index
      nOldIndex= LEADImage1->BitmapListIndex;
      // Set the First Bitmap as the Current Bitmap
      LEADImage1->BitmapListIndex= 0;

      // Get the Current Bitmap in the List
      TempLEADImage->Bitmap= LEADImage1->Bitmap;
      // Get the Current's Bitmap Width, Height
      nWidth= TempLEADImage->BitmapWidth;
      nHeight= TempLEADImage->BitmapHeight;

      // Loop into All the Animation List
      for (nCurrentBitmap= 1; nCurrentBitmap < (int)LEADImage1->BitmapListCount; nCurrentBitmap ++)
      {
         // Set the Current Bitmap as the Loop index
         LEADImage1->BitmapListIndex= nCurrentBitmap;
         // Get the Current Bitmap
         TempLEADImage->Bitmap= LEADImage1->Bitmap;
         // Check if the Current Bitmap Width > nWidth
         if(TempLEADImage->BitmapWidth > nWidth)
            nWidth= TempLEADImage->BitmapWidth;
         // Check if the Current Bitmap Height > nHeight
         if(TempLEADImage->BitmapHeight > nHeight)
            nHeight= TempLEADImage->BitmapHeight;
      }
      TempLEADImage->Free ();
      // Set the Old Bitmap Index
      LEADImage1->BitmapListIndex= nOldIndex;

      if(g_bUseAnimationWidthHeight)
      {
         LEADImage1->AnimationWidth= g_nAnimationWidth;
         LEADImage1->AnimationHeight= g_nAnimationHeight;
         g_bUseAnimationWidthHeight= false;
      }
      else
      {
         LEADImage1->AnimationWidth= nWidth;
         LEADImage1->AnimationHeight= nHeight;
      }
   }
   Screen->Cursor=crHourGlass;

   if(!LEADImage1->AnimationEnable)
   {
      LEADImage1->Cursor=crDefault;
      if(LEADImage1->HasRgn)
      {
         if(LEADBkgrnd->Bitmap) //restore background
         {
            LEADImage1->Combine(0, 0, LEADImage1->BitmapWidth, LEADImage1->BitmapHeight,
               LEADBkgrnd->Bitmap, 0, 0, CB_OP_ADD + CB_DST_0);
            LEADBkgrnd->Bitmap=0;
         }
         LEADImage1->Floater=0;
         LEADImage1->FreeRgn ();
      }
   }

   LEADImage1->AnimationEnable=!LEADImage1->AnimationEnable;
   mnuPlay1->Checked= LEADImage1->AnimationEnable;

   StatusBarChanged(this);
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuMultiPageClick(TObject *Sender)
{
   if(IsSupportMultiPage(LEADImage1->InfoFormat))
   {
      mnuInsertPage1->Enabled= true;
      mnuAppendPage1->Enabled= true;
      mnuReplacePage1->Enabled= true;
      if(LEADImage1->BitmapListCount == 1)
          mnuDeletePage1->Enabled= false;
      else
          mnuDeletePage1->Enabled= true;
   }
   else
   {
      mnuInsertPage1->Enabled= false;
      mnuAppendPage1->Enabled= false;
      mnuReplacePage1->Enabled= false;
      mnuDeletePage1->Enabled= false;
   }

   if(LEADImage1->AnimationEnable)
   {
      mnuInsertPage1->Enabled= false;
      mnuAppendPage1->Enabled= false;
      mnuReplacePage1->Enabled= false;
      mnuDeletePage1->Enabled= false;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuInsertPage1Click(TObject *Sender)
{
   if(MainFrm->ActiveMDIChild == NULL)
      return;

   if(GetImageName () == UNID)
   {
      Application->MessageBox((char *)"Please Save File Before Performing This Operation ... ",(char *)"Notice",MB_OK);
      return;
   }

   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_LOADBITMAP +
                           DLG_OPEN_SHOW_PROGRESSIVE +
                           DLG_OPEN_SHOW_MULTIPAGE +
                           DLG_OPEN_SHOW_LOADROTATED +
                           DLG_OPEN_SHOW_LOADCOMPRESSED +
                           DLG_OPEN_SHOW_FILEINFO +
                           DLG_OPEN_USEFILESTAMP +
                           DLG_OPEN_SHOW_PREVIEW;

   LEADDlgFile1->LEADImage= MainFrm->LEADImage2;
   L_INT nRet= LEADDlgFile1->ShowOpenDlg (this);
   if(nRet < SUCCESS_DLG_OK)
   {
      Application->MessageBox ("Error In Method ", "Error ", MB_OK);
      return;
   }
   if(nRet == SUCCESS_DLG_CANCEL)
      return;

   Screen->Cursor=crHourGlass;

   LEADImage1->GetFileInfo(((TChildImage*)MainFrm->ActiveMDIChild)->GetImageName (),0);
   MainFrm->LEADImage2->SavePage= LEADImage1->BitmapListIndex + 1;

   try
   {
      MainFrm->LEADImage2->Save(((TChildImage *)MainFrm->ActiveMDIChild)->GetImageName (),
                                 LEADImage1->InfoFormat,
                                 MainFrm->LEADImage2->BitmapBits,
                                 GetProperQualityFactor(LEADImage1->InfoFormat),SAVE_INSERT);
   }
   catch (ELEADImageError* e)
   {
      AnsiString msg="Save Result = " + IntToStr(MainFrm->LEADImage2->Error);
      Application->MessageBox (msg.c_str (),(char *)"Error ",MB_OK);

      Screen->Cursor=crDefault;
      return;
   }
   if(MainFrm->LEADImage2->Error == SUCCESS)
      LEADImage1->InsertBitmapListItem(LEADImage1->BitmapListIndex,MainFrm->LEADImage2->Bitmap);

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

void __fastcall TChildImage::mnuAppendPage1Click(TObject *Sender)
{
   if(MainFrm->ActiveMDIChild == NULL)
      return;

   AnsiString Name=GetImageName ();
   if(Name == UNID)
   {
      Application->MessageBox("Please Save File Before Performing This Operation ...","Notice",MB_OK);
      return;
   }

   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_LOADBITMAP +
                           DLG_OPEN_SHOW_PROGRESSIVE +
                           DLG_OPEN_SHOW_MULTIPAGE +
                           DLG_OPEN_SHOW_LOADROTATED +
                           DLG_OPEN_SHOW_LOADCOMPRESSED +
                           DLG_OPEN_SHOW_FILEINFO +
                           DLG_OPEN_USEFILESTAMP +
                           DLG_OPEN_SHOW_PREVIEW;

   LEADDlgFile1->LEADImage= MainFrm->LEADImage2;
   int nRet= LEADDlgFile1->ShowOpenDlg (this);
   if(nRet < SUCCESS_DLG_OK)
   {
      Application->MessageBox ("FileOpen Dialog Failed ...","Error ",MB_OK);
      return;
   }
   if(nRet == SUCCESS_DLG_CANCEL)
      return;

   Screen->Cursor= crHourGlass;

   LEADImage1->GetFileInfo(((TChildImage *)MainFrm->ActiveMDIChild)->GetImageName (), 0);
   LEADImage1->SavePage= SAVE_APPEND;
   AnsiString strFileName;
   try
   {
      strFileName = ((TChildImage *)MainFrm->ActiveMDIChild)->GetImageName();
      MainFrm->LEADImage2->Save(strFileName,
                                LEADImage1->InfoFormat,
                                MainFrm->LEADImage2->BitmapBits,
                                GetProperQualityFactor(LEADImage1->InfoFormat),
                                SAVE_APPEND);
   }
   catch (ELEADImageError* e)
   {
      AnsiString msg= "Save Result = " + IntToStr(nRet);
      Application->MessageBox (msg.c_str (), "Error ", MB_OK);

      Screen->Cursor=crDefault;
      return;
   }

   if(MainFrm->LEADImage2->Error == SUCCESS)
   {
      LEADImage1->Load(strFileName, 0, 0, -1);
      LEADImage1->BitmapListIndex= LEADImage1->BitmapListCount - 1;
      MainFrm->LEADImage2->Bitmap= 0;
   }

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

void __fastcall TChildImage::mnuReplacePage1Click(TObject *Sender)
{
   if(MainFrm->ActiveMDIChild == NULL)
      return;

   AnsiString Name=GetImageName ();
   if(Name == UNID)
   {
      Application->MessageBox("Please Save File Before Performing This Operation ...","Notice",MB_OK);
      return;
   }

   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_LOADBITMAP +
                           DLG_OPEN_SHOW_PROGRESSIVE +
                           DLG_OPEN_SHOW_MULTIPAGE +
                           DLG_OPEN_SHOW_LOADROTATED +
                           DLG_OPEN_SHOW_LOADCOMPRESSED +
                           DLG_OPEN_SHOW_FILEINFO +
                           DLG_OPEN_USEFILESTAMP +
                           DLG_OPEN_SHOW_PREVIEW;

   LEADDlgFile1->LEADImage= MainFrm->LEADImage2;

   int nRet= LEADDlgFile1->ShowOpenDlg (this);
   if(nRet < SUCCESS_DLG_OK)
   {
      Application->MessageBox ("FileOpen Dialog Failed ...","Error ",MB_OK);
      return;
   }

   if(nRet == SUCCESS_DLG_CANCEL)
      return;

   Screen->Cursor=crHourGlass;

   TChildImage *Child=(TChildImage *)MainFrm->ActiveMDIChild;
   Name=Child->GetImageName ();
   LEADImage1->GetFileInfo(Name,0);

   MainFrm->LEADImage2->SavePage= LEADImage1->BitmapListIndex + 1;
   try
   {
      MainFrm->LEADImage2->Save(Name,
                                LEADImage1->InfoFormat,
                                MainFrm->LEADImage2->BitmapBits,
                                GetProperQualityFactor(LEADImage1->InfoFormat),
                                SAVE_REPLACE);
   }
   catch (ELEADImageError* e)
   {
      AnsiString msg="Can not save an image, \nError: " + MainFrm->LEADImage2->ErrorMsg;
      Application->MessageBox(msg.c_str (),(char *)"Error",MB_OK);

      Screen->Cursor=crDefault;
      return;
   }

   if(MainFrm->LEADImage2->Error == SUCCESS)
      LEADImage1->Bitmap= MainFrm->LEADImage2->Bitmap;

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

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

   AnsiString Name=GetImageName ();
   LEADImage1->GetFileInfo(Name,0);

   if(Name !=  UNID)
   {
      if(MessageDlg("Delete this page, are you sure ... ?",
         mtConfirmation, TMsgDlgButtons () << mbYes << mbNo, 0) == mrYes)
      {
         try
         {
            int nRet = LEADImage1->DeletePage(Name, LEADImage1->BitmapListIndex+1);
            if(nRet == SUCCESS)
               LEADImage1->Bitmap=0; // delete current page, gets next page. 
         }
         catch (ELEADImageError* e)
         {
            Screen->Cursor=crDefault;
            return;
         }
      }
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuViewClick(TObject *Sender)
{
   mnuSnapWindowToImage1->Enabled= (WindowState == wsNormal);
   mnuEffectsPaintText1->Enabled= !((LEADImage1->BitmapBits == 2) ||
                                    (LEADImage1->BitmapBits == 3) ||
                                    (LEADImage1->BitmapBits == 5) ||
                                    (LEADImage1->BitmapBits == 6) ||
                                    (LEADImage1->BitmapBits == 7) ||
                                    (LEADImage1->BitmapBits == 12) ||
                                    (LEADImage1->BitmapBits == 16) ||
                                    (LEADImage1->BitmapBits == 32) ||
                                    (LEADImage1->BitmapBits == 48) ||
                                    (LEADImage1->BitmapBits == 64));

   mnuEffectsPaintShape1->Enabled= !((LEADImage1->BitmapBits == 2) ||
                                     (LEADImage1->BitmapBits == 3) ||
                                     (LEADImage1->BitmapBits == 5) ||
                                     (LEADImage1->BitmapBits == 6) ||
                                     (LEADImage1->BitmapBits == 7) ||
                                     (LEADImage1->BitmapBits == 12) ||
                                     (LEADImage1->BitmapBits == 16) ||
                                     (LEADImage1->BitmapBits == 32) ||
                                     (LEADImage1->BitmapBits == 48) ||
                                     (LEADImage1->BitmapBits == 64));
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuNormal1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   ViewNormalProc ();
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuZoom1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   ViewZoomProc ();
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuFitImageToWindow1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   ViewFitProc ();
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSnapWindowToImage1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   ViewSnapProc ();
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuEffectsPaintEffects1Click(TObject *Sender)
{
   LEADDlgEffect1->DlgFlags= DLG_EFFECT_SHOW_PREVIEW + 
                             DLG_EFFECT_DELAY +
                             DLG_EFFECT_GRAIN + 
                             DLG_EFFECT_PASSES + 
                             DLG_EFFECT_TRANSPARENT + 
                             DLG_EFFECT_WAND + 
                             DLG_EFFECT_CLASS_WIPE + 
                             DLG_EFFECT_CLASS_WIPERECT + 
                             DLG_EFFECT_CLASS_WIPECIRCLE + 
                             DLG_EFFECT_CLASS_PUSH + 
                             DLG_EFFECT_CLASS_SLIDE + 
                             DLG_EFFECT_CLASS_ROLL + 
                             DLG_EFFECT_CLASS_ROTATE + 
                             DLG_EFFECT_CLASS_ZOOM + 
                             DLG_EFFECT_CLASS_DRIP + 
                             DLG_EFFECT_CLASS_BLIND + 
                             DLG_EFFECT_CLASS_RANDOM + 
                             DLG_EFFECT_CLASS_CHECK + 
                             DLG_EFFECT_CLASS_BLOCKS + 
                             DLG_EFFECT_CLASS_CIRCLE + 
                             DLG_EFFECT_CLASS_ELLIPSE;

   LEADDlgEffect1->LEADImage= LEADImage1;

   int nRet= LEADDlgEffect1->ShowGetEffectDlg (this);
   if(nRet < SUCCESS_DLG_OK)
   {
      AnsiString Msg= "GetEffect Dialog Failed, \n Caused By: " + IntToStr(nRet);
      Application->MessageBox(Msg.c_str(), "Error", MB_OK);
      return;
   }
   if(nRet == SUCCESS_DLG_CANCEL)
      return;

   efxEffectDelay= LEADDlgEffect1->Delay;
   efxEffectGrain= LEADDlgEffect1->Grain;
   efxPaintMaxPasses= LEADDlgEffect1->MaxPass;
   efxPaintEffect= LEADDlgEffect1->Effect;
   efxWandColor= (TColor)LEADDlgEffect1->WandColor;
   efxWandSize= LEADDlgEffect1->WandThickness;
   PaintEffects ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuEffectsPaintPattern1Click(TObject *Sender)
{
   //enable preview, and all options
   LEADDlgEffect1->DlgFlags= DLG_TRANSITION_SHOW_PREVIEW +
                             DLG_TRANSITION_FORECOLOR +
                             DLG_TRANSITION_BACKCOLOR +
                             DLG_TRANSITION_DELAY +
                             DLG_TRANSITION_GRAIN +
                             DLG_TRANSITION_EFFECT +
                             DLG_TRANSITION_PASSES +
                             DLG_TRANSITION_WAND +
                             DLG_TRANSITION_TRANSPARENT;


   LEADDlgEffect1->LEADImage= LEADImage1;
   int nRet= LEADDlgEffect1->ShowGetTransitionDlg (this);
   if(nRet < SUCCESS_DLG_OK)
   {
      AnsiString Msg="GetTransition Dialog Failed.";
      Application->MessageBox(Msg.c_str (),(char *)"Error",MB_OK);
      return;
   }

   if(nRet == SUCCESS_DLG_CANCEL)
      return;

   ptnTransitionEffect= LEADDlgEffect1->Effect;
   ptnUseTransparentColor= LEADDlgEffect1->Transparent;
   ptnTransparentColor= (TColor)LEADDlgEffect1->TransparentColor;
   ptnWandColor= (TColor)LEADDlgEffect1->WandColor;
   ptnWandSize= LEADDlgEffect1->WandThickness;
   ptnEffectDelay= LEADDlgEffect1->Delay;
   ptnEffectGrain= LEADDlgEffect1->Grain;
   ptnPaintMaxPasses= LEADDlgEffect1->MaxPass;
   ptnPatternBackColor= (TColor)LEADDlgEffect1->BackColor;
   ptnPatternForeColor= (TColor)LEADDlgEffect1->ForeColor;
   ptnPatternStyle= LEADDlgEffect1->PatternStyle;
   ptnTransitionStyle= LEADDlgEffect1->TransitionStyle;   
   grdGradientStyle= LEADDlgEffect1->GradientStyle;
   grdGradientSteps= LEADDlgEffect1->GradientSteps;
   grdGradientStartColor= (TColor)LEADDlgEffect1->ForeColor;
   grdGradientEndColor= (TColor)LEADDlgEffect1->BackColor;

   PaintPatterns ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuEffectsPaintGradient1Click(TObject *Sender)
{
   LEADDlgEffect1->DlgFlags= DLG_GRADIENT_SHOW_PREVIEW +
                             DLG_GRADIENT_STARTCOLOR +
                             DLG_GRADIENT_ENDCOLOR +
                             DLG_GRADIENT_STEPS +
                             DLG_GRADIENT_CLASS_LINEAR +
                             DLG_GRADIENT_CLASS_ANGULAR +
                             DLG_GRADIENT_CLASS_RECTANGULAR +
                             DLG_GRADIENT_CLASS_ELLIPTICAL +
                             DLG_GRADIENT_CLASS_CONICAL;


   LEADDlgEffect1->LEADImage= LEADImage1;
   int nRet= LEADDlgEffect1->ShowGetGradientDlg (this);
   if(nRet < SUCCESS_DLG_OK)
   {
      AnsiString Msg="GetGradient Dialog Failed.";
      Application->MessageBox(Msg.c_str (), (char *)"Error", MB_OK);
      return;
   }
   if(nRet == SUCCESS_DLG_CANCEL)
      return;

   grdEffectDelay= LEADDlgEffect1->Delay;
   grdGradientSteps= LEADDlgEffect1->GradientSteps;
   grdGradientStyle= LEADDlgEffect1->GradientStyle;
   grdGradientStartColor= (TColor)LEADDlgEffect1->StartColor;
   grdGradientEndColor= (TColor)LEADDlgEffect1->EndColor;
   
   PaintGradients ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuEffectsPaintText1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   LEADDlgEffect1->DlgFlags= DLG_TEXT_AUTOPREVIEW +
                             DLG_TEXT_SHOW_PREVIEW +
                             DLG_TEXT_SAMPLETEXT +
                             DLG_TEXT_STYLE +
                             DLG_TEXT_COLOR +
                             DLG_TEXT_BORDERCOLOR +
                             DLG_TEXT_ALIGN +
                             DLG_TEXT_ANGLE +
                             DLG_TEXT_WORDWRAP +
                             DLG_TEXT_FONT +
                             DLG_TEXT_FOREIMAGE +
                             DLG_TEXT_BROWSEIMAGE +
                             DLG_TEXT_SHADOWCOLOR +
                             DLG_TEXT_SHADOW_X_Y;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgEffect1->ShapeBackgroundBitmap= MainFrm->LEADImage2->Bitmap;
			LEADDlgEffect1->LEADImage= MainFrm->LEADImage2;
			LEADDlgEffect1->TextFont= MainFrm->LEADImage2->TextFont;
			LEADDlgEffect1->TextAlign= MainFrm->LEADImage2->TextAlign;
         int nRet= LEADDlgEffect1->ShowGetShapeDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            EnablePaintShapeProc (MainFrm->LEADImage2);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgEffect1->TextForegroundBitmap= LEADImage1->Bitmap;
			LEADDlgEffect1->LEADImage= LEADImage1;
			LEADDlgEffect1->TextFont= LEADImage1->TextFont;
			LEADDlgEffect1->TextAlign= LEADImage1->TextAlign;
			int nRet= LEADDlgEffect1->ShowGetTextDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            EnablePaintTextProc (LEADImage1);
      }
   }
   catch(ELEADImageError* e)
   {
      AnsiString strErr="Draw Text Failed:\n" + LEADImage1->ErrorMsg;
      Application->MessageBox(strErr.c_str (), "Error", MB_OK);
      Screen->Cursor=crDefault;
      return;
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuEffectsPaintShape1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgEffect1->DlgFlags= DLG_SHAPE_SHOW_PREVIEW +
                                DLG_SHAPE_AUTOPREVIEW +
                                DLG_SHAPE_BACKSTYLE +
                                DLG_SHAPE_FILLSTYLE +
                                DLG_SHAPE_FORE_BACK_COLOR +
                                DLG_SHAPE_BORDERSTYLE +
                                DLG_SHAPE_BORDERWIDTH +
                                DLG_SHAPE_BORDERCOLOR +
                                DLG_SHAPE_INNERSTYLE +
                                DLG_SHAPE_INNERWIDTH +
                                DLG_SHAPE_INNER_HILITE_SHADOW +
                                DLG_SHAPE_OUTERSTYLE +
                                DLG_SHAPE_OUTERWIDTH +
                                DLG_SHAPE_OUTER_HILITE_SHADOW +
                                DLG_SHAPE_SHADOWCOLOR +
                                DLG_SHAPE_SHADOW_X_Y +
                                DLG_SHAPE_BROWSEIMAGE +
                                DLG_SHAPE_CLASS_SQUARE +
                                DLG_SHAPE_CLASS_RECTANGLE +
                                DLG_SHAPE_CLASS_PARALLELOGRAM  +
                                DLG_SHAPE_CLASS_TRAPEZOID +
                                DLG_SHAPE_CLASS_TRIANGLE +
                                DLG_SHAPE_CLASS_OTHER +
                                DLG_SHAPE_CLASS_CIRCLE +
                                DLG_SHAPE_CLASS_ELLIPSE +
                                DLG_SHAPE_CLASS_STAR +
                                DLG_SHAPE_CLASS_CROSS +
                                DLG_SHAPE_CLASS_ARROW;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         LEADDlgEffect1->ShapeBackgroundBitmap= MainFrm->LEADImage2->Bitmap;
         LEADDlgEffect1->LEADImage= MainFrm->LEADImage2;
         int nRet= LEADDlgEffect1->ShowGetShapeDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            EnablePaintShapeProc (MainFrm->LEADImage2);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgEffect1->ShapeBackgroundBitmap= LEADImage1->Bitmap;

         LEADDlgEffect1->LEADImage= LEADImage1;
         int nRet= LEADDlgEffect1->ShowGetShapeDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            EnablePaintShapeProc (LEADImage1);
      }
   }
   catch(ELEADImageError* e)
   {
      AnsiString strErr="Draw Shape Failed:\n" + LEADImage1->ErrorMsg;
      Application->MessageBox(strErr.c_str (), "Error", MB_OK);
      Screen->Cursor=crDefault;
      return;
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuEffectsEnablePaintEffects1Click(TObject *Sender)
{
   mnuEffectsEnablePaintEffects1->Checked=!mnuEffectsEnablePaintEffects1->Checked;

   if(mnuEffectsEnablePaintEffects1->Checked)
   {
      Screen->Cursor=crHourGlass;
      PaintEffects ();
      Screen->Cursor=crDefault;
   }
   else
   {
      Screen->Cursor=crHourGlass;
      LEADImage1->PaintEffect=EFX_EFFECT_NONE;
      PaintPatterns ();
      PaintGradients ();
      LEADImage1->ForceRepaint ();
      Screen->Cursor=crDefault;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuEffectsEnablePaintPattern1Click(TObject *Sender)
{
   mnuEffectsEnablePaintPattern1->Checked=!mnuEffectsEnablePaintPattern1->Checked;

   if(mnuEffectsEnablePaintPattern1->Checked)
   {
      Screen->Cursor=crHourGlass;
      PaintPatterns ();
      mnuEffectsEnablePaintGradient1->Checked= false;
      Screen->Cursor=crDefault;
   }
   else
   {
      Screen->Cursor= crHourGlass;
      LEADImage1->TransitionEffect= EFX_EFFECT_NONE;
      LEADImage1->TransitionStyle= etsNone;
      PaintGradients ();
      Screen->Cursor= crDefault;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuEffectsEnablePaintGradient1Click(TObject *Sender)
{
   mnuEffectsEnablePaintGradient1->Checked=!mnuEffectsEnablePaintGradient1->Checked;

   if(mnuEffectsEnablePaintGradient1->Checked)
   {
      Screen->Cursor=crHourGlass;
      PaintGradients ();      
      mnuEffectsEnablePaintPattern1->Checked= false;
      Screen->Cursor=crDefault;
   }
   else
   {
      LEADImage1->TransitionEffect= EFX_EFFECT_NONE;
      LEADImage1->TransitionStyle= etsNone;
      PaintGradients ();
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuPanWindow1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   mnuPanWindow1->Checked= !mnuPanWindow1->Checked;
   LEADImage1->PanWinTitle="Pan Window ";
   LEADImage1->ShowPanWin(mnuPanWindow1->Checked);
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuFlip1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         MainFrm->LEADImage2->Flip ();
         FinishRgnProcessing ();
      }
      else
         LEADImage1->Flip ();
   }
   catch(ELEADImageError* e)
   {
      AnsiString strErr="Flip Failed:\n" + LEADImage1->ErrorMsg;
      Application->MessageBox(strErr.c_str (), "Error", MB_OK);
      Screen->Cursor=crDefault;
      return;
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuDeskew1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         MainFrm->LEADImage2->Deskew (RGB(255, 0, 0), 0, NULL);
         FinishRgnProcessing ();
      }
      else
         LEADImage1->Deskew (RGB(255, 0, 0), 0, NULL);
   }
   catch(ELEADImageError* e)
   {
      AnsiString strErr="Deskew Failed:\n" + LEADImage1->ErrorMsg;
      Application->MessageBox(strErr.c_str (), "Error", MB_OK);
      Screen->Cursor=crDefault;
      return;
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuReverse1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         MainFrm->LEADImage2->Reverse ();
         FinishRgnProcessing ();
      }
      else
         LEADImage1->Reverse ();
   }
   catch(ELEADImageError* e)
   {
      AnsiString strErr="Reverse Failed:\n" + LEADImage1->ErrorMsg;
      Application->MessageBox(strErr.c_str (), "Error", MB_OK);
      Screen->Cursor=crDefault;
      return;
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuRotate90clockwise1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         MainFrm->LEADImage2->Rotate(9000, True, RGB(255, 255, 255));
         FinishRgnProcessing ();
      }
      else
         LEADImage1->Rotate(9000, True, RGB(255, 255, 255));
   }
   catch(ELEADImageError* e)
   {
      AnsiString strErr="Rotate Failed:\n" + LEADImage1->ErrorMsg;
      Application->MessageBox(strErr.c_str (), "Error", MB_OK);
      Screen->Cursor=crDefault;
      return;
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuRotate180clockwise1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         MainFrm->LEADImage2->Rotate(18000, True, RGB(255, 255, 255));
         FinishRgnProcessing ();
      }
      else
         LEADImage1->Rotate(18000, True, RGB(255, 255, 255));
   }
   catch(ELEADImageError* e)
   {
      AnsiString strErr="Rotate Failed:\n" + LEADImage1->ErrorMsg;
      Application->MessageBox(strErr.c_str (), "Error", MB_OK);
      Screen->Cursor=crDefault;
      return;
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuRotate270clockwise1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         MainFrm->LEADImage2->Rotate(27000, True, RGB(255, 255, 255));
         FinishRgnProcessing ();
      }
      else
         LEADImage1->Rotate(27000, True, RGB(255, 255, 255));
   }
   catch(ELEADImageError* e)
   {
      AnsiString strErr="Rotate Failed:\n" + LEADImage1->ErrorMsg;
      Application->MessageBox(strErr.c_str (), "Error", MB_OK);
      Screen->Cursor=crDefault;
      return;
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuRotateAnyAngle1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImage1->DlgFlags= DLG_ROTATE_SHOW_PREVIEW +
                               DLG_ROTATE_SHOW_BACKCOLOR +
                               DLG_ROTATE_SHOW_RESIZE;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         LEADDlgImage1->LEADImage= MainFrm->LEADImage2;
         LEADDlgImage1->Angle= 0;
         int nRet= LEADDlgImage1->ShowRotateDlg (this);
         if(nRet == SUCCESS_DLG_OK)
         {
            if(LEADDlgImage1->Resize)
               MainFrm->LEADImage2->Rotate (LEADDlgImage1->Angle, ROTATE_RESIZE, LEADDlgImage1->BackgroundColor);
            else
               MainFrm->LEADImage2->Rotate (LEADDlgImage1->Angle, 0, LEADDlgImage1->BackgroundColor);
         }
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImage1->DlgFlags= LEADDlgImage1->DlgFlags + DLG_ROTATE_AUTOPROCESS;
         LEADDlgImage1->LEADImage= LEADImage1;
         LEADDlgImage1->ShowRotateDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuShear1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImage1->DlgFlags= DLG_SHEAR_SHOW_PREVIEW +
                               DLG_SHEAR_SHOW_BACKCOLOR +
                               DLG_SHEAR_SHOW_HORIZONTAL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         LEADDlgImage1->LEADImage= MainFrm->LEADImage2;
         int nRet= LEADDlgImage1->ShowShearDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Shear (LEADDlgImage1->Angle,
                                         LEADDlgImage1->Horizontal,
                                         LEADDlgImage1->BackgroundColor);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImage1->DlgFlags= LEADDlgImage1->DlgFlags + DLG_SHEAR_AUTOPROCESS;
         
         LEADDlgImage1->LEADImage= LEADImage1;
         LEADDlgImage1->ShowShearDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuRemoveRedeye1Click(TObject *Sender)
{
   L_INT nRet;

   Screen->Cursor= crHourGlass;
   try
   {
      LEADDlgImgDoc1->DlgFlags= DLG_REMOVEREDEYE_SHOW_PREVIEW +
                                DLG_REMOVEREDEYE_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {

         PrepareRgnProcessing ();
         LEADDlgImgDoc1->LEADImage= MainFrm->LEADImage2;
         nRet= LEADDlgImgDoc1->ShowRemoveRedeyeDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->RemoveRedeye (LEADDlgImgDoc1->NewColor, LEADDlgImgDoc1->Threshold, LEADDlgImgDoc1->Lightness);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgDoc1->DlgFlags= LEADDlgImgDoc1->DlgFlags + DLG_REMOVEREDEYE_AUTOPROCESS;

         LEADDlgImgDoc1->LEADImage= LEADImage1;
         LEADDlgImgDoc1->ShowRemoveRedeyeDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor= crDefault; 
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuAutoTrim1Click(TObject *Sender)
{
   L_INT nRet;

   Screen->Cursor=crHourGlass;

   LEADDlgImage1->DlgFlags= DLG_AUTOTRIM_SHOW_PREVIEW;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         LEADDlgImage1->LEADImage= MainFrm->LEADImage2;
         nRet= LEADDlgImage1->ShowAutoTrimDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->AutoTrim (LEADDlgImage1->Threshold);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImage1->DlgFlags= LEADDlgImage1->DlgFlags + DLG_AUTOTRIM_AUTOPROCESS;
         LEADDlgImage1->LEADImage= LEADImage1;

         LEADDlgImage1->ShowAutoTrimDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuAddBorder1Click(TObject *Sender)
{
   L_INT nRet;

   nRet= LoadUserCustomBitmaps ("Select Border Images Folder", DLGIMAGE_CONTROL);
   if(nRet == SUCCESS)
   {
      LEADDlgImage1->DlgFlags= DLG_ADDBORDER_SHOW_PREVIEW +
                               DLG_ADDBORDER_AUTOPROCESS +
                               DLG_ADDBORDER_SHOW_TOOL_ZOOMLEVEL;

      LEADDlgImage1->LEADImage= LEADImage1;
      LEADDlgImage1->ShowAddBorderDlg (this);
   }  
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuAddFrame1Click(TObject *Sender)
{
   L_INT nRet;

   nRet= LoadUserCustomBitmaps ("Select Frame Images Folder", DLGIMAGE_CONTROL);
   if(nRet == SUCCESS)
   {
      LEADDlgImage1->DlgFlags= DLG_ADDFRAME_SHOW_PREVIEW +
                               DLG_ADDFRAME_AUTOPROCESS +
                               DLG_ADDFRAME_SHOW_TOOL_ZOOMLEVEL;

      LEADDlgImage1->LEADImage= LEADImage1;
      LEADDlgImage1->ShowAddFrameDlg (this);
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuDocumentImagingSmooth1Click(TObject *Sender)
{
   AnsiString Msg;
   Screen->Cursor=crHourGlass;

   LEADDlgImgDoc1->DlgFlags= DLG_SMOOTH_SHOW_PREVIEW +
                             DLG_SMOOTH_SHOW_TOOL_ZOOMLEVEL;
   LEADDlgImgDoc1->Length= 1;
   LEADDlgImgDoc1->MinHoleWidth= 1;
   LEADDlgImgDoc1->MinHoleHeight= 1;
   LEADDlgImgDoc1->MaxHoleWidth= 1;
   LEADDlgImgDoc1->MaxHoleHeight= 1;
   LEADDlgImgDoc1->MinHoleCount= 2;
   LEADDlgImgDoc1->MaxHoleCount= 4;
   LEADDlgImgDoc1->WhiteAreaColor= RGB (255, 0, 0);
   LEADDlgImgDoc1->BlackAreaColor= RGB (0, 0, 255);
   try
   {
      if((LEADImage1->HasRgn))
      {
         PrepareRgnProcessing ();
         LEADDlgImgDoc1->LEADImage= MainFrm->LEADImage2;
         int nRet= LEADDlgImgDoc1->ShowSmoothDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Smooth (LEADDlgImgDoc1->Length,
                                          LEADDlgImgDoc1->ProcessFlags);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgDoc1->DlgFlags= LEADDlgImgDoc1->DlgFlags + DLG_SMOOTH_AUTOPROCESS;

         LEADDlgImgDoc1->LEADImage= LEADImage1;
         LEADDlgImgDoc1->ShowSmoothDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------{

void __fastcall TChildImage::mnuDocumentImagingLineRemoval1Click(TObject *Sender)
{
   AnsiString Msg;
   Screen->Cursor=crHourGlass;

   LEADDlgImgDoc1->DlgFlags= DLG_LINEREMOVE_SHOW_PREVIEW +
                             DLG_LINEREMOVE_SHOW_TOOL_ZOOMLEVEL;

   LEADDlgImgDoc1->MinLineLength= 400;
   LEADDlgImgDoc1->MaxLineWidth= 9;
   LEADDlgImgDoc1->Wall= 15;
   LEADDlgImgDoc1->MaxWallPercent= 10;
   LEADDlgImgDoc1->GapLength= 3;
   LEADDlgImgDoc1->Variance= 3;
   LEADDlgImgDoc1->ModificationColor= RGB (0, 0, 255);
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgDoc1->LEADImage= MainFrm->LEADImage2;
         int nRet= LEADDlgImgDoc1->ShowLineRemoveDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            LEADImage1->LineRemove (LEADDlgImgDoc1->ProcessFlags,
                                     LEADDlgImgDoc1->MinLineLength,
                                     LEADDlgImgDoc1->MaxLineWidth,
                                     LEADDlgImgDoc1->Wall,
                                     LEADDlgImgDoc1->MaxWallPercent,
                                     LEADDlgImgDoc1->GapLength,
                                     LEADDlgImgDoc1->Variance,
                                     LEADDlgImgDoc1->RemoveFlags);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgDoc1->DlgFlags= LEADDlgImgDoc1->DlgFlags + DLG_LINEREMOVE_AUTOPROCESS;

         LEADDlgImgDoc1->LEADImage= LEADImage1;
         LEADDlgImgDoc1->ShowLineRemoveDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuDocumentImagingInvertedText1Click(TObject *Sender)
{
   AnsiString Msg;

   Screen->Cursor=crHourGlass;
   LEADDlgImgDoc1->DlgFlags= DLG_INVERTEDTEXT_SHOW_PREVIEW +
                             DLG_INVERTEDTEXT_SHOW_TOOL_ZOOMLEVEL;

   LEADDlgImgDoc1->MinInvertWidth= 900;
   LEADDlgImgDoc1->MinInvertHeight= 56;
   LEADDlgImgDoc1->MinBlackPercent= 75;
   LEADDlgImgDoc1->MaxBlackPercent= 95;
   LEADDlgImgDoc1->WhiteAreaColor= RGB (255, 0, 0);
   LEADDlgImgDoc1->BlackAreaColor= RGB (0, 0, 255);

   try
   {
      if((LEADImage1->HasRgn))
      {
         PrepareRgnProcessing ();
         LEADDlgImgDoc1->LEADImage= MainFrm->LEADImage2;
         int nRet= LEADDlgImgDoc1->ShowInvertedTextDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            LEADImage1->InvertedText (LEADDlgImgDoc1->ProcessFlags,
                                      LEADDlgImgDoc1->MinInvertWidth,
                                      LEADDlgImgDoc1->MinInvertHeight,
                                      LEADDlgImgDoc1->MinBlackPercent,
                                      LEADDlgImgDoc1->MaxBlackPercent);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgDoc1->DlgFlags= LEADDlgImgDoc1->DlgFlags + DLG_INVERTEDTEXT_AUTOPROCESS;

         LEADDlgImgDoc1->LEADImage= LEADImage1;
         LEADDlgImgDoc1->ShowInvertedTextDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuDocumentImagingDotRemoval1Click(TObject *Sender)
{
  AnsiString Msg;

   Screen->Cursor=crHourGlass;

   LEADDlgImgDoc1->DlgFlags= DLG_DOTREMOVE_SHOW_PREVIEW +
                             DLG_DOTREMOVE_SHOW_TOOL_ZOOMLEVEL;

   LEADDlgImgDoc1->MinDotWidth= 6;
   LEADDlgImgDoc1->MinDotHeight= 6;
   LEADDlgImgDoc1->MaxDotWidth= 8;
   LEADDlgImgDoc1->MaxDotHeight= 8;
   LEADDlgImgDoc1->WhiteAreaColor= RGB (255, 0, 0);
   LEADDlgImgDoc1->BlackAreaColor= RGB (0, 0, 255);

   try
   {
      if((LEADImage1->HasRgn))
      {
         PrepareRgnProcessing ();
         LEADDlgImgDoc1->LEADImage= MainFrm->LEADImage2;
         int nRet= LEADDlgImgDoc1->ShowDotRemoveDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            LEADImage1->DotRemove (LEADDlgImgDoc1->ProcessFlags,
                                   LEADDlgImgDoc1->MinDotWidth,
                                   LEADDlgImgDoc1->MinDotHeight,
                                   LEADDlgImgDoc1->MaxDotWidth,
                                   LEADDlgImgDoc1->MaxDotHeight);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgDoc1->DlgFlags= LEADDlgImgDoc1->DlgFlags + DLG_DOTREMOVE_AUTOPROCESS;

         LEADDlgImgDoc1->LEADImage= LEADImage1;
         LEADDlgImgDoc1->ShowDotRemoveDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuDocumentImagingBorderRemoval1Click(TObject *Sender)
{
   AnsiString Msg;
   Screen->Cursor=crHourGlass;
   LEADDlgImgDoc1->DlgFlags= DLG_BORDERREMOVE_SHOW_PREVIEW +
                             DLG_BORDERREMOVE_SHOW_TOOL_ZOOMLEVEL;

   LEADDlgImgDoc1->BorderToRemove= BORDER_ALL;
   LEADDlgImgDoc1->BorderPercent= 20;
   LEADDlgImgDoc1->WhiteNoiseLength= 9;
   LEADDlgImgDoc1->Variance= 3;
   LEADDlgImgDoc1->ModificationColor= RGB (255, 0, 0);

   try
   {
      if((LEADImage1->HasRgn))
      {
         PrepareRgnProcessing ();
         LEADDlgImgDoc1->LEADImage= MainFrm->LEADImage2;
         int nRet= LEADDlgImgDoc1->ShowBorderRemoveDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            LEADImage1->BorderRemove (LEADDlgImgDoc1->ProcessFlags,
                                       LEADDlgImgDoc1->BorderToRemove,
                                       LEADDlgImgDoc1->BorderPercent,
                                       LEADDlgImgDoc1->WhiteNoiseLength ,
                                       LEADDlgImgDoc1->Variance);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgDoc1->DlgFlags= LEADDlgImgDoc1->DlgFlags + DLG_BORDERREMOVE_AUTOPROCESS;

         LEADDlgImgDoc1->LEADImage= LEADImage1;
         LEADDlgImgDoc1->ShowBorderRemoveDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuDocumentImagingHolePunchRemoval1Click(TObject *Sender)
{
   AnsiString Msg;

   Screen->Cursor=crHourGlass;

   try
   {
      LEADDlgImgDoc1->MinHoleWidth= 1;
      LEADDlgImgDoc1->MinHoleHeight= 1;
      LEADDlgImgDoc1->MinHoleCount= 2;
      LEADDlgImgDoc1->MaxHoleCount= 4;
      LEADDlgImgDoc1->MaxHoleWidth= 2;
      LEADDlgImgDoc1->MaxHoleHeight= 2;
      LEADDlgImgDoc1->Location= HOLEPUNCH_LEFT;
      LEADDlgImgDoc1->WhiteAreaColor= RGB (255, 0, 0);
      LEADDlgImgDoc1->BlackAreaColor= RGB (0, 0, 255);
      LEADDlgImgDoc1->ProcessFlags= HOLEPUNCH_USE_DPI |
                                    HOLEPUNCH_USE_COUNT |
                                    HOLEPUNCH_USE_LOCATION;

      LEADDlgImgDoc1->DlgFlags= DLG_HOLEPUNCHREMOVE_SHOW_PREVIEW |
                                DLG_HOLEPUNCHREMOVE_SHOW_TOOL_ZOOMLEVEL;
      if((LEADImage1->HasRgn))
      {
         PrepareRgnProcessing();
         LEADDlgImgDoc1->LEADImage= MainFrm->LEADImage2;
         int nRet= LEADDlgImgDoc1->ShowHolePunchRemoveDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            LEADImage1->HolePunchRemove(LEADDlgImgDoc1->ProcessFlags,
                                        LEADDlgImgDoc1->MinHoleCount,
                                        LEADDlgImgDoc1->MaxHoleCount,
                                        LEADDlgImgDoc1->MinHoleWidth,
                                        LEADDlgImgDoc1->MinHoleHeight,
                                        LEADDlgImgDoc1->MaxHoleWidth,
                                        LEADDlgImgDoc1->MaxHoleHeight,
                                        LEADDlgImgDoc1->Location);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgDoc1->DlgFlags= LEADDlgImgDoc1->DlgFlags + DLG_HOLEPUNCHREMOVE_AUTOPROCESS;

         LEADDlgImgDoc1->LEADImage= LEADImage1;
         LEADDlgImgDoc1->ShowHolePunchRemoveDlg (this);
      }
   }
   catch (const ELEADImageError &E)
   {
      Screen->Cursor= crDefault;
      MainFrm->DisplayErrorMsg(MainFrm->LEADImage2->ErrorMsg);
   }
   catch(ELEADDlgImgDocError &E)
   {
      Screen->Cursor= crDefault;
      MainFrm->DisplayErrorMsg(LEADDlgImgDoc1->ErrorMsg);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuCanvasResize1Click(TObject *Sender)
{
   LEADDlgImage1->CurrentHeight= LEADImage1->BitmapHeight;
   LEADDlgImage1->CurrentWidth= LEADImage1->BitmapWidth;
   LEADDlgImage1->NewHeight= LEADImage1->BitmapHeight;
   LEADDlgImage1->NewWidth= LEADImage1->BitmapWidth;
   LEADDlgImage1->DlgFlags= DLG_CANVASRESIZE_AUTOPROCESS +
                            DLG_CANVASRESIZE_SHOW_BACKCOLOR +
                            DLG_CANVASRESIZE_SHOW_CURRENT_HEIGHT +
                            DLG_CANVASRESIZE_SHOW_CURRENT_WIDTH +
                            DLG_CANVASRESIZE_SHOW_HORIZPOS +
                            DLG_CANVASRESIZE_SHOW_VERTPOS +
                            DLG_CANVASRESIZE_SHOW_KEEPASPECT;

   LEADDlgImage1->LEADImage= LEADImage1;
   LEADDlgImage1->ShowCanvasResizeDlg (this);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuResize1Click(TObject *Sender)
{
   L_INT nRet;

   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImage1->OriginalResolutionX= LEADImage1->BitmapXRes;
      LEADDlgImage1->OriginalResolutionY= LEADImage1->BitmapYRes;
      LEADDlgImage1->OriginalBitsPerPixel= LEADImage1->BitmapBits;

      LEADDlgImage1->DlgFlags= DLG_CANVASRESIZE_SHOW_BACKCOLOR +
                               DLG_CANVASRESIZE_SHOW_CURRENT_HEIGHT +
                               DLG_CANVASRESIZE_SHOW_CURRENT_WIDTH +
                               DLG_CANVASRESIZE_SHOW_HORIZPOS +
                               DLG_CANVASRESIZE_SHOW_VERTPOS +
                               DLG_CANVASRESIZE_SHOW_KEEPASPECT;


      LEADDlgImage1->LEADImage= LEADImage1;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         LEADDlgImage1->LEADImage= MainFrm->LEADImage2;
         LEADDlgImage1->OriginalWidth= MainFrm->LEADImage2->BitmapWidth;
         LEADDlgImage1->OriginalHeight= MainFrm->LEADImage2->BitmapHeight;

         nRet= LEADDlgImage1->ShowResizeDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Size (LEADDlgImage1->NewWidth, LEADDlgImage1->NewHeight, SIZE_NORMAL);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImage1->DlgFlags= LEADDlgImage1->DlgFlags + DLG_RESIZE_AUTOPROCESS;
         LEADDlgImage1->LEADImage= LEADImage1;
         LEADDlgImage1->OriginalWidth= LEADImage1->BitmapWidth;
         LEADDlgImage1->OriginalHeight= LEADImage1->BitmapHeight;
         LEADDlgImage1->OriginalResolutionX= LEADImage1->BitmapXRes;
         LEADDlgImage1->OriginalResolutionY= LEADImage1->BitmapYRes;
         LEADDlgImage1->OriginalBitsPerPixel= LEADImage1->BitmapBits;

         LEADDlgImage1->ShowResizeDlg (this);
      }
   }
   catch(ELEADImageError* e)
   {
      AnsiString strErr="Resize Failed:\n" + LEADImage1->ErrorMsg;
      Application->MessageBox(strErr.c_str (), "Error", MB_OK);
      Screen->Cursor=crDefault;
      return;
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuHistogram1Click(TObject *Sender)
{
   LEADDlgImage1->RedChannelPenColor= RGB (255, 0, 0);
   LEADDlgImage1->GreenChannelPenColor= RGB (0, 255, 0);
   LEADDlgImage1->BlueChannelPenColor= RGB (0, 0, 255);
   LEADDlgImage1->MasterPenColor= RGB (0, 0, 0);
   LEADDlgImage1->HistogramFlags= HIST_LOWHIGH_BITS;
   LEADDlgImage1->DlgFlags= DLG_HISTOGRAM_SHOW_VIEWSTYLE +
                            DLG_HISTOGRAM_USERPENCOLORS;

   LEADDlgImage1->LEADImage= LEADImage1;

   LEADDlgImage1->ShowHistogramDlg (this);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuBlurMotionBlur1Click(TObject *Sender)
{
   Screen->Cursor= crHourGlass;
   LEADDlgImgEffect1->DlgFlags= DLG_MOTIONBLUR_SHOW_PREVIEW +
                                DLG_MOTIONBLUR_SHOW_TOOL_ZOOMLEVEL;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;
         L_INT nRet= LEADDlgImgEffect1->ShowMotionBlurDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->MotionBlur (LEADDlgImgEffect1->Dimension,
                                              LEADDlgImgEffect1->Angle,
                                              LEADDlgImgEffect1->Unidirectional);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_MOTIONBLUR_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowMotionBlurDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor= crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuBlurRadialBlur1Click(TObject *Sender)
{
   Screen->Cursor= crHourGlass;
   LEADDlgImgEffect1->DlgFlags= DLG_RADIALBLUR_SHOW_PREVIEW +
                                DLG_RADIALBLUR_SHOW_TOOL_ZOOMLEVEL;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;
         L_INT nRet= LEADDlgImgEffect1->ShowRadialBlurDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->RadialBlur (LEADDlgImgEffect1->Dimension,
                                              LEADDlgImgEffect1->Stress,
                                              LEADDlgImgEffect1->CenterPoint);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_RADIALBLUR_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowRadialBlurDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor= crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuBlurZoomBlur1Click(TObject *Sender)
{
   Screen->Cursor= crHourGlass;
   LEADDlgImgEffect1->DlgFlags= DLG_ZOOMBLUR_SHOW_PREVIEW +
                                DLG_ZOOMBLUR_SHOW_TOOL_ZOOMLEVEL;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;
         L_INT nRet= LEADDlgImgEffect1->ShowZoomBlurDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->ZoomBlur (LEADDlgImgEffect1->Dimension,
                                            LEADDlgImgEffect1->Stress,
                                            LEADDlgImgEffect1->CenterPoint);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_ZOOMBLUR_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowZoomBlurDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor= crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuBlurGaussianBlur1Click(TObject *Sender)
{
   Screen->Cursor= crHourGlass;
   LEADDlgImgEffect1->DlgFlags= DLG_GAUSSIANBLUR_SHOW_PREVIEW +
                                DLG_GAUSSIANBLUR_SHOW_TOOL_ZOOMLEVEL;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;
         L_INT nRet= LEADDlgImgEffect1->ShowGaussianBlurDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->GaussianFilter (LEADDlgImgEffect1->Radius);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_GAUSSIANBLUR_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowGaussianBlurDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor= crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuBlurAntiAlias1Click(TObject *Sender)
{
   Screen->Cursor= crHourGlass;
   LEADDlgImgEffect1->DlgFlags= DLG_ANTIALIAS_SHOW_PREVIEW +
                                DLG_ANTIALIAS_SHOW_TOOL_ZOOMLEVEL;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;
         L_INT nRet= LEADDlgImgEffect1->ShowAntiAliasDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->AntiAlias (LEADDlgImgEffect1->Threshold,
                                             LEADDlgImgEffect1->Dimension,
                                             LEADDlgImgEffect1->AntiAliasFilterType);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_ANTIALIAS_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowAntiAliasDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor= crDefault; 
}
//---------------------------------------------------------------------------

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

   LEADDlgImgEffect1->DlgFlags= DLG_AVERAGE_SHOW_PREVIEW +
                                DLG_AVERAGE_SHOW_TOOL_ZOOMLEVEL;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowAverageDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Average (LEADDlgImgEffect1->Dimension);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_AVERAGE_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowAverageDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_MEDIAN_SHOW_PREVIEW +
                                   DLG_MEDIAN_SHOW_TOOL_ZOOMLEVEL;

      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowMedianDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Median (LEADDlgImgEffect1->Dimension);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_MEDIAN_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowMedianDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_ADDNOISE_SHOW_PREVIEW +
                                   DLG_ADDNOISE_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowAddNoiseDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->AddNoise (LEADDlgImgEffect1->Range, LEADDlgImgEffect1->Channel);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_ADDNOISE_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowAddNoiseDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuNoiseMax1Click(TObject *Sender)
{
   Screen->Cursor= crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_MAXFILTER_SHOW_PREVIEW +
                                   DLG_MAXFILTER_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         if(!LEADImage1->Floater)
         {
            LEADImage1->Floater= LEADImage1->Bitmap;

            LEADImage1->SetFloaterDstRect(
               LEADImage1->RgnLeft * LEADImage1->DstWidth / LEADImage1->BitmapWidth + LEADImage1->DstLeft,
               LEADImage1->RgnTop * LEADImage1->DstHeight / LEADImage1->BitmapHeight + LEADImage1->DstTop,
               LEADImage1->RgnWidth * LEADImage1->DstWidth / LEADImage1->BitmapWidth,
               LEADImage1->RgnHeight * LEADImage1->DstHeight / LEADImage1->BitmapHeight);
         }

         MainFrm->LEADImage2->Bitmap = LEADImage1->Floater;

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowMaxFilterDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->MaxFilter (LEADDlgImgEffect1->Dimension);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_MAXFILTER_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowMaxFilterDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuNoiseMin1Click(TObject *Sender)
{
   Screen->Cursor= crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_MINFILTER_SHOW_PREVIEW +
                                   DLG_MINFILTER_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowMinFilterDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->MinFilter (LEADDlgImgEffect1->Dimension);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_MINFILTER_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowMinFilterDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSharpenUnsharpMask1Click(TObject *Sender)
{
   Screen->Cursor= crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_UNSHARPMASK_SHOW_PREVIEW +
                                   DLG_UNSHARPMASK_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowUnsharpMaskDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->UnsharpMask (LEADDlgImgEffect1->Amount,
                                             LEADDlgImgEffect1->Radius,
                                             LEADDlgImgEffect1->Threshold,
                                             LEADDlgImgEffect1->UnshrpMaskFlags);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_UNSHARPMASK_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowUnsharpMaskDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_SHARPEN_SHOW_PREVIEW +
                                   DLG_SHARPEN_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowSharpenDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Sharpen (LEADDlgImgEffect1->Sharpness);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_SHARPEN_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowSharpenDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_MULTIPLY_SHOW_PREVIEW +
                                   DLG_MULTIPLY_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowMultiplyDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Multiply (LEADDlgImgEffect1->Sharpness);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_MULTIPLY_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowMultiplyDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuCalculationsAddBitmaps1Click(
      TObject *Sender)
{
   MainFrm->mnuCalculationsAddBitmaps1Click (Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuCalculationsStitch1Click(TObject *Sender)
{
   MainFrm->mnuCalculationsStitch1Click (Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuDistortFreehandWave1Click(TObject *Sender)
{
   L_UINT i;
   L_INT Amplitudes[256];

   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_FREEHANDWAVE_SHOW_PREVIEW +
                                   DLG_FREEHANDWAVE_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowFreeHandWaveDlg (this);
         if(nRet == SUCCESS_DLG_OK)
         {
            for (i= 0; i < LEADDlgImgEffect1->AmplitudesCount; i ++)
            {
               Amplitudes[i]= LEADDlgImgEffect1->Amplitudes [i];
            }
            MainFrm->LEADImage2->FreeHandWave (Amplitudes,
                                                LEADDlgImgEffect1->AmplitudesCount,
                                                LEADDlgImgEffect1->Scale,
                                                LEADDlgImgEffect1->WaveLength,
                                                LEADDlgImgEffect1->Angle,
                                                LEADDlgImgEffect1->FillColor,
                                                LEADDlgImgEffect1->FreeHandWaveFlags);
         }

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_FREEHANDWAVE_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowFreeHandWaveDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_WIND_SHOW_PREVIEW +
                                   DLG_WIND_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowWindDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Wind (LEADDlgImgEffect1->Dimension,
                                        LEADDlgImgEffect1->Angle,
                                        LEADDlgImgEffect1->Opacity);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_WIND_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowWindDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_POLAR_SHOW_PREVIEW +
                                   DLG_POLAR_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowPolarDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Polar (LEADDlgImgEffect1->FillColor,
                                         LEADDlgImgEffect1->PolarFlags);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_POLAR_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowPolarDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;  
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_ZOOMWAVE_SHOW_PREVIEW +
                                   DLG_ZOOMWAVE_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowZoomWaveDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->ZoomWave (LEADDlgImgEffect1->Amplitude,
                                          LEADDlgImgEffect1->Frequency,
                                          LEADDlgImgEffect1->Phase,
                                          LEADDlgImgEffect1->ZoomFactor,
                                          LEADDlgImgEffect1->CenterPoint,
                                          LEADDlgImgEffect1->FillColor,
                                          LEADDlgImgEffect1->ZoomWaveFlags);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_ZOOMWAVE_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowZoomWaveDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor= crDefault; 
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_RADIALWAVE_SHOW_PREVIEW +
                                   DLG_RADIALWAVE_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowRadialWaveDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->RadWave (LEADDlgImgEffect1->Amplitude,
                                         LEADDlgImgEffect1->WaveLength,
                                         LEADDlgImgEffect1->Phase,
                                         LEADDlgImgEffect1->CenterPoint,
                                         LEADDlgImgEffect1->FillColor,
                                         LEADDlgImgEffect1->RadialWaveFlags);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_RADIALWAVE_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowRadialWaveDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;  
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_SWIRL_SHOW_PREVIEW +
                                   DLG_SWIRL_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowSwirlDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Swirl (LEADDlgImgEffect1->Angle,
                                         LEADDlgImgEffect1->CenterPoint);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_SWIRL_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowSwirlDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;  
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_WAVE_SHOW_PREVIEW +
                                   DLG_WAVE_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowWaveDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Wave (LEADDlgImgEffect1->Amplitude,
                                        LEADDlgImgEffect1->WaveLength,
                                        LEADDlgImgEffect1->Angle,
                                        LEADDlgImgEffect1->HorzScale,
                                        LEADDlgImgEffect1->VertScale,
                                        LEADDlgImgEffect1->FillColor,
                                        LEADDlgImgEffect1->WaveFlags);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_WAVE_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowWaveDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;  
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuDistortFreehandShear1Click(TObject *Sender)
{
   L_UINT i;
   L_INT Amplitudes [256];

   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_FREEHANDSHEAR_SHOW_PREVIEW +
                                   DLG_FREEHANDSHEAR_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowFreeHandShearDlg (this);
         if(nRet == SUCCESS_DLG_OK)
         {
            for (i= 0; i < LEADDlgImgEffect1->AmplitudesCount; i ++);
            {
               Amplitudes[i]= LEADDlgImgEffect1->Amplitudes [i];
            }

            MainFrm->LEADImage2->FreeHandShear (Amplitudes,
                                                 LEADDlgImgEffect1->AmplitudesCount,
                                                 LEADDlgImgEffect1->Scale,
                                                 LEADDlgImgEffect1->FillColor,
                                                 LEADDlgImgEffect1->FreeHandShearFlags);

         }
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_FREEHANDSHEAR_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowFreeHandShearDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_EMBOSS_SHOW_PREVIEW +
                                   DLG_EMBOSS_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowEmbossDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Emboss (LEADDlgImgEffect1->Direction,
                                          LEADDlgImgEffect1->Depth);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_EMBOSS_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowEmbossDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;  
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_PUNCH_SHOW_PREVIEW +
                                   DLG_PUNCH_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowPunchDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Punch (LEADDlgImgEffect1->Value,
                                         LEADDlgImgEffect1->Stress,
                                         LEADDlgImgEffect1->CenterPoint,
                                         LEADDlgImgEffect1->FillColor,
                                         LEADDlgImgEffect1->PunchFlags);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_PUNCH_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowPunchDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;  
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_RIPPLE_SHOW_PREVIEW +
                                   DLG_RIPPLE_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowRippleDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Ripple (LEADDlgImgEffect1->Amplitude,
                                          LEADDlgImgEffect1->Frequency,
                                          LEADDlgImgEffect1->Phase,
                                          LEADDlgImgEffect1->Attenuation,
                                          LEADDlgImgEffect1->CenterPoint,
                                          LEADDlgImgEffect1->FillColor,
                                          LEADDlgImgEffect1->RippleFlags);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_RIPPLE_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowRippleDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;  
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_BENDING_SHOW_PREVIEW +
                                   DLG_BENDING_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowBendingDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Bending (LEADDlgImgEffect1->Value,
                                           LEADDlgImgEffect1->CenterPoint,
                                           LEADDlgImgEffect1->FillColor,
                                           LEADDlgImgEffect1->BendingFlags);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_BENDING_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowBendingDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;  
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_CYLINDRICAL_SHOW_PREVIEW +
                                   DLG_CYLINDRICAL_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowCylindricalDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Cylindrical (LEADDlgImgEffect1->Value,
                                               LEADDlgImgEffect1->CylindricalType);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_CYLINDRICAL_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowCylindricalDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;  
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnu3DEffectsSpherize1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_SPHERIZE_SHOW_PREVIEW +
                                   DLG_SPHERIZE_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowSpherizeDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Spherize (LEADDlgImgEffect1->Value,
                                            LEADDlgImgEffect1->CenterPoint,
                                            LEADDlgImgEffect1->FillColor,
                                            LEADDlgImgEffect1->SpherizeFlags);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_SPHERIZE_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowSpherizeDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuArtisticImpressionist1Click(
      TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_IMPRESSIONIST_SHOW_PREVIEW +
                                   DLG_IMPRESSIONIST_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowImpressionistDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Impressionist (LEADDlgImgEffect1->HorizontalDim,
                                                 LEADDlgImgEffect1->VerticalDim);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_IMPRESSIONIST_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowImpressionistDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuArtisticOilify1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_OILIFY_SHOW_PREVIEW +
                                   DLG_OILIFY_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowOilifyDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Oilify (LEADDlgImgEffect1->Dimension);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_OILIFY_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowOilifyDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;  
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuTextureUnderlay1Click(TObject *Sender)
{
   L_INT nRet= LoadUserCustomBitmaps ("Select Underlay Images Folder", DLGIMAGEEFX_CONTROL);
   if(nRet == SUCCESS)
   {
      Screen->Cursor=crHourGlass;
      try
      {
         LEADDlgImgEffect1->DlgFlags= DLG_UNDERLAY_SHOW_PREVIEW +
                                      DLG_UNDERLAY_SHOW_TOOL_ZOOMLEVEL;
         if(LEADImage1->HasRgn)
         {
            PrepareRgnProcessing ();

            LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

            nRet= LEADDlgImgEffect1->ShowUnderlayDlg (this);
            if(nRet == SUCCESS_DLG_OK)
               MainFrm->LEADImage2->Underlay (LEADDlgImgEffect1->SelectedBitmap,
                                               LEADDlgImgEffect1->UnderlayFlags);
            FinishRgnProcessing ();
         }
         else
         {
            LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_UNDERLAY_AUTOPROCESS;

            LEADDlgImgEffect1->LEADImage= LEADImage1;
            LEADDlgImgEffect1->ShowUnderlayDlg (this);
         }
      }
      catch (const Exception &E)
      {
         MainFrm->DisplayErrorMsg (E.Message);
      }
      Screen->Cursor=crDefault;
   }  
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuPixelatePixelate1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_PIXELATE_SHOW_PREVIEW +
                                   DLG_PIXELATE_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowPixelateDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Pixelate (LEADDlgImgEffect1->CellWidth,
                                          LEADDlgImgEffect1->CellHeight,
                                          LEADDlgImgEffect1->Opacity,
                                          LEADDlgImgEffect1->CenterPoint,
                                          LEADDlgImgEffect1->PixelateFlags);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_PIXELATE_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowPixelateDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuPixelateMosaic1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_MOSAIC_SHOW_PREVIEW +
                                   DLG_MOSAIC_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowMosaicDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Mosaic (LEADDlgImgEffect1->Dimension);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_MOSAIC_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowMosaicDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuPixelatePicturize1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->CellWidth= 10;
      LEADDlgImgEffect1->CellHeight= 8;
      LEADDlgImgEffect1->PicturizeResizeFlags= PICTURIZE_RESAMPLE +
                                               PICTURIZE_LOADALL;

      LEADDlgImgEffect1->DlgFlags= 0;

      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;
         LEADDlgImgEffect1->BitmapWidth= MainFrm->LEADImage2->BitmapWidth;
         LEADDlgImgEffect1->BitmapHeight= MainFrm->LEADImage2->BitmapHeight;

         L_INT nRet= LEADDlgImgEffect1->ShowPicturizeDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Picturize (LEADDlgImgEffect1->DirectoryPath,
                                             LEADDlgImgEffect1->PicturizeResizeFlags,
                                             LEADDlgImgEffect1->CellWidth,
                                             LEADDlgImgEffect1->CellHeight);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_PICTURIZE_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->BitmapWidth= LEADImage1->BitmapWidth;
         LEADDlgImgEffect1->BitmapHeight= LEADImage1->BitmapHeight;

         LEADDlgImgEffect1->ShowPicturizeDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuEdgeDetect1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_EDGEDETECTOR_SHOW_PREVIEW +
                                   DLG_EDGEDETECTOR_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowEdgeDetectorDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->EdgeDetector (LEADDlgImgEffect1->Threshold,
                                              LEADDlgImgEffect1->EdgeDetectionFilterType);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_EDGEDETECTOR_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowEdgeDetectorDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuEdgeErosion1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_EROSIONFILTER_SHOW_PREVIEW +
                                   DLG_EROSIONFILTER_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowErosionFilterDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->BinaryFilter (LEADDlgImgEffect1->BinaryFilterType);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_EROSIONFILTER_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowErosionFilterDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;  
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuEdgeDilation1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_DILATIONFILTER_SHOW_PREVIEW +
                                   DLG_DILATIONFILTER_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowDilationFilterDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->BinaryFilter (LEADDlgImgEffect1->BinaryFilterType);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_DILATIONFILTER_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowDilationFilterDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuEdgeContour1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {

      LEADDlgImgEffect1->OptionFlags= DLG_CONTOURFILTER_SHOW_OPTION_THIN        +
                                      DLG_CONTOURFILTER_SHOW_OPTION_LINK_BW     +
                                      DLG_CONTOURFILTER_SHOW_OPTION_LINK_GRAY   +
                                      DLG_CONTOURFILTER_SHOW_OPTION_LINK_COLOR  +
                                      DLG_CONTOURFILTER_SHOW_OPTION_APPROX_COLOR;

      LEADDlgImgEffect1->DlgFlags= DLG_CONTOURFILTER_SHOW_PREVIEW +
                                   DLG_CONTOURFILTER_SHOW_OPTION     +
                                   DLG_CONTOURFILTER_SHOW_THRESHOLD  +
                                   DLG_CONTOURFILTER_SHOW_DELTADIRECTION   +
                                   DLG_CONTOURFILTER_SHOW_MAXIMUMERROR  +
                                   DLG_CONTOURFILTER_SHOW_TOOL_ZOOMLEVEL;
                                   
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowContourFilterDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->ContourFilter (LEADDlgImgEffect1->Threshold,
                                               LEADDlgImgEffect1->DeltaDirection,
                                               LEADDlgImgEffect1->MaxError,
                                               LEADDlgImgEffect1->Option);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_CONTOURFILTER_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowContourFilterDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSpatialFiltersGradient1Click(
      TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_GRADIENTFILTER_SHOW_PREVIEW +
                                   DLG_GRADIENTFILTER_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowGradientFilterDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->SpatialFilter (LEADDlgImgEffect1->SpatialFilterType);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_GRADIENTFILTER_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowGradientFilterDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSpatialFiltersLaplacian1Click(
      TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_LAPLACIANFILTER_SHOW_PREVIEW +
                                   DLG_LAPLACIANFILTER_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowLaplacianFilterDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->SpatialFilter (LEADDlgImgEffect1->SpatialFilterType);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_LAPLACIANFILTER_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowLaplacianFilterDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSpatialFiltersSobel1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_SOBELFILTER_SHOW_PREVIEW +
                                   DLG_SOBELFILTER_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowSobelFilterDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->SpatialFilter (LEADDlgImgEffect1->SpatialFilterType);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_SOBELFILTER_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowSobelFilterDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSpatialFiltersPrewitt1Click(
      TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_PREWITTFILTER_SHOW_PREVIEW +
                                   DLG_PREWITTFILTER_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowPrewittFilterDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->SpatialFilter (LEADDlgImgEffect1->SpatialFilterType);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_PREWITTFILTER_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowPrewittFilterDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSpatialFiltersShiftandDifference1Click(
      TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_SHIFTDIFFERENCEFILTER_SHOW_PREVIEW +
                                   DLG_SHIFTDIFFERENCEFILTER_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowShiftDifferenceFilterDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->SpatialFilter (LEADDlgImgEffect1->SpatialFilterType);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_SHIFTDIFFERENCEFILTER_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowShiftDifferenceFilterDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;  
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSpatialFiltersLineSegment1Click(
      TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgImgEffect1->DlgFlags= DLG_LINESEGMENTFILTER_SHOW_PREVIEW +
                                   DLG_LINESEGMENTFILTER_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgImgEffect1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgImgEffect1->ShowLineSegmentFilterDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->SpatialFilter (LEADDlgImgEffect1->SpatialFilterType);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgImgEffect1->DlgFlags= LEADDlgImgEffect1->DlgFlags + DLG_LINESEGMENTFILTER_AUTOPROCESS;

         LEADDlgImgEffect1->LEADImage= LEADImage1;
         LEADDlgImgEffect1->ShowLineSegmentFilterDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuColorClick(TObject *Sender)
{
   if((LEADImage1->IsGrayScale != GRAY_NO) &&
      ((LEADImage1->BitmapBits == 12) || (LEADImage1->BitmapBits == 16)))
      mnuWindowLevel1->Enabled= true;
   else
      mnuWindowLevel1->Enabled= false;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuInvert1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         MainFrm->LEADImage2->Invert ();
         FinishRgnProcessing ();
      }
      else
         LEADImage1->Invert ();

   }
   catch(ELEADImageError* e)
   {
      AnsiString strErr="Invert Failed:\n" + LEADImage1->ErrorMsg;
      Application->MessageBox(strErr.c_str (), "Error", MB_OK);
      Screen->Cursor=crDefault;
      return;
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuGrayScale8Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADImage1->GrayScale(8);
         MainFrm->LEADImage2->GrayScale(8);

         FinishRgnProcessing ();
      }
      else
         LEADImage1->GrayScale(8);
   }
   catch(ELEADImageError* e)
   {
      AnsiString strErr="GrayScale 8 Bit Failed:\n" + LEADImage1->ErrorMsg;
      Application->MessageBox(strErr.c_str (), "Error", MB_OK);
      Screen->Cursor=crDefault;
      return;
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuGrayScale12Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADImage1->GrayScale(12);
         MainFrm->LEADImage2->GrayScale(12);

         FinishRgnProcessing ();
      }
      else
         LEADImage1->GrayScale(12);
   }
   catch(ELEADImageError* e)
   {
      AnsiString strErr="GrayScale 12 Bit Failed:\n" + LEADImage1->ErrorMsg;
      Application->MessageBox(strErr.c_str (), "Error", MB_OK);
      Screen->Cursor=crDefault;
      return;
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuGrayScale16Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADImage1->GrayScale(16);
         MainFrm->LEADImage2->GrayScale(16);

         FinishRgnProcessing ();
      }
      else
         LEADImage1->GrayScale(16);
   }
   catch(ELEADImageError* e)
   {
      AnsiString strErr="GrayScale 16 Bit Failed:\n" + LEADImage1->ErrorMsg;
      Application->MessageBox(strErr.c_str (), "Error", MB_OK);
      Screen->Cursor=crDefault;
      return;
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuWindowLevel1Click(TObject *Sender)
{

   Screen->Cursor= crHourGlass;

   LEADImage1->GetMinMaxBits ();
   LEADImage1->GetMinMaxVal ();

   LEADDlgColor1->WindowLevelLowBit= LEADImage1->MinBit;
   LEADDlgColor1->WindowLevelHighBit= LEADImage1->MaxBit;
   LEADDlgColor1->WindowLevelLow= LEADImage1->MinVal;
   LEADDlgColor1->WindowLevelHigh= LEADImage1->MaxVal;

   LEADDlgColor1->WindowLevelFlags= FILLLUT_OUTSIDE + FILLLUT_LINEAR;
   LEADDlgColor1->DlgFlags= DLG_WINDOWLEVEL_AUTOPROCESS +
                            DLG_WINDOWLEVEL_SHOW_PREVIEW +
                            DLG_WINDOWLEVEL_SHOW_TOOL_ZOOMLEVEL +
                            DLG_WINDOWLEVEL_SHOW_RANGE;
   LEADDlgColor1->LEADImage= LEADImage1;

   switch (LEADImage1->IsGrayScale)
   {
      case GRAY_ORDEREDNORMAL:
      {
         LEADDlgColor1->WindowLevelStartColor= RGB (0, 0, 0);
         LEADDlgColor1->WindowLevelEndColor= RGB (255, 255, 255);
      }
      break;

      case GRAY_ORDEREDINVERSE:
      {
         LEADDlgColor1->WindowLevelStartColor= RGB (255, 255, 255);
         LEADDlgColor1->WindowLevelEndColor= RGB (0, 0, 0);
      }
      break;

      case GRAY_NOTORDERED:
      {
         LEADDlgColor1->WindowLevelStartColor= RGB (0, 0, 0);
         LEADDlgColor1->WindowLevelEndColor= RGB (255, 255, 255);
      }
      break;

      default:
      {
         ShowMessage ("Window Level is not supported for this bitmap order");
         return;
      }
   }
   try
   {
      L_INT nRet= LEADDlgColor1->ShowWindowLevelDlg (this);

      if((nRet == SUCCESS_DLG_OK) && (LEADImage1->Floater != NULL))
      {
         // just update the floater
         PrepareRgnProcessing();
         FinishRgnProcessing();
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
      Screen->Cursor= crDefault;
      return;
   }
   Screen->Cursor= crDefault;
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgColor1->Channel= IDB_CHANNEL_MASTER;
      LEADDlgColor1->DlgFlags= DLG_INTENSITYDETECT_SHOW_PREVIEW +
                               DLG_INTENSITYDETECT_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         LEADDlgColor1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgColor1->ShowIntensityDetectDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->IntensityDetect (LEADDlgColor1->IntensityLow,
                                                   LEADDlgColor1->IntensityHigh,
                                                   LEADDlgColor1->IntensityInColor,
                                                   LEADDlgColor1->IntensityOutColor,
                                                   LEADDlgColor1->Channel);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgColor1->DlgFlags= LEADDlgColor1->DlgFlags + DLG_INTENSITYDETECT_AUTOPROCESS;

         LEADDlgColor1->LEADImage= LEADImage1;
         LEADDlgColor1->ShowIntensityDetectDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSolarize1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgColor1->DlgFlags= DLG_SOLARIZE_SHOW_PREVIEW +
                               DLG_SOLARIZE_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         LEADDlgColor1->LEADImage= MainFrm->LEADImage2;

         int nRet= LEADDlgColor1->ShowSolarizeDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Solarize (LEADDlgColor1->Threshold);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgColor1->DlgFlags= LEADDlgColor1->DlgFlags + DLG_SOLARIZE_AUTOPROCESS;

         LEADDlgColor1->LEADImage= LEADImage1;
         LEADDlgColor1->ShowSolarizeDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgColor1->DlgFlags= DLG_POSTERIZE_SHOW_PREVIEW +
                               DLG_POSTERIZE_SHOW_TOOL_ZOOMLEVEL;

      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         LEADDlgColor1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgColor1->ShowPosterizeDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Posterize (LEADDlgColor1->Levels);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgColor1->DlgFlags= LEADDlgColor1->DlgFlags + DLG_POSTERIZE_AUTOPROCESS;

         LEADDlgColor1->LEADImage= LEADImage1;
         LEADDlgColor1->ShowPosterizeDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor= crDefault;
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgColor1->DlgFlags= DLG_BRIGHTNESS_SHOW_PREVIEW +
                               DLG_BRIGHTNESS_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgColor1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgColor1->ShowBrightnessDlg (this);

         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Intensity (LEADDlgColor1->Change);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgColor1->DlgFlags= LEADDlgColor1->DlgFlags + DLG_BRIGHTNESS_AUTOPROCESS;
         
         LEADDlgColor1->LEADImage= LEADImage1;
         LEADDlgColor1->ShowBrightnessDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;  
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgColor1->DlgFlags= DLG_CONTRAST_SHOW_PREVIEW +
                               DLG_CONTRAST_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgColor1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgColor1->ShowContrastDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Contrast (LEADDlgColor1->Change);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgColor1->DlgFlags= LEADDlgColor1->DlgFlags + DLG_CONTRAST_AUTOPROCESS;

         LEADDlgColor1->LEADImage= LEADImage1;
         LEADDlgColor1->ShowContrastDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgColor1->DlgFlags= DLG_HUE_SHOW_PREVIEW +
                               DLG_HUE_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgColor1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgColor1->ShowHueDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Hue (LEADDlgColor1->Angle);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgColor1->DlgFlags= LEADDlgColor1->DlgFlags + DLG_HUE_AUTOPROCESS;

         LEADDlgColor1->LEADImage= LEADImage1;
         LEADDlgColor1->ShowHueDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgColor1->DlgFlags= DLG_SATURATION_SHOW_PREVIEW +
                               DLG_SATURATION_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgColor1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgColor1->ShowSaturationDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->Saturation (LEADDlgColor1->Change);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgColor1->DlgFlags= LEADDlgColor1->DlgFlags + DLG_SATURATION_AUTOPROCESS;

         LEADDlgColor1->LEADImage= LEADImage1;
         LEADDlgColor1->ShowSaturationDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;  
}
//---------------------------------------------------------------------------

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

   try
   {
      LEADDlgColor1->DlgFlags= DLG_GAMMAADJUSTMENT_SHOW_PREVIEW +
                               DLG_GAMMAADJUSTMENT_SHOW_TOOL_ZOOMLEVEL +
                               DLG_GAMMAADJUSTMENT_FORCELINKCHANNELS;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgColor1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgColor1->ShowGammaAdjustmentDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->GammaCorrect (LEADDlgColor1->GammaBlueValue);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgColor1->DlgFlags= LEADDlgColor1->DlgFlags + DLG_GAMMAADJUSTMENT_AUTOPROCESS;

         LEADDlgColor1->LEADImage= LEADImage1;
         LEADDlgColor1->ShowGammaAdjustmentDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuAdjustBalanceColors1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgColor1->DlgFlags= DLG_BALANCECOLORS_SHOW_PREVIEW +
                               DLG_BALANCECOLORS_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgColor1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgColor1->ShowBalanceColorsDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->BalanceColors (LEADDlgColor1->BalanceRedFactor,
                                               LEADDlgColor1->BalanceGreenFactor,
                                               LEADDlgColor1->BalanceBlueFactor);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgColor1->DlgFlags= LEADDlgColor1->DlgFlags + DLG_BALANCECOLORS_AUTOPROCESS;

         LEADDlgColor1->LEADImage= LEADImage1;
         LEADDlgColor1->ShowBalanceColorsDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuTransformHalftone1Click(TObject *Sender)
{
   Screen->Cursor= crHourGlass;
   L_INT nRet= LoadUserCustomBitmaps ("Select Images Folder", DLGCOLOR_CONTROL);
   if(nRet == SUCCESS)
   {
      LEADDlgColor1->DlgFlags= DLG_HALFTONE_SHOW_PREVIEW +
                               DLG_HALFTONE_AUTOPROCESS +
                               DLG_HALFTONE_SHOW_TOOL_ZOOMLEVEL;

      LEADDlgColor1->LEADImage= LEADImage1;
      LEADDlgColor1->ShowHalftoneDlg (this);
   }
   Screen->Cursor= crDefault;   
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuTransformColorResolution1Click(
      TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgColor1->DlgFlags= DLG_COLORRES_SHOW_PREVIEW +
                               DLG_COLORRES_SHOW_ORDER +
                               DLG_COLORRES_SHOW_TOOL_ZOOMLEVEL;

      LEADDlgColor1->DlgFlagsEx= DLG_COLORRES_SHOW_BITALL +
                                 DLG_COLORRES_SHOW_DITHER_ALL +
                                 DLG_COLORRES_SHOW_PAL_ALL;

      LEADDlgColor1->BitsPerPixel= LEADImage1->BitmapBits;

      if(LEADImage1->HasRgn)
      {
         LEADDlgColor1->LEADImage= LEADImage1;
         L_INT nRet= LEADDlgColor1->ShowColorResDlg (this);
         if(nRet == SUCCESS_DLG_OK)
         {
            PrepareRgnProcessing ();
            if((LEADDlgColor1->BitsPerPixel <= 8) &&
                 (LEADDlgColor1->UserPaletteColorsCount > 0))
            {
               for (UINT i= 0; i < LEADDlgColor1->UserPaletteColorsCount; i ++)
               {
                  LEADImage1->UserPalette[i]= LEADDlgColor1->UserPaletteColors[i];
                  MainFrm->LEADImage2->UserPalette[i]= LEADDlgColor1->UserPaletteColors[i];
               }
               LEADImage1->ColorRes (LEADDlgColor1->BitsPerPixel,
                                      LEADDlgColor1->PaletteFlags,
                                      LEADDlgColor1->DitherFlags,
                                      LEADDlgColor1->UserPaletteColorsCount);
               MainFrm->LEADImage2->ColorRes (LEADDlgColor1->BitsPerPixel,
                                               LEADDlgColor1->PaletteFlags,
                                               LEADDlgColor1->DitherFlags,
                                               LEADDlgColor1->UserPaletteColorsCount);
            }
            else
            {
               LEADImage1->ColorRes (LEADDlgColor1->BitsPerPixel,
                                      LEADDlgColor1->PaletteFlags,
                                      LEADDlgColor1->DitherFlags,
                                      0);
               MainFrm->LEADImage2->ColorRes (LEADDlgColor1->BitsPerPixel,
                                               LEADDlgColor1->PaletteFlags,
                                               LEADDlgColor1->DitherFlags,
                                               0);
            }
            FinishRgnProcessing ();
         }
      }
      else
      {
         LEADDlgColor1->LEADImage= LEADImage1;
         LEADDlgColor1->DlgFlags= LEADDlgColor1->DlgFlags + DLG_COLORRES_AUTOPROCESS;
         LEADDlgColor1->ShowColorResDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor= crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuTransformGrayScale1Click(TObject *Sender)
{
   Screen->Cursor= crHourGlass;
   try
   {
      LEADDlgColor1->RedFactor= 333;
      LEADDlgColor1->GreenFactor= 333;
      LEADDlgColor1->BlueFactor= 334;
      LEADDlgColor1->DlgFlags= DLG_GRAYSCALE_SHOW_PREVIEW +
                               DLG_GRAYSCALE_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgColor1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgColor1->ShowGrayScaleDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->GrayScaleExt (LEADDlgColor1->RedFactor,
                                              LEADDlgColor1->GreenFactor,
                                              LEADDlgColor1->BlueFactor);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgColor1->DlgFlags= LEADDlgColor1->DlgFlags + DLG_GRAYSCALE_AUTOPROCESS;

         LEADDlgColor1->LEADImage= LEADImage1;
         LEADDlgColor1->ShowGrayScaleDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;  
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuTransformColoredGray1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgColor1->RedFactor= 333;
      LEADDlgColor1->GreenFactor= 333;
      LEADDlgColor1->BlueFactor= 334;
      LEADDlgColor1->DlgFlags= DLG_COLOREDGRAY_SHOW_PREVIEW +
                               DLG_COLOREDGRAY_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgColor1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgColor1->ShowColoredGrayDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->ConvertToColoredGray (LEADDlgColor1->RedFactor,
                                                      LEADDlgColor1->GreenFactor,
                                                      LEADDlgColor1->BlueFactor,
                                                      LEADDlgColor1->RedGrayFactor,
                                                      LEADDlgColor1->GreenGrayFactor,
                                                      LEADDlgColor1->BlueGrayFactor);
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgColor1->DlgFlags= LEADDlgColor1->DlgFlags + DLG_COLOREDGRAY_AUTOPROCESS;

         LEADDlgColor1->LEADImage= LEADImage1;
         LEADDlgColor1->ShowColoredGrayDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuRemapIntensity1Click(TObject *Sender)
{
   L_UINT i;

   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgColor1->DlgFlags= DLG_REMAPINTENSITY_SHOW_PREVIEW +
                               DLG_REMAPINTENSITY_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgColor1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgColor1->ShowRemapIntensityDlg (this);
         if(nRet == SUCCESS_DLG_OK)
         {
            MainFrm->LEADImage2->RemapTableSize= LEADDlgColor1->RemapIntensityTableSize;
            for (i= 0; i < LEADDlgColor1->RemapIntensityTableSize; i ++)
            {
               MainFrm->LEADImage2->RemapTable[i]= LEADDlgColor1->RemapIntensityTable[i];
            }
            MainFrm->LEADImage2->RemapIntensity (LEADDlgColor1->Channel);
         }
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgColor1->DlgFlags= LEADDlgColor1->DlgFlags + DLG_REMAPINTENSITY_AUTOPROCESS;

         LEADDlgColor1->LEADImage= LEADImage1;
         LEADDlgColor1->ShowRemapIntensityDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuRemapHue1Click(TObject *Sender)
{
   L_UINT i;

   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgColor1->DlgFlags= DLG_REMAPHUE_SHOW_PREVIEW +
                               DLG_REMAPHUE_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgColor1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgColor1->ShowRemapHueDlg (this);
         if(nRet == SUCCESS_DLG_OK)
         {
            MainFrm->LEADImage2->RemapHueTablesSize= LEADDlgColor1->RemapHueTableSize;
            for (i= 0; i < LEADDlgColor1->RemapHueTableSize; i ++)
            {
               MainFrm->LEADImage2->MaskTable[i]= LEADDlgColor1->RemapHueMaskTable[i];
               MainFrm->LEADImage2->HTable[i]= LEADDlgColor1->RemapHueHTable[i];
               MainFrm->LEADImage2->STable[i]= LEADDlgColor1->RemapHueSTable[i];
               MainFrm->LEADImage2->VTable[i]= LEADDlgColor1->RemapHueVTable[i];                                             
            }
            MainFrm->LEADImage2->RemapHue (True,
                                            True,
                                            True,
                                            True);
         }
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgColor1->DlgFlags= LEADDlgColor1->DlgFlags + DLG_REMAPHUE_AUTOPROCESS;

         LEADDlgColor1->LEADImage= LEADImage1;
         LEADDlgColor1->ShowRemapHueDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuHistogramEqualize1Click(TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         MainFrm->LEADImage2->HistoEqualize (GRAY_SPACE);
         FinishRgnProcessing ();
      }
      else
      {
         LEADImage1->HistoEqualize (GRAY_SPACE);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;  
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuHistogramStretchIntensity1Click(
      TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();
         MainFrm->LEADImage2->StretchIntensity ();
         FinishRgnProcessing ();
      }
      else
      {
         LEADImage1->StretchIntensity ();
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuHistogramLocalEqualize1Click(
      TObject *Sender)
{
   Screen->Cursor=crHourGlass;
   try
   {
      LEADDlgColor1->DlgFlags= DLG_LOCALHISTOEQUALIZE_SHOW_PREVIEW +
                               DLG_LOCALHISTOEQUALIZE_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgColor1->LEADImage= MainFrm->LEADImage2;

         LEADDlgColor1->RectWidth= MainFrm->LEADImage2->BitmapWidth;
         LEADDlgColor1->RectHeight= MainFrm->LEADImage2->BitmapHeight;
         L_INT nRet= LEADDlgColor1->ShowLocalHistoEqualizeDlg (this);
         if(nRet == SUCCESS_DLG_OK)
         {
            MainFrm->LEADImage2->LocalHistoEqualize (LEADDlgColor1->RectWidth,
                                                    LEADDlgColor1->RectHeight,
                                                    LEADDlgColor1->XExtension,
                                                    LEADDlgColor1->YExtension,
                                                    LEADDlgColor1->ColorSpace,
                                                    LEADDlgColor1->SmoothSize);
         }
         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgColor1->DlgFlags= LEADDlgColor1->DlgFlags + DLG_LOCALHISTOEQUALIZE_AUTOPROCESS;
         LEADDlgColor1->RectWidth= LEADImage1->BitmapWidth;
         LEADDlgColor1->RectHeight= LEADImage1->BitmapHeight;

         LEADDlgColor1->LEADImage= LEADImage1;
         LEADDlgColor1->ShowLocalHistoEqualizeDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuHistogramContrast1Click(TObject *Sender)
{
   Screen->Cursor= crHourGlass;
   try
   {
      LEADDlgColor1->DlgFlags= DLG_HISTOCONTRAST_SHOW_PREVIEW +
                               DLG_HISTOCONTRAST_SHOW_TOOL_ZOOMLEVEL;
      if(LEADImage1->HasRgn)
      {
         PrepareRgnProcessing ();

         LEADDlgColor1->LEADImage= MainFrm->LEADImage2;

         L_INT nRet= LEADDlgColor1->ShowHistoContrastDlg (this);
         if(nRet == SUCCESS_DLG_OK)
            MainFrm->LEADImage2->HistoContrast (LEADDlgColor1->Change);

         FinishRgnProcessing ();
      }
      else
      {
         LEADDlgColor1->DlgFlags= LEADDlgColor1->DlgFlags + DLG_HISTOCONTRAST_AUTOPROCESS;

         LEADDlgColor1->LEADImage= LEADImage1;
         LEADDlgColor1->ShowHistoContrastDlg (this);
      }
   }
   catch (const Exception &E)
   {
      MainFrm->DisplayErrorMsg (E.Message);
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuFill1Click(TObject *Sender)
{
   L_INT nRet;

   Screen->Cursor=crHourGlass;

   LEADDlgColor1->DlgFlags= DLG_COLOR_SHOW_OLDCOLOR +
                            DLG_COLOR_SHOW_NEWCOLOR +
                            DLG_COLOR_SHOW_NAME +
                            DLG_COLOR_COLORSPACE_SHOW_RGB +
                            DLG_COLOR_COLORMODEL_SHOW_RGB;

   LEADDlgColor1->SelectedColor= RGB (255, 255, 255);

   nRet= LEADDlgColor1->ShowColorDlg (this);
   if(nRet == SUCCESS_DLG_OK)
   {
      try
      {
         if(LEADImage1->HasRgn)
         {
            PrepareRgnProcessing ();
            MainFrm->LEADImage2->Fill (LEADDlgColor1->SelectedColor);
            FinishRgnProcessing ();
         }
         else
            LEADImage1->Fill (LEADDlgColor1->SelectedColor);
      }
      catch (ELEADImageError* e)
      {
         AnsiString strErr="Color Fill Failed:\n" + LEADImage1->ErrorMsg;
         Application->MessageBox(strErr.c_str (), "Error", MB_OK);
         Screen->Cursor=crDefault;
         return;
      }
   }
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSeparateRGB1Click(TObject *Sender)
{
   TChildImage *newChildArray[3];

   Screen->Cursor=crHourGlass;
   LEADImage1->ColorSeparate(COLORSEP_RGB);
   for(int i=0;i < 3;i++)
   {
      newChildArray[i]=new TChildImage(Parent);
      newChildArray[i]->LEADImage1->Bitmap= LEADImage1->ColorPlanes[i];
   }
   newChildArray[0]->Caption="Blue Plane of RGB - " + ImageName;
   StatusBarChanged(newChildArray[0]);

   newChildArray[1]->Caption="Green Plane of RGB - " + ImageName;
   StatusBarChanged(newChildArray[1]);

   newChildArray[2]->Caption="Red Plane of RGB - " + ImageName;
   StatusBarChanged(newChildArray[2]);
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSeparateCMYK1Click(TObject *Sender)
{
   TChildImage *newChildArray[4];

   Screen->Cursor=crHourGlass;
   LEADImage1->ColorSeparate(COLORSEP_CMYK);
   for(int i=0;i < 4;i++)
   {
      newChildArray[i]=new TChildImage(Parent);
      newChildArray[i]->LEADImage1->Bitmap= LEADImage1->ColorPlanes[i];
   }
   newChildArray[0]->Caption="Cyan Plane of CMYK - " + ImageName;
   StatusBarChanged(newChildArray[0]);

   newChildArray[1]->Caption="Magenta Plane of CMYK - " + ImageName;
   StatusBarChanged(newChildArray[1]);

   newChildArray[2]->Caption="Yellow Plane of CMYK - " + ImageName;
   StatusBarChanged(newChildArray[2]);

   newChildArray[3]->Caption="Black Plane of CMYK - " + ImageName;
   StatusBarChanged(newChildArray[3]);
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSeparateHSV1Click(TObject *Sender)
{
   TChildImage *newChildArray[3];

   Screen->Cursor=crHourGlass;
   LEADImage1->ColorSeparate(COLORSEP_HSV);
   for(int i=0;i < 3;i++)
   {
      newChildArray[i]=new TChildImage(Parent);
      newChildArray[i]->LEADImage1->Bitmap= LEADImage1->ColorPlanes[i];
   }
   newChildArray[0]->Caption="Hue Plane of HSV - " + ImageName;
   StatusBarChanged(newChildArray[0]);

   newChildArray[1]->Caption="Saturation Plane of HSV - " + ImageName;
   StatusBarChanged(newChildArray[1]);

   newChildArray[2]->Caption="Value Plane of HSV - " + ImageName;
   StatusBarChanged(newChildArray[2]);
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSeparateHLS1Click(TObject *Sender)
{
   TChildImage *newChildArray[3];

   Screen->Cursor=crHourGlass;
   LEADImage1->ColorSeparate(COLORSEP_HLS);
   for(int i=0;i < 3;i++)
   {
      newChildArray[i]=new TChildImage(Parent);
      newChildArray[i]->LEADImage1->Bitmap= LEADImage1->ColorPlanes[i];
   }
   newChildArray[0]->Caption="Hue Plane of HLS - " + ImageName;
   StatusBarChanged(newChildArray[0]);

   newChildArray[1]->Caption="Lightness Plane of HLS - " + ImageName;
   StatusBarChanged(newChildArray[1]);

   newChildArray[2]->Caption="Saturation Plane of HLS - " + ImageName;
   StatusBarChanged(newChildArray[2]);
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSeparateCMY1Click(TObject *Sender)
{
   TChildImage *newChildArray[3];

   Screen->Cursor=crHourGlass;
   LEADImage1->ColorSeparate(COLORSEP_CMY);
   for(int i=0;i < 3;i++)
   {
      newChildArray[i]=new TChildImage(Parent);
      newChildArray[i]->LEADImage1->Bitmap= LEADImage1->ColorPlanes[i];
   }
   newChildArray[0]->Caption="Cyan Plane of CMY - " + ImageName;
   StatusBarChanged(newChildArray[0]);

   newChildArray[1]->Caption="Magenta Plane of CMY - " + ImageName;
   StatusBarChanged(newChildArray[1]);

   newChildArray[2]->Caption="Yellow Plane of CMY - " + ImageName;
   StatusBarChanged(newChildArray[2]);
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuCountUniqueColors1Click(TObject *Sender)
{
   AnsiString Msg;
   int Count;
   Screen->Cursor=crHourGlass;

   if(LEADImage1->HasRgn)
   {
      PrepareRgnProcessing ();
      Count= MainFrm->LEADImage2->ColorCount;
      Msg="Region contains " + IntToStr(Count) + " unique colors";
      FinishRgnProcessing ();
   }
   else
   {
      Count= LEADImage1->ColorCount;
      Msg="Bitmap contains " + IntToStr(Count) + " unique colors";
   }
   Application->MessageBox(Msg.c_str (), "Unique Colors", MB_OK);
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuImageListClick(TObject *Sender)
{
    mnuInsertImage1->Enabled=BrowseForm->Visible;
    mnuRemoveImage1->Enabled=BrowseForm->Visible;
    mnuSortItems1->Enabled=BrowseForm->Visible;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuOptionsStopOnErrors1Click(TObject *Sender)
{
   mnuOptionsStopOnErrors1->Checked= ! mnuOptionsStopOnErrors1->Checked;
   MainFrm->mnuOptionsStopOnErrors1Click(Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuOptionsIncludeSubDirectory1Click(TObject *Sender)
{
   mnuOptionsIncludeSubDirectory1->Checked=! mnuOptionsIncludeSubDirectory1->Checked;
   MainFrm->mnuOptionsIncludeSubDirectory1Click(Sender);

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

void __fastcall TChildImage::mnuOptionsExpandMultipage1Click(TObject *Sender)
{
   mnuOptionsExpandMultipage1->Checked=! mnuOptionsExpandMultipage1->Checked;
   MainFrm->mnuOptionsExpandMultipage1Click(Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuOptionsDisplayText1Click(TObject *Sender)
{
   mnuOptionsDisplayText1->Checked=! mnuOptionsDisplayText1->Checked;
   MainFrm->mnuOptionsDisplayText1Click(Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuOptionsEnableKeyboard1Click(TObject *Sender)
{
   mnuOptionsEnableKeyboard1->Checked=! mnuOptionsEnableKeyboard1->Checked;
   MainFrm->mnuOptionsEnableKeyboard1Click(Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuShowSelectionColor1Click(TObject *Sender)
{
  mnuShowSelectionColor1->Checked= true;
  MainFrm->mnuShowSelectionColor1Click(Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuShowSelectionButton1Click(TObject *Sender)
{
   mnuShowSelectionButton1->Checked= true;
   MainFrm->mnuShowSelectionButton1Click(Sender);
}
//---------------------------------------------------------------------------
void __fastcall TChildImage::mnuShowSelectionUseBitmap1Click(TObject *Sender)
{
   mnuShowSelectionUseBitmap1->Checked= true;
   MainFrm->mnuShowSelectionUseBitmap1Click (Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuAllowSelectionNone1Click(TObject *Sender)
{
  mnuAllowSelectionNone1->Checked= true;
  MainFrm->mnuAllowSelectionNone1Click(Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuAllowSelectionSingle1Click(TObject *Sender)
{
  mnuAllowSelectionSingle1->Checked= true;
  MainFrm->mnuAllowSelectionSingle1Click (Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuAllowSelectionMulti1Click(TObject *Sender)
{
   mnuAllowSelectionMulti1->Checked= true;
   MainFrm->mnuAllowSelectionMulti1Click(Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuScrollStyleVertical1Click(TObject *Sender)
{
   mnuScrollStyleVertical1->Checked= true;
   MainFrm->mnuScrollStyleVertical1Click(Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuScrollStyleHorizontal1Click(TObject *Sender)
{
   mnuScrollStyleHorizontal1->Checked= true;
   MainFrm->mnuScrollStyleHorizontal1Click(Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuSortItemsAscending1Click(TObject *Sender)
{
   MainFrm->mnuSortItemsAscending1Click(Sender);
   mnuSortItemsAscending1->Checked= true;
   mnuSortItemsDescending1->Checked= false;
}
//---------------------------------------------------------------------------

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

void __fastcall TChildImage::mnuInsertImage1Click(TObject *Sender)
{
   MainFrm->mnuInsertImage1Click(Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuRemoveImage1Click(TObject *Sender)
{
   MainFrm->mnuRemoveImage1Click(Sender);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuDitheringOrdered1Click(TObject *Sender)
{
   if(mnuDitheringOrdered1->Checked == false)
   {
      mnuDitheringOrdered1->Checked= true;
      mnuDitheringErrorDiffusion1->Checked= false;
      MainFrm->mnuDitheringOrdered1->Checked= true;
      MainFrm->mnuDitheringErrorDiffusion1->Checked= false;
      MainFrm->PaintDitherVal=pdOrdered;
      for(int i=0;i<MainFrm->MDIChildCount;i++)
         ((TChildImage *)MainFrm->MDIChildren[i])->LEADImage1->PaintDither= MainFrm->PaintDitherVal;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuDitheringErrorDiffusion1Click(TObject *Sender)
{
   if(mnuDitheringErrorDiffusion1->Checked == false)
   {
      mnuDitheringOrdered1->Checked= false;
      mnuDitheringErrorDiffusion1->Checked= true;
      MainFrm->mnuDitheringOrdered1->Checked= false;
      MainFrm->mnuDitheringErrorDiffusion1->Checked= true;
      MainFrm->PaintDitherVal=pdDiffusion;
      for(int i=0;i<MainFrm->MDIChildCount;i++)
         ((TChildImage *)MainFrm->MDIChildren[i])->LEADImage1->PaintDither= MainFrm->PaintDitherVal;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuBitonalScalingNormal1Click(TObject *Sender)
{
   if(mnuBitonalScalingNormal1->Checked == false)
   {
      mnuBitonalScalingNormal1->Checked= true;
      mnuBitonalScalingFavorBlack1->Checked= false;
      mnuBitonalScalingScaleToGray1->Checked= false;
      MainFrm->mnuBitonalScalingNormal1->Checked= true;
      MainFrm->mnuBitonalScalingFavorBlack1->Checked= false;
      MainFrm->mnuBitonalScalingScaleToGray1->Checked= false;
      MainFrm->BitonalScalingVal =btsNormal;
      for(int i=0;i < MainFrm->MDIChildCount;i++)
         ((TChildImage *)MainFrm->MDIChildren[i])->LEADImage1->BitonalScaling= MainFrm->BitonalScalingVal;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuBitonalScalingFavorBlack1Click(TObject *Sender)
{
   if(mnuBitonalScalingFavorBlack1->Checked == false)
   {
      mnuBitonalScalingNormal1->Checked= false;
      mnuBitonalScalingFavorBlack1->Checked= true;
      mnuBitonalScalingScaleToGray1->Checked= false;
      MainFrm->mnuBitonalScalingNormal1->Checked= false;
      MainFrm->mnuBitonalScalingFavorBlack1->Checked= true;
      MainFrm->mnuBitonalScalingScaleToGray1->Checked= false;
      MainFrm->BitonalScalingVal =btsFavorBlack;
      for(int i=0; i < MainFrm->MDIChildCount; i++)
         ((TChildImage *)MainFrm->MDIChildren[i])->LEADImage1->BitonalScaling= MainFrm->BitonalScalingVal;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuBitonalScalingScaleToGray1Click(
      TObject *Sender)
{
   if(mnuBitonalScalingScaleToGray1->Checked == false)
   {
      mnuBitonalScalingNormal1->Checked= false;
      mnuBitonalScalingFavorBlack1->Checked= false;
      mnuBitonalScalingScaleToGray1->Checked= true;
      MainFrm->mnuBitonalScalingNormal1->Checked= false;
      MainFrm->mnuBitonalScalingFavorBlack1->Checked= false;
      MainFrm->mnuBitonalScalingScaleToGray1->Checked= true;
      MainFrm->BitonalScalingVal =btsScaleToGray;
      for(int i=0;i < MainFrm->MDIChildCount;i++)
         ((TChildImage *)MainFrm->MDIChildren[i])->LEADImage1->BitonalScaling= MainFrm->BitonalScalingVal;
   }
}
//---------------------------------------------------------------------------

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

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

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

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

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

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

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

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

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

void __fastcall TChildImage::mnuPaintScalingNormal1Click(TObject *Sender)
{
   MainFrm->mnuPaintScalingNormal1->Click ();
   mnuPaintScalingNormal1->Checked= true;
   for(int i=0;i< MainFrm->MDIChildCount;i++)
   {
      ((TChildImage *)MainFrm->MDIChildren[i])->LEADImage1->PaintScaling= MainFrm->PaintScalingVal;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuPaintScalingResample1Click(TObject *Sender)
{
   MainFrm->mnuPaintScalingResample1->Click ();
   mnuPaintScalingResample1->Checked= true;
   for(int i=0;i< MainFrm->MDIChildCount;i++)
   {
      ((TChildImage *)MainFrm->MDIChildren[i])->LEADImage1->PaintScaling= MainFrm->PaintScalingVal;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuPaintScalingBicubic1Click(TObject *Sender)
{
   MainFrm->mnuPaintScalingBicubic1->Click ();
   mnuPaintScalingBicubic1->Checked= true;
   for(int i=0;i< MainFrm->MDIChildCount;i++)
   {
      ((TChildImage *)MainFrm->MDIChildren[i])->LEADImage1->PaintScaling= MainFrm->PaintScalingVal;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuPaintWhileLoad1Click(TObject *Sender)
{
   mnuPaintWhileLoad1->Checked=!mnuPaintWhileLoad1->Checked;
   MainFrm->mnuPaintWhileLoad1->Checked=!MainFrm->mnuPaintWhileLoad1->Checked;
   MainFrm->bUsePaintWhileLoad=mnuPaintWhileLoad1->Checked;
   for(int i=0;i< MainFrm->MDIChildCount;i++)
      ((TChildImage *)MainFrm->MDIChildren[i])->LEADImage1->PaintWhileLoad= MainFrm->bUsePaintWhileLoad;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuEnableDropFile1Click(TObject *Sender)
{
   mnuEnableDropFile1->Checked=!mnuEnableDropFile1->Checked;

   if(mnuEnableDropFile1->Checked)
   {
      LEADImage1->DropAutoLoad= true;
      LEADImage1->DropFilesAllowed= true;
   }
   else
   {
      LEADImage1->DropAutoLoad= false;
      LEADImage1->DropFilesAllowed= false;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuCloseAll1Click(TObject *Sender)
{
   for(int i= 0; i< MainFrm->MDIChildCount; i++)
      MainFrm->MDIChildren[i]->Close ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuCascade1Click(TObject *Sender)
{
   MainFrm->Cascade ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuTile1Click(TObject *Sender)
{
   MainFrm->Tile ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuArrangeIcons1Click(TObject *Sender)
{
   MainFrm->ArrangeIcons ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuLEADTOOLSOnTheWeb1Click(TObject *Sender)
{
   MainFrm->mnuLEADTOOLSOnTheWeb1->Click ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuAbout1Click(TObject *Sender)
{
   MainFrm->mnuAbout1->Click ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::ViewSnapProc(void)
{
   if(WindowState == wsNormal)
   {
      LEADImage1->AutoScroll= false;
      ClientWidth=(int)(LEADImage1->BitmapWidth * LEADImage1->PaintZoomFactor /100);
      ClientHeight=(int)(LEADImage1->BitmapHeight * LEADImage1->PaintZoomFactor / 100);

      LEADImage1->AutoScroll= true;

      mnuNormal1->Checked= false;
      mnuZoom1->Checked= false;
      mnuFitImageToWindow1->Checked= false;
      mnuSnapWindowToImage1->Checked= true;
      LEADImage1->PaintSizeMode=smZoom;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::ViewNormalProc(void)
{
   LEADImage1->PaintSizeMode=smNormal;
   nZoomFactor=100;
   nZoomPercent=VIEW_NORMAL;

   mnuNormal1->Checked= true;
   mnuZoom1->Checked= false;
   mnuFitImageToWindow1->Checked= false;
   mnuSnapWindowToImage1->Checked= false;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::ViewFitProc(void)
{
   LEADImage1->PaintSizeMode=smFit;
   LEADImage1->ForceRepaint ();

   mnuNormal1->Checked= false;
   mnuZoom1->Checked= false;
   mnuFitImageToWindow1->Checked= true;
   mnuSnapWindowToImage1->Checked= false;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::ViewZoomProc(void)
{
   LEADImage1->PaintSizeMode=smZoom;
   Application->CreateForm(__classid(TDlgGetValue), &DlgGetValue);
   if(nZoomPercent <= 0)
      DlgGetValue->InitTheForm ("Zoom In/Out","Whole Percent:", 800, 1, VIEW_NORMAL, 100, 10, false);
   else
      DlgGetValue->InitTheForm ("Zoom In/Out", "Whole Percent:", 800, 1, LEADImage1->PaintZoomFactor, 100, 10, false);

   DlgGetValue->ShowModal ();
   if(DlgGetValue->UserResult () == true)
   {
      LEADImage1->AutoRepaint= false;
      nZoomPercent=DlgGetValue->GetAmount ();
      ResetAllRects(LEADImage1->BitmapWidth * nZoomPercent / 100,LEADImage1->BitmapHeight * nZoomPercent / 100);
      LEADImage1->AutoRepaint= true;
   }
   DlgGetValue->Free ();

   mnuNormal1->Checked= false;
   mnuZoom1->Checked= true;
   mnuFitImageToWindow1->Checked= false;
   mnuSnapWindowToImage1->Checked= false;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::ResetAllRects(int nDispWidth,int nDispHeight)
{
   LEADImage1->SetSrcRect (0, 0, LEADImage1->BitmapWidth, LEADImage1->BitmapHeight);
   LEADImage1->SetSrcClipRect(0, 0, LEADImage1->BitmapWidth, LEADImage1->BitmapHeight);
   LEADImage1->SetDstRect(0, 0, nDispWidth, nDispHeight);
   LEADImage1->SetDstClipRect(0, 0, nDispWidth, nDispHeight);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::ZoomImage(void)
{
   LEADImage1->AutoRepaint= false;
   LEADImage1->SetDstRect(LEADImage1->DstLeft, LEADImage1->DstTop, LEADImage1->BitmapWidth * nZoomFactor / 100, LEADImage1->BitmapHeight * nZoomFactor / 100);
   LEADImage1->SetDstClipRect(LEADImage1->DstLeft, LEADImage1->DstTop, LEADImage1->DstWidth, LEADImage1->DstHeight);
   LEADImage1->AutoRepaint= true;
}
//---------------------------------------------------------------------------

int  __fastcall TChildImage::GetProperQualityFactor(int nFileFormat)
{
   int nQFactor;
   switch (nFileFormat)
   {
   case FILE_JTIF:
      nQFactor=JTIF;
      break;
   case FILE_LEAD1JTIF:
      nQFactor= LEAD1JTIF;
      break;
   case FILE_LEAD2JTIF:
      nQFactor= LEAD2JTIF;
      break;
   case FILE_TIF:
      nQFactor= TIFF_CCITT;
      break;
   case FILE_CCITT:
      nQFactor= TIFF_CCITT;
      break;
   case FILE_CCITT_GROUP3_1DIM:
      nQFactor= TIFF_CCITTG3_FAX1D;
      break;
   case FILE_CCITT_GROUP3_2DIM:
      nQFactor= TIFF_CCITTG3_FAX2D;
      break;
   case FILE_CCITT_GROUP4:
      nQFactor= TIFF_CCITTG4_FAX;
      break;
   case FILE_TIF_CMYK:
   case FILE_TIF_YCC:
   case FILE_TIF_PACKBITS:
   case FILE_TIF_PACKBITS_CMYK:
   case FILE_TIF_PACKBITS_YCC:
   case FILE_TIFLZW:
   case FILE_TIFLZW_CMYK:
   case FILE_TIFLZW_YCC:
   case FILE_WFX_G3_1D:
   case FILE_WFX_G4:
   case FILE_PCX:
   case FILE_GIF:
   case FILE_FLC:
   case FILE_FLI:
   case FILE_ANI:
      nQFactor= LEAD;
      break;
   default:
      nQFactor= LEAD;
   }
   return (nQFactor);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::SetImageName(AnsiString strImageName)
{
   ImageName=strImageName;
}
//---------------------------------------------------------------------------

AnsiString __fastcall TChildImage::GetImageName(void)
{
   return(ImageName);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::EnablePaintShapeProc(TLEADImage *LEADShape)
{
   Screen->Cursor=crHourGlass;

   LEADShape->ShapeLeft=0;
   LEADShape->ShapeTop=0;
   LEADShape->ShapeWidth= LEADShape->BitmapWidth;
   LEADShape->ShapeHeight= LEADShape->BitmapHeight;

   LEADShape->ShapeBorderColor= (TColor)LEADDlgEffect1->ShapeBorderColor;
   LEADShape->ShapeBorderStyle= LEADDlgEffect1->ShapeBorderStyle;
   LEADShape->ShapeBorderThickness= LEADDlgEffect1->ShapeBorderThickness;

   LEADShape->ShapeInnerBandHiliteColor= (TColor)LEADDlgEffect1->ShapeInnerBandHiliteColor;
   LEADShape->ShapeInnerBandShadowColor= (TColor)LEADDlgEffect1->ShapeInnerBandShadowColor;
   LEADShape->ShapeInnerBandStyle= LEADDlgEffect1->ShapeInnerBandStyle;
   LEADShape->ShapeInnerBandThickness= LEADDlgEffect1->ShapeInnerBandThickness;

   LEADShape->ShapeOuterBandHiliteColor= (TColor)LEADDlgEffect1->ShapeOuterBandHiliteColor;
   LEADShape->ShapeOuterBandShadowColor= (TColor)LEADDlgEffect1->ShapeOuterBandShadowColor;
   LEADShape->ShapeOuterBandStyle= LEADDlgEffect1->ShapeOuterBandStyle;
   LEADShape->ShapeOuterBandThickness= LEADDlgEffect1->ShapeOuterBandThickness;

   LEADShape->ShadowColor= (TColor)LEADDlgEffect1->ShadowColor;
   LEADShape->ShadowXDepth= LEADDlgEffect1->ShadowXDepth;
   LEADShape->ShadowYDepth= LEADDlgEffect1->ShadowYDepth;

   LEADShape->PatternBackColor= (TColor)LEADDlgEffect1->BackColor;
   LEADShape->PatternForeColor= (TColor)LEADDlgEffect1->ForeColor;
   LEADShape->PatternStyle= LEADDlgEffect1->ShapeFillStyle;

   LEADShape->ShapeBackgroundStyle= LEADDlgEffect1->ShapeBackgroundStyle;

   TLEADImage *TempBitmap= new TLEADImage(this);
   TempBitmap->Visible= false;
   TempBitmap->Parent = this;

   if(LEADDlgEffect1->ShapeBackgroundBitmap != 0)
   {
      TempBitmap->Bitmap= LEADDlgEffect1->ShapeBackgroundBitmap;

      LEADShape->BackgroundImageLeft=0;
      LEADShape->BackgroundImageTop=0;
      LEADShape->BackgroundImageWidth= TempBitmap->BitmapWidth;
      LEADShape->BackgroundImageHeight= TempBitmap->BitmapHeight;
   }

   LEADShape->DrawPersistence= true;
   LEADShape->DrawShape (LEADDlgEffect1->Shape, TempBitmap->Bitmap);

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

void __fastcall TChildImage::EnablePaintTextProc(TLEADImage *LEADText)
{
   Screen->Cursor=crHourGlass;

   LEADText->TextLeft=0;
   LEADText->TextTop=0;
   LEADText->TextWidth= LEADText->BitmapWidth;
   LEADText->TextHeight= LEADText->BitmapHeight;
   LEADText->TextAlign= LEADDlgEffect1->TextAlign;
   LEADText->TextAngle= LEADDlgEffect1->TextAngle;
   LEADText->TextFont= LEADDlgEffect1->TextFont;
   LEADText->TextStyle= LEADDlgEffect1->TextStyle;
   LEADText->TextWordWrap= LEADDlgEffect1->TextWordWrap;
   LEADText->TextHiliteColor= (TColor)LEADDlgEffect1->TextHiliteColor;
   LEADText->ShadowColor= (TColor)LEADDlgEffect1->ShadowColor;
   LEADText->ShadowXDepth= LEADDlgEffect1->ShadowXDepth;
   LEADText->ShadowYDepth= LEADDlgEffect1->ShadowYDepth;

   LEADText->DrawPersistence= true;

   if(LEADDlgEffect1->TextUseForegroundImage)
      LEADText->DrawTextStr(LEADDlgEffect1->SampleText, LEADDlgEffect1->TextForegroundBitmap);
   else
      LEADText->DrawTextStr(LEADDlgEffect1->SampleText, 0);

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

void __fastcall TChildImage::PaintEffects(void)
{
   if(mnuEffectsEnablePaintEffects1->Checked == true)
   {
      LEADImage1->BackErase= true;

      LEADImage1->EffectDelay=efxEffectDelay;
      LEADImage1->EffectGrain=efxEffectGrain;
      LEADImage1->PaintMaxPasses=efxPaintMaxPasses;
      LEADImage1->PaintEffect=efxPaintEffect;
      LEADImage1->WandColor=efxWandColor;
      LEADImage1->WandSize=efxWandSize;

      LEADImage1->BackErase= false;
      LEADImage1->Refresh ();
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::PaintGradients(void)
{
   if(mnuEffectsEnablePaintGradient1->Checked == true)
   {
      LEADImage1->AutoRepaint= false;

      LEADImage1->EffectDelay= grdEffectDelay;
      LEADImage1->GradientStyle= grdGradientStyle;
      LEADImage1->GradientSteps= grdGradientSteps;
      LEADImage1->GradientStartColor= grdGradientStartColor;
      LEADImage1->GradientEndColor= grdGradientEndColor;

      LEADImage1->TransitionEffect= EFX_EFFECT_WIPE_RECTANGLE_OUT;
      LEADImage1->TransitionStyle= etsGradient;

      LEADImage1->AutoRepaint= true;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::PaintPatterns(void)
{
   if(mnuEffectsEnablePaintPattern1->Checked == true)
   {
      LEADImage1->AutoRepaint= false;

      LEADImage1->TransitionEffect= ptnTransitionEffect;
      LEADImage1->UseTransparentColor= ptnUseTransparentColor;
      LEADImage1->TransparentColor= ptnTransparentColor;
      LEADImage1->WandColor= ptnWandColor;
      LEADImage1->WandSize= ptnWandSize;
      LEADImage1->EffectDelay= ptnEffectDelay;
      LEADImage1->EffectGrain= ptnEffectGrain;
      LEADImage1->PaintMaxPasses= ptnPaintMaxPasses;
      LEADImage1->PatternBackColor= ptnPatternBackColor;
      LEADImage1->PatternForeColor= ptnPatternForeColor;
      LEADImage1->GradientSteps= grdGradientSteps;      
      LEADImage1->GradientStartColor= grdGradientStartColor;
      LEADImage1->GradientEndColor= grdGradientEndColor;
      LEADImage1->GradientStyle= grdGradientStyle;
      LEADImage1->PatternStyle= ptnPatternStyle;
      LEADImage1->TransitionStyle= ptnTransitionStyle;

      LEADImage1->AutoRepaint= true;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::UpdateFloater(bool f_resize)
{
   if(LEADImage1->Floater)
   {
      int newX= LEADImage1->RgnLeft * LEADImage1->DstWidth / LEADImage1->BitmapWidth+LEADImage1->DstLeft,
          newY= LEADImage1->RgnTop * LEADImage1->DstHeight / LEADImage1->BitmapHeight+LEADImage1->DstTop;

      if(f_resize)
      {
         LEADImage1->SetFloaterDstRect(newX, newY,
            LEADImage1->RgnWidth * LEADImage1->DstWidth / LEADImage1->BitmapWidth,
            LEADImage1->RgnHeight * LEADImage1->DstHeight / LEADImage1->BitmapHeight);
      }
      else
      {
         LEADImage1->FloaterDstLeft=newX;
         LEADImage1->FloaterDstTop=newY;
      }
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::LEADImage1MouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
   // Do nothing if we are drawing a region Or loading, Or not left button.
   if(!LEADImage1->Bitmap || !LEADImage1->BitmapWidth || !LEADImage1->BitmapHeight || (Button!= mbLeft))
      return;
   /*Declare local variables. */
   int BitmapX, BitmapY;
   float ZoomFactorX, ZoomFactorY;
   int NewX, NewY, NewWidth, NewHeight;
   /*Translate the current mouse coordinates. */
   /*These coordinates account for the zoom factor and offset. */
   ZoomFactorX=(float)LEADImage1->DstWidth / (float)LEADImage1->BitmapWidth;
   ZoomFactorY=(float)LEADImage1->DstHeight / (float)LEADImage1->BitmapHeight;
   BitmapX=((X / ZoomFactorX) - (LEADImage1->DstLeft / ZoomFactorX));
   BitmapY=((Y / ZoomFactorY) - (LEADImage1->DstTop / ZoomFactorY));
   /*Continue to create the floater if the mouse is pointing to the region we marked*/
   if(LEADImage1->IsPtInRgn(BitmapX, BitmapY))
   {
      m_RgnFrame= LEADImage1->RgnFrameType;
      LEADImage1->RgnFrameType= ftNone;
      m_RgnMarkingMode= LEADImage1->RgnMarkingMode;
      LEADImage1->RgnMarkingMode= mmNone;

      /*Create the floater bitmap, which will be the part of the*/
      /* main bitmap that is in the region's bounding rectangle */
      if(!LEADImage1->Floater)
      {
         LEADImage1->Floater= LEADImage1->Bitmap;
         /*Translate the bitmap region coordinates to client area coordinates. */
         NewY= LEADImage1->RgnTop * ZoomFactorY + LEADImage1->DstTop;
         NewX= LEADImage1->RgnLeft * ZoomFactorX + LEADImage1->DstLeft;
         NewWidth= LEADImage1->RgnWidth * ZoomFactorX;
         NewHeight= LEADImage1->RgnHeight * ZoomFactorY;
         /*Set the initial display position of the floater. */
         LEADImage1->SetFloaterDstRect(NewX, NewY, NewWidth, NewHeight);
         LEADImage1->SetFloaterDstClipRect(0, 0, LEADImage1->ClientWidth, LEADImage1->ClientHeight);
      }
      /*Set form-level variables. */
      m_nFloaterY=Y;
      m_nFloaterX=X;
      LEADImage1->FloaterVisible= true;
      if(LEADBkgrnd->Bitmap) //restore background
         LEADImage1->Combine(0, 0, LEADImage1->BitmapWidth, LEADImage1->BitmapHeight,
            LEADBkgrnd->Bitmap, 0, 0, CB_OP_ADD + CB_DST_0);
      m_fFloaterMoving= true;
   }
   else // should paste here
    PasteFloater ();
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::LEADImage1MouseMove(TObject *Sender,
      TShiftState Shift, int X, int Y)
{
   // Do nothing if we are drawing a region + loading.
   if(!LEADImage1->Bitmap || !LEADImage1->DstWidth || !LEADImage1->DstHeight)
      return;

   if(m_fFloaterMoving)
   {
      int newX= LEADImage1->FloaterDstLeft + (X-m_nFloaterX),
          newY= LEADImage1->FloaterDstTop + (Y-m_nFloaterY);
      LEADImage1->SetFloaterDstRect(newX, newY, LEADImage1->FloaterDstWidth, LEADImage1->FloaterDstHeight);
      m_nFloaterX=X;
      m_nFloaterY=Y;
   }
   else
   {
      int BitmapX=((X - LEADImage1->DstLeft) * LEADImage1->BitmapWidth) / (float)LEADImage1->DstWidth,
          BitmapY=((Y - LEADImage1->DstTop) * LEADImage1->BitmapHeight) / (float)LEADImage1->DstHeight;

      if(LEADImage1->IsPtInRgn(BitmapX, BitmapY))
         LEADImage1->Cursor=crHandPoint;
      else
         LEADImage1->Cursor=crDefault;

      if(LEADImage1->AnimationEnable)
         Cursor=crArrow;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::LEADImage1MouseUp(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
   if(m_fFloaterMoving && (Button== mbLeft))
   {
/*    Save dimensions of region before it is offset to use in creating a new
**    floater by combinging using MainFrm->LEADImage2.
**    This is done to clip the floater to the region after the region is finally offset
*/
      int n_cmbnWidth= LEADImage1->RgnWidth,
          n_cmbnHeight= LEADImage1->RgnHeight;
/*    Calculate new x and y coordinates of floater.
      Note that these may not be the actual ones used eventually because the region may
      get clipped at top and left. In any case the floater distination rect is taken from
      the region dimensions after the region is offset
*/
      int n_newX=(LEADImage1->FloaterDstLeft-LEADImage1->DstLeft) * LEADImage1->BitmapWidth / LEADImage1->DstWidth,
          n_newY=(LEADImage1->FloaterDstTop-LEADImage1->DstTop) * LEADImage1->BitmapHeight / LEADImage1->DstHeight;

/*    Move the region to the new location where the user released the mouse button.
**    During mouse moving, the region is not moved so that
**    it does not get clipped at boundaries.
*/
      LEADImage1->OffsetRgn(n_newX-LEADImage1->RgnLeft, n_newY - LEADImage1->RgnTop);
      MainFrm->LEADImage2->Bitmap= LEADImage1->Bitmap;
      MainFrm->LEADImage2->Combine(n_newX, n_newY, n_cmbnWidth, n_cmbnHeight,
         LEADImage1->Floater, 0, 0, CB_OP_ADD + CB_DST_0);
      LEADImage1->AutoRepaint= false;
      LEADImage1->FloaterVisible= false;
      LEADImage1->Floater= MainFrm->LEADImage2->Bitmap;
      LEADImage1->SetFloaterDstRect(
         LEADImage1->RgnLeft * LEADImage1->DstWidth / LEADImage1->BitmapWidth + LEADImage1->DstLeft,
         LEADImage1->RgnTop * LEADImage1->DstHeight / LEADImage1->BitmapHeight+LEADImage1->DstTop,
         LEADImage1->RgnWidth * LEADImage1->DstWidth / LEADImage1->BitmapWidth,
         LEADImage1->RgnHeight * LEADImage1->DstHeight / LEADImage1->BitmapHeight);
      LEADImage1->FloaterVisible= true;
      LEADImage1->RgnFrameType= m_RgnFrame;
      LEADImage1->RgnMarkingMode= m_RgnMarkingMode;
      m_fFloaterMoving= false;
      if(LEADImage1->RgnWidth==0 || LEADImage1->RgnHeight==0) //was dragged outside
      {
         LEADImage1->FreeRgn ();
         LEADImage1->Floater=0;
         LEADBkgrnd->Bitmap=0;
      }
      else
      {
         LEADBkgrnd->Bitmap= LEADImage1->Bitmap; // save background
         LEADImage1->Combine(LEADImage1->RgnLeft, LEADImage1->RgnTop, LEADImage1->RgnWidth, LEADImage1->RgnHeight, LEADImage1->Floater, 0, 0, CB_OP_ADD + CB_DST_0);
      }
      LEADImage1->FloaterVisible= false;
      LEADImage1->AutoRepaint= true;
   }
   StatusBarChanged(this);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::LEADImage1Change(TObject *Sender)
{
   if(WindowState != wsNormal)
      mnuSnapWindowToImage1->Enabled= false;
   else
      mnuSnapWindowToImage1->Enabled= true;

   StatusBarChanged(this);
   if(LEADImage1->Bitmap != 0)
   {
      if(LEADImage1->HScrollStep != (LEADImage1->BitmapWidth / 5) + 1
         || LEADImage1->VScrollStep != (LEADImage1->BitmapHeight / 5) + 1)
      {
         LEADImage1->HScrollStep=(LEADImage1->BitmapWidth / 5) + 1;
         LEADImage1->VScrollStep=(LEADImage1->BitmapHeight / 5) + 1;
      }
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::LEADImage1ReadyStateChanged(TObject *Sender,
      TReadyState ReadyState)
{
   if(ReadyState == rsLoading)
   {
      Screen->Cursor=crHourGlass;
      MainFrm->btnSaveAs->Enabled= false;
      MainFrm->btnCopy->Enabled= false;
      MainFrm->btnPrint->Enabled= false;
      m_fSavePaintWhileLoad= LEADImage1->PaintWhileLoad;
      LEADImage1->PaintWhileLoad= true;
   }
   else
   {
      if(LEADImage1->Error != SUCCESS)
      {
         mnuClose1->Click ();
         return;
      }
      LEADImage1->PaintWhileLoad= m_fSavePaintWhileLoad;
      MainFrm->btnSaveAs->Enabled= true;
      MainFrm->btnCopy->Enabled= true;
      MainFrm->btnPrint->Enabled= true;

      Screen->Cursor=crDefault;
      Caption="URL: " + ImageName;
      StatusBarChanged(this);

      mnuFile->Enabled= true;
      mnuEdit->Enabled= true;
      mnuAnimation->Enabled= true;
      
      mnuView->Enabled= true;
      mnuMultiPage->Enabled= true;
      mnuImage->Enabled= true;
      mnuEffects->Enabled= true;
      mnuColor->Enabled= true;
      mnuImageList->Enabled= true;
      mnuPreferences->Enabled= true;
      mnuWindow->Enabled= true;
      mnuWindow->Enabled= true;
      mnuHelp->Enabled= true;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::LEADImage1Animate(TObject *Sender, bool bEnable)
{
   mnuPlay1->Checked= bEnable;

   mnuFile->Enabled= !bEnable;
   mnuOptimizeColors1->Enabled= !bEnable;
   mnuEdit->Enabled= !bEnable;
   mnuView->Enabled= !bEnable;
   mnuMultiPage->Enabled= !bEnable;
   mnuImage->Enabled= !bEnable;
   mnuEffects->Enabled= !bEnable;
   mnuColor->Enabled= !bEnable;
   mnuImageList->Enabled= !bEnable;
   mnuPreferences->Enabled= !bEnable;
   mnuWindow->Enabled= !bEnable;
   mnuHelp->Enabled= !bEnable;

   MainFrm->btnSaveAs->Enabled= !bEnable;
   MainFrm->btnCopy->Enabled= !bEnable;
   MainFrm->btnPaste->Enabled= !bEnable;
   MainFrm->btnPrint->Enabled= !bEnable;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::LEADImage1PanWin(TObject *Sender, L_HANDLE hPanWin,
      int iFlag)
{
   switch(iFlag)
   {
      case PANWIN_DESTROYED:
         mnuPanWindow1->Checked= false;
         break;
      case PANWIN_UPDATED:
         UpdateFloater(false);
         break;
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::LEADImage1Scroll(TObject *Sender)
{
   UpdateFloater(false);
}

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

void __fastcall TChildImage::LEADImage1Resize(TObject *Sender)
{
   static int n_oldWidth, n_oldHeight;

   if(n_oldWidth== LEADImage1->ClientWidth && n_oldHeight== LEADImage1->ClientHeight)
      return;
   n_oldWidth= LEADImage1->ClientWidth;
   n_oldHeight= LEADImage1->ClientHeight;
   LEADImage1->SetFloaterDstClipRect(0, 0, n_oldWidth, n_oldHeight);
   UpdateFloater(true);
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::LEADImage1DropFile(TObject *Sender,
      AnsiString fName)
{
   Screen->Cursor=crHourGlass;

   TLEADImage *TempImage=new TLEADImage(this);
   TempImage->Visible= false;
   TempImage->Parent = this;
   try
   {
      TempImage->Load(fName, 0, 0, -1);
   }
   catch (ELEADImageError *e)
   {
      AnsiString strErr="Drop File Failed:\n" + TempImage->ErrorMsg;
      Application->MessageBox(strErr.c_str (), "Error", MB_OK);
      TempImage->Free ();
      Screen->Cursor=crDefault;
      return;
   }
   LEADImage1->Bitmap= TempImage->Bitmap;
   SetImageName(fName);
   Caption= fName;

   TempImage->Free ();
   StatusBarChanged(this);
   Screen->Cursor=crDefault;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::StatusBarChanged(TChildImage *child)
{
   MainFrm->StatusBar->Panels->Items[0]->Text=Caption;

   if(LEADImage1->AnimationEnable)
   {
      MainFrm->StatusBar->Panels->Items[1]->Text=IntToStr(LEADImage1->AnimationWidth)+" X "+IntToStr(LEADImage1->AnimationHeight);
      MainFrm->StatusBar->Panels->Items[2]->Text=IntToStr(LEADImage1->AnimationBitsPerPixel)+" BPP";
   }
   else
   {
      MainFrm->StatusBar->Panels->Items[1]->Text=IntToStr(LEADImage1->BitmapWidth)+" X "+IntToStr(LEADImage1->BitmapHeight);
      MainFrm->StatusBar->Panels->Items[2]->Text=IntToStr(LEADImage1->BitmapBits)+" BPP";
   }

   if(LEADImage1->InfoSizeMem != 0)
      MainFrm->StatusBar->Panels->Items[3]->Text=IntToStr(LEADImage1->InfoSizeMem)+" bytes,MEMORY";
   else
      MainFrm->StatusBar->Panels->Items[3]->Text="File Not Saved";

   if(LEADImage1->HasRgn)
      MainFrm->StatusBar->Panels->Items[4]->Text= "(" + IntToStr(LEADImage1->RgnLeft)+
                                                        "," + IntToStr(LEADImage1->RgnTop)+
                                                  ")-(" + IntToStr(LEADImage1->RgnLeft+LEADImage1->RgnWidth)+
                                                        "," + IntToStr(LEADImage1->RgnTop+LEADImage1->RgnHeight) +
                                                   ")";
   else
      MainFrm->StatusBar->Panels->Items[4]->Text ="NO REGION";
}
//---------------------------------------------------------------------------

AnsiString __fastcall TChildImage::GetFormatName(int nFileFormat)
{
   AnsiString FormatName;

   switch (nFileFormat)
   {
   case FILE_PCX:
      FormatName="ZSoft PCX";  //1
      break;

   case FILE_GIF:
      FormatName="CompuServe GIF"; //2
      break;

   case FILE_TIF:
      FormatName="Tagged Image File Format"; //3
      break;

   case FILE_TGA:
      FormatName="Targa"; //4
      break;

   case FILE_CMP:
      FormatName="LEAD CMP"; //5
      break;

   case FILE_BMP:
      FormatName="Windows BMP"; //6
      break;

   case FILE_JFIF:
      FormatName="Jpeg File Interchange Format"; //10
      break;

   case FILE_JTIF:
      FormatName="Jpeg Tag Image File Format";//11
      break;

   case FILE_OS2:
      FormatName="OS/2 BMP "; //14
      break;

   case FILE_WMF:
      FormatName="Windows Meta File"; //15
      break;

   case FILE_EPS:
      FormatName="Encapsulated Post Script"; //16
      break;

   case FILE_TIFLZW:
      FormatName="TIF Format with LZW compression"; //17
      break;

   case FILE_LEAD:
      FormatName="LEAD  Proprietary";  //  20
      break;

   case FILE_LEAD1JFIF:
      FormatName="JPEG  4:1:1";
      break;

   case FILE_LEAD1JTIF:
      FormatName="JPEG  4:1:1";
      break;

   case FILE_LEAD2JFIF:
      FormatName="JPEG  4:2:2";
      break;

   case FILE_LEAD2JTIF:
      FormatName="JPEG  4:2:2";
      break;

   case FILE_CCITT:
      FormatName="TIFF  CCITT";
      break;

   case FILE_LEAD1BIT:
      FormatName="LEAD 1 bit, lossless compression";
      break;

   case FILE_CCITT_GROUP3_1DIM:
      FormatName="CCITT Group3 one dimension";
      break;

   case FILE_CCITT_GROUP3_2DIM:
      FormatName="CCITT Group3 two dimensions";
      break;

   case FILE_CCITT_GROUP4:
      FormatName="CCITT Group4 two dimensions";
      break;

   case FILE_LEAD1BITA:
      FormatName="old LEAD 1 bit, lossless compression";
      break;

   case FILE_CALS:
      FormatName="FILE_CALS";
      break;

   case FILE_MAC:
      FormatName="FILE_MAC";
      break;

   case FILE_IMG:
      FormatName="FILE_IMG";
      break;

   case FILE_MSP:
      FormatName="FILE_MSP";
      break;

   case FILE_WPG:
      FormatName="FILE_WPG";
      break;

   case FILE_RAS:
      FormatName="FILE_RAS";
      break;

   case FILE_PCT:
      FormatName="FILE_PCT";
      break;

   case FILE_PCD:
      FormatName="FILE_PCD";
      break;

   case FILE_DXF:
      FormatName="FILE_DXF";
      break;

   case FILE_AVI:
      FormatName="FILE_AVI";
      break;

   case FILE_WAV:
      FormatName="FILE_WAV";
      break;

   case FILE_FLI:
      FormatName="FILE_FLI";
      break;

   case FILE_FLC:
      FormatName="FILE_FLC";
      break;

   case FILE_ANI:
      FormatName="FILE_ANI";
      break;

   case FILE_CGM:
      FormatName="FILE_CGM";
      break;

   case FILE_EPSTIFF:
      FormatName="EPS with TIFF Preview";
      break;

   case FILE_EPSWMF:
      FormatName="EPS with Metafile Preview";
      break;

   case FILE_CMPNOLOSS:
      FormatName="FILE_CMPNOLOSS";
      break;

   case FILE_FAX_G3_1D:
      FormatName="FILE_FAX_G3_1D";
      break;

   case FILE_FAX_G3_2D:
      FormatName="FILE_FAX_G3_2D";
      break;

   case FILE_FAX_G4:
      FormatName="FILE_FAX_G4";
      break;

   case FILE_WFX_G3_1D:
      FormatName="FILE_WFX_G3_1D";
      break;

   case FILE_WFX_G4:
      FormatName="FILE_WFX_G4";
      break;

   case FILE_ICA_G3_1D:
      FormatName="FILE_ICA_G3_1D";
      break;

   case FILE_ICA_G3_2D:
      FormatName="FILE_ICA_G3_2D";
      break;

   case FILE_ICA_G4:
      FormatName="FILE_ICA_G4";
      break;

   case FILE_OS2_2:
      FormatName="FILE_OS2_2";
      break;

   case FILE_PNG:
      FormatName="FILE_PNG";
      break;

   case FILE_PSD:
      FormatName="FILE_PSD";
      break;

   case FILE_RAWICA_G3_1D:
      FormatName="FILE_RAWICA_G3_1D";
      break;

   case FILE_RAWICA_G3_2D:
      FormatName="FILE_RAWICA_G3_2D";
      break;

   case FILE_RAWICA_G4:
      FormatName="FILE_RAWICA_G4";
      break;

   case FILE_FPX:
      FormatName="FlashPix, no compression";
      break;

   case FILE_FPX_SINGLE_COLOR:
      FormatName="FlashPix, compression single color method";
      break;

   case FILE_FPX_JPEG:
      FormatName="FlashPix, compression JPEG";
      break;

   case FILE_FPX_JPEG_QFACTOR:
      FormatName="FlashPix, compression JPEG, specify qFactor";
      break;

   case FILE_BMP_RLE:
      FormatName="compressed Windows BMP";
      break;

   case FILE_TIF_CMYK:
      FormatName="TIFF no compression, CMYK data";
      break;

   case FILE_TIFLZW_CMYK:
      FormatName="TIFF LZW compression, CMYK data";
      break;

   case FILE_TIF_PACKBITS:
      FormatName="TIFF PackBits compression, RGB data";
      break;

   case FILE_TIF_PACKBITS_CMYK:
      FormatName="TIFF PackBits compression, CMYK data";
      break;

   case FILE_DICOM_GRAY:
      FormatName="FILE_DICOm_GRAY";
      break;

   case FILE_DICOM_COLOR:
      FormatName="FILE_DICOm_COLOR";
      break;

   case FILE_WIN_ICO:
      FormatName="FILE_WIN_ICO";
      break;

   case FILE_WIN_CUR:
      FormatName="FILE_WIN_CUR";
      break;

   case FILE_TIF_YCC:
      FormatName="TIFF YCbCr color space, no compression";
      break;

   case FILE_TIFLZW_YCC:
      FormatName="TIFF YCbCr color space, LZW compression";
      break;

   case FILE_TIF_PACKBITS_YCC:
      FormatName="TIFF YCbCr color space, PackBits compression";
      break;

   case FILE_EXIF:
      FormatName="uncompressed RGB Exif file";
      break;

   case FILE_EXIF_YCC:
      FormatName="uncompressed YCbCr Exif file";
      break;

   case FILE_EXIF_JPEG:
      FormatName="JPEG 4:2:2 compressed Exif file";
      break;

   case FILE_AWD:
      FormatName="Microsoft Fax format";
      break;

   case FILE_FASTEST:
      FormatName="for ISIS only! use the data as is, from the ISIS Scanner";
      break;

   case FILE_EXIF_JPEG_411:
      FormatName="JPEG 4:1:1 compressed Exif file";
      break;

   default:
      FormatName="NOT SUPPORTED";
   }

   return (FormatName);
}
//---------------------------------------------------------------------------

bool __fastcall TChildImage::IsSupportMultiPage(int nFileFormat)
{
   int nMultiPageFormats [ ] = { FILE_JTIF,
                                 FILE_LEAD2JTIF,
                                 FILE_LEAD1JTIF,
                                 FILE_TIFLZW,
                                 FILE_TIFLZW_CMYK,
                                 FILE_TIFLZW_YCC,
                                 FILE_TIF,FILE_TIF_CMYK,
                                 FILE_TIF_YCC,
                                 FILE_TIF_PACKBITS,
                                 FILE_TIF_PACKBITS_CMYK,
                                 FILE_TIF_PACKBITS_YCC,
                                 FILE_PCX,
                                 FILE_WFX_G3_1D,
                                 FILE_WFX_G4,
                                 FILE_CCITT_GROUP4,
                                 FILE_CCITT,
                                 FILE_CCITT_GROUP3_1DIM,
                                 FILE_CCITT_GROUP3_2DIM};
   bool IsMultiPage= false;

   for(int i=0; i < (sizeof(nMultiPageFormats)/sizeof(nMultiPageFormats[0])); i++)
      if(nFileFormat == nMultiPageFormats[i])
      {
         IsMultiPage= true;
         break;
      }

   return IsMultiPage;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::PrepareRgnProcessing(void)
{
   LEADImage1->AutoRepaint= false;
   // if we have region without floater, create one.
   if(!LEADImage1->Floater)
   {
      LEADImage1->Floater= LEADImage1->Bitmap;
      LEADImage1->SetFloaterDstRect(
         LEADImage1->RgnLeft * LEADImage1->DstWidth / LEADImage1->BitmapWidth + LEADImage1->DstLeft,
         LEADImage1->RgnTop * LEADImage1->DstHeight / LEADImage1->BitmapHeight+LEADImage1->DstTop,
         LEADImage1->RgnWidth * LEADImage1->DstWidth / LEADImage1->BitmapWidth,
         LEADImage1->RgnHeight * LEADImage1->DstHeight / LEADImage1->BitmapHeight);
   }
   if(LEADBkgrnd->Bitmap) //restore background
      LEADImage1->Combine(0, 0, LEADImage1->BitmapWidth, LEADImage1->BitmapHeight,
         LEADBkgrnd->Bitmap, 0, 0, CB_OP_ADD + CB_DST_0);
   MainFrm->LEADImage2->Bitmap= LEADImage1->Bitmap;
   MainFrm->LEADImage2->Size(LEADImage1->RgnWidth, LEADImage1->RgnHeight, SIZE_NORMAL);
   L_HRGN tmpRgn= LEADImage1->GetRgnHandle ();
   MainFrm->LEADImage2->FreeRgn ();
   MainFrm->LEADImage2->Fill(TColor(RGB(255, 255, 255)));
   MainFrm->LEADImage2->SetRgnHandle(tmpRgn, -LEADImage1->RgnLeft, -LEADImage1->RgnTop, L_RGN_SET);
   LEADImage1->DeleteRgnHandle(tmpRgn);
   MainFrm->LEADImage2->Combine(0, 0, LEADImage1->RgnWidth, LEADImage1->RgnHeight,
      LEADImage1->Floater, 0, 0, CB_OP_ADD + CB_DST_0);
   LEADImage1->FloaterVisible= true;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::FinishRgnProcessing(void)
{
   LEADImage1->FloaterVisible= false;
   L_HRGN tmpRgn; //used to get region after processsing
   TLEADImage *LEAD3=new TLEADImage(this->Handle);
   LEAD3->Visible= false;
   int n_rgnOffsetX= LEADImage1->RgnLeft-MainFrm->LEADImage2->RgnLeft + (LEADImage1->RgnWidth-MainFrm->LEADImage2->RgnWidth)/2,
       n_rgnOffsetY= LEADImage1->RgnTop-MainFrm->LEADImage2->RgnTop + (LEADImage1->RgnHeight-MainFrm->LEADImage2->RgnHeight)/2;

   tmpRgn= MainFrm->LEADImage2->GetRgnHandle ();
   // LEAD3 bitmap keeps the dimensions of LEADImage1 regardless of image processsing
   LEAD3->Bitmap= LEADImage1->Bitmap;
   LEAD3->SetRgnHandle(tmpRgn, n_rgnOffsetX, n_rgnOffsetY, L_RGN_SET);
   LEADImage1->SetRgnHandle(tmpRgn, n_rgnOffsetX, n_rgnOffsetY, L_RGN_SET);
   MainFrm->LEADImage2->DeleteRgnHandle(tmpRgn);
   LEAD3->Combine(MainFrm->LEADImage2->RgnLeft+n_rgnOffsetX,MainFrm->LEADImage2->RgnTop+n_rgnOffsetY, MainFrm->LEADImage2->RgnWidth,
      MainFrm->LEADImage2->RgnHeight, MainFrm->LEADImage2->Bitmap, MainFrm->LEADImage2->RgnLeft, MainFrm->LEADImage2->RgnTop, CB_OP_ADD + CB_DST_0);
   LEADImage1->Floater= LEAD3->Bitmap;
   delete LEAD3;
   LEAD3=NULL;
   LEADImage1->SetFloaterDstRect(
      LEADImage1->RgnLeft * LEADImage1->DstWidth / LEADImage1->BitmapWidth + LEADImage1->DstLeft,
      LEADImage1->RgnTop * LEADImage1->DstHeight / LEADImage1->BitmapHeight+LEADImage1->DstTop,
      LEADImage1->RgnWidth * LEADImage1->DstWidth / LEADImage1->BitmapWidth,
      LEADImage1->RgnHeight * LEADImage1->DstHeight / LEADImage1->BitmapHeight);
   LEADBkgrnd->Bitmap= LEADImage1->Bitmap; // save background
   LEADImage1->Combine(LEADImage1->RgnLeft, LEADImage1->RgnTop, LEADImage1->RgnWidth, LEADImage1->RgnHeight, LEADImage1->Floater, 0, 0, CB_OP_ADD + CB_DST_0);
   LEADImage1->AutoRepaint= true;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::UpdateMenuItems(void)
{
   mnuPaintPaletteAuto1->Checked= MainFrm->mnuPaintPaletteAuto1->Checked;
   mnuPaintPaletteFixed1->Checked= MainFrm->mnuPaintPaletteFixed1->Checked;
   mnuPaintPaletteUseNetscape1->Checked= MainFrm->mnuPaintPaletteUseNetscape1->Checked;
   nZoomPercent=VIEW_NORMAL;
   mnuPaintWhileLoad1->Checked= MainFrm->bUsePaintWhileLoad;
   mnuDitheringOrdered1->Checked= MainFrm->mnuDitheringOrdered1->Checked;
   mnuDitheringErrorDiffusion1->Checked= MainFrm->mnuDitheringErrorDiffusion1->Checked;
   mnuBitonalScalingNormal1->Checked= MainFrm->mnuBitonalScalingNormal1->Checked;
   mnuBitonalScalingFavorBlack1->Checked= MainFrm->mnuBitonalScalingFavorBlack1->Checked;
   mnuBitonalScalingScaleToGray1->Checked= MainFrm->mnuBitonalScalingScaleToGray1->Checked;

   mnuPaintScalingNormal1->Checked= MainFrm->mnuPaintScalingNormal1->Checked;
   mnuPaintScalingResample1->Checked= MainFrm->mnuPaintScalingResample1->Checked;
   mnuPaintScalingBicubic1->Checked= MainFrm->mnuPaintScalingBicubic1->Checked;

   LEADImage1->PaintPalette= MainFrm->PaintPaletteVal;
   LEADImage1->PaintDither= MainFrm->PaintDitherVal;
   LEADImage1->BitonalScaling= MainFrm->BitonalScalingVal;
   LEADImage1->PaintScaling= MainFrm->PaintScalingVal;
   LEADImage1->PaintWhileLoad= MainFrm->bUsePaintWhileLoad;


   MainFrm->btnSaveAs->Enabled= true;
   MainFrm->btnCopy->Enabled= true;
   MainFrm->btnPrint->Enabled= true;
   
   mnuRemoveImage1->Checked= MainFrm->mnuRemoveImage1->Checked;
   mnuInsertImage1->Checked= MainFrm->mnuInsertImage1->Checked;
   mnuSortItemsDescending1->Checked= MainFrm->mnuSortItemsDescending1->Checked;
   mnuSortItemsAscending1->Checked= MainFrm->mnuSortItemsAscending1->Checked;
   mnuScrollStyleHorizontal1->Checked= MainFrm->mnuScrollStyleHorizontal1->Checked;
   mnuScrollStyleVertical1->Checked= MainFrm->mnuScrollStyleVertical1->Checked;
   mnuAllowSelectionMulti1->Checked= MainFrm->mnuAllowSelectionMulti1->Checked;
   mnuAllowSelectionSingle1->Checked= MainFrm->mnuAllowSelectionSingle1->Checked;
   mnuAllowSelectionNone1->Checked= MainFrm->mnuAllowSelectionNone1->Checked;
   mnuShowSelectionColor1->Checked= MainFrm->mnuShowSelectionColor1->Checked;
   mnuShowSelectionButton1->Checked= MainFrm->mnuShowSelectionButton1->Checked;
   mnuShowSelectionUseBitmap1->Checked= MainFrm->mnuShowSelectionUseBitmap1->Checked;

   mnuOptionsStopOnErrors1->Checked= MainFrm->mnuOptionsStopOnErrors1->Checked;
   mnuOptionsEnableKeyboard1->Checked= MainFrm->mnuOptionsEnableKeyboard1->Checked;
   mnuOptionsDisplayText1->Checked= MainFrm->mnuOptionsDisplayText1->Checked;
   mnuOptionsExpandMultipage1->Checked= MainFrm->mnuOptionsExpandMultipage1->Checked;
   mnuOptionsIncludeSubDirectory1->Checked= MainFrm->mnuOptionsIncludeSubDirectory1->Checked;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::PasteFloater(void)
{
  if(LEADImage1->Floater)
  {
     LEADImage1->AutoRepaint= false;
     LEADImage1->Combine(LEADImage1->RgnLeft, LEADImage1->RgnTop, LEADImage1->RgnWidth, LEADImage1->RgnHeight,
        LEADImage1->Floater, 0, 0, CB_OP_ADD + CB_DST_0);
     LEADImage1->AutoRepaint= true;
     LEADImage1->Floater=0;
     LEADImage1->FreeRgn ();
  }
  LEADImage1->RgnFrameType= m_RgnFrame;
  LEADImage1->RgnMarkingMode = m_RgnMarkingMode;
  LEADBkgrnd->Bitmap=0;
  m_fFloaterMoving= false;
}
//---------------------------------------------------------------------------

void __fastcall DisplayDICOMSaveMsg(int nFileFormat)
{
   if(bDICOMSaveMsg)
   {
      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:
            bDICOMSaveMsg= false; //only do this one time
            Application->MessageBox("This demo can only be used to create a 'Secondary Capture Image Storage' DICOM Dataset.\n" \
                       "All elements in the Dataset will be set to appropriate default values.\n" \
                       "For full DICOM support, refer to the LEADTOOLS Medical Imaging demos.","DICOM Save Information", MB_OK);
            break;

      }

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

int TChildImage::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)
   {
      LEADThumb1->EnableMethodErrors= False;
      LEADThumb1->Filter= "*.*";
      LEADThumb1->LoadStamp= False;
      try
      {
         nRet= LEADThumb1->BrowseDir (LEADDlgFile1->Directory);
      }
      catch (...)
      {
         if(LEADThumb1->Error != ERROR_USER_ABORT)
         {
            ShowMessage(LEADThumb1->ErrorMsg);
            return nRet;
         }
      }
      if((nRet == SUCCESS) || (nRet == ERROR_USER_ABORT))
      {
         nRet= SUCCESS;
         // Create a temp LEADImage Control.
         TmpLEADImage= new TLEADImage (this);
         // Set the Visibility As False.
         TmpLEADImage->Visible= False;
         // Set The Parent for the Temp LEADImage Control
         TmpLEADImage->Parent= this;

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

            case DLGIMAGE_CONTROL:
            {
               LEADDlgImage1->ItemsCount= nImagesCount;
               for (i= 0; i < nImagesCount; i ++)
               {
                  LEADDlgImage1->ItemFileName[i]= ImagesNames[i];
                  LEADDlgImage1->ItemDescription[i]= ImagesNames[i];
                  TmpLEADImage->Load (ImagesNames[i], 0, 1, 1);
                  LEADDlgImage1->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 TChildImage::LEADThumb1ThumbnailEvent(TObject *Sender,
      TBitmapHandle Bitmap, AnsiString FileName, int nStatusCode,
      int nPercent)
{
   if(nStatusCode == 0)
   {
      if(nImagesCount >= DLG_IMAGE_LIST_COUNT)
      {
         LEADThumb1->ContinueBrowse= False;
         return;
      }
      ImagesNames[nImagesCount]= FileName;
      nImagesCount++;
   }
   Application->ProcessMessages ();
   LEADThumb1->ContinueBrowse= true;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::FormKeyPress(TObject *Sender, char &Key)
{
   if((Key == 27) && (mnuPlay1->Checked))
   {
      mnuPlay1Click (Sender);
   }
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::mnuImageClick(TObject *Sender)
{
   mnuDeskew1->Enabled= (! LEADImage1->HasRgn);
   mnuDocumentImaging1->Enabled= (LEADImage1->BitmapBits == 1);
}
//---------------------------------------------------------------------------

void TChildImage::SetJ2KOptions()
{
   LEADImage1->J2KCompressionControl= LEADDlgFile1->SaveJ2KCompressionControl;
   LEADImage1->J2KUseColorTransform = LEADDlgFile1->SaveJ2KUseColorTransform;
   LEADImage1->J2KDerivedQuantization= LEADDlgFile1->SaveJ2KDerivedQuantization;
   LEADImage1->J2KCompressionControl= LEADDlgFile1->SaveJ2KCompressionControl;
   if(LEADDlgFile1->SaveJ2KCompressionControl == J2K_COMPRESSION_RATIO)
      LEADImage1->J2KCompressionRatio= LEADDlgFile1->SaveJ2KCompressionRatio;
   else if(LEADDlgFile1->SaveJ2KCompressionControl == J2K_COMPRESSION_TARGETSIZE)
      LEADImage1->J2KTargetFileSize= LEADDlgFile1->SaveJ2KTargetFileSize;

   LEADImage1->J2KXOsiz= LEADDlgFile1->SaveJ2KXOsiz;
   LEADImage1->J2KYOsiz= LEADDlgFile1->SaveJ2KYOsiz;
   LEADImage1->J2KXTsiz= LEADDlgFile1->SaveJ2KXTsiz;
   LEADImage1->J2KYTsiz= LEADDlgFile1->SaveJ2KYTsiz;

   LEADImage1->J2KXTOsiz= LEADDlgFile1->SaveJ2KXTOsiz;
   LEADImage1->J2KYTOsiz= LEADDlgFile1->SaveJ2KYTOsiz;

   LEADImage1->J2KDecompLevel= LEADDlgFile1->SaveJ2KDecompLevel;
   LEADImage1->J2KProgressOrder= LEADDlgFile1->SaveJ2KProgressOrder;
   LEADImage1->J2KCodBlockWidth= LEADDlgFile1->SaveJ2KCodBlockWidth;
   LEADImage1->J2KCodBlockHeight= LEADDlgFile1->SaveJ2KCodBlockHeight;

   LEADImage1->J2KCBS_SelectiveACBypass= LEADDlgFile1->SaveJ2KCBS_SelectiveACBypass;
   LEADImage1->J2KCBS_ResetContextOnBoundaries= LEADDlgFile1->SaveJ2KCBS_ResetContextOnBoundaries;
   LEADImage1->J2KCBS_TerminationOnEachPass= LEADDlgFile1->SaveJ2KCBS_TerminationOnEachPass;
   LEADImage1->J2KCBS_VerticallyCausalContext= LEADDlgFile1->SaveJ2KCBS_VerticallyCausalContext;
   LEADImage1->J2KCBS_PredictableTermination= LEADDlgFile1->SaveJ2KCBS_PredictableTermination;
   LEADImage1->J2KCBS_ErrorResilienceSymbol= LEADDlgFile1->SaveJ2KCBS_ErrorResilienceSymbol;

   LEADImage1->J2KGuardBits= LEADDlgFile1->SaveJ2KGuardBits;
   LEADImage1->J2KDerivedBaseMantissa= LEADDlgFile1->SaveJ2KDerivedBaseMantissa;
   LEADImage1->J2KDerivedBaseExponent= LEADDlgFile1->SaveJ2KDerivedBaseExponent;
   LEADImage1->J2KUseSOPMarker= LEADDlgFile1->SaveJ2KUseSOPMarker;
   LEADImage1->J2KUseEPHMarker= LEADDlgFile1->SaveJ2KUseEPHMarker;
}
//---------------------------------------------------------------------------

void __fastcall TChildImage::LEADImage1LoadInfo(TObject *Sender)
{
   LEADImage1->LoadInfoFormat= MainFrm->LoadInfoFormat;
   LEADImage1->LoadInfoFlags= MainFrm->LoadInfoFlags;
   LEADImage1->LoadInfoWidth= MainFrm->LoadInfoWidth;
   LEADImage1->LoadInfoHeight= MainFrm->LoadInfoHeight;
   LEADImage1->LoadInfoBits= MainFrm->LoadInfoBitsPerPixel;
   LEADImage1->LoadInfoXRes= MainFrm->LoadInfoXRes;
   LEADImage1->LoadInfoYRes= MainFrm->LoadInfoYRes;
   LEADImage1->LoadInfoOffset= MainFrm->LoadInfoOffset;

   for(int i=0; i < 256; i ++)
   {
      LEADImage1->UserPalette[i] = MainFrm->LEADImage2->UserPalette[i];
   }
}
//---------------------------------------------------------------------------