// SegmentationPropPage.cpp : implementation file
//

#include "stdafx.h"

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

/////////////////////////////////////////////////////////////////////////////
// CSegmentationPropPage property page

IMPLEMENT_DYNCREATE(CSegmentationPropPage, CPropertyPage)

int CombineThreshold;

CSegmentationPropPage::CSegmentationPropPage() : CPropertyPage(CSegmentationPropPage::IDD)
{
	//{{AFX_DATA_INIT(CSegmentationPropPage)
	m_bSearchBkgnd = FALSE;
	m_nInputImageQuality = -1;
	m_nOutputImageQuality = -1;
	m_nType = -1;
	m_nBkgndThreshold = 0;
	m_nCleanSize = 0;
	m_nColorThreshold = 0;
	m_nCombineThreshold = 0;
	m_nQuality = 0;
	m_nBkgndThresholdSlider = 0;
	m_nCleanSizeSlider = 0;
	m_nColorThresholdSlider = 0;
	m_nCombineThresholdSlider = 0;
	m_nQualitySlider = 0;
	//}}AFX_DATA_INIT
   CombineThreshold = 0 ;
}

CSegmentationPropPage::~CSegmentationPropPage()
{
}

void CSegmentationPropPage::DoDataExchange(CDataExchange* pDX)
{
	CPropertyPage::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CSegmentationPropPage)
	DDX_Check(pDX, IDC_CHECK_SEARCHBKGND, m_bSearchBkgnd);
	DDX_CBIndex(pDX, IDC_COMBO_SEGM_IIQ, m_nInputImageQuality);
	DDX_CBIndex(pDX, IDC_COMBO_SEGM_OIQ, m_nOutputImageQuality);
	DDX_CBIndex(pDX, IDC_COMBO_SEGM_TYPE, m_nType);
	DDX_Text(pDX, IDC_EDIT_BKGNDTHRESHOLD, m_nBkgndThreshold);
	DDV_MinMaxInt(pDX, m_nBkgndThreshold, 0, 100);
	DDX_Text(pDX, IDC_EDIT_CLEANSIZE, m_nCleanSize);
	DDV_MinMaxInt(pDX, m_nCleanSize, 0, 10);
	DDX_Text(pDX, IDC_EDIT_COLORTHRESHOLD, m_nColorThreshold);
	DDV_MinMaxInt(pDX, m_nColorThreshold, 0, 100);
	DDX_Text(pDX, IDC_EDIT_COMBINETHRESHOLD, m_nCombineThreshold);
	DDV_MinMaxInt(pDX, m_nCombineThreshold, 0, 300);
	DDX_Text(pDX, IDC_EDIT_QUALITY, m_nQuality);
	DDV_MinMaxInt(pDX, m_nQuality, 0, 100);
	DDX_Slider(pDX, IDC_SLIDER_BKGNDTHRESHOLD, m_nBkgndThresholdSlider);
	DDX_Slider(pDX, IDC_SLIDER_CLEANSIZE, m_nCleanSizeSlider);
	DDX_Slider(pDX, IDC_SLIDER_COLORTHRESHOLD, m_nColorThresholdSlider);
	DDX_Slider(pDX, IDC_SLIDER_COMBINETHRESHOLD, m_nCombineThresholdSlider);
	DDX_Slider(pDX, IDC_SLIDER_QUALITY, m_nQualitySlider);
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CSegmentationPropPage, CPropertyPage)
	//{{AFX_MSG_MAP(CSegmentationPropPage)
	ON_CBN_SELCHANGE(IDC_COMBO_SEGM_IIQ, OnSelchangeComboSegmIiq)
	ON_CBN_SELCHANGE(IDC_COMBO_SEGM_OIQ, OnSelchangeComboSegmOiq)
	ON_NOTIFY(NM_CUSTOMDRAW, IDC_SLIDER_BKGNDTHRESHOLD, OnCustomdrawSliderBkgndthreshold)
	ON_NOTIFY(NM_CUSTOMDRAW, IDC_SLIDER_CLEANSIZE, OnCustomdrawSliderCleansize)
	ON_NOTIFY(NM_CUSTOMDRAW, IDC_SLIDER_COMBINETHRESHOLD, OnCustomdrawSliderCombinethreshold)
	ON_NOTIFY(NM_CUSTOMDRAW, IDC_SLIDER_QUALITY, OnCustomdrawSliderQuality)
	ON_NOTIFY(NM_CUSTOMDRAW, IDC_SLIDER_COLORTHRESHOLD, OnCustomdrawSliderColorthreshold)
	ON_EN_KILLFOCUS(IDC_EDIT_BKGNDTHRESHOLD, OnKillfocusEditBkgndthreshold)
	ON_EN_KILLFOCUS(IDC_EDIT_CLEANSIZE, OnKillfocusEditCleansize)
	ON_EN_KILLFOCUS(IDC_EDIT_COLORTHRESHOLD, OnKillfocusEditColorthreshold)
	ON_EN_KILLFOCUS(IDC_EDIT_COMBINETHRESHOLD, OnKillfocusEditCombinethreshold)
	ON_EN_KILLFOCUS(IDC_EDIT_QUALITY, OnKillfocusEditQuality)
	ON_BN_CLICKED(IDC_CHECK_SEARCHBKGND, OnCheckSearchbkgnd)
	ON_CBN_SELCHANGE(IDC_COMBO_SEGM_TYPE, OnSelchangeComboSegmType)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CSegmentationPropPage message handlers

BOOL CSegmentationPropPage::OnInitDialog() 
{
	CPropertyPage::OnInitDialog();
	
	// TODO: Add extra initialization here

   CDemo*      pTheApp   =  (CDemo*)     AfxGetApp(); 

   m_nInputImageQuality    = pTheApp->Options.SEGM_nInputImageQuality;
   m_nOutputImageQuality   = pTheApp->Options.SEGM_nOutputImageQuality;

   m_nCombineThreshold     = pTheApp->Options.SEGM_nCombineThreshold;
   m_nBkgndThreshold       = pTheApp->Options.SEGM_nBkgndThreshold;
   m_nCleanSize            = pTheApp->Options.SEGM_nCleanSize;

   m_nQuality              = pTheApp->Options.SEGM_nQuality;
   m_nColorThreshold       = pTheApp->Options.SEGM_nColorThreshold;
   m_nType                 = pTheApp->Options.SEGM_nType;
   m_uFlags                = pTheApp->Options.SEGM_uFlags;

   CombineThreshold        = m_nCombineThreshold ;
   
   UpdateData(FALSE);

   OnSelchangeComboSegmIiq();
   OnSelchangeComboSegmOiq();
   
	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}

void CSegmentationPropPage::OnSelchangeComboSegmIiq() 
{
   SetModified(TRUE);

   UpdateData(TRUE);
   if (m_nInputImageQuality==6)
   {
      GetDlgItem(IDC_SLIDER_BKGNDTHRESHOLD)->EnableWindow(TRUE);
      GetDlgItem(IDC_SLIDER_CLEANSIZE)->EnableWindow(TRUE);
      GetDlgItem(IDC_SLIDER_COMBINETHRESHOLD)->EnableWindow(TRUE);
      GetDlgItem(IDC_EDIT_BKGNDTHRESHOLD)->EnableWindow(TRUE);
      GetDlgItem(IDC_EDIT_CLEANSIZE)->EnableWindow(TRUE);
      GetDlgItem(IDC_EDIT_COMBINETHRESHOLD)->EnableWindow(TRUE);
   }
   else
   {
      GetDlgItem(IDC_SLIDER_BKGNDTHRESHOLD)->EnableWindow(FALSE);
      GetDlgItem(IDC_SLIDER_CLEANSIZE)->EnableWindow(FALSE);
      GetDlgItem(IDC_SLIDER_COMBINETHRESHOLD)->EnableWindow(FALSE);
      GetDlgItem(IDC_EDIT_BKGNDTHRESHOLD)->EnableWindow(FALSE);
      GetDlgItem(IDC_EDIT_CLEANSIZE)->EnableWindow(FALSE);
      GetDlgItem(IDC_EDIT_COMBINETHRESHOLD)->EnableWindow(FALSE);
   }

   switch(m_nInputImageQuality)
   {
   case 0:
      m_nCombineThresholdSlider  = 100/3;
      m_nBkgndThresholdSlider    = 15;
      m_nCleanSizeSlider         = 7*10;
      m_nCombineThreshold        = 100;
      m_nCleanSize               = 7 ;
      break;
   case 1:
      m_nCombineThresholdSlider  = 125/3;
      m_nBkgndThresholdSlider    = 25;
      m_nCleanSizeSlider         = 10*10;
      m_nCombineThreshold        = 125;
      m_nCleanSize               = 10 ;
      break;
   case 2:
      m_nCombineThresholdSlider  = 125/3;
      m_nBkgndThresholdSlider    = 15;
      m_nCleanSizeSlider         = 8*10;
      m_nCombineThreshold        = 125;
      m_nCleanSize               = 8 ;
     break;
   case 3:
      m_nCombineThresholdSlider  = 100/3;
      m_nBkgndThresholdSlider    = 10;
      m_nCleanSizeSlider         = 7*10;
      m_nCombineThreshold        = 100;
      m_nCleanSize               = 7 ;
      break;
   case 4:
      m_nCombineThresholdSlider  = 75/3;
      m_nBkgndThresholdSlider    = 10;
      m_nCleanSizeSlider         = 3*10;
      m_nCombineThreshold        = 75;
      m_nCleanSize               = 3 ;
      break;
   case 5:
      m_nCombineThresholdSlider  = 75/3;
      m_nBkgndThresholdSlider    = 0;
      m_nCleanSizeSlider         = 3*10;
      m_nCombineThreshold        = 75;
      m_nBkgndThreshold          = 0;
      m_nCleanSize               = 3 ;
      break;
   case 6: //user-defined image quality
      CDemo*      pTheApp   =  (CDemo*)     AfxGetApp(); 

      m_nCombineThresholdSlider  = pTheApp->Options.SEGM_nCombineThreshold/3;
      m_nBkgndThresholdSlider    = pTheApp->Options.SEGM_nBkgndThreshold;
      m_nCleanSizeSlider         = pTheApp->Options.SEGM_nCleanSize*10;
      m_nCombineThreshold        = pTheApp->Options.SEGM_nCombineThreshold;
      m_nCleanSize               = pTheApp->Options.SEGM_nCleanSize ;
      break;
   }

   CombineThreshold  = m_nCombineThreshold ;

   m_nBkgndThreshold = m_nBkgndThresholdSlider;
   UpdateData(FALSE);
}

void CSegmentationPropPage::OnSelchangeComboSegmOiq() 
{
   SetModified(TRUE);
   
   UpdateData(TRUE);
   if (m_nOutputImageQuality==5)
   {
      GetDlgItem(IDC_SLIDER_QUALITY)->EnableWindow(TRUE);
      GetDlgItem(IDC_SLIDER_COLORTHRESHOLD)->EnableWindow(TRUE);
      GetDlgItem(IDC_EDIT_QUALITY)->EnableWindow(TRUE);
      GetDlgItem(IDC_EDIT_COLORTHRESHOLD)->EnableWindow(TRUE);
      GetDlgItem(IDC_COMBO_SEGM_TYPE)->EnableWindow(TRUE);
      GetDlgItem(IDC_CHECK_SEARCHBKGND)->EnableWindow(TRUE);
   }
   else
   {
      GetDlgItem(IDC_SLIDER_QUALITY)->EnableWindow(FALSE);
      GetDlgItem(IDC_SLIDER_COLORTHRESHOLD)->EnableWindow(FALSE);
      GetDlgItem(IDC_EDIT_QUALITY)->EnableWindow(FALSE);
      GetDlgItem(IDC_EDIT_COLORTHRESHOLD)->EnableWindow(FALSE);
      GetDlgItem(IDC_COMBO_SEGM_TYPE)->EnableWindow(FALSE);
      GetDlgItem(IDC_CHECK_SEARCHBKGND)->EnableWindow(FALSE);
   }

   switch(m_nOutputImageQuality)
   {
   case 0:
      m_nQualitySlider        = 50;
      m_nColorThresholdSlider = 25;
      m_uFlags                = SGM_FAVOR_TWOBIT | SGM_WITHOUTBKGRND;
      break;
   case 1:
      m_nQualitySlider        = 0;
      m_nColorThresholdSlider = 30;
      m_uFlags                = SGM_FORCE_ONEBIT | SGM_WITHBKGRND;
      break;
   case 2:
      m_nQualitySlider        = 50;
      m_nColorThresholdSlider = 25;
      m_uFlags                = SGM_FAVOR_ONEBIT | SGM_WITHBKGRND;
      break;
   case 3:
      m_nQualitySlider        = 75;
      m_nColorThresholdSlider = 25;
      m_uFlags                = SGM_FAVOR_TWOBIT | SGM_WITHOUTBKGRND;
      break;
   case 4:
      m_nQualitySlider        = 100;
      m_nColorThresholdSlider = 25;
      m_uFlags                = SGM_FORCE_TWOBIT | SGM_WITHOUTBKGRND;
      break;
   case 5: //user-defined image quality
      CDemo*      pTheApp   =  (CDemo*)     AfxGetApp(); 

      m_nQualitySlider        = pTheApp->Options.SEGM_nQuality;
      m_nColorThresholdSlider = pTheApp->Options.SEGM_nColorThreshold;
      m_uFlags                = pTheApp->Options.SEGM_uFlags;
      break;
   }

   m_nQuality        = m_nQualitySlider ;
   m_nColorThreshold = m_nColorThresholdSlider ;
   m_nType           = m_uFlags & 0x000F ;
   m_bSearchBkgnd    = !(m_uFlags & 0x00F0);

   UpdateData(FALSE);
}

void CSegmentationPropPage::OnCustomdrawSliderBkgndthreshold(NMHDR* pNMHDR, LRESULT* pResult) 
{
   *pResult = 0;

   UpdateData(TRUE);
   if(m_nBkgndThreshold != m_nBkgndThresholdSlider)
      SetModified(TRUE);

   m_nBkgndThreshold = m_nBkgndThresholdSlider;
   UpdateData(FALSE);
}

void CSegmentationPropPage::OnCustomdrawSliderCleansize(NMHDR* pNMHDR, LRESULT* pResult) 
{
   *pResult = 0;
   
   UpdateData(TRUE);
   if(m_nCleanSize != m_nCleanSizeSlider / 10)
      SetModified(TRUE);

   m_nCleanSize = m_nCleanSizeSlider / 10 ;
   UpdateData(FALSE);
}

void CSegmentationPropPage::OnCustomdrawSliderCombinethreshold(NMHDR* pNMHDR, LRESULT* pResult) 
{
   *pResult = 0;
   
   UpdateData(TRUE);
   CombineThreshold = m_nCombineThresholdSlider*3 ;
   if (CombineThreshold%2)
      CombineThreshold++;

   if(m_nCombineThreshold != CombineThreshold)
      SetModified(TRUE);

   m_nCombineThreshold = CombineThreshold ;
   UpdateData(FALSE);
}

void CSegmentationPropPage::OnCustomdrawSliderQuality(NMHDR* pNMHDR, LRESULT* pResult) 
{
   *pResult = 0;
   
   UpdateData(TRUE);
   if(m_nQuality != m_nQualitySlider)
      SetModified(TRUE);

   m_nQuality = m_nQualitySlider ;
   UpdateData(FALSE);
}

void CSegmentationPropPage::OnCustomdrawSliderColorthreshold(NMHDR* pNMHDR, LRESULT* pResult) 
{
   *pResult = 0;
   
   UpdateData(TRUE);
   if(m_nColorThreshold != m_nColorThresholdSlider)
      SetModified(TRUE);

   m_nColorThreshold = m_nColorThresholdSlider ;
   UpdateData(FALSE);
}

void CSegmentationPropPage::OnKillfocusEditBkgndthreshold() 
{
   SetModified(TRUE);
   
   UpdateData(TRUE);
   m_nBkgndThresholdSlider = m_nBkgndThreshold ;
   UpdateData(FALSE);
}

void CSegmentationPropPage::OnKillfocusEditCleansize() 
{
   SetModified(TRUE);
   
   UpdateData(TRUE);
   m_nCleanSizeSlider = m_nCleanSize * 10 ;
   UpdateData(FALSE);
}

void CSegmentationPropPage::OnKillfocusEditCombinethreshold() 
{
   SetModified(TRUE);
   
   UpdateData(TRUE);
   CombineThreshold = m_nCombineThreshold;
   m_nCombineThresholdSlider = m_nCombineThreshold / 3 ;
   UpdateData(FALSE);
}

void CSegmentationPropPage::OnKillfocusEditQuality() 
{
   SetModified(TRUE);
   
   UpdateData(TRUE);
   m_nQualitySlider = m_nQuality ;
   UpdateData(FALSE);
}

void CSegmentationPropPage::OnKillfocusEditColorthreshold() 
{
   SetModified(TRUE);
   
   UpdateData(TRUE);
   m_nColorThresholdSlider = m_nColorThreshold ;
   UpdateData(FALSE);
}

void CSegmentationPropPage::OnCheckSearchbkgnd() 
{
   SetModified(TRUE);
}

void CSegmentationPropPage::OnSelchangeComboSegmType() 
{
   SetModified(TRUE);
}

void CSegmentationPropPage::OnOK() 
{
   CPropertyPage::OnOK();
}


BOOL CSegmentationPropPage::OnApply() 
{
   GetDlgItem(IDC_COMBO_SEGM_IIQ)->SetFocus();
   UpdateData(TRUE);
   
   CDemo*      pTheApp   =  (CDemo*)     AfxGetApp(); 
   
   pTheApp->Options.SEGM_nInputImageQuality  = m_nInputImageQuality ;
   pTheApp->Options.SEGM_nOutputImageQuality = m_nOutputImageQuality ;
   
   pTheApp->Options.SEGM_nCombineThreshold   = m_nCombineThreshold ;
   pTheApp->Options.SEGM_nBkgndThreshold     = m_nBkgndThreshold ;
   pTheApp->Options.SEGM_nCleanSize          = m_nCleanSize ;
   
   pTheApp->Options.SEGM_nQuality            = m_nQuality ;
   pTheApp->Options.SEGM_nColorThreshold     = m_nColorThreshold ;
   pTheApp->Options.SEGM_nType               = m_nType ;
   pTheApp->Options.SEGM_bSearchBkgnd        = m_bSearchBkgnd ;
   
   m_uFlags                                  = 0 ;
   
   if (m_bSearchBkgnd == TRUE)
      m_uFlags |= SGM_WITHBKGRND;
   else
      m_uFlags |= SGM_WITHOUTBKGRND;
   
   switch(m_nType)
   {
   case 0:
      m_uFlags |= SGM_FAVOR_ONEBIT;
      break;
   case 1:
      m_uFlags |= SGM_FAVOR_TWOBIT;
      break;
   case 2:
      m_uFlags |= SGM_FORCE_ONEBIT;
      break;
   case 3:
      m_uFlags |= SGM_FORCE_TWOBIT;
      break;
   }
   
   pTheApp->Options.SEGM_uFlags              = m_uFlags ;

   return TRUE;
}