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

#include "ImgPF.h"

static L_BOOL KfmnDlg_OnInitDialog (HWND hWnd, HWND hWndFocus, LPARAM lParam);
static L_BOOL KfmnDlg_OnCommand    (HWND hWnd, L_INT nID, HWND hWndCtl, L_UINT uCodeNotify);
static L_BOOL KfmnDlg_OnHScroll    (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos);
static L_VOID KfmnDlg_OnTimer      (HWND hWnd, L_INT nID);
static L_VOID L_ApplyFilter        (HWND hWnd);

L_VOID AddTextToDialog(HWND hWnd)
{
   L_TCHAR L_FAR * szText;
   szText = (L_TCHAR L_FAR *)malloc(4095 * sizeof(L_TCHAR));

   wsprintf(szText, TEXT("%s\r\n\r\n%s\r\n\r\n%s\r\n\r\n%s\r\n\r\n%s\r\n\r\n%s\r\n\r\n%s\r\n\r\n%s"), 
            TEXT("This dialog was made especially for Kaufmann Volume Analysis."),
            TEXT("This dialog is used to calculate the ratio between the corpus callosm (which is the white matter in the middle of the brain that looks like the letter X) and the brain sphere."),
            TEXT("To Achieve this, do the following steps:"), 
            TEXT("1) Make sure that the Inner Region radio button is checked."),
            TEXT("2) Start adjusting the parameters in order to make a selection around the corpus callosm."),
            TEXT("3) Check the outer radio button."),
            TEXT("4) Now Adjust the parameter in order to make a selection around the outer brain sphere."),
            TEXT("5) The kaufmann ratio will be at the bottom of the Kaufmann dialog along with some other informations."));
   SetWindowText(hWnd, szText);
   free(szText);
}

L_BOOL CALLBACK IntroDlg(HWND hWnd, L_UINT uMessage, WPARAM wParam, LPARAM lParam)
{
   switch(uMessage)
   {
   case WM_INITDIALOG:
      MoveDialogToMiddle(hWnd);
      AddTextToDialog(GetDlgItem(hWnd, IDD_KINTRO_TXT));
      ShowWindow(hWnd, SW_SHOW);
      UpdateWindow(hWnd);
      break;
   case WM_COMMAND:
      {
         L_INT nID = (L_INT)(LOWORD(wParam));

         switch(nID)
         {
         case IDCANCEL:
         case IDOK:
            EndDialog(hWnd, IDOK - nID);
            break;
         }
      }
   }
   return FALSE;
}

L_BOOL CALLBACK KfmnDlgProc(HWND hWnd, L_UINT uMessage, WPARAM wParam, LPARAM lParam)
{
   HWND       hWndParent = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pCHILDDATA pData      = LOCKCHILDDATA (hWndParent);

   switch(uMessage)
   {
      HANDLE_MSG (hWnd, WM_COMMAND,    KfmnDlg_OnCommand);
      HANDLE_MSG (hWnd, WM_INITDIALOG, KfmnDlg_OnInitDialog);
      HANDLE_MSG (hWnd, WM_HSCROLL,    KfmnDlg_OnHScroll);
      HANDLE_MSG (hWnd, WM_TIMER,      KfmnDlg_OnTimer);

   case WM_NCLBUTTONDOWN:
      {
         LPKFNRGNDLGDATA pKfnRgnDlgData = (LPKFNRGNDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
         pKfnRgnDlgData->bShowFrame = FALSE;
         pData->bDrawColoredFrame = FALSE;
      }
      break;

   case WM_EXITSIZEMOVE:
      {
         LPKFNRGNDLGDATA pKfnRgnDlgData = (LPKFNRGNDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
         pKfnRgnDlgData->bShowFrame = TRUE;
         pData->bDrawColoredFrame = TRUE;
         InvalidateRect(hWndParent, NULL, FALSE);
      }
      break;

   case WM_USER_UPDATEVIEW:
      StatusProc.ProgressValue = 100;
      L_ApplyFilter (hWnd);
      break;
   }
   return FALSE;
}

L_VOID UpdateRegionTextInfo (HWND hWnd, L_UINT nCtrlID, L_INT nRet)
{
   LPKFNRGNDLGDATA   pKfnRgnDlgData;
   TCHAR             pStr[200];
   L_INT             nIndex;

   if (nRet == ERROR_USER_ABORT)
      return;

   nIndex = nCtrlID - IDC_KFMN_IN_TXT;

   pKfnRgnDlgData = (LPKFNRGNDLGDATA) GetWindowLong(hWnd,GWL_USERDATA);

   if (nRet == SUCCESS)
      wsprintf(pStr, TEXT("Threshold: %d\nDim: %d\nMin: %d\nMax: %d\nRemove Hole: %s\n(X, Y): %d, %d\nPixel Count: %d"),
               pKfnRgnDlgData->nThr[nIndex],
               pKfnRgnDlgData->nDim[nIndex],
               pKfnRgnDlgData->nMin[nIndex],
               pKfnRgnDlgData->nMax[nIndex],
               (pKfnRgnDlgData->bRemHole[nIndex] ? "True" : "False"),
               pKfnRgnDlgData->ptCenter[nIndex].x,
               pKfnRgnDlgData->ptCenter[nIndex].y,
               pKfnRgnDlgData->uPixelCount[nIndex]);
   else
      wsprintf(pStr, TEXT("Could not load information"));
   SetDlgItemText(hWnd, nCtrlID, pStr);
}

L_VOID CalculatePercentage(HWND hWnd)
{
   LPKFNRGNDLGDATA pKfnRgnDlgData;
   TCHAR           pStr[200];
   TCHAR           pRes[20];

   pKfnRgnDlgData = (LPKFNRGNDLGDATA) GetWindowLong(hWnd,GWL_USERDATA);

   wsprintf(pRes, TEXT("0.00"));
   if (pKfnRgnDlgData->uPixelCount[1])
      ConvertFloatToString(pKfnRgnDlgData->uPixelCount[0] * 10000 / pKfnRgnDlgData->uPixelCount[1], pRes, 2);
   wsprintf(pStr, TEXT("  Area: %s %% (In / Out)        -        "), pRes);

   wsprintf(pRes, TEXT("0.00"));
   if (pKfnRgnDlgData->uPixelCount[0])
      ConvertFloatToString(pKfnRgnDlgData->uPixelCount[1] * 10000 / pKfnRgnDlgData->uPixelCount[0], pRes, 2);
   wsprintf(pStr, TEXT("%s%s %% (Out / In)"), pStr, pRes);

   
   SetDlgItemText(hWnd, IDC_KFMN_RES_TXT, pStr);
}

static LRESULT CALLBACK Mouse(L_INT nCode, WPARAM wParam, LPARAM lParam) 
{
   LPKFNRGNDLGDATA   pKfnRgnDlgData;
   LPMOUSEHOOKSTRUCT pMouseHook;
   HWND              hWndParent;
   pCHILDDATA        pData;
   RECT              rcRect;
   POINT             TmpPoint;
   L_INT             nLevel;

   hWndParent     = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData          = LOCKCHILDDATA (hWndParent);
   pKfnRgnDlgData = (LPKFNRGNDLGDATA)GetWindowLong(hGlobalWnd, GWL_USERDATA);
   pMouseHook     = (LPMOUSEHOOKSTRUCT)lParam;

   nLevel = (IsDlgButtonChecked(hGlobalWnd, IDC_KFMN_IN_RAD) ? 0 : 1);

   GetWindowRect(hGlobalWnd, &rcRect);
   if (PtInRect(&rcRect, pMouseHook->pt))
      return 0;

   switch(LOWORD(wParam))
   {
   case WM_NCMOUSEMOVE:
      TmpPoint = pMouseHook->pt;
      if (PtInRect(&rcRect, TmpPoint))
         break;
      ScreenToClient(hWndParent, &TmpPoint);
      if (PtInRect(&pData->rcView, TmpPoint))
         PostMessage (hWndParent, WM_USER_CHANGECURSOR, 0, (LONG)IDC_CROSS);
      else
         PostMessage (hWndParent, WM_USER_CHANGECURSOR, 0, (LONG)IDC_ARROW);
      break;

   case WM_NCLBUTTONDOWN:
      TmpPoint = pMouseHook->pt;
      if (PtInRect(&rcRect, TmpPoint))
         break;
      if (L_BitmapHasRgn(&pData->LeadBitmap))
         L_FreeBitmapRgn(&pData->LeadBitmap);
      PostMessage (hWndParent, WM_USER_CHANGECURSOR, 0, (LONG)IDC_CROSS);
      ScreenToClient(hWndParent, &pMouseHook->pt);
      GetClientRect(hWndParent, &rcRect);
      if (PtInRect(&pData->rcView, pMouseHook->pt))
      {
         pData->ptCenter.x = pKfnRgnDlgData->ptCenter[nLevel].x = pMouseHook->pt.x + pData->nHScrollPos;
         pData->ptCenter.y = pKfnRgnDlgData->ptCenter[nLevel].y = pMouseHook->pt.y + pData->nVScrollPos;
         
         L_ApplyFilter (hGlobalWnd);
         PostMessage (hWndParent, WM_USER_CHANGECURSOR, 0, (LONG)IDC_CROSS);
      }
      else
         PostMessage (hWndParent, WM_USER_CHANGECURSOR, 0, (LONG)IDC_ARROW);
      break;

   case WM_LBUTTONUP:
   case WM_NCLBUTTONUP:
      TmpPoint = pMouseHook->pt;
      if (PtInRect(&rcRect, TmpPoint))
         break;
      PostMessage (hWndParent, WM_USER_CHANGECURSOR, 0, (LONG)IDC_CROSS);
      pKfnRgnDlgData->bShowFrame = TRUE;
      InvalidateRect(hWndParent, NULL, FALSE);
      break;
   }

   if (pKfnRgnDlgData)
   {
      if (LOWORD(wParam) >= WM_NCMOUSEMOVE && LOWORD(wParam) <= WM_NCMBUTTONDBLCLK)
         return TRUE;
      else
         return CallNextHookEx(pKfnRgnDlgData->hMouseHook , nCode, wParam, lParam); 
   }
   else
      return FALSE;
}

static L_BOOL KfmnDlg_OnInitDialog (HWND hWnd, HWND hWndFocus, LPARAM lParam)
{
   LPKFNRGNDLGDATA pKfnRgnDlgData;
   HWND         hWndParent;
   pCHILDDATA   pData;
   RECT         rcRgn;
   L_INT        nRangeMax[] = {100, 255, 255, 255};
   L_INT        nRangeMin[] = {  1,   0,   0,   0};
   L_INT        nPosInit [] = {  5,   5, 255,  25};
   L_INT        nSlider;
   
   hWndParent     = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData          = LOCKCHILDDATA (hWndParent);
   pKfnRgnDlgData = (LPKFNRGNDLGDATA)lParam;
   hGlobalWnd     = hWnd;
   pData->bCross  = TRUE;
   pKfnRgnDlgData->bFirstTime = TRUE;
   MoveDialogToMiddle(hWnd);

   pKfnRgnDlgData->hRgn = NULL;
   pData->bDrawColoredFrame = FALSE;
   if (pData->LeadBitmap.BitsPerPixel == 12)
   {
      nPosInit[1] = 0;
      nPosInit[2] = 0xfff;
      nPosInit[3] = nPosInit[3] * 16; 

      nRangeMax[1] = 0xfff;
      nRangeMax[2] = 0xfff;
      nRangeMax[3] = 0xfff; 
   }
   else
   {
      if ((pData->LeadBitmap.BitsPerPixel == 16) && (L_IsGrayScaleBitmap(&pData->LeadBitmap)))
      {
         nPosInit[1] = 0;
         nPosInit[2] = 0xffff;
         nPosInit[3] = nPosInit[3] * 256; 

         nRangeMax[1] = 0xffff;
         nRangeMax[2] = 0xffff;
         nRangeMax[3] = 0xffff;
      }
   }

   SetWindowLong(hWnd, GWL_USERDATA, (LONG)pKfnRgnDlgData);

   pKfnRgnDlgData->crFrameColor = RGB(255, 0, 0);
   pKfnRgnDlgData->bShowFrame   = FALSE;

   //MEMDISK...//
   MemorizeAndCopyBitmap (hWndParent, &pKfnRgnDlgData->LeadBitmap);
   L_GetBitmapRgnBounds(&pKfnRgnDlgData->LeadBitmap, NULL, &rcRgn);

   Progress_SetRange(StatusProc.ProgWnd, 0, 100);
   Progress_SetPos(StatusProc.ProgWnd, 0);

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

   ShowWindow(hWnd, SW_SHOW);

   CheckDlgButton(hWnd, IDC_KFMN_STF_CHK, BST_CHECKED);
   CheckDlgButton(hWnd, IDC_KFMN_IN_RAD,  BST_CHECKED);

   pKfnRgnDlgData->nDim[1]       = pKfnRgnDlgData->nDim[0] = nPosInit[0];
   pKfnRgnDlgData->nMin[1]       = pKfnRgnDlgData->nMin[0] = nPosInit[1];
   pKfnRgnDlgData->nMax[1]       = pKfnRgnDlgData->nMax[0] = nPosInit[2];
   pKfnRgnDlgData->nThr[1]       = pKfnRgnDlgData->nThr[0] = nPosInit[3];
   pKfnRgnDlgData->ptCenter[1].x = pKfnRgnDlgData->ptCenter[0].x = pData->LeadBitmap.Width / 2;
   pKfnRgnDlgData->ptCenter[1].y = pKfnRgnDlgData->ptCenter[0].y = pData->LeadBitmap.Height / 2;
   pKfnRgnDlgData->bRemHole[1]   = pKfnRgnDlgData->bRemHole[0];
   pData->ptCenter.x             = pKfnRgnDlgData->ptCenter[0].x;
   pData->ptCenter.y             = pKfnRgnDlgData->ptCenter[0].y;

   pKfnRgnDlgData->nSlideNum  = 4;
   pKfnRgnDlgData->nSldBaseID = IDC_KFMN_DIM_SLD;
   pKfnRgnDlgData->nEdtBaseID = IDC_KFMN_DIM_EDT;

   for (nSlider = 0; nSlider < pKfnRgnDlgData->nSlideNum; nSlider++)
   {
      Trackbar_SetTheRange(GetDlgItem(hWnd, pKfnRgnDlgData->nSldBaseID + nSlider), TRUE, nRangeMin[nSlider], nRangeMax[nSlider]);
      SetDlgItemInt(hWnd, pKfnRgnDlgData->nEdtBaseID + nSlider, nPosInit[nSlider], TRUE);
      SetNumericEditBox(GetDlgItem(hWnd, pKfnRgnDlgData->nEdtBaseID + nSlider), nRangeMin[nSlider], nRangeMax[nSlider], 1, 0, FALSE);
   }

   pKfnRgnDlgData->hMouseHook = SetWindowsHookEx(WH_MOUSE, Mouse, hInst, GetCurrentThreadId());
   pData->uTimerID = SetTimer(hWnd, 1, 100, NULL);

   Button_SetCheck(GetDlgItem(hWnd, IDC_KFMN_RH_CHK), TRUE);
   pKfnRgnDlgData->bRemHole[0] = pKfnRgnDlgData->bRemHole[1] = TRUE;
   UpdateRegionTextInfo (hWnd, IDC_KFMN_OUT_TXT, 1);
   L_ApplyFilter(hWnd);
   pKfnRgnDlgData->bShowFrame = TRUE;
   pData->bDrawColoredFrame = TRUE;

   return TRUE;
}

static L_VOID KfmnDlg_OnTimer (HWND hWnd, L_INT nID)
{
   Dialog_Timer(nID);
}

static L_BOOL KfmnDlg_OnCommand (HWND hWnd, L_INT nID, HWND hWndCtl, L_UINT uCodeNotify)
{
   LPKFNRGNDLGDATA pKfnRgnDlgData;
   HWND            hWndParent;
   L_INT           nLevel = 0;
   HWND            hCtl;
   pCHILDDATA      pData;
   L_INT           nValue, nIndex;
   RECT            rcRgn;

   hWndParent     = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData          = LOCKCHILDDATA (hWndParent);
   pKfnRgnDlgData = (LPKFNRGNDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);

   L_GetBitmapRgnBounds(&pKfnRgnDlgData->LeadBitmap, NULL, &rcRgn);
   
   nLevel = (IsDlgButtonChecked(hWnd, IDC_KFMN_IN_RAD) ? 0 : 1);

   if (nID >= pKfnRgnDlgData->nEdtBaseID && nID < pKfnRgnDlgData->nEdtBaseID + pKfnRgnDlgData->nSlideNum)
   {
      if(uCodeNotify == EN_CHANGE)
      {
         nValue = GetDlgItemInt(hWnd, nID, NULL, TRUE);
         hCtl   = GetDlgItem(hWnd,nID + pKfnRgnDlgData->nSlideNum);
         nIndex = nID - pKfnRgnDlgData->nEdtBaseID;
         Trackbar_SetPos(hCtl, TRUE, nValue);

         switch (nIndex)
         {
         case 0:
            if(pKfnRgnDlgData->nDim[nLevel] == nValue)
               return TRUE;
            pKfnRgnDlgData->nDim[nLevel] = nValue;
            break;

         case 1:
            if(pKfnRgnDlgData->nMin[nLevel] == nValue)
               return TRUE;
            if ((nValue + 2) > pKfnRgnDlgData->nMax[nLevel])
            {
               nValue = pKfnRgnDlgData->nMax[nLevel] - 2;
               pKfnRgnDlgData->nMin[nLevel] = nValue;
               Trackbar_SetPos(GetDlgItem(hWnd, IDC_KFMN_MIN_SLD), TRUE, nValue);
               SetDlgItemInt(hWnd, nID, nValue, FALSE);
            }
            else
               pKfnRgnDlgData->nMin[nLevel] = nValue;
            break;

         case 2:
            if(pKfnRgnDlgData->nMax[nLevel] == nValue)
               return TRUE;
            if ((nValue - 2) < pKfnRgnDlgData->nMin[nLevel])
            {
               nValue = pKfnRgnDlgData->nMin[nLevel] + 2;
               pKfnRgnDlgData->nMax[nLevel] = nValue;
               Trackbar_SetPos(GetDlgItem(hWnd, IDC_KFMN_MAX_SLD), TRUE, nValue);
               SetDlgItemInt(hWnd, nID, nValue, FALSE);
            }
            else
               pKfnRgnDlgData->nMax[nLevel] = nValue;
            break;

         case 3:
            if(pKfnRgnDlgData->nThr[nLevel] == nValue)
               return TRUE;
            pKfnRgnDlgData->nThr[nLevel] = nValue;
            break;
         }
         L_ApplyFilter (hWnd);
      }
   }

   switch(nID)
   {
   case IDC_KFMN_HLP_BTN:
      UnhookWindowsHookEx(pKfnRgnDlgData->hMouseHook);
      DoDialogBoxParam(IDD_KINTRO_DLG, hWnd, IntroDlg, 0);
      pKfnRgnDlgData->hMouseHook = SetWindowsHookEx(WH_MOUSE, Mouse, hInst, GetCurrentThreadId());
      break;

   case IDC_KFMN_RH_CHK:
      pKfnRgnDlgData->bRemHole[nLevel] = IsDlgButtonChecked(hWnd, IDC_KFMN_RH_CHK);
      L_ApplyFilter(hWnd);
      break;

   case IDC_KFMN_SHW_CHK:
      L_ApplyFilter(hWnd);
      break;

   case IDC_KFMN_STF_CHK:
      pKfnRgnDlgData->bShowFrame = 
      pData->bDrawColoredFrame = Button_GetCheck(hWndCtl);
      InvalidateRect(hWndParent, NULL, FALSE);
      break;

   case IDC_KFMN_IN_RAD:
   case IDC_KFMN_OUT_RAD:
      {
         HRGN  hTmpRgn = NULL;

         pKfnRgnDlgData->crFrameColor = RGB(255, 0, 0);
         if (nID == IDC_KFMN_OUT_RAD)
            pKfnRgnDlgData->crFrameColor = RGB(0, 0, 255);

         nLevel = (IsDlgButtonChecked(hWnd, IDC_KFMN_IN_RAD) ? 0 : 1);
         SetDlgItemInt(hWnd,IDC_KFMN_THR_EDT, pKfnRgnDlgData->nThr[nLevel], FALSE);
         SetDlgItemInt(hWnd,IDC_KFMN_DIM_EDT, pKfnRgnDlgData->nDim[nLevel], FALSE);
         SetDlgItemInt(hWnd,IDC_KFMN_MIN_EDT, pKfnRgnDlgData->nMin[nLevel], FALSE);
         SetDlgItemInt(hWnd,IDC_KFMN_MAX_EDT, pKfnRgnDlgData->nMax[nLevel], FALSE);
         CheckDlgButton(hWnd, IDC_KFMN_RH_CHK, pKfnRgnDlgData->bRemHole[nLevel]);
         pData->bCross = TRUE;
         pData->ptCenter.x = pKfnRgnDlgData->ptCenter[nLevel].x;
         pData->ptCenter.y = pKfnRgnDlgData->ptCenter[nLevel].y;

         if (pKfnRgnDlgData->hRgn)
         {
            hTmpRgn = CreateRectRgn(0, 0, 0, 0);
            CopyRgn(hTmpRgn, pKfnRgnDlgData->hRgn);
            DeleteObject(pKfnRgnDlgData->hRgn);
         }

         L_GetBitmapRgnHandle(&pData->LeadBitmap, NULL, &pKfnRgnDlgData->hRgn);
         L_SetBitmapRgnHandle(&pData->LeadBitmap, NULL, hTmpRgn, L_RGN_SET);
         DeleteObject(hTmpRgn);

         if (IsDlgButtonChecked(hWnd, IDC_KFMN_SHW_CHK))
            L_ApplyFilter(hWnd);
         else
            InvalidateRect(hWndParent, NULL, FALSE);
      }
      break;

   case IDOK:
   case IDCANCEL:
      pData->bCross            = FALSE;
      StatusProc.bProgress     = FALSE;
      StatusProc.bKillProgress = TRUE;
      StatusProc.ProgressValue = 100;
      UnhookWindowsHookEx(pKfnRgnDlgData->hMouseHook);

      if (pKfnRgnDlgData->hRgn)
         DeleteRgn(pKfnRgnDlgData->hRgn);
      pKfnRgnDlgData->hRgn = NULL;
      pKfnRgnDlgData->bShowFrame = FALSE;
      pData->bDrawColoredFrame = FALSE;
      L_FreeBitmap(&pData->LeadBitmap);
      L_CopyBitmap(&pData->LeadBitmap, &pKfnRgnDlgData->LeadBitmap, sizeof(BITMAPHANDLE));

      EndDialog(hWnd, FALSE);
      break;
   }
   return TRUE;
}

static L_BOOL KfmnDlg_OnHScroll (HWND hWnd, HWND hWndCtl, L_UINT nCode, L_INT nPos)
{
   LPKFNRGNDLGDATA pKfnRgnDlgData;

   pKfnRgnDlgData = (LPKFNRGNDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);
   SetDlgItemInt(hWnd, GetDlgCtrlID(hWndCtl) - pKfnRgnDlgData->nSlideNum , Trackbar_GetPos(hWndCtl), TRUE);
   return TRUE;
}

L_VOID L_ApplyFilter (HWND hWnd)
{
   pCHILDDATA        pData;
   L_INT             nRet = 0;
   HWND              hWndParent;
   LPKFNRGNDLGDATA   pKfnRgnDlgData;
   BITMAPHANDLE      ProcessedBmp;
   L_INT             nIndex;

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

   pKfnRgnDlgData = (LPKFNRGNDLGDATA) GetWindowLong(hWnd,GWL_USERDATA);
   hWndParent  = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData       = LOCKCHILDDATA (hWndParent);

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

   // Finding information
   nIndex = (IsDlgButtonChecked(hWnd, IDC_KFMN_IN_RAD) ? 0 : 1);

   ProcessedBmp.uStructSize = sizeof(BITMAPHANDLE);
   nRet = L_SetKaufmannRgnBitmap(&pData->LeadBitmap,
                                 &ProcessedBmp,
                                 pKfnRgnDlgData->nDim[nIndex],
                                 pKfnRgnDlgData->nMin[nIndex],
                                 pKfnRgnDlgData->nMax[nIndex],
                                 pKfnRgnDlgData->nThr[nIndex],
                                 pKfnRgnDlgData->ptCenter[nIndex],
                                 pKfnRgnDlgData->bRemHole[nIndex],
                                 &pKfnRgnDlgData->uPixelCount[nIndex],
                                 L_RGN_SET);

   UpdateRegionTextInfo (hWnd, IDC_KFMN_IN_TXT + nIndex, nRet);

   if (nRet != SUCCESS)
   {
      StatusProc.ProgressValue = 100;
      return;
   }

   if (Button_GetCheck(GetDlgItem(hWnd, IDC_KFMN_SHW_CHK)))
   {
      L_FreeBitmap(&pData->LeadBitmap);
      L_CopyBitmapHandle(&pData->LeadBitmap, &ProcessedBmp, sizeof(BITMAPHANDLE));
   }
   else
      L_FreeBitmap(&ProcessedBmp);

   if (nRet == SUCCESS)
      CalculatePercentage(hWnd);

   if(nRet == SUCCESS)
   {
      if (pKfnRgnDlgData->bFirstTime)
      {
         pKfnRgnDlgData->bFirstTime = FALSE;
         L_GetBitmapRgnHandle(&pData->LeadBitmap, NULL, &pKfnRgnDlgData->hRgn);
         pKfnRgnDlgData->uPixelCount[1] = pKfnRgnDlgData->uPixelCount[0];
         CalculatePercentage (hWnd);
      }

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

L_VOID DrawColoredFrame(HWND hWnd, HDC hDC)
{
   LPKFNRGNDLGDATA pKfnRgnDlgData;
   HWND            hWndParent;
   pCHILDDATA      pData;
   HBRUSH          hBrush;
   HRGN            hTmpRgn = NULL;
   RECT            rcRect;
   hWndParent     = FORWARD_WM_MDIGETACTIVE(hWndClient,SendMessage);
   pData          = LOCKCHILDDATA (hWndParent);
   pKfnRgnDlgData = (LPKFNRGNDLGDATA) GetWindowLong(hWnd, GWL_USERDATA);

   SetCursor (LoadCursor(NULL, IDC_WAIT));
   hTmpRgn = CreateRectRgn(0, 0, 1, 1);
   CopyRgn(hTmpRgn, pKfnRgnDlgData->hRgn);
   GetRgnBox(pKfnRgnDlgData->hRgn, &rcRect);
   OffsetRgn(hTmpRgn, -pData->nHScrollPos, -pData->nVScrollPos);
   hBrush = CreateSolidBrush(pKfnRgnDlgData->crFrameColor);

   FrameRgn(hDC, hTmpRgn, hBrush, 1, 1);

   DeleteObject(hBrush);
   DeleteObject(hTmpRgn);
   SetCursor (LoadCursor(NULL, IDC_ARROW));
}