// CKfmnRgnDlg.cpp : implementation file
//

#include "stdafx.h"
#include "clipf32.h"
#include "KfmnRgnDlg.h"
#include "HelpMsgDlg.h"
#include "MainFrm.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CKfmnRgnDlg dialog

const int CLIPF_KFMNRGNDLG_INNER_RGN                        = 0;
const int CLIPF_KFMNRGNDLG_OUTER_RGN                        = 1;

const int CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX           = 0;
const int CLIPF_KFMNRGNDLG_BLURRADIUS_SLIDER_INDEX          = 1;
const int CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX        = 2;
const int CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX        = 3;

CKfmnRgnDlg* CKfmnRgnDlg::m_pKfmnRgnDlg = NULL;

CKfmnRgnDlg::CKfmnRgnDlg(CWnd* pParent /*=NULL*/)
   : CDialog(CLIPF_KFMNRGNDLG_IDDLG, pParent)
{
   m_nSelectedRegion = CLIPF_KFMNRGNDLG_INNER_RGN;

   m_bInnerRegion = FALSE;
   m_bShowTemplate = FALSE;
   m_bShowTrackFrame = TRUE;
   
   m_uFrameType = 0;
   m_bRemoveHoles[CLIPF_KFMNRGNDLG_INNER_RGN]  = m_bRemoveHoles[CLIPF_KFMNRGNDLG_OUTER_RGN]  = TRUE;
   m_uPixelCount[CLIPF_KFMNRGNDLG_INNER_RGN] = m_uPixelCount[CLIPF_KFMNRGNDLG_OUTER_RGN] = 0;
   
   m_crFrame = RGB(255, 0, 0);
   
   m_fAcceptNewValues = TRUE;

   m_pKfmnRgnDlg = NULL;

   m_bInProcess = FALSE;

   m_bKillProgress = FALSE;

   m_bFirstTime = TRUE;
}

CKfmnRgnDlg::~CKfmnRgnDlg()
{
   if(m_hMouseHook)
   {
      UnhookWindowsHookEx(m_hMouseHook);
      m_hMouseHook = NULL;
   }   
   m_pKfmnRgnDlg = NULL;
}

void CKfmnRgnDlg::DoDataExchange(CDataExchange* pDX)
{
   CDialog::DoDataExchange(pDX);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDRB_INNERREGION,
               m_rbInnerRegion);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDRB_OUTERREGION,
               m_rbOuterRegion);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDCHK_SHOWTEMPLATE,
               m_chkShowTemplate);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDCHK_SHOWTRACKFRAME,
               m_chkShowTrackFrame);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDSLDR_THRESHOLD,
               m_sldrThreshold);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDEDT_THRESHOLD,
               m_edtThreshold);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDSLDR_BLURRADIUS,
               m_sldrBlurRadius);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDEDT_BLURRADIUS,
               m_edtBlurRadius);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDSLDR_MINTHRESHOLD,
               m_sldrMinThreshold);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDEDT_MINTHRESHOLD,
               m_edtMinThreshold);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDSLDR_MAXTHRESHOLD,
               m_sldrMaxThreshold);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDEDT_MAXTHRESHOLD,
               m_edtMaxThreshold);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDCHK_REMOVEHOLES,
               m_chkRemoveHoles);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDSTC_INNERTEXT,
               m_stcInnerText);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDSTC_OUTERTEXT,
               m_stcOuterText);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDSTC_AREA,
               m_stcArea);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDBTN_HELP,
               m_btnHelp);

   DDX_Control(pDX,
               CLIPF_KFMNRGNDLG_IDPROG,
               m_progress);
}


BEGIN_MESSAGE_MAP(CKfmnRgnDlg, CDialog)
   ON_BN_CLICKED(CLIPF_KFMNRGNDLG_IDRB_INNERREGION, OnInnerRgn)
   ON_BN_CLICKED(CLIPF_KFMNRGNDLG_IDRB_OUTERREGION, OnOuterRgn)
   ON_BN_CLICKED(CLIPF_KFMNRGNDLG_IDCHK_SHOWTEMPLATE, OnShowTemplate)
   ON_BN_CLICKED(CLIPF_KFMNRGNDLG_IDCHK_SHOWTRACKFRAME, OnShowTrackFrame)
   ON_EN_CHANGE(CLIPF_KFMNRGNDLG_IDEDT_THRESHOLD, OnThresholdChanged)
   ON_EN_KILLFOCUS(CLIPF_KFMNRGNDLG_IDEDT_THRESHOLD, OnKillFocusThresholdEdit)
   ON_EN_CHANGE(CLIPF_KFMNRGNDLG_IDEDT_BLURRADIUS, OnBlurRadiusChanged)
   ON_EN_KILLFOCUS(CLIPF_KFMNRGNDLG_IDEDT_BLURRADIUS, OnKillFocusBlurRadiusEdit)
   ON_EN_CHANGE(CLIPF_KFMNRGNDLG_IDEDT_MINTHRESHOLD, OnMinThresholdChanged)
   ON_EN_KILLFOCUS(CLIPF_KFMNRGNDLG_IDEDT_MINTHRESHOLD, OnKillFocusMinThresholdEdit)
   ON_EN_CHANGE(CLIPF_KFMNRGNDLG_IDEDT_MAXTHRESHOLD, OnMaxThresholdChanged)
   ON_EN_KILLFOCUS(CLIPF_KFMNRGNDLG_IDEDT_MAXTHRESHOLD, OnKillFocusMaxThresholdEdit)
   ON_BN_CLICKED(CLIPF_KFMNRGNDLG_IDCHK_REMOVEHOLES, OnRemoveHoles)
   ON_WM_TIMER()
   ON_WM_HSCROLL()
   ON_WM_CLOSE()
   ON_WM_DESTROY()
   ON_BN_CLICKED(CLIPF_KFMNRGNDLG_IDBTN_HELP, OnHelp)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CKfmnRgnDlg message handlers

BOOL CKfmnRgnDlg::OnInitDialog() 
{
   CDialog::OnInitDialog();

   m_fAcceptNewValues = FALSE;

   m_rbInnerRegion.SetCheck(TRUE);

   m_chkShowTemplate.SetCheck(m_bShowTemplate);
   m_chkShowTrackFrame.SetCheck(m_bShowTrackFrame);
   
   m_sldrThreshold.SetRange(m_SlidersControlsInfo.uMinRange[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX], m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX]);
   m_sldrThreshold.SetPos(m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX]);
   m_edtThreshold.SetWindowText(m_SlidersControlsInfo.strDefaultValue[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX]);
   m_edtThreshold.SetLimitText(m_SlidersControlsInfo.uMaxLimitText[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX]);

   m_sldrBlurRadius.SetRange(m_SlidersControlsInfo.uMinRange[CLIPF_KFMNRGNDLG_BLURRADIUS_SLIDER_INDEX], m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_BLURRADIUS_SLIDER_INDEX]);
   m_sldrBlurRadius.SetPos(m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_BLURRADIUS_SLIDER_INDEX]);
   m_edtBlurRadius.SetWindowText(m_SlidersControlsInfo.strDefaultValue[CLIPF_KFMNRGNDLG_BLURRADIUS_SLIDER_INDEX]);
   m_edtBlurRadius.SetLimitText(m_SlidersControlsInfo.uMaxLimitText[CLIPF_KFMNRGNDLG_BLURRADIUS_SLIDER_INDEX]);

   m_sldrMinThreshold.SetRange(m_SlidersControlsInfo.uMinRange[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX], m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX]);
   m_sldrMinThreshold.SetPos(m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX]);
   m_edtMinThreshold.SetWindowText(m_SlidersControlsInfo.strDefaultValue[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX]);
   m_edtMinThreshold.SetLimitText(m_SlidersControlsInfo.uMaxLimitText[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX]);

   m_sldrMaxThreshold.SetRange(m_SlidersControlsInfo.uMinRange[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX], m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX]);
   m_sldrMaxThreshold.SetPos(m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX]);
   m_edtMaxThreshold.SetWindowText(m_SlidersControlsInfo.strDefaultValue[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX]);
   m_edtMaxThreshold.SetLimitText(m_SlidersControlsInfo.uMaxLimitText[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX]);

   m_chkRemoveHoles.SetCheck(m_bRemoveHoles[m_nSelectedRegion]);
   
   m_progress.SetRange(0, 100);

   m_fAcceptNewValues = TRUE;

   m_hRgn = NULL;

   m_pKfmnRgnDlg = this;

   m_hMouseHook = SetWindowsHookEx(WH_MOUSE, MouseHookProc, AfxGetInstanceHandle(), GetCurrentThreadId());
  
   OnInnerRgn();
   OnOuterRgn();
   OnInnerRgn();

   m_uTimerID = ::SetTimer(GetSafeHwnd(), 1, 100, NULL);
   
   return TRUE;
}

void CKfmnRgnDlg::OnHelp()
{
   if(m_hMouseHook)
   {
      UnhookWindowsHookEx(m_hMouseHook);
      m_hMouseHook = NULL;
   }

   CHelpMsgDlg dlgHelpMsg;

   dlgHelpMsg.DoModal();

   m_hMouseHook = SetWindowsHookEx(WH_MOUSE, MouseHookProc, AfxGetInstanceHandle(), GetCurrentThreadId());
}

void CKfmnRgnDlg::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
   if(m_fAcceptNewValues)
   {
      if(pScrollBar->GetSafeHwnd() == m_sldrThreshold.GetSafeHwnd())
      {
         L_UINT32 nValue = m_sldrThreshold.GetPos();

         if(nValue != m_uThreshold[m_nSelectedRegion])
         {
            CString strValue = _T("");

            strValue.Format(_T("%d"), nValue);

            m_fAcceptNewValues = FALSE;
            m_edtThreshold.SetWindowText(strValue);
            m_fAcceptNewValues = TRUE;
            m_uThreshold[m_nSelectedRegion] = nValue;

            ApplyFunction();
         }
      }
      else if(pScrollBar->GetSafeHwnd() == m_sldrBlurRadius.GetSafeHwnd())
      {
         L_UINT32 nValue = m_sldrBlurRadius.GetPos();

         if(nValue != m_uBlurRadius[m_nSelectedRegion])
         {
            CString strValue = _T("");

            strValue.Format(_T("%d"), nValue);

            m_fAcceptNewValues = FALSE;
            m_edtBlurRadius.SetWindowText(strValue);
            m_fAcceptNewValues = TRUE;
      
            m_uBlurRadius[m_nSelectedRegion] = nValue;

            ApplyFunction();
         }
      }
      else if(pScrollBar->GetSafeHwnd() == m_sldrMinThreshold.GetSafeHwnd())
      {
         L_UINT32 nValue = m_sldrMinThreshold.GetPos();

         if(nValue != m_uMaxThreshold[m_nSelectedRegion])
         {
            if((nValue + 2) < m_uMaxThreshold[m_nSelectedRegion])
            {
               CString strValue = _T("");

               strValue.Format(_T("%d"), nValue); 

               m_fAcceptNewValues = FALSE;
               m_edtMinThreshold.SetWindowText(strValue);
               m_fAcceptNewValues = TRUE;
               m_uMinThreshold[m_nSelectedRegion] = nValue;

               ApplyFunction();
            }
            else
            {
               m_uMinThreshold[m_nSelectedRegion] = m_uMaxThreshold[m_nSelectedRegion]-2;

               m_sldrMinThreshold.SetPos(m_uMinThreshold[m_nSelectedRegion]);

               CString strValue = _T("");

               strValue.Format(_T("%d"), m_uMinThreshold[m_nSelectedRegion]);
               m_fAcceptNewValues = FALSE;
               m_edtMinThreshold.SetWindowText(strValue);
               m_fAcceptNewValues = TRUE;
            }
         }
      }
      else if(pScrollBar->GetSafeHwnd() == m_sldrMaxThreshold.GetSafeHwnd())
      {
         L_UINT32 nValue = m_sldrMaxThreshold.GetPos();

         if(nValue != m_uMaxThreshold[m_nSelectedRegion])
         {
            if((nValue - 2) > m_uMinThreshold[m_nSelectedRegion])
            {
               CString strValue = _T("");

               strValue.Format(_T("%d"), nValue);

               m_fAcceptNewValues = FALSE;
               m_edtMaxThreshold.SetWindowText(strValue);
               m_fAcceptNewValues = TRUE;
               m_uMaxThreshold[m_nSelectedRegion] = nValue;
               
               ApplyFunction();
            }
            else
            {
               m_uMaxThreshold[m_nSelectedRegion] = m_uMinThreshold[m_nSelectedRegion]+2;
               m_sldrMaxThreshold.SetPos(m_uMaxThreshold[m_nSelectedRegion]);
         
               CString strValue;
               strValue.Format(_T("%d"), m_uMaxThreshold[m_nSelectedRegion]);
               m_fAcceptNewValues = FALSE;
               m_edtMaxThreshold.SetWindowText(strValue);
               m_fAcceptNewValues = TRUE;
            }
         }
      }
   }
}

void CKfmnRgnDlg::OnThresholdChanged() 
{
   CString strValue = _T("");

   m_edtThreshold.GetWindowText(strValue);

   L_UINT32 nValue = (int)_tcstod(strValue, NULL);

   if(nValue < m_SlidersControlsInfo.uMinRange[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX]) 
   {
      return;
   }
   else if(nValue > m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX]) 
   {
      return;
   }

   m_uThreshold[m_nSelectedRegion] = nValue;

   if(GetFocus()->GetSafeHwnd() == m_edtThreshold.GetSafeHwnd())
      m_sldrThreshold.SetPos(m_uThreshold[m_nSelectedRegion]);

   ApplyFunction();
}

void CKfmnRgnDlg::OnBlurRadiusChanged()
{
   CString strValue = _T("");

   m_edtBlurRadius.GetWindowText(strValue);

   L_UINT32 nValue = (int)_tcstod(strValue, NULL);

   if(nValue < m_SlidersControlsInfo.uMinRange[CLIPF_KFMNRGNDLG_BLURRADIUS_SLIDER_INDEX]) 
   {
      return;
   }
   else if(nValue > m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_BLURRADIUS_SLIDER_INDEX]) 
   {
      return;
   }

   m_uBlurRadius[m_nSelectedRegion] = nValue;

   if(GetFocus()->GetSafeHwnd() == m_edtBlurRadius.GetSafeHwnd())
      m_sldrBlurRadius.SetPos(m_uBlurRadius[m_nSelectedRegion]);

   ApplyFunction();
}

void CKfmnRgnDlg::OnMinThresholdChanged()
{
   CString strValue = _T("");

   m_edtMinThreshold.GetWindowText(strValue);

   L_UINT32 nValue = (int)_tcstod(strValue, NULL);

   if(nValue < m_SlidersControlsInfo.uMinRange[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX])
   {
      return;
   }
   else if((nValue + 2) > m_uMaxThreshold[m_nSelectedRegion]) 
   {
      nValue = m_uMaxThreshold[m_nSelectedRegion] - 2;

      CString strValue = _T("");

      strValue.Format(_T("%d"), nValue);

      m_edtMinThreshold.SetWindowText(strValue);
   }

   m_uMinThreshold[m_nSelectedRegion] = nValue;

   if(GetFocus()->GetSafeHwnd() == m_edtMinThreshold.GetSafeHwnd())
      m_sldrMinThreshold.SetPos(m_uMinThreshold[m_nSelectedRegion]);

   ApplyFunction();
}

void CKfmnRgnDlg::OnMaxThresholdChanged()
{
   CString strValue = _T("");

   m_edtMaxThreshold.GetWindowText(strValue);

   L_UINT32 nValue = (int)_tcstod(strValue, NULL);

   if(nValue < m_SlidersControlsInfo.uMinRange[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX]) 
   {
      return;
   }
   else if((nValue - 2) < m_uMinThreshold[m_nSelectedRegion]) 
   {
      nValue = m_uMinThreshold[m_nSelectedRegion] + 2;

      CString strValue = _T("");

      strValue.Format(_T("%d"), nValue);

      m_edtMaxThreshold.SetWindowText(strValue);
   }

   m_uMaxThreshold[m_nSelectedRegion] = nValue;

   if(GetFocus()->GetSafeHwnd() == m_edtMaxThreshold.GetSafeHwnd())
      m_sldrMaxThreshold.SetPos(m_uMaxThreshold[m_nSelectedRegion]);

   ApplyFunction();
}

void CKfmnRgnDlg::OnKillFocusThresholdEdit()
{
   CString strValue;

   GetDlgItemText(CLIPF_KFMNRGNDLG_IDEDT_THRESHOLD, strValue);

   if(strValue.GetLength() == 0)
   {
      SetDlgItemInt(CLIPF_KFMNRGNDLG_IDEDT_THRESHOLD, m_uThreshold[m_nSelectedRegion]);
      return;
   }
   else
   {
      L_UINT nValue = GetDlgItemInt(CLIPF_KFMNRGNDLG_IDEDT_THRESHOLD);

      if(nValue > m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX])
      {
         m_uThreshold[m_nSelectedRegion] = m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX];

         SetDlgItemInt(CLIPF_KFMNRGNDLG_IDEDT_THRESHOLD, m_uThreshold[m_nSelectedRegion]);
         return;
      }
   }

   ApplyFunction();

   return;
}

void CKfmnRgnDlg::OnKillFocusBlurRadiusEdit()
{
   CString strValue;

   GetDlgItemText(CLIPF_KFMNRGNDLG_IDEDT_BLURRADIUS, strValue);

   if(strValue.GetLength() == 0)
   {
      SetDlgItemInt(CLIPF_KFMNRGNDLG_IDEDT_BLURRADIUS, m_uBlurRadius[m_nSelectedRegion]);
      return;
   }
   else
   {
      L_UINT nValue = GetDlgItemInt(CLIPF_KFMNRGNDLG_IDEDT_BLURRADIUS);

         
      if(nValue > m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_BLURRADIUS_SLIDER_INDEX])
      {
         m_uBlurRadius[m_nSelectedRegion] = m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_BLURRADIUS_SLIDER_INDEX];

         SetDlgItemInt(CLIPF_KFMNRGNDLG_IDEDT_BLURRADIUS, m_uBlurRadius[m_nSelectedRegion]);
         return;
      }
   }

   ApplyFunction();

   return;
}

void CKfmnRgnDlg::OnKillFocusMinThresholdEdit()
{
   CString strValue;

   GetDlgItemText(CLIPF_KFMNRGNDLG_IDEDT_MINTHRESHOLD, strValue);

   if(strValue.GetLength() == 0)
   {
      SetDlgItemInt(CLIPF_KFMNRGNDLG_IDEDT_MINTHRESHOLD, m_uMinThreshold[m_nSelectedRegion]);
      return;
   }
   else
   {
      L_UINT nValue = GetDlgItemInt(CLIPF_KFMNRGNDLG_IDEDT_MINTHRESHOLD);

      if(nValue > m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX])
      {
         m_uMinThreshold[m_nSelectedRegion] = m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX];

         SetDlgItemInt(CLIPF_KFMNRGNDLG_IDEDT_MINTHRESHOLD, m_uThreshold[m_nSelectedRegion]);
         return;
      }
   }

   ApplyFunction();

   return;
}

void CKfmnRgnDlg::OnKillFocusMaxThresholdEdit()
{
   CString strValue;

   GetDlgItemText(CLIPF_KFMNRGNDLG_IDEDT_MAXTHRESHOLD, strValue);

   if(strValue.GetLength() == 0)
   {
      SetDlgItemInt(CLIPF_KFMNRGNDLG_IDEDT_MAXTHRESHOLD, m_uMaxThreshold[m_nSelectedRegion]);
      return;
   }
   else
   {
      L_UINT nValue = GetDlgItemInt(CLIPF_KFMNRGNDLG_IDEDT_MAXTHRESHOLD);

      if(nValue < m_SlidersControlsInfo.uMinRange[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX])
      {
         m_uMaxThreshold[m_nSelectedRegion] = m_SlidersControlsInfo.uMinRange[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX];

         SetDlgItemInt(CLIPF_KFMNRGNDLG_IDEDT_MAXTHRESHOLD, m_uMaxThreshold[m_nSelectedRegion]);
         return;
      }

      if(nValue > m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX])
      {
         m_uMaxThreshold[m_nSelectedRegion] = m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX];

         SetDlgItemInt(CLIPF_KFMNRGNDLG_IDEDT_MAXTHRESHOLD, m_uMaxThreshold[m_nSelectedRegion]);
         return;
      }
   }

   ApplyFunction();

   return;
}

void CKfmnRgnDlg::OnRemoveHoles()
{
   m_bRemoveHoles[m_nSelectedRegion] = m_chkRemoveHoles.GetCheck();

   ApplyFunction();   
}

void CKfmnRgnDlg::ApplyFunction()
{
   L_INT        nRet = 0;
   LUserBitmap  lViewedBitmap;

   lViewedBitmap.m_pKfmnDlg = this;
   
   if(!m_fAcceptNewValues)
      return;

   if(m_bInProcess)
   {
      m_bKillProgress = TRUE;
      return;
   }

   nRet = lViewedBitmap.Copy(m_lOrgBitmap);

   // Finding information
   BITMAPHANDLE hProcessedBitmap;
   hProcessedBitmap.uStructSize = sizeof(BITMAPHANDLE);

   lViewedBitmap.EnableStatusCallBack(TRUE);
   m_bInProcess = TRUE;
   nRet = lViewedBitmap.SetKaufmannRgn(&hProcessedBitmap,
                                       m_uBlurRadius[m_nSelectedRegion],
                                       m_uMinThreshold[m_nSelectedRegion],
                                       m_uMaxThreshold[m_nSelectedRegion],
                                       m_uThreshold[m_nSelectedRegion],
                                       m_ptCenter[m_nSelectedRegion],
                                       m_bRemoveHoles[m_nSelectedRegion],
                                       &m_uPixelCount[m_nSelectedRegion],
                                       L_RGN_SET);


   LBitmap  lProcessedBitmap;

   if (nRet != SUCCESS)
   {
      m_progress.SetPos(0);
      return;
   }

   lProcessedBitmap.SetHandle(&hProcessedBitmap);
   UpdateRgnTextInfo();


   if(m_bShowTemplate)
   {
      lViewedBitmap.SetHandle(lProcessedBitmap.GetHandle());
   }

   m_pMainView->m_Bitmap.SetHandle(lViewedBitmap.GetHandle());
   
   m_pMainView->RefreshBitmap();

   if(m_bFirstTime)
   {
      m_uPixelCount[CLIPF_KFMNRGNDLG_OUTER_RGN] = m_uPixelCount[CLIPF_KFMNRGNDLG_INNER_RGN];
      m_bFirstTime = FALSE;
   }

   if (nRet == SUCCESS)
      CalculatePercentage();

   m_bInProcess = FALSE;
}

void CKfmnRgnDlg::SetDlgParams(CCLIPF32View * pMainView)
{
   m_pMainView = pMainView;

   m_lOrgBitmap.Copy(m_pMainView->m_Bitmap);

   if(m_lOrgBitmap.IsAllocated())
   {
      m_ptCenter[CLIPF_KFMNRGNDLG_INNER_RGN]  = m_ptCenter[CLIPF_KFMNRGNDLG_OUTER_RGN] = 
      
      m_ptCenter[CLIPF_KFMNRGNDLG_INNER_RGN].x = m_ptCenter[CLIPF_KFMNRGNDLG_OUTER_RGN].x = m_lOrgBitmap.GetWidth() / 2;
      m_ptCenter[CLIPF_KFMNRGNDLG_INNER_RGN].y = m_ptCenter[CLIPF_KFMNRGNDLG_OUTER_RGN].y = m_lOrgBitmap.GetHeight() / 2;

      m_hRgn = m_pMainView->m_Bitmap.Region()->GetRgnHandle();

      m_SlidersControlsInfo.uMinRange[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX] = 0;
      m_SlidersControlsInfo.uMinRange[CLIPF_KFMNRGNDLG_BLURRADIUS_SLIDER_INDEX] = 1;
      m_SlidersControlsInfo.uMinRange[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX] = 0;
      m_SlidersControlsInfo.uMinRange[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX] = 2;
 
      m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX] = 255;
      m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_BLURRADIUS_SLIDER_INDEX] = 100;
      m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX] = 255;
      m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX] = 255;

      m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX] = 25;
      m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_BLURRADIUS_SLIDER_INDEX] = 5;
      m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX] = 5;
      m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX] = 255;

      m_SlidersControlsInfo.uMaxLimitText[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX] = 3;
      m_SlidersControlsInfo.uMaxLimitText[CLIPF_KFMNRGNDLG_BLURRADIUS_SLIDER_INDEX] = 3;
      m_SlidersControlsInfo.uMaxLimitText[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX] = 3;
      m_SlidersControlsInfo.uMaxLimitText[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX] = 3;

      m_SlidersControlsInfo.strDefaultValue[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX] = _T("25");
      m_SlidersControlsInfo.strDefaultValue[CLIPF_KFMNRGNDLG_BLURRADIUS_SLIDER_INDEX] = _T("5");
      m_SlidersControlsInfo.strDefaultValue[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX] = _T("5");
      m_SlidersControlsInfo.strDefaultValue[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX] = _T("255");

      if(m_lOrgBitmap.GetBitsPerPixel() == 12)
      {
         m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX] = 4095;
         m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX] = 4093;
         m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX] = 4095;

         m_SlidersControlsInfo.uMaxLimitText[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX] = 4;
         m_SlidersControlsInfo.uMaxLimitText[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX] = 4;
         m_SlidersControlsInfo.uMaxLimitText[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX] = 4;

         m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX] = 400;
         m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX] = 0;
         m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX] = 4095;

         m_SlidersControlsInfo.strDefaultValue[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX] = _T("400");
         m_SlidersControlsInfo.strDefaultValue[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX] = _T("0");
         m_SlidersControlsInfo.strDefaultValue[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX] = _T("4095");
      }
      else if(m_lOrgBitmap.GetBitsPerPixel() == 16 && m_lOrgBitmap.IsGrayScale())
      {
         m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX] = 65535;
         m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX] = 65533;
         m_SlidersControlsInfo.uMaxRange[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX] = 65535;

         m_SlidersControlsInfo.uMaxLimitText[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX] = 5;
         m_SlidersControlsInfo.uMaxLimitText[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX] = 5;
         m_SlidersControlsInfo.uMaxLimitText[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX] = 5;

         m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX] = 6400;
         m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX] = 0;
         m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX] = 65535;

         m_SlidersControlsInfo.strDefaultValue[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX] = _T("6400");
         m_SlidersControlsInfo.strDefaultValue[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX] = _T("0");
         m_SlidersControlsInfo.strDefaultValue[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX] = _T("65535");
      }

      m_uThreshold[CLIPF_KFMNRGNDLG_INNER_RGN]    = m_uThreshold[CLIPF_KFMNRGNDLG_OUTER_RGN]    = m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_THRESHOLD_SLIDER_INDEX];
      m_uBlurRadius[CLIPF_KFMNRGNDLG_INNER_RGN]   = m_uBlurRadius[CLIPF_KFMNRGNDLG_OUTER_RGN]   = m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_BLURRADIUS_SLIDER_INDEX];
      m_uMinThreshold[CLIPF_KFMNRGNDLG_INNER_RGN] = m_uMinThreshold[CLIPF_KFMNRGNDLG_OUTER_RGN] = m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_MINTHRESHOLD_SLIDER_INDEX];
      m_uMaxThreshold[CLIPF_KFMNRGNDLG_INNER_RGN] = m_uMaxThreshold[CLIPF_KFMNRGNDLG_OUTER_RGN] = m_SlidersControlsInfo.uDefaultValue[CLIPF_KFMNRGNDLG_MAXTHRESHOLD_SLIDER_INDEX];
   }
}

void CKfmnRgnDlg::UpdateRgnTextInfo()
{
   CString strText = _T("");

   strText.Format(_T("Threshold: %d\nBlur Radius: %d\nMin: %d\nMax: %d\nRemove Hole: %s\n(X, Y): %d, %d\nPixel Count: %d"),
                  m_uThreshold[m_nSelectedRegion],
                  m_uBlurRadius[m_nSelectedRegion],
                  m_uMinThreshold[m_nSelectedRegion],
                  m_uMaxThreshold[m_nSelectedRegion],
                  (m_bRemoveHoles[m_nSelectedRegion] ? _T("True") : _T("False")),
                  m_ptCenter[m_nSelectedRegion].x,
                  m_ptCenter[m_nSelectedRegion].y,
                  m_uPixelCount[m_nSelectedRegion]);

   if(m_nSelectedRegion == CLIPF_KFMNRGNDLG_INNER_RGN)
      m_stcInnerText.SetWindowText(strText);
   else
      m_stcOuterText.SetWindowText(strText);
}

void CKfmnRgnDlg::UpdateControls()
{
   CString strValue = _T("");

   m_fAcceptNewValues = FALSE;
   m_sldrThreshold.SetPos(m_uThreshold[m_nSelectedRegion]);
   strValue.Format(_T("%d"), m_uThreshold[m_nSelectedRegion]);
   m_edtThreshold.SetWindowText(strValue);
   m_fAcceptNewValues = TRUE;

   m_fAcceptNewValues = FALSE;
   m_sldrBlurRadius.SetPos(m_uBlurRadius[m_nSelectedRegion]);
   strValue.Format(_T("%d"), m_uBlurRadius[m_nSelectedRegion]);
   m_edtBlurRadius.SetWindowText(strValue);
   m_fAcceptNewValues = TRUE;

   m_fAcceptNewValues = FALSE;
   m_sldrMinThreshold.SetPos(m_uMinThreshold[m_nSelectedRegion]);
   strValue.Format(_T("%d"), m_uMinThreshold[m_nSelectedRegion]);
   m_edtMinThreshold.SetWindowText(strValue);
   m_fAcceptNewValues = TRUE;

   m_fAcceptNewValues = FALSE;
   m_sldrMaxThreshold.SetPos(m_uMaxThreshold[m_nSelectedRegion]);
   strValue.Format(_T("%d"), m_uMaxThreshold[m_nSelectedRegion]);
   m_edtMaxThreshold.SetWindowText(strValue);
   m_fAcceptNewValues = TRUE;

   m_fAcceptNewValues = FALSE;
   m_chkRemoveHoles.SetCheck(m_bRemoveHoles[m_nSelectedRegion]);
   m_fAcceptNewValues = TRUE;

   UpdateRgnTextInfo();
}

void CKfmnRgnDlg::OnInnerRgn()
{
   if(!m_bInnerRegion)
   {
      m_bInnerRegion = TRUE;

      m_nSelectedRegion = CLIPF_KFMNRGNDLG_INNER_RGN;

      m_crFrame = RGB(255, 0, 0);

      HRGN  hTmpRgn = NULL;

      if(m_hRgn)
      {
         hTmpRgn = CreateRectRgn(0, 0, 0, 0);
         CombineRgn(hTmpRgn, m_hRgn, 0, RGN_COPY);
         DeleteObject(m_hRgn);
      }

      m_hRgn = m_pMainView->m_Bitmap.Region()->GetRgnHandle();
      m_pMainView->m_Bitmap.Region()->SetRgnCombineMode(L_RGN_SET);
      m_pMainView->m_Bitmap.Region()->SetRgnHandle(hTmpRgn);

      DeleteObject(hTmpRgn);

      UpdateControls();

      ApplyFunction();

      m_pMainView->InvalidateRect( NULL, FALSE);
      m_pMainView->UpdateWindow();
   }
}

void CKfmnRgnDlg::OnOuterRgn()
{
   if(m_bInnerRegion)
   {
      m_bInnerRegion = FALSE;

      m_nSelectedRegion = CLIPF_KFMNRGNDLG_OUTER_RGN;

      m_crFrame = RGB(0, 0, 255);

      HRGN  hTmpRgn = NULL;

      if(m_hRgn)
      {
         hTmpRgn = CreateRectRgn(0, 0, 0, 0);
         CombineRgn(hTmpRgn, m_hRgn, 0, RGN_COPY);
         DeleteObject(m_hRgn);
      }

      m_hRgn = m_pMainView->m_Bitmap.Region()->GetRgnHandle();
      m_pMainView->m_Bitmap.Region()->SetRgnHandle(hTmpRgn);
      DeleteObject(hTmpRgn);

      UpdateControls();

      ApplyFunction();

      m_pMainView->InvalidateRect( NULL, FALSE);
      m_pMainView->UpdateWindow();
   }
}

void CKfmnRgnDlg::OnShowTemplate()
{
   m_bShowTemplate = m_chkShowTemplate.GetCheck();
   ApplyFunction();
}

void CKfmnRgnDlg::OnShowTrackFrame()
{
   m_bShowTrackFrame = m_chkShowTrackFrame.GetCheck();
   m_pMainView->InvalidateRect( NULL, FALSE);
   m_pMainView->UpdateWindow();
}

void CKfmnRgnDlg::ConvertFloatToString(L_INT flt, L_TCHAR szBuff[], L_INT nPrecise)
{
   L_INT   left, right;
   TCHAR   lChar[10] = _T("\0");
   TCHAR   rChar[10] = _T("\0");
   L_INT   nPercentage;

   nPercentage = (L_INT)pow(10, nPrecise);

   left  = flt / nPercentage;
   if (left)
      right = flt % (left * nPercentage);
   else
      right = flt;

   wsprintf(lChar, _T("%d"), left);
   
   if (right > 9)
      wsprintf(rChar, _T("%d"), right);
   else
      wsprintf(rChar, _T("0%d"), right);

   wsprintf(szBuff, _T("%s.%s"), lChar, rChar);
}

void CKfmnRgnDlg::CalculatePercentage()
{
   TCHAR           szStr[200];
   TCHAR           szRes[20];

   wsprintf(szRes, _T("0.00"));
   if(m_uPixelCount[CLIPF_KFMNRGNDLG_OUTER_RGN])
      ConvertFloatToString(m_uPixelCount[CLIPF_KFMNRGNDLG_INNER_RGN] * 10000 / m_uPixelCount[CLIPF_KFMNRGNDLG_OUTER_RGN], szRes, 2);

   wsprintf(szStr, TEXT("  Area: %s %% (In / Out)        -        "), szRes);

   wsprintf(szRes, TEXT("0.00"));
   if (m_uPixelCount[CLIPF_KFMNRGNDLG_INNER_RGN])
      ConvertFloatToString(m_uPixelCount[CLIPF_KFMNRGNDLG_OUTER_RGN] * 10000 / m_uPixelCount[CLIPF_KFMNRGNDLG_INNER_RGN], szRes, 2);
   wsprintf(szStr, TEXT("%s%s %% (Out / In)"), szStr, szRes);

   m_stcArea.SetWindowText(szStr); 
}

LRESULT CKfmnRgnDlg::MouseHookProc(L_INT nCode, WPARAM wParam, LPARAM lParam)
{
   if((m_pKfmnRgnDlg != NULL))
      if(m_pKfmnRgnDlg->IsWindowVisible())
   {
      LPMOUSEHOOKSTRUCT pMouseHook;
      RECT              rcRect;
      POINT             TmpPoint;

      pMouseHook = (LPMOUSEHOOKSTRUCT)lParam;

      ASSERT(m_pKfmnRgnDlg != NULL);
      
      m_pKfmnRgnDlg->GetWindowRect(&rcRect);

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

      switch(LOWORD(wParam))
      {
         case WM_NCMOUSEMOVE:
         {
            TmpPoint = pMouseHook->pt;
            if(PtInRect(&rcRect, TmpPoint))
               break;

            ::ScreenToClient(m_pKfmnRgnDlg->m_pMainView->GetSafeHwnd(), &TmpPoint);

            CRect rcDst;            
            m_pKfmnRgnDlg->m_pMainView->m_Bitmap.GetRects(NULL, NULL, &rcDst, NULL);

            if(PtInRect(&rcDst, TmpPoint))
            {
               m_pKfmnRgnDlg->m_pMainView->OnChangeCursor(IDC_CROSS);
            }
            else
            {
               m_pKfmnRgnDlg->m_pMainView->OnChangeCursor(IDC_ARROW);
            }
         }
         break;

         case WM_NCLBUTTONDOWN:
         {
            TmpPoint = pMouseHook->pt;
            if (PtInRect(&rcRect, TmpPoint))
               break;
            
            m_pKfmnRgnDlg->m_pMainView->m_Bitmap.Region()->Free();
            m_pKfmnRgnDlg->m_pMainView->OnChangeCursor(IDC_CROSS);

            ::ScreenToClient(m_pKfmnRgnDlg->m_pMainView->GetSafeHwnd(), &pMouseHook->pt);

            CRect rcDst;            
            m_pKfmnRgnDlg->m_pKfmnRgnDlg->m_pMainView->m_Bitmap.GetRects(NULL, NULL, &rcDst, NULL);

            if(PtInRect(&rcDst, pMouseHook->pt))
            {
               m_pKfmnRgnDlg->m_ptCenter[m_pKfmnRgnDlg->m_nSelectedRegion].x = pMouseHook->pt.x - rcDst.left;
               m_pKfmnRgnDlg->m_ptCenter[m_pKfmnRgnDlg->m_nSelectedRegion].y = pMouseHook->pt.y - rcDst.top;
         
               m_pKfmnRgnDlg->ApplyFunction();
               m_pKfmnRgnDlg->m_pMainView->OnChangeCursor(IDC_CROSS);
            }
            else
            {
               m_pKfmnRgnDlg->m_pMainView->OnChangeCursor(IDC_ARROW);
            }
         }
         break;

         case WM_LBUTTONUP:
         case WM_NCLBUTTONUP:
         {
            TmpPoint = pMouseHook->pt;
            if (PtInRect(&rcRect, TmpPoint))
               break;

            m_pKfmnRgnDlg->m_pMainView->OnChangeCursor(IDC_ARROW);
         }
         break;
      }

      if (LOWORD(wParam) >= WM_NCMOUSEMOVE && LOWORD(wParam) <= WM_NCMBUTTONDBLCLK)
         return TRUE;
      else
         return CallNextHookEx(m_pKfmnRgnDlg->m_hMouseHook , nCode, wParam, lParam);
   }

   return FALSE;
}

void CKfmnRgnDlg::OnTimer(UINT nIDEvent)
{
   if(m_uTimerID == nIDEvent)
   {
      Btmp_Timer();
   }
}

void CKfmnRgnDlg::Btmp_Timer()
{
   RGNXFORM     XForm;
   HDC          hDC;

   if(m_pMainView->m_Bitmap.HasRgn())
   {
      hDC = ::GetDC(m_pMainView->GetSafeHwnd());
      if (!hDC)
         return;

      m_pMainView->m_Bitmap.Paint()->SetDC(hDC);

      XForm.uViewPerspective = TOP_LEFT;
      XForm.nXScalarNum = 1;
      XForm.nXScalarDen = 1;
      XForm.nYScalarNum = 1;
      XForm.nYScalarDen = 1;
      XForm.nXOffset    = -::GetScrollPos(m_pMainView->GetSafeHwnd(), SB_HORZ);
      XForm.nYOffset    = -::GetScrollPos(m_pMainView->GetSafeHwnd(), SB_VERT);

      m_uFrameType = (m_uFrameType + 1) % 8;
      m_pMainView->m_Bitmap.Paint()->FrameRgn(m_uFrameType, &XForm);
 
      ::ReleaseDC(m_pMainView->GetSafeHwnd(), hDC);

      m_pMainView->m_Bitmap.Paint()->SetDC(NULL);
   }
}

void CKfmnRgnDlg::OnDestroy()
{
   KillTimer(m_uTimerID);
}