/*********************************************************/
//	NkILSampleSet2Dlg.cpp
//		Source file of Settings2 dialog class.
//
//	Copyright(c) 2007, Nikon Corporation - All rights reserved.
/*********************************************************/

#include "stdafx.h"
#include "NkILSample.h"
#include "NkILSampleSet2Dlg.h"

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

#define MIN_RGB			0
#define MAX_RGB			255
#define UNIT_HUE_SLIDER	3
// table of combination slidercontrol with editcontrol 
const UINT g_slider_edit[SLIDER_CNT][2] =
{
	// SliderControlID,				EditControlID
	{IDC_SLIDER_COMMON_EXPCOMP,		IDC_EDIT_COMMON_EXPCOMP		},		
	{IDC_SLIDER_COMMON_WB,			IDC_EDIT_COMMON_WB			},
	{IDC_SLIDER_COMMON_TINT,		IDC_EDIT_COMMON_TINT		},
	{IDC_SLIDER_COLORMODE_HUE,		IDC_EDIT_COLORMODE_HUE		},
	{IDC_SLIDER_PICCTRL_QUICKADJ,	IDC_EDIT_PICCTRL_QUICKADJ	},
	{IDC_SLIDER_PICCTRL_SHARP,		IDC_EDIT_PICCTRL_SHARP		},
	{IDC_SLIDER_PICCTRL_CONTRAST,	IDC_EDIT_PICCTRL_CONTRAST	},
	{IDC_SLIDER_PICCTRL_BRIGHTNESS,	IDC_EDIT_PICCTRL_BRIGHTNESS	},
	{IDC_SLIDER_PICCTRL_SATURATION,	IDC_EDIT_PICCTRL_SATURATION	},
	{IDC_SLIDER_PICCTRL_HUE,		IDC_EDIT_PICCTRL_HUE		},
	{IDC_SLIDER_PICCTRL_TONINGINT,	IDC_EDIT_PICCTRL_TONINGINT	}
};

IMPLEMENT_DYNAMIC(CNkILSampleSet2Dlg, CDialog)

CNkILSampleSet2Dlg::CNkILSampleSet2Dlg(CWnd* pParent /*=NULL*/)
	: CDialog(CNkILSampleSet2Dlg::IDD, pParent)
{
	m_pParent			= pParent;		// set pointer of owner window
	m_ulParamSet		= kNkfl_RawParameterSet_AsShot;
	m_bApplyPictCtrl	= false;
	m_bIsInitDlg		= false;	

	// init structure
	memset( &m_StrCommon, 0x00, sizeof( m_StrCommon ) );
	memset( &m_StrColor, 0x00, sizeof( m_StrColor ) );
	memset( &m_StrWBRange, 0x00, sizeof( m_StrWBRange ) );
	memset( &m_StrPicture, 0x00, sizeof( m_StrPicture ) );
}

CNkILSampleSet2Dlg::~CNkILSampleSet2Dlg()
{
}

void CNkILSampleSet2Dlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
}

BEGIN_MESSAGE_MAP(CNkILSampleSet2Dlg, CDialog)
	ON_WM_HSCROLL()
	ON_COMMAND( IDC_BUTTON_PARAMSET_APPLY, OnApplyParamSettings )
	ON_COMMAND( IDC_BUTTON_COMMON_APPLY, OnApplyCommon )
	ON_COMMAND( IDC_BUTTON_COLORMODE_APPLY, OnApplyColorMode )
	ON_COMMAND(	IDC_BUTTON_PICCONTROL, OnApplyPictureCtrl )		
	
	ON_CONTROL_RANGE( EN_UPDATE, IDC_EDIT_COMMON_EXPCOMP, IDC_EDIT_COMMON_TINT, OnUpdateEdit )
	ON_CONTROL_RANGE( EN_KILLFOCUS, IDC_EDIT_COMMON_EXPCOMP, IDC_EDIT_COMMON_TINT, OnKillFocusEdit )
	
	ON_CBN_SELCHANGE( IDC_COMBO_COMMON_WB, OnSelChangeWBCombo )
	ON_CBN_SELCHANGE( IDC_COMBO_COMMON_ADL, OnSelChangeADLCombo )
	ON_CBN_SELCHANGE( IDC_COMBO_PARAMSET, OnSelChangeParamSet )
	ON_CBN_SELCHANGE( IDC_COMBO_COLORMODE_COLOR, OnSelChangeColorMode )
	ON_CBN_SELCHANGE( IDC_COMBO_PICCTRL_PICCTRL, OnSelChangePictCtrl )
	ON_BN_CLICKED( IDC_RADIO_PICCTRL_QUICK, OnCheckQuickAdj )
	ON_BN_CLICKED( IDC_RADIO_PICCTRL_EACH, OnCheckQuickAdj )
	ON_BN_CLICKED( IDC_CHECK_PICCTRL_SHARP_AUTO, OnCheckSharpAuto )
	ON_BN_CLICKED( IDC_CHECK_PICCTRL_CONTRAST_AUTO, OnCheckContrast )
	ON_BN_CLICKED( IDC_CHECK_PICCTRL_CONTRAST_USER, OnCheckContrast )
	ON_BN_CLICKED( IDC_CHECK_PICCTRL_SATURATION_AUTO, OnCheckSaturation )		
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////
// OnInitDialog
BOOL CNkILSampleSet2Dlg::OnInitDialog()
{	
	CDialog::OnInitDialog();
	
	ChangeDlgDesign();								// hind picturecontrol group or colormode group
	InitSet2DlgStatus();							// set enable or disable
	// set dialog title
	CString strTitle;
	strTitle.LoadString( IDS_TITLE_SET2DLG );
	SetWindowText( strTitle );

	m_bIsInitDlg = true;							// flag of Initialized
	return TRUE;
}
// OnInitDialog
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// ChangeDlgDesign
void CNkILSampleSet2Dlg::ChangeDlgDesign()
{
	if( !m_bApplyPictCtrl )
	{
		// hind picturecontrol group
		GetDlgItem( IDC_GROUP_PICCTRL )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_PICCTRL )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_PARAMMODE )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_QUICKADJ )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_SHARP )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_CONTRAST )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_SATURATION )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_BRIGHT )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_HUE )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_FILTER )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_TONING )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_TONINGINT )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_COMBO_PICCTRL_PICCTRL )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_RADIO_PICCTRL_QUICK )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_RADIO_PICCTRL_EACH )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_SLIDER_PICCTRL_QUICKADJ )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_EDIT_PICCTRL_QUICKADJ )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_SLIDER_PICCTRL_SHARP )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_EDIT_PICCTRL_SHARP )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_CHECK_PICCTRL_SHARP_AUTO )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_SLIDER_PICCTRL_CONTRAST )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_EDIT_PICCTRL_CONTRAST )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_EDIT_PICCTRL_BRIGHTNESS )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_EDIT_PICCTRL_SATURATION )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_EDIT_PICCTRL_HUE )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_EDIT_PICCTRL_TONINGINT )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_SLIDER_PICCTRL_BRIGHTNESS )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_SLIDER_PICCTRL_SATURATION )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_SLIDER_PICCTRL_HUE )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_SLIDER_PICCTRL_TONINGINT )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_COMBO_PICCTRL_FLTEFFECT )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_COMBO_PICCTRL_TONING )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_CHECK_PICCTRL_CONTRAST_AUTO )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_CHECK_PICCTRL_CONTRAST_USER )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_CHECK_PICCTRL_SATURATION_AUTO )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_BUTTON_PICCONTROL )->ShowWindow(SW_HIDE);
		
		// adjust dialog size only size of picturecontrol group
		CRect rc, rcDlg;	
		GetDlgItem( IDC_GROUP_PICCTRL )->GetWindowRect( rc );
		GetWindowRect( rcDlg );
		rcDlg.bottom = rc.top;	
		MoveWindow( rcDlg.left, rcDlg.top, rcDlg.Width(), rcDlg.Height(), true);
	}
	else
	{
		// hind colormode group
		GetDlgItem( IDC_GROUP_COLORMODE )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_COLORMODE )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_COLOR_SHARP )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_TONE )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_COLOR_HUE )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_COLOR_SATURATION )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_STATIC_COLOR_FILTER )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_COMBO_COLORMODE_COLOR )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_COMBO_COLORMODE_SHARP )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_COMBO_COLORMODE_TONECOMP )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_COMBO_COLORMODE_SATURATION )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_COMBO_COLORMODE_FLTEFFECT )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_SLIDER_COLORMODE_HUE )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_EDIT_COLORMODE_HUE )->ShowWindow(SW_HIDE);
		GetDlgItem( IDC_BUTTON_COLORMODE_APPLY )->ShowWindow(SW_HIDE);
	
		// move picturecontrol group
		CRect rcColor, rcPict;	
		GetDlgItem( IDC_GROUP_COLORMODE )->GetWindowRect( rcColor );
		GetDlgItem( IDC_GROUP_PICCTRL )->GetWindowRect( rcPict );
		long lMoveSize = rcPict.top - rcColor.top;			// amount of movement

		MoveControl( IDC_GROUP_PICCTRL, lMoveSize );		
		MoveControl( IDC_STATIC_PICCTRL, lMoveSize );
		MoveControl( IDC_STATIC_PARAMMODE, lMoveSize );
		MoveControl( IDC_STATIC_QUICKADJ, lMoveSize );
		MoveControl( IDC_STATIC_SHARP, lMoveSize );
		MoveControl( IDC_STATIC_CONTRAST, lMoveSize );
		MoveControl( IDC_STATIC_SATURATION, lMoveSize );
		MoveControl( IDC_STATIC_BRIGHT, lMoveSize );
		MoveControl( IDC_STATIC_HUE, lMoveSize );
		MoveControl( IDC_STATIC_FILTER, lMoveSize );
		MoveControl( IDC_STATIC_TONING, lMoveSize );
		MoveControl( IDC_STATIC_TONINGINT, lMoveSize );
		MoveControl( IDC_COMBO_PICCTRL_PICCTRL, lMoveSize );
		MoveControl( IDC_RADIO_PICCTRL_QUICK, lMoveSize );
		MoveControl( IDC_RADIO_PICCTRL_EACH, lMoveSize );
		MoveControl( IDC_SLIDER_PICCTRL_QUICKADJ, lMoveSize );
		MoveControl( IDC_EDIT_PICCTRL_QUICKADJ, lMoveSize );
		MoveControl( IDC_SLIDER_PICCTRL_SHARP, lMoveSize );
		MoveControl( IDC_EDIT_PICCTRL_SHARP, lMoveSize );
		MoveControl( IDC_CHECK_PICCTRL_SHARP_AUTO, lMoveSize );
		MoveControl( IDC_SLIDER_PICCTRL_CONTRAST, lMoveSize );
		MoveControl( IDC_EDIT_PICCTRL_CONTRAST, lMoveSize );
		MoveControl( IDC_EDIT_PICCTRL_BRIGHTNESS, lMoveSize );
		MoveControl( IDC_EDIT_PICCTRL_SATURATION, lMoveSize );
		MoveControl( IDC_EDIT_PICCTRL_HUE, lMoveSize );
		MoveControl( IDC_EDIT_PICCTRL_TONINGINT, lMoveSize );
		MoveControl( IDC_SLIDER_PICCTRL_BRIGHTNESS, lMoveSize );
		MoveControl( IDC_SLIDER_PICCTRL_SATURATION, lMoveSize );
		MoveControl( IDC_SLIDER_PICCTRL_HUE, lMoveSize );
		MoveControl( IDC_SLIDER_PICCTRL_TONINGINT, lMoveSize );
		MoveControl( IDC_COMBO_PICCTRL_FLTEFFECT, lMoveSize );
		MoveControl( IDC_COMBO_PICCTRL_TONING, lMoveSize );
		MoveControl( IDC_CHECK_PICCTRL_CONTRAST_AUTO, lMoveSize );
		MoveControl( IDC_CHECK_PICCTRL_CONTRAST_USER, lMoveSize );
		MoveControl( IDC_CHECK_PICCTRL_SATURATION_AUTO, lMoveSize );
		MoveControl( IDC_BUTTON_PICCONTROL, lMoveSize );

		// adjust dialog size only size of colormode group
		CRect rcDlg;
		GetWindowRect( rcDlg );
		rcDlg.bottom -= lMoveSize;	
		MoveWindow( rcDlg.left, rcDlg.top, rcDlg.Width(), rcDlg.Height(), true);
	}
}
// ChangeDlgDesign
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// MoveControl
void CNkILSampleSet2Dlg::MoveControl( UINT nID, long lMoveSize )
{
	CRect rcCtrl, rcRect;
	// get current rect and move 	
	GetDlgItem( nID )->GetWindowRect( rcCtrl );
	// convert to coordinates in dialog from that in screen
	this->ScreenToClient( rcCtrl );
	// move control
	GetDlgItem( nID )->MoveWindow( rcCtrl.left, rcCtrl.top - lMoveSize, rcCtrl.Width(), rcCtrl.Height(), true );	
}
// MoveControl
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// InitSet2DlgStatus
void CNkILSampleSet2Dlg::InitSet2DlgStatus()
{
	InitComboCtrl(IDC_COMBO_PARAMSET, IDS_PRAMSET_ASSHOT, 2 );	// initialize ParamSettings		
	InitCommonGroup();											// initialize common group	
	if( !m_bApplyPictCtrl )
	{
		InitColorModeGroup();									// initialize colormode group
	}
	else
	{
		InitPicCtrlGroup();										// initialize PictureControl group	
	}
}
// InitSet2DlgStatus
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// PreTranslateMessage
BOOL CNkILSampleSet2Dlg::PreTranslateMessage(MSG *pMsg)
{
	if( WM_KEYDOWN == pMsg->message )
	{
		if( VK_RETURN == pMsg->wParam )
		{
			return TRUE;	// prevent calling OnOK() by click Enter
		}
		if( VK_ESCAPE == pMsg->wParam )
		{
			return TRUE;	// prevent calling OnCancel() by click Escape
		}
	}

	return CDialog::PreTranslateMessage(pMsg);
}
// PreTranslateMessage
/////////////////////////////////////////////////////////////////

//====================================================================
// function name		：InitComboCtrl
// function abstract	：initialize ComboBox control
// parameter			：nComboID		ID of ComboBox control
//						  nFirstParamID	ID of first parameter's string
//						  nParamNum		total parameter number of this ComboBox 
// return value			：none
//====================================================================
void CNkILSampleSet2Dlg::InitComboCtrl( UINT nComboID, UINT nFirstParamID, int nParamNum )
{
	// get current sel
	int nCurSel = 0;
	switch( nComboID )
	{
	case IDC_COMBO_PARAMSET:
		nCurSel = ( kNkfl_RawParameterSet_AsShot == m_ulParamSet ) ? 0 : 1;
		break;
	case IDC_COMBO_COMMON_WB:	
		if( kNkfl_WB_GrayPoint == m_StrCommon.StrWBInfo.ulMWB )
		{
			nCurSel = 1;
		}
		else if( kNkfl_WB_Auto == m_StrCommon.StrWBInfo.ulMWB )
		{
			nCurSel = 2;
		}
		else if( kNkfl_WB_Incandescent == m_StrCommon.StrWBInfo.ulMWB )
		{
			nCurSel = 3;
		}
		else if( kNkfl_WB_Flourescent == m_StrCommon.StrWBInfo.ulMWB )
		{
			nCurSel = 4;
		}
		else if( kNkfl_WB_DirectSunLight == m_StrCommon.StrWBInfo.ulMWB )
		{
			nCurSel = 5;
		}
		else if( kNkfl_WB_Flash == m_StrCommon.StrWBInfo.ulMWB )
		{
			nCurSel = 6;
		}
		else if( kNkfl_WB_Cloudy == m_StrCommon.StrWBInfo.ulMWB )
		{
			nCurSel = 7;
		}
		else if( kNkfl_WB_Shade == m_StrCommon.StrWBInfo.ulMWB )
		{
			nCurSel = 8;
		}	
		else if( kNkfl_WB_HCFlourescent == m_StrCommon.StrWBInfo.ulMWB )
		{
			nCurSel = 9;
		}
		else
		{		
			nCurSel = 0;	// asshot		
		}
		break;		
	case IDC_COMBO_COMMON_NR:
		switch( m_StrCommon.ulNRType )
		{		
		case kNkfl_NR_OFF:
			nCurSel = 1;
			break;
		case kNkfl_NR_Low:		
			nCurSel = 2;
			break;
		case kNkfl_NR_Normal:		
			nCurSel = 3;
			break;
		case kNkfl_NR_High:
			nCurSel = 4;
			break;
		case kNkfl_NR_AsShot:
		default:
			nCurSel = 0;			
		}
		break;
	case IDC_COMBO_COMMON_ADL:
		switch( m_StrCommon.ulADLight )
		{
		case kNkfl_ActiveDLighting_None:
			nCurSel = 1;
			break;
		case kNkfl_ActiveDLighting_Low:
			nCurSel = 2;
			break;
		case kNkfl_ActiveDLighting_Normal:
			nCurSel = 3;
			break;
		case kNkfl_ActiveDLighting_High:
			nCurSel = 4;
			break;
		case kNkfl_ActiveDLighting_AsShot:
		default:
			nCurSel = 0;
		}
		break;
	case IDC_COMBO_COLORMODE_COLOR:
		switch( m_StrColor.ulColorMode )
		{		
		case kNkfl_ColorMode_ModeI:
			nCurSel = 1;
			break;
		case kNkfl_ColorMode_ModeII:
			nCurSel = 2;
			break;
		case kNkfl_ColorMode_ModeIII:
			nCurSel = 3;
			break;
		case kNkfl_ColorMode_ModeIa:
			nCurSel = 4;
			break;
		case kNkfl_ColorMode_ModeIIIa:
			nCurSel = 5;
			break;
		case kNkfl_ColorMode_BW:
			nCurSel = 6;
			break;
		case kNkfl_ColorMode_AsShot:
		default:
			nCurSel = 0;			
		}
		break;
	case IDC_COMBO_COLORMODE_SHARP:
		switch( m_StrColor.ulSharpness )
		{		
		case kNkfl_Sharpness_None:
			nCurSel = 1;
			break;
		case kNkfl_Sharpness_Low:
			nCurSel = 2;
			break;
		case kNkfl_Sharpness_MediumLow:		
			nCurSel = 3;
			break;
		case kNkfl_Sharpness_Normal:		
			nCurSel = 4;
			break;
		case kNkfl_Sharpness_MediumHigh:
			nCurSel = 5;
			break;
		case kNkfl_Sharpness_High:
			nCurSel = 6;
			break;
		case kNkfl_Sharpness_AsShot:
		default:
			nCurSel = 0;			
		}
		break;
	case IDC_COMBO_COLORMODE_TONECOMP:
		switch( m_StrColor.ulToneComp )
		{		
		case kNkfl_ToneComp_LowContrast:
			nCurSel = 1;
			break;
		case kNkfl_ToneComp_MediumLow:
			nCurSel = 2;
			break;		
		case kNkfl_ToneComp_Normal:
			nCurSel = 3;
			break;
		case kNkfl_ToneComp_MediumHigh:
			nCurSel = 4;
			break;
		case kNkfl_ToneComp_HighContrast:
			nCurSel = 5;
			break;
		case kNkfl_ToneComp_UserDefinedCurve:
			nCurSel = 6;
			break;
		case kNkfl_ToneComp_AsShot:
		default:
			nCurSel = 0;			
		}
		break;
	case IDC_COMBO_COLORMODE_SATURATION:
		switch( m_StrColor.ulSaturation )
		{		
		case kNkfl_Saturation_Moderate:
			nCurSel = 1;
			break;
		case kNkfl_Saturation_Normal:		
			nCurSel = 2;
			break;
		case kNkfl_Saturation_Enhanced:
			nCurSel = 3;
			break;
		case kNkfl_Saturation_AsShot:
		default:
			nCurSel = 0;			
		}
		break;
	case IDC_COMBO_COLORMODE_FLTEFFECT:
		switch( m_StrColor.ulFilterEffect )
		{		
		case kNkfl_FilterEffect_OFF:
			nCurSel = 1;
			break;
		case kNkfl_FilterEffect_Yellow:		
			nCurSel = 2;
			break;
		case kNkfl_FilterEffect_Orange:
			nCurSel = 3;
			break;
		case kNkfl_FilterEffect_Red:		
			nCurSel = 4;
			break;
		case kNkfl_FilterEffect_Green:
			nCurSel = 5;
			break;
		case kNkfl_FilterEffect_AsShot:
		default:
			nCurSel = 0;			
		}
		break;
	case IDC_COMBO_PICCTRL_PICCTRL:
		switch( m_StrPicture.ulPictureControl )
		{		
		case kNkfl_PictureControl_Standard:
			nCurSel = 1;
			break;
		case kNkfl_PictureControl_Neutral:
			nCurSel = 2;
			break;
		case kNkfl_PictureControl_Vivid:
			nCurSel = 3;
			break;
		case kNkfl_PictureControl_Monochrome:
			nCurSel = 4;
			break;
		case kNkfl_PictureControl_D2XModeI:
			nCurSel = 5;
			break;
		case kNkfl_PictureControl_D2XModeII:
			nCurSel = 6;
			break;
		case kNkfl_PictureControl_D2XModeIII:
			nCurSel = 7;
			break;
		case kNkfl_PictureControl_AsShot:
		default:
			nCurSel = 0;			
		}
		break;
	case IDC_COMBO_PICCTRL_FLTEFFECT:
		switch( m_StrPicture.lFilter )
		{		
		case kNkfl_FilterEffect_OFF:
			nCurSel = 1;
			break;
		case kNkfl_FilterEffect_Yellow:		
			nCurSel = 2;
			break;
		case kNkfl_FilterEffect_Orange:
			nCurSel = 3;
			break;
		case kNkfl_FilterEffect_Red:		
			nCurSel = 4;
			break;
		case kNkfl_FilterEffect_Green:
			nCurSel = 5;
			break;
		case kNkfl_FilterEffect_AsShot:
		default:
			nCurSel = 0;			
		}		
		break;
	case IDC_COMBO_PICCTRL_TONING:
		switch( m_StrPicture.lToning )
		{		
		case kNkfl_Toning_BW:
			nCurSel = 1;
			break;
		case kNkfl_Toning_Sepia:
			nCurSel = 2;
			break;
		case kNkfl_Toning_Cyanotype:
			nCurSel = 3;
			break;
		case kNkfl_Toning_Red:
			nCurSel = 4;
			break;
		case kNkfl_Toning_Yellow:
			nCurSel = 5;
			break;
		case kNkfl_Toning_Green:
			nCurSel = 6;
			break;
		case kNkfl_Toning_Turquoize:
			nCurSel = 7;
			break;
		case kNkfl_Toning_Cyan:
			nCurSel = 8;
			break;
		case kNkfl_Toning_Violet:
			nCurSel = 9;
			break;	
		case kNkfl_Toning_Magenta:
			nCurSel = 10;
			break;	
		case kNkfl_Toning_AsShot:
		default:
			nCurSel = 0;			
		}
		break;
	}

	CComboBox* pCombo = (CComboBox*)GetDlgItem( nComboID );	
	if( !m_bIsInitDlg )
	{
		for( int i = 0; i < nParamNum; i++ )
		{
			CString strComboParam;
			strComboParam.LoadString( nFirstParamID++ );// get string of param
			pCombo->AddString( strComboParam );			// add param to ComboBox		
		}
	}
	pCombo->SetCurSel( nCurSel );					// set current sel
}
//InitComboCtrl
/////////////////////////////////////////////////////////////////

//====================================================================
// function name		：InitSliderCtrl
// function abstract	：initialize slider control and related edit control 
// parameter			：nSliderID		control id
//						  nEditID		control id
//						  nMin			minimum value of range	
//						  nMax			maxmum value of range
//						  nCurPos		current posision
// return value			：none
//====================================================================
void CNkILSampleSet2Dlg::InitSliderCtrl( UINT nSliderID, UINT nEditID, int nMin, int nMax, int nCurPos )
{	
	CSliderCtrl* pSlider = (CSliderCtrl*)GetDlgItem( nSliderID );	// get slider control hundle	

	// set value to edit box		
	SetEditValue( nEditID, nCurPos );	
	
	pSlider->SetRange( nMin, nMax );			// set range
	pSlider->SetPageSize(1);					// set page size
	
	if( IDC_SLIDER_COLORMODE_HUE == nSliderID )
	{
		nCurPos = nCurPos / UNIT_HUE_SLIDER;	// 1/3 of edit value
	}
	// check pos
	if( nMin > nCurPos || nMax < nCurPos )
	{
		nCurPos = GetCtrlDefault( nEditID );	// if out of range, set default value
		SetEditValue( nEditID, nCurPos );		// re-set edit value
	}

	pSlider->SetPos( nCurPos );					// set current position	
	pSlider->ClearSel( true );					// need to set default pos		
}
//InitSliderCtrl
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
//InitCommonGroup
void CNkILSampleSet2Dlg::InitCommonGroup()
{	
	// initialize expcomp slider 
	InitSliderCtrl( IDC_SLIDER_COMMON_EXPCOMP, IDC_EDIT_COMMON_EXPCOMP, -2, 2, (int)m_StrCommon.dbExpComp);	
	// WhiteBalance in Common group
	InitComboCtrl(IDC_COMBO_COMMON_WB, IDS_COMMON_WB_ASSHOT, 10);	
	// get range
	int nMin = 0, nMax = 0;
	for( int i = 0; i < WB_NEED_RANGE_NUM; i++) 
	{
		// get minimum and maximum value of range
		if( m_StrWBRange.ulWBParam[i] == m_StrCommon.StrWBInfo.ulMWB )
		{
			nMin = (int)m_StrWBRange.ulMinColorTemp[i];
			nMax = (int)m_StrWBRange.ulMaxColorTemp[i];
		}
	}
	InitSliderCtrl( IDC_SLIDER_COMMON_WB, IDC_EDIT_COMMON_WB, nMin, nMax, (int)m_StrCommon.StrWBInfo.lColorTemp );	
	// tint slider and edit
	InitSliderCtrl( IDC_SLIDER_COMMON_TINT, IDC_EDIT_COMMON_TINT, -12, 12, (int)m_StrCommon.lTint );	
	// rgb of white balance	
	// R
	SetEditValue( IDC_EDIT_WB_R, m_StrCommon.StrWBInfo.rgb.ulR );		
	// G
	SetEditValue( IDC_EDIT_WB_G, m_StrCommon.StrWBInfo.rgb.ulG );		
	// B
	SetEditValue( IDC_EDIT_WB_B, m_StrCommon.StrWBInfo.rgb.ulB );	

	InitComboCtrl(IDC_COMBO_COMMON_NR, IDS_COMMON_NR_ASSHOT, 5);	// NoiseReduction in Common group
	InitComboCtrl(IDC_COMBO_COMMON_ADL, IDS_COMMON_ADL_ASSHOT, 5);	// ActiveD-Lighting in Common group
	EnableCommonGroup();											// change disable or enable
}
//InitCommonGroup
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// EnableCommonGroup
void CNkILSampleSet2Dlg::EnableCommonGroup()
{	
	if( kNkfl_RawParameterSet_AsShot != m_ulParamSet )
	{
		// if parametersettings is lastsavedsetting, disable all control 
		GetDlgItem( IDC_SLIDER_COMMON_EXPCOMP )->EnableWindow( false );
		GetDlgItem( IDC_EDIT_COMMON_EXPCOMP )->EnableWindow( false );
		GetDlgItem( IDC_COMBO_COMMON_WB )->EnableWindow( false );
		GetDlgItem( IDC_SLIDER_COMMON_WB )->EnableWindow( false );
		GetDlgItem( IDC_EDIT_COMMON_WB )->EnableWindow( false );
		GetDlgItem( IDC_EDIT_WB_R )->EnableWindow( false );
		GetDlgItem( IDC_EDIT_WB_G )->EnableWindow( false );
		GetDlgItem( IDC_EDIT_WB_B )->EnableWindow( false );
		GetDlgItem( IDC_SLIDER_COMMON_TINT )->EnableWindow( false );
		GetDlgItem( IDC_EDIT_COMMON_TINT )->EnableWindow( false );
		GetDlgItem( IDC_COMBO_COMMON_NR )->EnableWindow( false );
		GetDlgItem( IDC_COMBO_COMMON_ADL )->EnableWindow( false );
		// apply button
		GetDlgItem( IDC_BUTTON_COMMON_APPLY )->EnableWindow( false );
	}
	else
	{
		GetDlgItem( IDC_SLIDER_COMMON_EXPCOMP )->EnableWindow( true );
		GetDlgItem( IDC_EDIT_COMMON_EXPCOMP )->EnableWindow( true );
		GetDlgItem( IDC_COMBO_COMMON_WB )->EnableWindow( true );		
		EnableWBParam( true );					// other control of white balance
		GetDlgItem( IDC_SLIDER_COMMON_TINT )->EnableWindow( true );
		GetDlgItem( IDC_EDIT_COMMON_TINT )->EnableWindow( true );
		GetDlgItem( IDC_COMBO_COMMON_NR )->EnableWindow( m_StrCommon.bIsNR );
		GetDlgItem( IDC_COMBO_COMMON_ADL )->EnableWindow( m_StrCommon.bIsADLight );
				
		// apply button
		GetDlgItem( IDC_BUTTON_COMMON_APPLY )->EnableWindow( true );
	}
}
// EnableCommonGroup
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
//InitColorModeGroup
void CNkILSampleSet2Dlg::InitColorModeGroup()
{	
	// enaable only either of ColorMode group or PictureControl group 
	InitComboCtrl(IDC_COMBO_COLORMODE_COLOR, IDS_COLOR_CM_ASSHOT, 7);				// ColorMode in ColorMode group
	InitComboCtrl(IDC_COMBO_COLORMODE_SHARP, IDS_COLOR_SHARP_ASSHOT, 7);			// Sharpening in ColorMode group
	InitComboCtrl(IDC_COMBO_COLORMODE_TONECOMP, IDS_COLOR_TONE_ASSHOT, 7);			// ToneComp in ColorMode group
	InitComboCtrl(IDC_COMBO_COLORMODE_SATURATION, IDS_COLOR_SATURATION_ASSHOT, 4);	// ToneComp in ColorMode group
	InitComboCtrl(IDC_COMBO_COLORMODE_FLTEFFECT, IDS_FILTEREFFECT_ASSHOT, 6);		// FilterEffect in ColorMode group
	InitSliderCtrl( IDC_SLIDER_COLORMODE_HUE, IDC_EDIT_COLORMODE_HUE, -3, 3, (int)m_StrColor.lHueAdj );

	EnableColorModeGroup();
}
//InitColorModeGroup
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// EnableColorModeGroup
void CNkILSampleSet2Dlg::EnableColorModeGroup()
{
	// if apply picturecontrol, disable colormode group
	bool bEnable = ( kNkfl_RawParameterSet_AsShot != m_ulParamSet || m_bApplyPictCtrl )  ? false : true;	

	GetDlgItem( IDC_COMBO_COLORMODE_COLOR )->EnableWindow( bEnable );
	GetDlgItem( IDC_COMBO_COLORMODE_SHARP )->EnableWindow( bEnable );
	GetDlgItem( IDC_COMBO_COLORMODE_TONECOMP )->EnableWindow( bEnable );
	GetDlgItem( IDC_COMBO_COLORMODE_SATURATION )->EnableWindow( bEnable );
	OnSelChangeColorMode();
	GetDlgItem( IDC_SLIDER_COLORMODE_HUE )->EnableWindow( bEnable );
	GetDlgItem( IDC_EDIT_COLORMODE_HUE )->EnableWindow( bEnable );
	GetDlgItem( IDC_BUTTON_COLORMODE_APPLY )->EnableWindow( bEnable );	
}
// EnableColorModeGroup
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// InitPicCtrlGroup
void CNkILSampleSet2Dlg::InitPicCtrlGroup()
{
	InitComboCtrl(IDC_COMBO_PICCTRL_PICCTRL, IDS_PIC_PICTCTRL_ASSHOT, 8);			// PictureControl settings

	int nCheck;
	// quick adjust
	if( m_StrPicture.bApplyQuickAdjust )  
	{
		((CButton*)GetDlgItem(IDC_RADIO_PICCTRL_QUICK))->SetCheck(BST_CHECKED);		// check to QuickAdjust
		((CButton*)GetDlgItem(IDC_RADIO_PICCTRL_EACH))->SetCheck(BST_UNCHECKED);	// uncheck to EachParam
	}
	else
	{
		((CButton*)GetDlgItem(IDC_RADIO_PICCTRL_EACH))->SetCheck(BST_CHECKED);		// check to EachParam
		((CButton*)GetDlgItem(IDC_RADIO_PICCTRL_QUICK))->SetCheck(BST_UNCHECKED);	// uncheck to QuickAdjust
	}			
	InitSliderCtrl( IDC_SLIDER_PICCTRL_QUICKADJ ,IDC_EDIT_PICCTRL_QUICKADJ ,-2, 2, (int)m_StrPicture.lQuickAdjust );
	
	// sharpness
	InitSliderCtrl( IDC_SLIDER_PICCTRL_SHARP, IDC_EDIT_PICCTRL_SHARP, 0, 9, (int)m_StrPicture.ulSharpness );
	nCheck = ( m_StrPicture.bSharpessAuto ) ? BST_CHECKED : BST_UNCHECKED;
	((CButton*)GetDlgItem(IDC_CHECK_PICCTRL_SHARP_AUTO))->SetCheck( nCheck );				
			
	// contrast
	InitSliderCtrl( IDC_SLIDER_PICCTRL_CONTRAST ,IDC_EDIT_PICCTRL_CONTRAST, -3, 3, (int)m_StrPicture.lContrast );			
	nCheck = ( m_StrPicture.bUserDefinedCurve ) ? BST_CHECKED : BST_UNCHECKED;
	((CButton*)GetDlgItem(IDC_CHECK_PICCTRL_CONTRAST_USER))->SetCheck(nCheck);			
	nCheck = ( m_StrPicture.bContrastAuto ) ? BST_CHECKED : BST_UNCHECKED;
	((CButton*)GetDlgItem(IDC_CHECK_PICCTRL_CONTRAST_AUTO))->SetCheck(nCheck);	

	// brightness
	InitSliderCtrl( IDC_SLIDER_PICCTRL_BRIGHTNESS, IDC_EDIT_PICCTRL_BRIGHTNESS, -1, 1, (int)m_StrPicture.lBrightness );
	
	// saturation
	nCheck = ( m_StrPicture.bSaturationAuto ) ? BST_CHECKED : BST_UNCHECKED;
	((CButton*)GetDlgItem(IDC_CHECK_PICCTRL_SATURATION_AUTO))->SetCheck(nCheck);
	InitSliderCtrl( IDC_SLIDER_PICCTRL_SATURATION, IDC_EDIT_PICCTRL_SATURATION,  -3, 3,(int)m_StrPicture.lSaturation );	

	// hue adjust
	InitSliderCtrl( IDC_SLIDER_PICCTRL_HUE, IDC_EDIT_PICCTRL_HUE,  -3, 3,(int)m_StrPicture.lHue );	

	// fiter effect
	InitComboCtrl(IDC_COMBO_PICCTRL_FLTEFFECT, IDS_FILTEREFFECT_ASSHOT, 6);		

	// toning	
	InitComboCtrl(IDC_COMBO_PICCTRL_TONING, IDS_PIC_TONING_ASSHOT, 11);	

	// toning intensity	
	InitSliderCtrl( IDC_SLIDER_PICCTRL_TONINGINT, IDC_EDIT_PICCTRL_TONINGINT, 1, 7, (int)m_StrPicture.lToningIntensity );
	EnablePicCtrlGroup();	
}
// InitPicCtrlGroup
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// EnablePicCtrlGroup
void CNkILSampleSet2Dlg::EnablePicCtrlGroup()
{
	if( kNkfl_RawParameterSet_AsShot != m_ulParamSet || !m_bApplyPictCtrl )
	{
		// disable all control in picture control group
		// picture control
		GetDlgItem( IDC_COMBO_PICCTRL_PICCTRL )->EnableWindow( false );
		// param mode
		GetDlgItem( IDC_RADIO_PICCTRL_QUICK )->EnableWindow( false );
		GetDlgItem( IDC_RADIO_PICCTRL_EACH )->EnableWindow( false );
		// quick adjust
		GetDlgItem( IDC_SLIDER_PICCTRL_QUICKADJ )->EnableWindow( false );
		GetDlgItem( IDC_EDIT_PICCTRL_QUICKADJ )->EnableWindow( false );	
		// disable other control 
		EnableUnderQuickAdj( true );
		// apply button
		GetDlgItem( IDC_BUTTON_PICCONTROL )->EnableWindow( false );			
	}
	else
	{	
		// picture control
		GetDlgItem( IDC_COMBO_PICCTRL_PICCTRL )->EnableWindow( true );
		OnSelChangePictCtrl();
		// apply button			
		GetDlgItem( IDC_BUTTON_PICCONTROL )->EnableWindow( true );
	}	
}
// EnablePicCtrlGroup
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// EnableUnderQuickAdj
void CNkILSampleSet2Dlg::EnableUnderQuickAdj( bool bQuickAdj )
{
	if( bQuickAdj )
	{
		// if check QuickAdjust, disable under control
		// sharpneing
		GetDlgItem( IDC_SLIDER_PICCTRL_SHARP )->EnableWindow( false );		
		GetDlgItem( IDC_EDIT_PICCTRL_SHARP )->EnableWindow( false );
		GetDlgItem( IDC_CHECK_PICCTRL_SHARP_AUTO )->EnableWindow( false );
		// contrast
		GetDlgItem( IDC_SLIDER_PICCTRL_CONTRAST )->EnableWindow( false );
		GetDlgItem( IDC_EDIT_PICCTRL_CONTRAST )->EnableWindow( false );
		GetDlgItem( IDC_CHECK_PICCTRL_CONTRAST_AUTO )->EnableWindow( false );
		GetDlgItem( IDC_CHECK_PICCTRL_CONTRAST_USER )->EnableWindow( false );
		// brightness
		GetDlgItem( IDC_SLIDER_PICCTRL_BRIGHTNESS )->EnableWindow( false );
		GetDlgItem( IDC_EDIT_PICCTRL_BRIGHTNESS )->EnableWindow( false );
		// saturation
		GetDlgItem( IDC_SLIDER_PICCTRL_SATURATION )->EnableWindow( false );
		GetDlgItem( IDC_EDIT_PICCTRL_SATURATION )->EnableWindow( false );
		GetDlgItem( IDC_CHECK_PICCTRL_SATURATION_AUTO )->EnableWindow( false );
		// hue
		GetDlgItem( IDC_SLIDER_PICCTRL_HUE )->EnableWindow( false );
		GetDlgItem( IDC_EDIT_PICCTRL_HUE )->EnableWindow( false );	
		// filter effect
		GetDlgItem( IDC_COMBO_PICCTRL_FLTEFFECT )->EnableWindow( false );
		// toning
		GetDlgItem( IDC_COMBO_PICCTRL_TONING )->EnableWindow( false );
		// toning intensity
		GetDlgItem( IDC_SLIDER_PICCTRL_TONINGINT )->EnableWindow( false );
		GetDlgItem( IDC_EDIT_PICCTRL_TONINGINT )->EnableWindow( false );	
	}
	else
	{
		// if check EachParam, enable under control
		OnCheckSharpAuto();		// sharpness
		// get active d-lighting sel
		int nADLSel = ((CComboBox*)GetDlgItem(IDC_COMBO_COMMON_ADL))->GetCurSel();
		if( !m_StrCommon.bIsADLight || 1 == nADLSel )
		{
			// not apply d-lighting
			EnableHueAndContrast();		// contrast	
		}
		else
		{			
			// apply active d-lighting
			GetDlgItem( IDC_CHECK_PICCTRL_CONTRAST_USER )->EnableWindow( true );
			GetDlgItem( IDC_CHECK_PICCTRL_CONTRAST_AUTO )->EnableWindow( false );	
			GetDlgItem( IDC_SLIDER_PICCTRL_CONTRAST )->EnableWindow( false );
			GetDlgItem( IDC_EDIT_PICCTRL_CONTRAST )->EnableWindow( false );	
			GetDlgItem( IDC_SLIDER_PICCTRL_BRIGHTNESS )->EnableWindow( false );
			GetDlgItem( IDC_EDIT_PICCTRL_BRIGHTNESS )->EnableWindow( false );	
		}
		
		// get picturecontrol sel
		int nPicCtrlSel = ((CComboBox*)GetDlgItem(IDC_COMBO_PICCTRL_PICCTRL))->GetCurSel();
		// change enable of slider and related edit control
		if( 4 == nPicCtrlSel )
		{
			// picturecontrol is monochrome
			// saturation
			GetDlgItem( IDC_SLIDER_PICCTRL_SATURATION )->EnableWindow( false );
			GetDlgItem( IDC_EDIT_PICCTRL_SATURATION )->EnableWindow( false );
			GetDlgItem( IDC_CHECK_PICCTRL_SATURATION_AUTO )->EnableWindow( false );
			// hue
			GetDlgItem( IDC_SLIDER_PICCTRL_HUE )->EnableWindow( false );
			GetDlgItem( IDC_EDIT_PICCTRL_HUE )->EnableWindow( false );	
			// filter effect
			GetDlgItem( IDC_COMBO_PICCTRL_FLTEFFECT )->EnableWindow( true );
			// toning
			GetDlgItem( IDC_COMBO_PICCTRL_TONING )->EnableWindow( true );
			// toning intensity
			GetDlgItem( IDC_SLIDER_PICCTRL_TONINGINT )->EnableWindow( true );
			GetDlgItem( IDC_EDIT_PICCTRL_TONINGINT )->EnableWindow( true );	
		}
		else
		{
			// picturecontrol isn't monochrome			
			OnCheckSaturation();	// saturation
			// hue
			GetDlgItem( IDC_SLIDER_PICCTRL_HUE )->EnableWindow( true );
			GetDlgItem( IDC_EDIT_PICCTRL_HUE )->EnableWindow( true );
			// filter effect
			GetDlgItem( IDC_COMBO_PICCTRL_FLTEFFECT )->EnableWindow( false );
			// toning
			GetDlgItem( IDC_COMBO_PICCTRL_TONING )->EnableWindow( false );
			// toning intensity
			GetDlgItem( IDC_SLIDER_PICCTRL_TONINGINT )->EnableWindow( false );
			GetDlgItem( IDC_EDIT_PICCTRL_TONINGINT )->EnableWindow( false );	
		}			
	}
}
// EnableUnderQuickAdj
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// EnableHueAndContrast
void CNkILSampleSet2Dlg::EnableHueAndContrast()
{
	
	// get current sel
	int nSel = ((CComboBox*)GetDlgItem(IDC_COMBO_COMMON_ADL))->GetCurSel();
	// check active d-lighting is apply
	bool bApplyADL = ( m_StrCommon.bIsADLight && 1 != nSel ) ? true : false;
	// check quickadjust radio button
	bool bQuickAdj = ( BST_CHECKED == ((CButton*)GetDlgItem(IDC_RADIO_PICCTRL_QUICK))->GetCheck() ) ? true : false;

	// if select quickadjust, disable all control 
	if( bQuickAdj )
	{
		GetDlgItem(IDC_CHECK_PICCTRL_CONTRAST_USER)->EnableWindow( false );
	}
	else
	{
		GetDlgItem(IDC_CHECK_PICCTRL_CONTRAST_USER)->EnableWindow( true );
	}

	// check sharpness check button			
	if( bQuickAdj || BST_CHECKED == ((CButton*)GetDlgItem(IDC_CHECK_PICCTRL_CONTRAST_USER))->GetCheck() || bApplyADL )
	{
		// check userdefine
		GetDlgItem( IDC_CHECK_PICCTRL_CONTRAST_AUTO )->EnableWindow( false );	
		GetDlgItem( IDC_SLIDER_PICCTRL_CONTRAST )->EnableWindow( false );
		GetDlgItem( IDC_EDIT_PICCTRL_CONTRAST )->EnableWindow( false );	
		GetDlgItem( IDC_SLIDER_PICCTRL_BRIGHTNESS )->EnableWindow( false );
		GetDlgItem( IDC_EDIT_PICCTRL_BRIGHTNESS )->EnableWindow( false );		
	}
	else if( BST_CHECKED == ((CButton*)GetDlgItem(IDC_CHECK_PICCTRL_CONTRAST_AUTO))->GetCheck() )
	{
		// check auto
		GetDlgItem( IDC_CHECK_PICCTRL_CONTRAST_AUTO )->EnableWindow( true );
		GetDlgItem( IDC_SLIDER_PICCTRL_CONTRAST )->EnableWindow( false );
		GetDlgItem( IDC_EDIT_PICCTRL_CONTRAST )->EnableWindow( false );	
		GetDlgItem( IDC_SLIDER_PICCTRL_BRIGHTNESS )->EnableWindow( true );
		GetDlgItem( IDC_EDIT_PICCTRL_BRIGHTNESS )->EnableWindow( true );		
	}
	else
	{
		// not check userdefine and auto
		GetDlgItem( IDC_CHECK_PICCTRL_CONTRAST_AUTO )->EnableWindow( true );
		GetDlgItem( IDC_SLIDER_PICCTRL_CONTRAST )->EnableWindow( true );
		GetDlgItem( IDC_EDIT_PICCTRL_CONTRAST )->EnableWindow( true );
		GetDlgItem( IDC_SLIDER_PICCTRL_BRIGHTNESS )->EnableWindow( true );
		GetDlgItem( IDC_EDIT_PICCTRL_BRIGHTNESS )->EnableWindow( true );		
	}
}
// EnableHueAndContrast
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// EnableWBParam
void CNkILSampleSet2Dlg::EnableWBParam( bool bInit )
{
	// get current sel
	int nSel = ((CComboBox*)GetDlgItem(IDC_COMBO_COMMON_WB))->GetCurSel();
	
	// change enable of slider and related edit control
	if( 0 == nSel || 1 == nSel )
	{
		// asshot or graypoint
		GetDlgItem( IDC_SLIDER_COMMON_WB )->EnableWindow(false);
		GetDlgItem( IDC_EDIT_COMMON_WB )->EnableWindow(false);
	}
	else
	{
		// other parameter
		GetDlgItem( IDC_SLIDER_COMMON_WB )->EnableWindow(true);
		GetDlgItem( IDC_EDIT_COMMON_WB )->EnableWindow(true);
		// get slider range and default pos
		int nMin, nMax, nDefault;
		for( int i = 0; i < WB_NEED_RANGE_NUM; i++ )
		{
			// exclude GrayPoint and AsShot 
			if( nSel - 2 == i )
			{
				nMin		= (int)m_StrWBRange.ulMinColorTemp[i];
				nMax		= (int)m_StrWBRange.ulMaxColorTemp[i];
				nDefault	= (int)m_StrWBRange.ulDefault[i];
			}
		}
		if( !bInit )
		{
			// set range and pos to control
			InitSliderCtrl( IDC_SLIDER_COMMON_WB, IDC_EDIT_COMMON_WB, nMin, nMax, nDefault );			
		}
	}

	// change enable of edit of rgb
	bool bEnable = ( 1 == nSel ) ? true : false;
	GetDlgItem( IDC_EDIT_WB_R )->EnableWindow( bEnable );
	GetDlgItem( IDC_EDIT_WB_G )->EnableWindow( bEnable );
	GetDlgItem( IDC_EDIT_WB_B )->EnableWindow( bEnable );	
}
// EnableWBParam
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
//OnCancel
void CNkILSampleSet2Dlg::OnCancel()
{
	if( m_pParent != NULL )
	{
		m_pParent->PostMessage( MSG_WM_DELETE_SET2DLG );	// send message for notify delete dialog	
	}
	else
	{
		CDialog::OnCancel();
	}
}
//OnCancel
/////////////////////////////////////////////////////////////////

//====================================================================
// function name		：OnApplyParamSettings
// function abstract	：set ParamSettings on dialog and send message with data
// parameter			：none
// return value			：none
//====================================================================
void CNkILSampleSet2Dlg::OnApplyParamSettings()
{
	// check exist ownerwindow hundle
	if( NULL != m_pParent )
	{	
		// get parameter of combobox
		int nSel = ((CComboBox*)GetDlgItem(IDC_BUTTON_PARAMSET_APPLY))->GetCurSel();
		// set parameter from sel
		m_ulParamSet = ( 0 == nSel ) ? kNkfl_RawParameterSet_AsShot : kNkfl_RawParameterSet_LastSaveSetting ;
		// send message with pointer of struct and enum value for check kind of struct
		m_pParent->SendMessage( MSG_WM_APPLY_SET2DLG, kILSample_Group_ParamSet, (LPARAM)m_ulParamSet );
	}
}
//OnApplyParamSettings
/////////////////////////////////////////////////////////////////

//====================================================================
// function name		：OnApplyCommon
// function abstract	：set Common group data on dialog and send message with data
// parameter			：none
// return value			：none
//====================================================================
void CNkILSampleSet2Dlg::OnApplyCommon()
{
	// check exist ownerwindow hundle
	if( NULL != m_pParent )
	{	
		// set parameter of dialog to struct
		// expcomp
		m_StrCommon.dbExpComp = (double)((CSliderCtrl*)GetDlgItem(IDC_SLIDER_COMMON_EXPCOMP))->GetPos();
		// whitebalance
		int nSel = ((CComboBox*)GetDlgItem(IDC_COMBO_COMMON_WB))->GetCurSel();
		// get whitebalance parameter
		if( 0 == nSel )
		{			
			m_StrCommon.StrWBInfo.ulMWB = kNkfl_WB_AsShot;	// as shot
		}
		else if( 1 == nSel )
		{
			// gray point
			m_StrCommon.StrWBInfo.ulMWB = kNkfl_WB_GrayPoint;
			// rgb value						
			m_StrCommon.StrWBInfo.rgb.ulR = GetEditValue( IDC_EDIT_WB_R );
			m_StrCommon.StrWBInfo.rgb.ulG = GetEditValue( IDC_EDIT_WB_G );
			m_StrCommon.StrWBInfo.rgb.ulB = GetEditValue( IDC_EDIT_WB_B );			
		}
		else
		{
			// other whitebalance parameter
			m_StrCommon.StrWBInfo.ulMWB			= m_StrWBRange.ulWBParam[ nSel-2 ];
			m_StrCommon.StrWBInfo.lColorTemp	= (long)GetEditValue( IDC_EDIT_COMMON_WB );
			// if colortemperature is over or under limit, set default value
			if( m_StrCommon.StrWBInfo.lColorTemp < (long)m_StrWBRange.ulMinColorTemp[ nSel-2 ] || m_StrCommon.StrWBInfo.lColorTemp > (long)m_StrWBRange.ulMaxColorTemp[ nSel-2 ] )
			{
				m_StrCommon.StrWBInfo.lColorTemp = m_StrWBRange.ulDefault[ nSel-2 ];
			}
		}
		// tint
		m_StrCommon.lTint = (long)((CSliderCtrl*)GetDlgItem(IDC_SLIDER_COMMON_TINT))->GetPos();
		// noise reduction
		nSel = ((CComboBox*)GetDlgItem(IDC_COMBO_COMMON_NR))->GetCurSel();
		switch( nSel )
		{
		case 0:
			m_StrCommon.ulNRType = kNkfl_NR_AsShot;
			break;
		case 1:
			m_StrCommon.ulNRType = kNkfl_NR_OFF;
			break;
		case 2:
			m_StrCommon.ulNRType = kNkfl_NR_Low;
			break;
		case 3:
			m_StrCommon.ulNRType = kNkfl_NR_Normal;
			break;
		case 4:
			m_StrCommon.ulNRType = kNkfl_NR_High;
			break;			
		}
		// active d-lighting
		nSel = ((CComboBox*)GetDlgItem(IDC_COMBO_COMMON_ADL))->GetCurSel();
		switch( nSel )
		{
		case 0:
			m_StrCommon.ulADLight = kNkfl_ActiveDLighting_AsShot;
			break;
		case 1:
			m_StrCommon.ulADLight = kNkfl_ActiveDLighting_None;
			break;
		case 2:
			m_StrCommon.ulADLight = kNkfl_ActiveDLighting_Low;
			break;
		case 3:
			m_StrCommon.ulADLight = kNkfl_ActiveDLighting_Normal;
			break;
		case 4:
			m_StrCommon.ulADLight = kNkfl_ActiveDLighting_High;
			break;
		}
		// send message with pointer of struct and enum value for check kind of struct
		m_pParent->SendMessage( MSG_WM_APPLY_SET2DLG, kILSample_Group_Common, (LPARAM)&m_StrCommon );
	}
}
//OnApplyCommon
/////////////////////////////////////////////////////////////////

//====================================================================
// function name		：OnApplyColorMode
// function abstract	：set ColorMode group data on dialog and send message with data
// parameter			：none
// return value			：none
//====================================================================
void CNkILSampleSet2Dlg::OnApplyColorMode()
{
	// check exist ownerwindow hundle
	if( NULL != m_pParent )
	{
		// set parameter of dialog to struct
		// colormode
		int nSel = ((CComboBox*)GetDlgItem(IDC_COMBO_COLORMODE_COLOR))->GetCurSel();
		switch( nSel )
		{
		case 0:
			m_StrColor.ulColorMode = kNkfl_ColorMode_AsShot;
			break;
		case 1:
			m_StrColor.ulColorMode = kNkfl_ColorMode_ModeI;
			break;
		case 2:
			m_StrColor.ulColorMode = kNkfl_ColorMode_ModeII;
			break;
		case 3:
			m_StrColor.ulColorMode = kNkfl_ColorMode_ModeIII;
			break;
		case 4:
			m_StrColor.ulColorMode = kNkfl_ColorMode_ModeIa;
			break;
		case 5:
			m_StrColor.ulColorMode = kNkfl_ColorMode_ModeIIIa;
			break;
		case 6:
			m_StrColor.ulColorMode = kNkfl_ColorMode_BW;
			break;
		}
		// shrpening
		nSel = ((CComboBox*)GetDlgItem(IDC_COMBO_COLORMODE_SHARP))->GetCurSel();
		switch( nSel )
		{
		case 0:
			m_StrColor.ulSharpness = kNkfl_Sharpness_AsShot;
			break;
		case 1:
			m_StrColor.ulSharpness = kNkfl_Sharpness_None;
			break;
		case 2:
			m_StrColor.ulSharpness = kNkfl_Sharpness_Low;
			break;
		case 3:
			m_StrColor.ulSharpness = kNkfl_Sharpness_MediumLow;
			break;
		case 4:
			m_StrColor.ulSharpness = kNkfl_Sharpness_Normal;
			break;
		case 5:
			m_StrColor.ulSharpness = kNkfl_Sharpness_MediumHigh;
			break;
		case 6:
			m_StrColor.ulSharpness = kNkfl_Sharpness_High;
			break;
		}
		// tonecomp
		nSel = ((CComboBox*)GetDlgItem(IDC_COMBO_COLORMODE_TONECOMP))->GetCurSel();
		switch( nSel )
		{
		case 0:
			m_StrColor.ulToneComp = kNkfl_ToneComp_AsShot;
			break;
		case 1:
			m_StrColor.ulToneComp = kNkfl_ToneComp_LowContrast;
			break;
		case 2:
			m_StrColor.ulToneComp = kNkfl_ToneComp_MediumLow;
			break;
		case 3:
			m_StrColor.ulToneComp = kNkfl_ToneComp_Normal;
			break;
		case 4:
			m_StrColor.ulToneComp = kNkfl_ToneComp_MediumHigh;
			break;
		case 5:
			m_StrColor.ulToneComp = kNkfl_ToneComp_HighContrast;
			break;
		case 6:
			m_StrColor.ulToneComp = kNkfl_ToneComp_UserDefinedCurve;
			break;
		}
		// hue
		m_StrColor.lHueAdj = (long)(((CSliderCtrl*)GetDlgItem(IDC_SLIDER_COLORMODE_HUE))->GetPos() * UNIT_HUE_SLIDER );
		// saturation
		nSel = ((CComboBox*)GetDlgItem(IDC_COMBO_COLORMODE_SATURATION))->GetCurSel();
		switch( nSel )
		{
		case 0:
			m_StrColor.ulSaturation = kNkfl_Saturation_AsShot;
			break;
		case 1:
			m_StrColor.ulSaturation = kNkfl_Saturation_Moderate;
			break;
		case 2:
			m_StrColor.ulSaturation = kNkfl_Saturation_Normal;
			break;
		case 3:
			m_StrColor.ulSaturation = kNkfl_Saturation_Enhanced;
			break;
		}
		// filtereffect
		nSel = ((CComboBox*)GetDlgItem(IDC_COMBO_COLORMODE_FLTEFFECT))->GetCurSel();
		switch( nSel )
		{
		case 0:
			m_StrColor.ulFilterEffect = kNkfl_FilterEffect_AsShot;
			break;
		case 1:
			m_StrColor.ulFilterEffect = kNkfl_FilterEffect_OFF;
			break;
		case 2:
			m_StrColor.ulFilterEffect = kNkfl_FilterEffect_Yellow;
			break;
		case 3:
			m_StrColor.ulFilterEffect = kNkfl_FilterEffect_Orange;
			break;
		case 4:
			m_StrColor.ulFilterEffect = kNkfl_FilterEffect_Red;
			break;
		case 5:
			m_StrColor.ulFilterEffect = kNkfl_FilterEffect_Green;
			break;
		}
		// send message with pointer of struct and enum value for check kind of struct
		m_pParent->SendMessage( MSG_WM_APPLY_SET2DLG, kILSample_Group_ColorMode, (LPARAM)&m_StrColor );
	}
}
//OnApplyColorMode
/////////////////////////////////////////////////////////////////

//====================================================================
// function name		：OnApplyPictureCtrl
// function abstract	：set PictureControl group data on dialog and send message with data
// parameter			：none
// return value			：none
//====================================================================
void CNkILSampleSet2Dlg::OnApplyPictureCtrl()
{
	// check exist ownerwindow hundle
	if( NULL != m_pParent )
	{
		// set parameter of dialog to struct
		// picturecontrol
		int nSel = ((CComboBox*)GetDlgItem(IDC_COMBO_PICCTRL_PICCTRL))->GetCurSel();
		switch( nSel )
		{
		case 0:
			m_StrPicture.ulPictureControl = kNkfl_PictureControl_AsShot;
			break;
		case 1:
			m_StrPicture.ulPictureControl = kNkfl_PictureControl_Standard;
			break;
		case 2:
			m_StrPicture.ulPictureControl = kNkfl_PictureControl_Neutral;
			break;
		case 3:
			m_StrPicture.ulPictureControl = kNkfl_PictureControl_Vivid;
			break;
		case 4:
			m_StrPicture.ulPictureControl = kNkfl_PictureControl_Monochrome;
			break;
		case 5:
			m_StrPicture.ulPictureControl = kNkfl_PictureControl_D2XModeI;
			break;
		case 6:
			m_StrPicture.ulPictureControl = kNkfl_PictureControl_D2XModeII;
			break;
		case 7:
			m_StrPicture.ulPictureControl = kNkfl_PictureControl_D2XModeIII;
			break;
		}
		// quickadjust radiobutton
		if( BST_CHECKED == ((CButton*)GetDlgItem( IDC_RADIO_PICCTRL_QUICK ))->GetCheck())
		{
			// apply quickadjust
			m_StrPicture.bApplyQuickAdjust	= true;
			m_StrPicture.lQuickAdjust		= (long)((CSliderCtrl*)GetDlgItem( IDC_SLIDER_PICCTRL_QUICKADJ ))->GetPos();
		}
		else
		{
			// not apply quickadjust
			m_StrPicture.bApplyQuickAdjust	= false;
			// sharpness
			if( BST_CHECKED == ((CButton*)GetDlgItem(IDC_CHECK_PICCTRL_SHARP_AUTO))->GetCheck() )
			{
				m_StrPicture.bSharpessAuto	= true;
			}
			else
			{
				m_StrPicture.bSharpessAuto	= false;
				// get slider value
				m_StrPicture.ulSharpness	= (unsigned long)((CSliderCtrl*)GetDlgItem( IDC_SLIDER_PICCTRL_SHARP ))->GetPos();
			}
			// contrast		
			m_StrPicture.bUserDefinedCurve	= false;
			if( BST_CHECKED == ((CButton*)GetDlgItem(IDC_CHECK_PICCTRL_CONTRAST_USER))->GetCheck() )
			{
				m_StrPicture.bUserDefinedCurve	= true;
			}
			else if( BST_CHECKED == ((CButton*)GetDlgItem(IDC_CHECK_PICCTRL_CONTRAST_AUTO))->GetCheck() )
			{			
				m_StrPicture.bContrastAuto		= true;
				// brightness
				m_StrPicture.lBrightness	= (long)((CSliderCtrl*)GetDlgItem( IDC_SLIDER_PICCTRL_BRIGHTNESS ))->GetPos();
			}
			else
			{			
				m_StrPicture.bContrastAuto		= false;
				// get slider value
				m_StrPicture.lContrast	= (long)((CSliderCtrl*)GetDlgItem( IDC_SLIDER_PICCTRL_CONTRAST ))->GetPos();
				// brightness
				m_StrPicture.lBrightness	= (long)((CSliderCtrl*)GetDlgItem( IDC_SLIDER_PICCTRL_BRIGHTNESS ))->GetPos();
			}		
			// saturation
			if( BST_CHECKED == ((CButton*)GetDlgItem(IDC_CHECK_PICCTRL_SATURATION_AUTO))->GetCheck() )
			{
				m_StrPicture.bSaturationAuto	= true;
			}
			else
			{
				m_StrPicture.bSaturationAuto	= false;
				m_StrPicture.lSaturation		= (long)((CSliderCtrl*)GetDlgItem( IDC_SLIDER_PICCTRL_SATURATION ))->GetPos();
			}
			// hue
			m_StrPicture.lHue = (long)((CSliderCtrl*)GetDlgItem( IDC_SLIDER_PICCTRL_HUE ))->GetPos();
			// filtereffect
			nSel = ((CComboBox*)GetDlgItem(IDC_COMBO_PICCTRL_FLTEFFECT))->GetCurSel();
			switch( nSel )
			{
			case 0:
				m_StrPicture.lFilter = kNkfl_FilterEffect_AsShot;
				break;
			case 1:
				m_StrPicture.lFilter = kNkfl_FilterEffect_OFF;
				break;
			case 2:
				m_StrPicture.lFilter = kNkfl_FilterEffect_Yellow;
				break;
			case 3:
				m_StrPicture.lFilter = kNkfl_FilterEffect_Orange;
				break;
			case 4:
				m_StrPicture.lFilter = kNkfl_FilterEffect_Red;
				break;
			case 5:
				m_StrPicture.lFilter = kNkfl_FilterEffect_Green;
				break;
			}
			// toning
			nSel = ((CComboBox*)GetDlgItem(IDC_COMBO_PICCTRL_TONING))->GetCurSel();
			switch( nSel )
			{
			case 0:
				m_StrPicture.lToning = kNkfl_Toning_AsShot;
				break;
			case 1:
				m_StrPicture.lToning = kNkfl_Toning_BW;
				break;
			case 2:
				m_StrPicture.lToning = kNkfl_Toning_Sepia;
				break;
			case 3:
				m_StrPicture.lToning = kNkfl_Toning_Cyanotype;
				break;
			case 4:
				m_StrPicture.lToning = kNkfl_Toning_Red;
				break;
			case 5:
				m_StrPicture.lToning = kNkfl_Toning_Yellow;
				break;
			case 6:
				m_StrPicture.lToning = kNkfl_Toning_Green;
				break;
			case 7:
				m_StrPicture.lToning = kNkfl_Toning_Turquoize;
				break;
			case 8:
				m_StrPicture.lToning = kNkfl_Toning_Cyan;
				break;
			case 9:
				m_StrPicture.lToning = kNkfl_Toning_Violet;
				break;
			case 10:
				m_StrPicture.lToning = kNkfl_Toning_Magenta;
				break;
			}
			// tonint intensity
			m_StrPicture.lToningIntensity	= (long)((CSliderCtrl*)GetDlgItem( IDC_SLIDER_PICCTRL_TONINGINT ))->GetPos();
		}		
		// send message with pointer of struct and enum value for check kind of struct
		m_pParent->SendMessage( MSG_WM_APPLY_SET2DLG, kILSample_Group_PictureCtrl, (LPARAM)&m_StrPicture );
	}
}
//OnApplyPictureCtrl
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
//OnHScroll
void CNkILSampleSet2Dlg::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
{
	CSliderCtrl* pSlider = (CSliderCtrl*)pScrollBar;
	int nSlider = 0;				// index of slider

	// check kind of SliderControl by table
	for( ; nSlider < SLIDER_CNT; nSlider++ )
	{
		if(  (CSliderCtrl*)GetDlgItem( g_slider_edit[nSlider][0] ) == pSlider )
		{
			break;
		}
	}	

	// if slider control doesn't agree with that of Table, do nothing
	if( SLIDER_CNT == nSlider )
	{
		return;
	}

	// get slider position
	int nCurPos = pSlider->GetPos();	
	if( IDC_SLIDER_COLORMODE_HUE == g_slider_edit[nSlider][0] )
	{
		nCurPos *= UNIT_HUE_SLIDER;		// triple value to set edit
	}
	
	// get editvalue and check	
	int nValue = GetEditValue( g_slider_edit[nSlider][1] );
	if( nCurPos == nValue )
	{		
		return;		// if value is corresponding, do nothing
	}
	// change slider position to string for set Edit	
	SetEditValue( g_slider_edit[nSlider][1], nCurPos );	
}
//OnHScroll
/////////////////////////////////////////////////////////////////

//====================================================================
// function name		：UpdateEdit
// function abstract	：check edit data, if data is illegal, set default
// parameter			：nEditID	ID of Edit Control
//                        nMinValue minimum value of edit
//						  nMaxValue maximum value of edit
//						  pnValue	pointer of value
// return value			：true/false
//====================================================================
bool CNkILSampleSet2Dlg::UpdateEdit( UINT nEditID, int nMinValue, int nMaxValue, int* pnValue /* = NULL */ )
{
	CEdit* pEdit = (CEdit*)GetDlgItem( nEditID );		// get edit control hundle

	bool bDefault = false;
	// get value on editBox
	CString strOrgEdit, strNewEdit;	
	pEdit->GetWindowText( strOrgEdit );
	
	strNewEdit = strOrgEdit;
	strNewEdit.TrimLeft();								// trim space of the first part
	if( ( IDC_EDIT_COMMON_WB == nEditID || IDC_EDIT_PICCTRL_SHARP == nEditID || IDC_EDIT_PICCTRL_TONINGINT == nEditID ||
		  IDC_EDIT_WB_R == nEditID	|| IDC_EDIT_WB_G == nEditID || IDC_EDIT_WB_B == nEditID ) && '-' == strNewEdit[0] )
	{
		// these control treate only Positive number
		// so if '-', set default value
		bDefault = true;
	}
	else if( 0 == strNewEdit.GetLength() || '+' == strNewEdit || '-' == strNewEdit )
	{
		return false;									// only space or '+' or '-', not update
	}
	
	int	nEdit = 0;
	// check need to set default value 
	if( !bDefault && ( '+' == strNewEdit[0] || '-' == strNewEdit[0] || ( '0' <= strNewEdit[0] && '9' >= strNewEdit[0] )))
	{
		// convert to numeric by strtod()
		char* pCheck = NULL;							// for check end of scan edit value	
		nEdit = (int)strtod( strNewEdit, &pCheck );		// drops below the decimal point
				
		if( NULL != *pCheck || nMinValue > nEdit || nMaxValue < nEdit )
		{
			if( IDC_EDIT_COMMON_WB == nEditID && nMinValue > nEdit )
			{
				// when whitebalance color temperature is smaller than limit, do nothing
				return false;
			}
			else
			{
				// if end of scan is not NULL, illegal value and need set default value because this string is not numeric	
				bDefault = true;
			}
		}			
		else if( NULL != pnValue )
		{			
			*pnValue = nEdit;	
			/*if colormode hue, only Multiple of three from -9 to 9
			and slider pos is 1/3 of that value*/
			if( IDC_EDIT_COLORMODE_HUE == nEditID )
			{
				if( -9 <= nEdit && -6 > nEdit )
				{
					nEdit = -9;					
				}
				else if( -6 <= nEdit && -3 > nEdit )
				{
					nEdit = -6;					
				}
				else if( -3 <= nEdit && 0 > nEdit )
				{
					nEdit = -3;					
				}
				else if( 6 < nEdit && 9 >= nEdit )
				{
					nEdit = 9;					
				}
				else if( 3 < nEdit && 6 >= nEdit )
				{
					nEdit = 6;					
				}
				else if( 0 < nEdit && 3 >= nEdit )
				{
					nEdit = 3;					
				}
				*pnValue = nEdit / 3;
			}
			strNewEdit.Format( "%d", nEdit );
		}
	}
	else
	{
		bDefault = true;
	}
	// check need to set default
	if( bDefault )
	{
		// excluding illegal charcter, get default value
		nEdit = GetCtrlDefault( nEditID );		
		// reset value fo editbox
		strNewEdit.Format( "%d", nEdit );		
		if( NULL != pnValue )
		{
			*pnValue = nEdit;
		}
	}	
	// check there was a change or not
	if( strOrgEdit != strNewEdit )
	{
		pEdit->SetWindowText( strNewEdit );
	}

	return true;
}
// UpdateEdit
/////////////////////////////////////////////////////////////////

//====================================================================
// function name		：OnUpdateEdit
// function abstract	：check edit data and reflect to slider control
// parameter			：nID	ID of Edit Control
// return value			：none
//====================================================================
void CNkILSampleSet2Dlg::OnUpdateEdit( UINT nID )
{	
	if( !m_bIsInitDlg )
	{
		return;				// if not initialize dialog, do nothing
	}

	switch( nID )
	{
	case IDC_EDIT_COMMON_EXPCOMP:
	case IDC_EDIT_COMMON_WB:
	case IDC_EDIT_COMMON_TINT:	
	case IDC_EDIT_COLORMODE_HUE:
	case IDC_EDIT_PICCTRL_QUICKADJ:
	case IDC_EDIT_PICCTRL_SHARP:
	case IDC_EDIT_PICCTRL_CONTRAST:
	case IDC_EDIT_PICCTRL_BRIGHTNESS:
	case IDC_EDIT_PICCTRL_SATURATION:
	case IDC_EDIT_PICCTRL_HUE:
	case IDC_EDIT_PICCTRL_TONINGINT:
		{	
			// get slider control related edit by control ID in table 
			CSliderCtrl* pSlider = GetSliderOfEdit( nID );			

			// get range of position and check validity of edit value
			int nMin, nMax;	
			pSlider->GetRange( nMin, nMax );	
			// check and update editbox and reflect edit value to slider position
			int nValue = 0;
			bool bChangeSlider = false;
			if( IDC_EDIT_COLORMODE_HUE == nID )
			{
				// hue in colormode group use multiple of three number
				bChangeSlider = UpdateEdit( nID, nMin * UNIT_HUE_SLIDER, nMax * UNIT_HUE_SLIDER, &nValue );
			}
			else
			{
				bChangeSlider = UpdateEdit( nID, nMin, nMax, &nValue );
			}

			if( bChangeSlider )
			{
				pSlider->SetPos( nValue );	
			}
		}
		break;		
	case IDC_EDIT_WB_R:
	case IDC_EDIT_WB_G:
	case IDC_EDIT_WB_B:
		UpdateEdit( nID, MIN_RGB, MAX_RGB );
		break;
	}	
}
// OnUpdateEdit
/////////////////////////////////////////////////////////////////

//====================================================================
// function name		：OnKillFocusEdit
// function abstract	：check edit data and set minimum value when edit is empty
// parameter			：nID	ID of Edit Control
// return value			：none
//====================================================================
void CNkILSampleSet2Dlg::OnKillFocusEdit(UINT nID)
{
	if( !m_bIsInitDlg )
	{
		return;				// if not initialize dialog, do nothing
	}

	switch( nID )
	{
	case IDC_EDIT_COMMON_EXPCOMP:
	case IDC_EDIT_COMMON_WB:
	case IDC_EDIT_COMMON_TINT:	
	case IDC_EDIT_PICCTRL_QUICKADJ:
	case IDC_EDIT_PICCTRL_SHARP:
	case IDC_EDIT_PICCTRL_CONTRAST:
	case IDC_EDIT_PICCTRL_BRIGHTNESS:
	case IDC_EDIT_PICCTRL_SATURATION:
	case IDC_EDIT_PICCTRL_HUE:
	case IDC_EDIT_PICCTRL_TONINGINT:
	case IDC_EDIT_COLORMODE_HUE:	
		{	
			CString strEdit;
			((CEdit*)GetDlgItem( nID ))->GetWindowText(strEdit);
			strEdit.TrimLeft();										// delete space
			if( 0 == strEdit.GetLength() )
			{
				// get slider control related edit 
				CSliderCtrl* pSlider = GetSliderOfEdit( nID );			

				// get range of position and check validity of edit value
				int nMin, nMax;	
				pSlider->GetRange( nMin, nMax );
				if( IDC_EDIT_COLORMODE_HUE == nID )
				{
					SetEditValue( nID, nMin * UNIT_HUE_SLIDER );		// set minimum value
				}
				else
				{
					SetEditValue( nID, nMin );							// set minimum value
				}				
			}
		}
		break;
	case IDC_EDIT_WB_R:
	case IDC_EDIT_WB_G:
	case IDC_EDIT_WB_B:
		CString strEdit;
		((CEdit*)GetDlgItem( nID ))->GetWindowText(strEdit);
		strEdit.TrimLeft();											//delete space						
		if( 0 == strEdit.GetLength() )
		{
			SetEditValue( nID, 0 );									// set minimum value
		}
		break;	
	}
}
// OnKillFocusEdit
/////////////////////////////////////////////////////////////////

//====================================================================
// function name		：InitParameter
// function abstract	：initialize paramete
// parameter			：ulGroup	parameter group of this dialog
//						  pData		pointer of each data
// return value			：true/false
//====================================================================
bool CNkILSampleSet2Dlg::InitParameter(unsigned long ulGroup, void* pData)
{
	// check parameter
	if( NULL == pData )
	{
		return false;
	}
	// initilize param each group on dialog
	switch( ulGroup )
	{
	case kILSample_Group_ParamSet:
		m_ulParamSet = *((unsigned long*)pData); 
		break;
	case kILSample_Group_Common:
		m_StrCommon	 = *( (ILSample_CommonGroup*)pData );
		break;
	case kILSample_Group_ColorMode:
		m_StrColor	 = *( (ILSample_ColorModeGroup*)pData );		
		break;
	case kILSample_Group_PictureCtrl:
		m_StrPicture = *( (NkIL_PicCtrlParam*)pData );
		break;
	case kILSample_Apply_PictureCtrl:
		m_bApplyPictCtrl = *( (bool*)pData );
		break;
	case kILSample_WB_RangeInfo:
		m_StrWBRange = *( (ILSample_WBRange*)pData );
		break;
	default:
		return false;		// not support parameter
	}

	return true;
}
// InitParameter
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// OnSelChangeParamSet
void CNkILSampleSet2Dlg::OnSelChangeParamSet()
{
	// check sel
	if( 0 == ((CComboBox*)GetDlgItem( IDC_COMBO_PARAMSET ))->GetCurSel())
	{
		m_ulParamSet = kNkfl_RawParameterSet_AsShot;
	}
	else
	{
		m_ulParamSet = kNkfl_RawParameterSet_LastSaveSetting;
	}
	// switch enable of control
	EnableCommonGroup();
	EnableColorModeGroup();
	EnablePicCtrlGroup();
}
// OnSelChangeParamSet
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// OnSelChangeWBCombo
void CNkILSampleSet2Dlg::OnSelChangeWBCombo()
{
	EnableWBParam(false);
}
// OnSelChangeWBCombo
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// OnSelChangeADLCombo
void CNkILSampleSet2Dlg::OnSelChangeADLCombo()
{
	EnablePicCtrlGroup();
}
// OnSelChangeADLCombo
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// OnSelChangeColorMode
void CNkILSampleSet2Dlg::OnSelChangeColorMode()
{
	int nSel = ((CComboBox*)GetDlgItem(IDC_COMBO_COLORMODE_COLOR))->GetCurSel();
	bool bEnable = ( 6 == nSel ) ? true : false;	
	// if colormode is B&W, filtereffect is enable
	GetDlgItem( IDC_COMBO_COLORMODE_FLTEFFECT )->EnableWindow( bEnable );
}
// OnSelChangeColorMode
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// OnSelChangePictCtrl
void CNkILSampleSet2Dlg::OnSelChangePictCtrl()
{
	// get current sel
	int nSel = ((CComboBox*)GetDlgItem(IDC_COMBO_PICCTRL_PICCTRL))->GetCurSel();

	// change enable of slider and related edit control
	if( 0 == nSel )
	{
		// asshot
		GetDlgItem( IDC_RADIO_PICCTRL_QUICK )->EnableWindow( false );
		GetDlgItem( IDC_RADIO_PICCTRL_EACH )->EnableWindow( false );
		GetDlgItem( IDC_SLIDER_PICCTRL_QUICKADJ )->EnableWindow( false );
		GetDlgItem( IDC_EDIT_PICCTRL_QUICKADJ )->EnableWindow( false );		
		EnableUnderQuickAdj( true );
		return;
	}
	else if( 2 == nSel || 4 == nSel )
	{
		// neutral and monochrome
		((CButton*)GetDlgItem(IDC_RADIO_PICCTRL_QUICK))->SetCheck(BST_UNCHECKED);
		((CButton*)GetDlgItem(IDC_RADIO_PICCTRL_EACH))->SetCheck(BST_CHECKED);
		GetDlgItem( IDC_RADIO_PICCTRL_QUICK )->EnableWindow( false );
		GetDlgItem( IDC_RADIO_PICCTRL_EACH )->EnableWindow( false );		
	}
	else
	{
		// standard, vivid, D2XModeI-III
		GetDlgItem( IDC_RADIO_PICCTRL_QUICK )->EnableWindow( true );
		GetDlgItem( IDC_RADIO_PICCTRL_EACH )->EnableWindow( true );
	}	
	
	OnCheckQuickAdj();
}
// OnSelChangePictCtrl
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// OnCheckQuickAdj
void CNkILSampleSet2Dlg::OnCheckQuickAdj()
{
	// check quickadjust radio button
	bool bTrue = ( BST_CHECKED == ((CButton*)GetDlgItem(IDC_RADIO_PICCTRL_QUICK))->GetCheck() ) ? true : false;
	// quick adjust
	GetDlgItem( IDC_SLIDER_PICCTRL_QUICKADJ )->EnableWindow( bTrue );
	GetDlgItem( IDC_EDIT_PICCTRL_QUICKADJ )->EnableWindow( bTrue );		
	EnableUnderQuickAdj( bTrue );
}
// OnCheckQuickAdj
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// OnCheckSharpAuto
void CNkILSampleSet2Dlg::OnCheckSharpAuto()
{
	GetDlgItem( IDC_CHECK_PICCTRL_SHARP_AUTO )->EnableWindow( true );
	// check sharpness check button
	bool bEnable = ( BST_CHECKED == ((CButton*)GetDlgItem(IDC_CHECK_PICCTRL_SHARP_AUTO))->GetCheck() ) ? false : true;
	GetDlgItem( IDC_SLIDER_PICCTRL_SHARP )->EnableWindow( bEnable );
	GetDlgItem( IDC_EDIT_PICCTRL_SHARP )->EnableWindow( bEnable );	
}
// OnCheckSharpAuto
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// OnCheckContrast
void CNkILSampleSet2Dlg::OnCheckContrast()
{
	// check from active d-lighting and check box of contrast
	EnableHueAndContrast();
}
// OnCheckContrast
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// OnCheckSaturation
void CNkILSampleSet2Dlg::OnCheckSaturation()
{
	GetDlgItem( IDC_CHECK_PICCTRL_SATURATION_AUTO )->EnableWindow( true );
	// check saturation check button
	bool bEnable = ( BST_CHECKED == ((CButton*)GetDlgItem(IDC_CHECK_PICCTRL_SATURATION_AUTO))->GetCheck() ) ? false : true;
	GetDlgItem( IDC_SLIDER_PICCTRL_SATURATION )->EnableWindow( bEnable );
	GetDlgItem( IDC_EDIT_PICCTRL_SATURATION )->EnableWindow( bEnable );	
}
// OnCheckSaturation
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// GetCtrlDefault
int	CNkILSampleSet2Dlg::GetCtrlDefault( UINT nCtrlID )
{
	switch( nCtrlID )
	{	
	case IDC_EDIT_COMMON_WB:
		{
			// whitebalance, need default as parameter
			// get current sel
			int nSel = ((CComboBox*)GetDlgItem(IDC_COMBO_COMMON_WB))->GetCurSel();
			for( int i = 0; i < WB_NEED_RANGE_NUM; i++)
			{
				// exclude GrayPoint and AsShot 
				if( nSel - 2 == i )
				{					
					return m_StrWBRange.ulDefault[i];		// get default value from ILSample_WBRange structure
				}
			}			
		}	
		break;
	case IDC_EDIT_PICCTRL_SHARP:
		// sharpning
		return 3;	
	case IDC_EDIT_PICCTRL_TONINGINT:
		// toningintensity
		return 4;
	}

	return 0;
}
// GetCtrlDefault
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// GetSliderOfEdit
CSliderCtrl* CNkILSampleSet2Dlg::GetSliderOfEdit( UINT nEditID )
{
	// find slider control related editbox indicated
	for( int i = 0; i < SLIDER_CNT; i++ )	
	{
		if( g_slider_edit[i][1] == nEditID )
		{
			return (CSliderCtrl*)GetDlgItem( g_slider_edit[i][0] );			
		}
	} 
	// not supported id
	return NULL;
}
// GetSliderOfEdit
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// GetEditValue
int CNkILSampleSet2Dlg::GetEditValue( UINT nEditID )
{
	// get numerical value in editbox
	CString strEdit;
	((CEdit*)GetDlgItem( nEditID ))->GetWindowText(strEdit);
	return atoi( strEdit );
}
// GetEditValue
/////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////
// GetEditValue
void CNkILSampleSet2Dlg::SetEditValue( UINT nEditID, int nEditValue )
{
	// get numerical value in editbox
	CString strEdit;
	strEdit.Format( "%d", nEditValue );
	((CEdit*)GetDlgItem( nEditID ))->SetWindowText(strEdit);
	return;
}
// GetEditValue
/////////////////////////////////////////////////////////////////