/*[]=====================================================================[]*/
/*[]     LeadTools Run Time Library - Version 14                         []*/
/*[]                                                                     []*/
/*[]                                                                     []*/
/*[]     Copyright (c) 1991-2004 LEAD Technologies, Inc.                 []*/
/*[]     All Rights Reserved.                                            []*/
/*[]=====================================================================[]*/

#include "ImgPF.h"

static L_BOOL LevelingDialog_OnInitDialog (HWND hWnd, HWND hWndFocus, LPARAM lParam);
static L_BOOL LevelingDialog_OnHScroll    (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos);
static L_BOOL LevelingDialog_OnCommand    (HWND hWnd, L_INT nID, HWND hWndCtl, L_UINT codeNotify);
static L_BOOL LevelingDialog_OnClose      (HWND hWnd);
static L_VOID LevelingDialog_OnTimer      (HWND hWnd, L_INT nID);
static L_VOID L_ApplyFilter               (HWND hWnd);

static L_VOID InitLevels (LPLVLDLGDATA pLvlDlgData)
{
   pLvlDlgData->red.uMinInput  = 0;
   pLvlDlgData->red.uMinOutput = 0;
   pLvlDlgData->red.uMaxInput  = pLvlDlgData->uMaxClrVal;
   pLvlDlgData->red.uMaxOutput = pLvlDlgData->uMaxClrVal;
   pLvlDlgData->red.uGamma     = DEFAULT_GAMMA;

   memcpy(&pLvlDlgData->green,  &pLvlDlgData->red, sizeof(LVLCLRINF));
   memcpy(&pLvlDlgData->blue,   &pLvlDlgData->red, sizeof(LVLCLRINF));
   memcpy(&pLvlDlgData->master, &pLvlDlgData->red, sizeof(LVLCLRINF));
}

static L_UINT GetMaxCompVal (pBITMAPHANDLE pBitmap)
{
   L_UINT uMaxCompVal;

   // Check that that the bitmap handle is correct
   if ((!pBitmap) || (!pBitmap->Flags.Allocated))
      return ERROR_INVALID_HANDLE;

   switch (pBitmap->BitsPerPixel)
   {
   case 12:
   case 48:
   case 64:
      uMaxCompVal = 65535;
      break;

   case 16:
      if (GRAY_NO == L_IsGrayScaleBitmap (pBitmap))
         uMaxCompVal = 255;
      else
         uMaxCompVal = 65535;
      break;

   default:
      uMaxCompVal = 255;
   }
   return uMaxCompVal;
}

L_BOOL CALLBACK LevelingDlgProc (HWND hWnd, L_UINT msg, WPARAM wParam, LPARAM lParam)
{
   LPLVLDLGDATA pLvlDlgData;
   pCHILDDATA   pData;
   HWND         hWndParent;

   hWndParent  = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData       = LOCKCHILDDATA (hWndParent);
   pLvlDlgData = (LPLVLDLGDATA) GetWindowLong(hWnd,GWL_USERDATA);

   switch (msg)
   {
      HANDLE_MSG (hWnd, WM_INITDIALOG, LevelingDialog_OnInitDialog);
      HANDLE_MSG (hWnd, WM_COMMAND   , LevelingDialog_OnCommand);
      HANDLE_MSG (hWnd, WM_CLOSE     , LevelingDialog_OnClose);
      HANDLE_MSG (hWnd, WM_HSCROLL   , LevelingDialog_OnHScroll);
      HANDLE_MSG (hWnd, WM_TIMER,      LevelingDialog_OnTimer);
   case WM_USER_UPDATEVIEW:
      StatusProc.ProgressValue = 100;
      L_ApplyFilter (hWnd);
      break;
   }
   return FALSE;
}

static L_BOOL LevelingDialog_OnInitDialog (HWND hWnd, HWND hWndFocus, LPARAM lParam)
{
   LPLVLDLGDATA  pLvlDlgData;
//   LPEDITBOXDATA pEditBoxData;
   pCHILDDATA    pData;
   L_DOUBLE      dClip;
   L_INT         uItems;
   L_UINT        uRangeMax [] = { 1000, 255, 255, 255, 255};   // Should be 255 or 65535
   L_UINT        uRangeMin [] = {   10,   0,   0,   0,   0};
   L_UINT        uLineSize [] = {    1,   1,   1,   1,   1};
   L_UINT        uPageSize [] = {    5,   5,   5,   5,   5};
   L_UINT        uPosition [] = {  100,   0, 255,   0, 255};    // 255 might be here 65535
   L_UINT        uMaxClrVal;
   L_UINT        uIndex;
   HWND          hWndParent;
   HWND          hCmboCtrl;
   HWND          hEditBox;
   HWND          hSlider;
   RECT          rcRgn;

   hWndParent  = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData       = LOCKCHILDDATA (hWndParent);
   pLvlDlgData = (LPLVLDLGDATA)lParam;
   MoveDialogToMiddle(hWnd);

   memset (pLvlDlgData, 0, sizeof(LVLDLGDATA));
   SetWindowLong (hWnd, GWL_USERDATA, (LONG)pLvlDlgData);
   
   //MEMDISK...//
   MemorizeAndCopyBitmap (hWndParent, &pLvlDlgData->Bitmap);
   L_GetBitmapRgnBounds(&pLvlDlgData->Bitmap, NULL, &rcRgn);

   StatusProc.bProgress     = TRUE;
   StatusProc.bInvalidate   = FALSE;
   StatusProc.bEnd          = FALSE;
   StatusProc.DlgWnd        = hWnd;
   StatusProc.ProgressValue = 100;
   StatusProc.ProgWnd       = GetDlgItem(hWnd, IDC_LVL_PROG);
   StatusProc.bKillProgress = TRUE;

   // Set the progress bar
   Progress_SetRange(StatusProc.ProgWnd, 0, 100);
   Progress_SetPos  (StatusProc.ProgWnd, 0);

   UpdateWindow(hWnd);

   // Check whether it is a 8 or 16-bit image
   uMaxClrVal = GetMaxCompVal(&pData->LeadBitmap);
   if (pLvlDlgData->Bitmap.BitsPerPixel == 12)
      uMaxClrVal = 4095;
   uRangeMax[1] = uMaxClrVal;
   uRangeMax[2] = uMaxClrVal;
   uRangeMax[3] = uMaxClrVal;
   uRangeMax[4] = uMaxClrVal;
   uPosition[2] = uMaxClrVal;
   uPosition[4] = uMaxClrVal;
   if (uMaxClrVal == 65535)
   {
      uLineSize[1] *= 256; // Increase the spacing 256 = 65535 / 255
      uLineSize[2] *= 256;
      uLineSize[3] *= 256;
      uLineSize[4] *= 256;
      uPageSize[1] *= 256;
      uPageSize[2] *= 256;
      uPageSize[3] *= 256;
      uPageSize[4] *= 256;
   }

   // Initiate the structure
   pLvlDlgData->uMaxClrVal = uMaxClrVal;
   InitLevels (pLvlDlgData);

   // Set the sliders
   // Notice that in Trackbar_SetRange(), if ranges are very huge like
   //    65535, then this macro will not work. You must use 
   //    SendMessage(hwnd, TBM_SETRANGEMIN, redraw, minRange) and
   //    SendMessage(hwnd, TBM_SETRANGEMAX, redraw, maxRange).
   
   pLvlDlgData->nEdtBaseID = IDC_LVL_GMA_EDT;
   pLvlDlgData->nSldBaseID = IDC_LVL_GMA_SLD;
   pLvlDlgData->nSlideNum = 5;

   for (uItems = 0; uItems < pLvlDlgData->nSlideNum; uItems++)
   {
      uIndex  = pLvlDlgData->nSldBaseID + uItems;
      hSlider = GetDlgItem(hWnd, uIndex);
      Trackbar_SetTheRange(hSlider, TRUE, uRangeMin[uItems], uRangeMax[uItems]);
      Trackbar_SetPos     (hSlider, TRUE, uPosition[uItems]);
      Trackbar_SetLineSize(hSlider, uLineSize[uItems]);
      Trackbar_SetPageSize(hSlider, uPageSize[uItems]);
   }
   
   // Set the combo box
   hCmboCtrl = GetDlgItem (hWnd, IDC_LVL_CHA_COM);
   ComboBox_AddString (hCmboCtrl, TEXT("Master"));
   if (!L_IsGrayScaleBitmap(&pLvlDlgData->Bitmap))
   {
      ComboBox_AddString (hCmboCtrl, TEXT("Red"));
      ComboBox_AddString (hCmboCtrl, TEXT("Greens"));
      ComboBox_AddString (hCmboCtrl, TEXT("Blues"));
   }
   ComboBox_SetCurSel (hCmboCtrl, 0);

   // CAN be a *GLOBAL* variable instead
   pLvlDlgData->bDoProcess = TRUE;

   SetNumericEditBox(GetDlgItem(hWnd, IDC_LVL_GMA_EDT), 0.10, 10.00, 0.05, 2, TRUE);
   for(uItems = 1; uItems < pLvlDlgData->nSlideNum; uItems++)
   {
      SetNumericEditBox(GetDlgItem(hWnd, pLvlDlgData->nEdtBaseID + uItems), uRangeMin[uItems], uRangeMax[uItems], 1, 0, FALSE);
   }

   SetDlgItemText(hWnd, IDC_LVL_GMA_EDT, TEXT("1.00"));
   for (uItems = 1; uItems < pLvlDlgData->nSlideNum; uItems++)
   {
      uIndex = pLvlDlgData->nEdtBaseID + uItems;
      SetDlgItemInt (hWnd, uIndex, uPosition[uItems], FALSE);
   }

   for (uItems = IDC_LVL_WHT_STA; uItems <= IDC_LVL_PE2_STA; uItems++)
   {
      hEditBox = GetDlgItem(hWnd, uItems);
      ShowWindow (hEditBox, SW_MINIMIZE);
      ShowWindow (hEditBox, SW_HIDE);

      if ((uItems == IDC_LVL_WHT_EDT) || (uItems == IDC_LVL_BLK_EDT))
      {
         L_CHAR szBuff[20] = "\0";

         switch (uItems)
         {
         case IDC_LVL_WHT_EDT:
            dClip = uWhtClip / 100.0; // *GLOBAL*
            break;
            
         case IDC_LVL_BLK_EDT:
            dClip = uBlkClip / 100.0; // *GLOBAL*
            break;
         }
         _gcvt (dClip, 9, szBuff);
         SetNumericEditBox(hEditBox, 0.00, 100.00, 0.10, 2, TRUE);
         SetWindowTextA (hEditBox, szBuff);
      }      
   }


   pData->uTimerID = SetTimer(hWnd, 1, 100, NULL);
   SetDlgItemInt (hWnd, IDC_LVL_MNI_EDT, uPosition[1], FALSE); // Don't remove this line
   return TRUE;
}
static L_VOID LevelingDialog_OnTimer  (HWND hWnd, L_INT nID)
{
   Dialog_Timer(nID);
}
static L_BOOL LevelingDialog_OnHScroll (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos)
{
   L_UINT uNewPosition;
   L_INT  nCtrlID;
   TCHAR  szBuff[20] = TEXT("\0");
   HWND   hSlider;

   if (nCode == SB_ENDSCROLL) 
      return TRUE;

   // When a slider change, then change its associated edit box.
   nCtrlID = GetWindowLong (hWndCtl, GWL_ID);
   uNewPosition = (L_UINT)Trackbar_GetPos(hWndCtl);

   // L_LevelingBitmap documentation says that uMaxInput should be larger 
   //    from uMinInput by at least two
   if (nCtrlID == IDC_LVL_MNI_SLD)
   {
      hSlider = GetDlgItem (hWnd, IDC_LVL_MXI_SLD);
      if ((L_INT32)Trackbar_GetPos(hSlider) < (L_INT32)(2 + uNewPosition))
         uNewPosition = Trackbar_GetPos(hSlider) - 2;
   }
   if (nCtrlID == IDC_LVL_MXI_SLD)
   {
      hSlider = GetDlgItem (hWnd, IDC_LVL_MNI_SLD);
      if ((L_INT32)(Trackbar_GetPos(hSlider) + 2) > (L_INT32)uNewPosition)
         uNewPosition = Trackbar_GetPos(hSlider) + 2;
   }


   // Update the Edit Box and notify it that the slider caused the edit to change
   if (nCtrlID == IDC_LVL_GMA_SLD)
   {
      ConvertFloatToString(uNewPosition, szBuff, 2);
      SetDlgItemText (hWnd, nCtrlID - 5, szBuff);
   }
   else
      SetDlgItemInt (hWnd, nCtrlID - 5, uNewPosition, TRUE);
   return TRUE;
}



static L_BOOL LevelingDialog_OnCommand (HWND hWnd, L_INT nID, HWND hWndCtl, L_UINT codeNotify)
{
   //LPEDITBOXDATA pEdtBxData = NULL;
   pLVLCLRINF   pLvlClrInf[4];
   LPLVLDLGDATA  pLvlDlgData;
   LVLCLR     lvlValues;
   pCHILDDATA    pData;
   L_UINT        uRangeMax [] = { 1000, 255, 255, 255, 255};   // Should be 255 or 65535
   L_UINT        uRangeMin [] = {   10,   0,   0,   0,   0};
   L_UINT        uEditBoxValue;
   L_UINT        uCmboChannel;
   L_UINT        uIndex;
   L_INT         mxVal, nRet;
   TCHAR         szBuff[20] = TEXT("\0");
   HWND          hWndParent;
   L_BOOL        bNoChange = TRUE;

   
   hWndParent  = FORWARD_WM_MDIGETACTIVE(hWndClient, SendMessage);
   pData       = LOCKCHILDDATA (hWndParent);
   pLvlDlgData = (LPLVLDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
   
   switch (nID)
   {
   case IDCANCEL:
      StatusProc.bProgress     = FALSE;
      StatusProc.bKillProgress = TRUE;
      StatusProc.ProgressValue = 100;
      EndDialog     (hWnd, FALSE);
      break;

   case IDOK:  
      ShowStatusWindow(FALSE);
      StatusProc.bStillWork  = TRUE;
      StatusProc.bInvalidate = TRUE;
      StatusProc.bEnd        = TRUE;
      EndDialog    (hWnd, TRUE);
      break;

   case IDC_LVL_RST_BTN:
      // Reset the dialog to zeros
      mxVal = pLvlDlgData->uMaxClrVal;
      InitLevels (pLvlDlgData);

      pLvlDlgData->bDoProcess = FALSE;
      SetDlgItemInt (hWnd, IDC_LVL_MNI_EDT, 0 , FALSE);
      SetDlgItemInt (hWnd, IDC_LVL_MNO_EDT, 0 , FALSE);
      SetDlgItemInt (hWnd, IDC_LVL_MXI_EDT, mxVal, FALSE);
      SetDlgItemInt (hWnd, IDC_LVL_MXO_EDT, mxVal, FALSE);
      SetDlgItemText(hWnd, IDC_LVL_GMA_EDT, TEXT("1.00")); // This should not be static, but whatever
      pLvlDlgData->bDoProcess = TRUE;
      L_ApplyFilter (hWnd);
      break;

   case IDC_LVL_AIN_BTN:
      StatusProc.bProgress = FALSE;
      lvlValues.uStructSize = sizeof(LVLCLR);
      nRet = L_AutoColorLevelBitmap(&pLvlDlgData->Bitmap,
                                        &lvlValues,
                                        uBlkClip, // *GLOBAL*
                                        uWhtClip,
                                        AUTO_INTENSITY|AUTO_NOPROCESS);

      StatusProc.bProgress = TRUE;
      if (nRet != SUCCESS)
         break;
      
      pLvlDlgData->red    = lvlValues.red   ;
      pLvlDlgData->green  = lvlValues.green ;
      pLvlDlgData->blue   = lvlValues.blue  ;
      pLvlDlgData->master = lvlValues.master;
      
      // Update the dialog
      uCmboChannel  = ComboBox_GetCurSel (GetDlgItem(hWnd, IDC_LVL_CHA_COM));
      pLvlClrInf[0] = &pLvlDlgData->master;
      pLvlClrInf[1] = &pLvlDlgData->red;
      pLvlClrInf[2] = &pLvlDlgData->green;
      pLvlClrInf[3] = &pLvlDlgData->blue;
      pLvlDlgData->bDoProcess = FALSE;
      SetDlgItemInt (hWnd, IDC_LVL_MNI_EDT, pLvlClrInf[uCmboChannel]->uMinInput, FALSE);
      SetDlgItemInt (hWnd, IDC_LVL_MXI_EDT, pLvlClrInf[uCmboChannel]->uMaxInput, FALSE);
      SetDlgItemInt (hWnd, IDC_LVL_MNO_EDT, pLvlClrInf[uCmboChannel]->uMinOutput, FALSE);
      SetDlgItemInt (hWnd, IDC_LVL_MXO_EDT, pLvlClrInf[uCmboChannel]->uMaxOutput, FALSE);
      ConvertFloatToString (pLvlClrInf[uCmboChannel]->uGamma, szBuff, 2);
      SetDlgItemText (hWnd, IDC_LVL_GMA_EDT, szBuff);
      pLvlDlgData->bDoProcess = TRUE;
      L_ApplyFilter (hWnd);
      break;

   case IDC_LVL_ALE_BTN:
      StatusProc.bProgress = FALSE;
      lvlValues.uStructSize = sizeof(LVLCLR);
      nRet = L_AutoColorLevelBitmap(&pLvlDlgData->Bitmap,
                                        &lvlValues,
                                        uBlkClip, // *GLOBAL*
                                        uWhtClip,
                                        AUTO_LEVEL|AUTO_NOPROCESS);

      StatusProc.bProgress = TRUE;
      if (nRet != SUCCESS)
         break;
      
      pLvlDlgData->red    = lvlValues.red   ;
      pLvlDlgData->green  = lvlValues.green ;
      pLvlDlgData->blue   = lvlValues.blue  ;
      pLvlDlgData->master = lvlValues.master;
      
      // Update the dialog
      uCmboChannel  = ComboBox_GetCurSel (GetDlgItem(hWnd, IDC_LVL_CHA_COM));
      pLvlClrInf[0] = &pLvlDlgData->master;
      pLvlClrInf[1] = &pLvlDlgData->red;
      pLvlClrInf[2] = &pLvlDlgData->green;
      pLvlClrInf[3] = &pLvlDlgData->blue;
      pLvlDlgData->bDoProcess = FALSE;
      SetDlgItemInt (hWnd, IDC_LVL_MNI_EDT, pLvlClrInf[uCmboChannel]->uMinInput, FALSE);
      SetDlgItemInt (hWnd, IDC_LVL_MXI_EDT, pLvlClrInf[uCmboChannel]->uMaxInput, FALSE);
      SetDlgItemInt (hWnd, IDC_LVL_MNO_EDT, pLvlClrInf[uCmboChannel]->uMinOutput, FALSE);
      SetDlgItemInt (hWnd, IDC_LVL_MXO_EDT, pLvlClrInf[uCmboChannel]->uMaxOutput, FALSE);
      ConvertFloatToString (pLvlClrInf[uCmboChannel]->uGamma, szBuff, 2);
      SetDlgItemText (hWnd, IDC_LVL_GMA_EDT, szBuff);
      pLvlDlgData->bDoProcess = TRUE;
      L_ApplyFilter (hWnd);
      break;

   case IDC_LVL_ACO_BTN:
      StatusProc.bProgress = FALSE;
      lvlValues.uStructSize = sizeof(LVLCLR);
      nRet = L_AutoColorLevelBitmap(&pLvlDlgData->Bitmap,
                                        &lvlValues,
                                        uBlkClip, // *GLOBAL*
                                        uWhtClip,
                                        AUTO_CONTRAST|AUTO_NOPROCESS);
      StatusProc.bProgress = TRUE;
      if (nRet != SUCCESS)
         break;

      pLvlDlgData->red    = lvlValues.red;
      pLvlDlgData->green  = lvlValues.green;
      pLvlDlgData->blue   = lvlValues.blue;
      pLvlDlgData->master = lvlValues.master;
      
      // Update the dialog
      uCmboChannel  = ComboBox_GetCurSel (GetDlgItem(hWnd, IDC_LVL_CHA_COM));
      pLvlClrInf[0] = &pLvlDlgData->master;
      pLvlClrInf[1] = &pLvlDlgData->red   ;
      pLvlClrInf[2] = &pLvlDlgData->green ;
      pLvlClrInf[3] = &pLvlDlgData->blue  ;
      pLvlDlgData->bDoProcess = FALSE;
      SetDlgItemInt (hWnd, IDC_LVL_MNI_EDT, pLvlClrInf[uCmboChannel]->uMinInput, FALSE);
      SetDlgItemInt (hWnd, IDC_LVL_MXI_EDT, pLvlClrInf[uCmboChannel]->uMaxInput, FALSE);
      SetDlgItemInt (hWnd, IDC_LVL_MNO_EDT, pLvlClrInf[uCmboChannel]->uMinOutput, FALSE);
      SetDlgItemInt (hWnd, IDC_LVL_MXO_EDT, pLvlClrInf[uCmboChannel]->uMaxOutput, FALSE);
      ConvertFloatToString (pLvlClrInf[uCmboChannel]->uGamma, szBuff, 2);
      SetDlgItemText (hWnd, IDC_LVL_GMA_EDT, szBuff);
      pLvlDlgData->bDoProcess = TRUE;
      L_ApplyFilter (hWnd);
      break;

   case IDC_LVL_GMA_EDT:
   case IDC_LVL_MNI_EDT:
   case IDC_LVL_MXI_EDT:
   case IDC_LVL_MNO_EDT:
   case IDC_LVL_MXO_EDT:
      if (codeNotify == EN_CHANGE)
      {
         L_CHAR szTemp [20] = "\0";


         for (uIndex = 1; uIndex <= 4; uIndex++)
            uRangeMax[uIndex] = pLvlDlgData->uMaxClrVal;

         // When edit box is changed, then place new edit value in the associated structure,
         //   move sliders, and ApplyFilter.
         uCmboChannel  = ComboBox_GetCurSel (GetDlgItem(hWnd, IDC_LVL_CHA_COM));
         GetDlgItemTextA(hWnd, nID, szTemp, 20);

         // For IDC_LVL_GMA_EDT, its value is a double and should be converted to int
         if (nID == IDC_LVL_GMA_EDT)
            uEditBoxValue = (L_UINT) (atof (szTemp) * 100);
         else
            uEditBoxValue = (L_UINT) atoi (szTemp);

         // L_LevelingBitmap documentation says that uMaxInput should be larger 
         //    from uMinInput by at least two

         if (nID == IDC_LVL_MNI_EDT)
         {
            if ((L_INT32)GetDlgItemInt(hWnd, IDC_LVL_MXI_EDT, NULL, FALSE) < (L_INT32)(2 + uEditBoxValue))
            {
               uEditBoxValue = GetDlgItemInt(hWnd, IDC_LVL_MXI_EDT, NULL, FALSE) - 2;
               SetDlgItemInt (hWnd, nID, uEditBoxValue, FALSE);
               break;
            }
         }
         if (nID == IDC_LVL_MXI_EDT)
         {
            if ((L_INT32)(GetDlgItemInt(hWnd, IDC_LVL_MNI_EDT, NULL, FALSE) + 2) > (L_INT32)uEditBoxValue)
            {
               uEditBoxValue = GetDlgItemInt(hWnd, IDC_LVL_MNI_EDT, NULL, FALSE) + 2;
               SetDlgItemInt (hWnd, nID, uEditBoxValue, FALSE);
               break;
            }
         }

         // make sure that the edit box value is within range
         uIndex = nID - IDC_LVL_GMA_EDT;
         uEditBoxValue = min(uRangeMax[uIndex], max(uRangeMin[uIndex], uEditBoxValue));

         pLvlClrInf[0] = &pLvlDlgData->master;
         pLvlClrInf[1] = &pLvlDlgData->red;
         pLvlClrInf[2] = &pLvlDlgData->green;
         pLvlClrInf[3] = &pLvlDlgData->blue;

         // First: Update the structure
         switch (nID - IDC_LVL_GMA_EDT)
         {
         case 0: 
            if (pLvlClrInf[uCmboChannel]->uGamma != uEditBoxValue)
            {
               bNoChange = FALSE;
               pLvlClrInf[uCmboChannel]->uGamma = uEditBoxValue;
            }
            break;

         case 1: 
            if (pLvlClrInf[uCmboChannel]->uMinInput != uEditBoxValue)
            {
               bNoChange = FALSE;
               pLvlClrInf[uCmboChannel]->uMinInput = uEditBoxValue;
            }
            break;

         case 2:
            if (pLvlClrInf[uCmboChannel]->uMaxInput != uEditBoxValue)
            {
               bNoChange = FALSE;
               pLvlClrInf[uCmboChannel]->uMaxInput = uEditBoxValue;
            }
            break;

         case 3:
            if (pLvlClrInf[uCmboChannel]->uMinOutput != uEditBoxValue)
            {
               bNoChange = FALSE;
               pLvlClrInf[uCmboChannel]->uMinOutput = uEditBoxValue;
            }
            break;

         case 4:
            if (pLvlClrInf[uCmboChannel]->uMaxOutput != uEditBoxValue)
            {
               bNoChange = FALSE;
               pLvlClrInf[uCmboChannel]->uMaxOutput = uEditBoxValue;
            }
            break;
         }

         // Second: Move the slider. 
         // Notice that this method will not call LevelingDialog_OnHScroll();
         Trackbar_SetPos (GetDlgItem(hWnd, nID + 5), TRUE, uEditBoxValue);

         if (bNoChange)
            break;

         // Third: Apply filter unless it is told not to process
         if (pLvlDlgData->bDoProcess)
            L_ApplyFilter  (hWnd);
         break;
      }
      break;

   case IDC_LVL_WHT_EDT:
      GetDlgItemText (hWnd, nID, szBuff, 8);
      mxVal = (L_INT)(_tcstod (szBuff, NULL) * 100);
      uWhtClip = (L_UINT) mxVal;  // *GLOBAL*
      break;

   case IDC_LVL_BLK_EDT:
      GetDlgItemText (hWnd, nID, szBuff, 8);
      mxVal = (L_INT)(_tcstod (szBuff, NULL) * 100);
      uBlkClip = (L_UINT) mxVal; // *GLOBAL*
      break;

   case IDC_LVL_CHA_COM:
      if (codeNotify == CBN_SELCHANGE)
      {
         pLvlDlgData->bDoProcess = FALSE;
         pLvlClrInf[0] = &pLvlDlgData->master;
         pLvlClrInf[1] = &pLvlDlgData->red   ;
         pLvlClrInf[2] = &pLvlDlgData->green ;
         pLvlClrInf[3] = &pLvlDlgData->blue  ;
         uCmboChannel = ComboBox_GetCurSel (GetDlgItem(hWnd, IDC_LVL_CHA_COM));
         SetDlgItemInt (hWnd, IDC_LVL_MNI_EDT, pLvlClrInf[uCmboChannel]->uMinInput,  FALSE);
         SetDlgItemInt (hWnd, IDC_LVL_MXI_EDT, pLvlClrInf[uCmboChannel]->uMaxInput,  FALSE);
         SetDlgItemInt (hWnd, IDC_LVL_MNO_EDT, pLvlClrInf[uCmboChannel]->uMinOutput, FALSE);
         SetDlgItemInt (hWnd, IDC_LVL_MXO_EDT, pLvlClrInf[uCmboChannel]->uMaxOutput, FALSE);
         ConvertFloatToString (pLvlClrInf[uCmboChannel]->uGamma, szBuff, 2);
         SetDlgItemText(hWnd, IDC_LVL_GMA_EDT, szBuff);
         pLvlDlgData->bDoProcess = TRUE;
         InvalidateRect(hWndCtl, NULL, FALSE);
      }
      break;

   case IDC_LVL_CLP_BTN:
      GetWindowText (hWndCtl, szBuff, 38);

      if (lstrcmp(szBuff, TEXT("S&how Clip")))
      {
         SetWindowText (hWndCtl, TEXT("S&how Clip"));
         for (uIndex = IDC_LVL_WHT_STA; uIndex <= IDC_LVL_PE2_STA; uIndex++)
         {
            ShowWindow (GetDlgItem(hWnd, uIndex), SW_MINIMIZE);
            ShowWindow (GetDlgItem(hWnd, uIndex), SW_HIDE);
         }
      }
      else
      {
         SetWindowText (hWndCtl, TEXT("&Hide Clip"));
         for (uIndex = IDC_LVL_WHT_STA; uIndex <= IDC_LVL_PE2_STA; uIndex++)
         {
            ShowWindow (GetDlgItem(hWnd, uIndex), SW_SHOW);
            ShowWindow (GetDlgItem(hWnd, uIndex), SW_RESTORE);
         }
      }      

      break;
   }
   return TRUE;
}

static L_BOOL LevelingDialog_OnClose (HWND hWnd)
{
   SendMessage (hWnd, IDCANCEL, 0, 0);
   return TRUE;
}

static L_VOID L_ApplyFilter (HWND hWnd)
{
   LPLVLDLGDATA pLvlDlgData;
   pCHILDDATA   pData;
   L_INT        nRet = 0;
   HWND         hWndParent;
//   L_INT        startTime, endTime;
   L_BOOL       bIsTimingChecked;
   L_CHAR       pOutputStr[200] ="\0";
   L_BOOL       bIsGray;
   LVLCLR       LvlClr;
   L_UINT       uFlag;

   if ( 100 != StatusProc.ProgressValue )
   {
      StatusProc.bKillProgress = TRUE ;
      return ;
   }

   pLvlDlgData = (LPLVLDLGDATA) GetWindowLong(hWnd,GWL_USERDATA);

   hWndParent = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData      = LOCKCHILDDATA (hWndParent);

   FreeMemorizedBitmap (hWndParent); //MEMDISK//
   L_CopyBitmap(&pData->LeadBitmap, &pLvlDlgData->Bitmap, sizeof(BITMAPHANDLE));

   bIsTimingChecked = Button_GetCheck (GetDlgItem(hWnd, IDC_LVL_TIM_CHK));

   bIsGray = L_IsGrayScaleBitmap(&pData->LeadBitmap);
   LvlClr.blue   = pLvlDlgData->blue;
   LvlClr.green  = pLvlDlgData->green;
   LvlClr.red    = pLvlDlgData->red;
   LvlClr.master = pLvlDlgData->master;
   LvlClr.uStructSize = sizeof(LVLCLR);
   
   uFlag  = LEVEL_MASTER;
   uFlag |= bIsGray ? 0 : LEVEL_RED;
   uFlag |= bIsGray ? 0 : LEVEL_GREEN;
   uFlag |= bIsGray ? 0 : LEVEL_BLUE;

   nRet = L_ColorLevelBitmap(&pData->LeadBitmap, &LvlClr, uFlag);

   if(nRet == SUCCESS)
   {
      InvalidateRect(hWndParent, NULL, FALSE);
      StatusProc.ProgressValue = 100;
      Progress_SetPos(StatusProc.ProgWnd , 0);
      if(StatusProc.bEnd)
      {
         StatusProc.bProgress     = FALSE;
         StatusProc.bKillProgress = TRUE ;
      }
   }
}