/*********************************************************/
//	NkILSampleDoc.cpp
//		Source file of ImageSDKLibrary Sample's Document class.
//
//	Copyright(c) 2007, Nikon Corporation - All rights reserved.
/*********************************************************/

#include "stdafx.h"
#include "NkILSample.h"
#include "NkILSampleDoc.h"
#include "NkILSampleView.h"
#include "MainFrm.h"

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

// CNkILSampleDoc
IMPLEMENT_DYNCREATE(CNkILSampleDoc, CDocument)

BEGIN_MESSAGE_MAP(CNkILSampleDoc, CDocument)	
END_MESSAGE_MAP()


// CNkILSampleDoc construction/destruction

CNkILSampleDoc::CNkILSampleDoc()
{
	m_StrImage.pData = NULL;	
}

CNkILSampleDoc::~CNkILSampleDoc()
{	
}

BOOL CNkILSampleDoc::OnNewDocument()
{
	if (!CDocument::OnNewDocument())
		return FALSE;

	return TRUE;
}

BOOL CNkILSampleDoc::OnOpenDocument(LPCTSTR lpszPathName)
{
	if (!CDocument::OnOpenDocument( lpszPathName ))
		return FALSE;

	SetPathName( lpszPathName, true );		// set filepath to thisclass
	
	// file open and load image
	if( !LoadImageFile( lpszPathName ))
	{		
		m_ILCtrl.CloseSession();		
		return FALSE;
	}	

	DisplayImage();							// display image at view

	return TRUE;
}

void CNkILSampleDoc::DeleteContents()
{
	// initialize each parameter
	if( NULL != m_StrImage.pData )
	{
		delete [] m_StrImage.pData;
		m_StrImage.pData = NULL;
	}			
	// get view object
	POSITION			pos		= GetFirstViewPosition();
	CNkILSampleView*	view	= (CNkILSampleView*)GetNextView(pos);
	view->DeleteAllDlg();			// destroy settings dialog
	// initialize parameter	
	m_ulFormat		    = 0;	
	m_SetSize.SetSize(0, 0);
	m_ulUserOrientation	= kNkfl_Orientation_CW0;	
	m_ILCtrl.CloseSession();		// CloseSession of ImageSDKLib
}

// CNkILSampleDoc diagnostics

#ifdef _DEBUG
void CNkILSampleDoc::AssertValid() const
{
	CDocument::AssertValid();
}

void CNkILSampleDoc::Dump(CDumpContext& dc) const
{
	CDocument::Dump(dc);
}
#endif //_DEBUG

// CNkILSampleDoc commands

//====================================================================
// function name		：LoadImageFile
// function abstract	：load iamge file 
// parameter			：pFilePath		pointer of imagefile path
// return value			：none
//====================================================================
bool CNkILSampleDoc::LoadImageFile(const char *pFilePath)
{
	// open session for ImageSDKLib
	unsigned long ulError = kNkfl_Code_None;
	ulError = m_ILCtrl.OpenSession( (char*)pFilePath );
	if( kNkfl_Code_Err_NotSupported  == ulError )
	{
		// not supported format
		CString strError;
		strError.LoadString(IDS_ERROR_NOTSUPPORT);
		AfxMessageBox( strError, MB_OK | MB_ICONEXCLAMATION );		
		return false;
	}
	else if( kNkfl_Code_None != ulError )
	{		
		return false;
	}
	///////////////////////////////////////////////////////
	// get file format from tag
	///////////////////////////////////////////////////////

	// initialize structure
	NkIL_TagDataParam StrTagParam	= {0};
	StrTagParam.ulTagID				= kNkfl_Tag_NkFileFormat;
	StrTagParam.ulTagType			= kNkfl_TagType_SLong;
	// get tag data
	if( kNkfl_Code_None == m_ILCtrl.GetTagData( &StrTagParam ))
	{				
		m_ulFormat = StrTagParam.ulTagValue;
	}	

	///////////////////////////////////////////////////////
	// get image info
	///////////////////////////////////////////////////////

	// get image info
	NkIL_ImageInfo StrInfo = {0};
	if( kNkfl_Code_None != m_ILCtrl.GetImageInfo( &StrInfo ))
	{		
		return false;
	}

	// check file format
	unsigned long ulFile;
	m_ILCtrl.GetFileInfo( &ulFile );
	if(( kNkfl_Format_None != ulFile && kNkfl_Format_JPEG != ulFile && kNkfl_Format_TIFF != ulFile && kNkfl_Format_NEF != ulFile )
		|| kNkfl_Color_Gray == StrInfo.ulColor || kNkfl_Color_CMYK_Gray == StrInfo.ulColor || kNkfl_Color_CMYK == StrInfo.ulColor)
	{
		// not supported format
		CString strError;
		strError.LoadString(IDS_ERROR_NOTSUPPORT);
		AfxMessageBox( strError, MB_OK | MB_ICONEXCLAMATION );		
		return false;
	}
	
	// get original size for use 
	InitSet1DlgParam();

	// get image data
	if( !ReloadImage() )				
	{
		return false;
	}

	// display setting1&2dialog and infomationdialog
	// get view object
	POSITION			pos		= GetFirstViewPosition();
	CNkILSampleView*	view	= (CNkILSampleView*)GetNextView(pos);
	view->DisplayAllDlg();			// destroy settings dialog

	return true;
}
// LoadImageFile
///////////////////////////////////////////////////////////////////////

//====================================================================
// function name		：DisplayImage
// function abstract	：display image at CNkILSampleView
// parameter			：bChangeRatio		flag of change display ratio
// return value			：none
//====================================================================
void CNkILSampleDoc::DisplayImage( bool bChangeRatio /* = true*/)
{
	if( NULL == m_StrImage.pData )
	{
		return;
	}
	// get view object
	POSITION			pos	 = GetFirstViewPosition();
	CNkILSampleView*	view = (CNkILSampleView*)GetNextView(pos);
	
	if( bChangeRatio )
	{
		view->SetDispayRatio();	// set display ratio
	}
	view->PrepareImageForDisp();
	// don't need image data, so delete it
	delete [] m_StrImage.pData;
	m_StrImage.pData = NULL;
	view->Invalidate();			// update client
	view->UpdateWindow();		// display image	
}
// DisplayImage
///////////////////////////////////////////////////////////////////////

//====================================================================
// function name		：ReDisplayImage
// function abstract	：re-get and re-display image 
// parameter			：none
// return value			：true/false
//====================================================================
bool CNkILSampleDoc::ReDisplayImage()
{
	// reload image and display	
	if( !ReloadImage() )				
	{
		return false;
	}
	DisplayImage( false );	// display without change display ratio
	return true;
}
// ReDisplayImage
///////////////////////////////////////////////////////////////////////

//====================================================================
// function name		：ReloadImage
// function abstract	：get image data from ImageSDKLib
// parameter			：none
// return value			：none
//====================================================================
bool CNkILSampleDoc::ReloadImage()
{
	// if imagedata exist, delete this
	if( NULL != m_StrImage.pData )
	{
		delete [] m_StrImage.pData;
		m_StrImage.pData = NULL;
	}

	///////////////////////////////////////////////////////
	// set image param for get image
	///////////////////////////////////////////////////////
	NkIL_ImageInfo StrInfo = {0};
	if( NULL != m_ILCtrl.GetImageInfo( &StrInfo ))
	{
		return false;
	}
	// if NEF or 16bitTiff, for display as RGB, set bytedepth as 1
	if( 2 <= StrInfo.ulByteDepth )
	{
		NkIL_ImageInfo StrNefInfo	= StrInfo;
		StrNefInfo.ulByteDepth		= 1;
		// set size before rotation
		StrNefInfo.ulWidth			= m_SetSize.cx;
		StrNefInfo.ulHeight			= m_SetSize.cy;
		StrNefInfo.ulOrientation	= m_ulUserOrientation;
		if( kNkfl_Code_None != m_ILCtrl.SetImageInfo( &StrNefInfo ))
		{
			return false;
		}
	}
	m_StrImage.rect.left		= 0;
	m_StrImage.rect.top			= 0;
	m_StrImage.rect.right		= StrInfo.ulWidth;
	m_StrImage.rect.bottom		= StrInfo.ulHeight;
	m_StrImage.ulLength			= StrInfo.ulWidth * StrInfo.ulHeight * BYTEPIXEL;
	m_StrImage.pFunc			= NULL;
	m_StrImage.pProgressParam	= NULL;

	// prepare image buffer
	if( 0 == m_StrImage.ulLength )
	{
		return false;
	}
	m_StrImage.pData	= new char[m_StrImage.ulLength];
	if( NULL == m_StrImage.pData )
	{
		return false;
	}		
	// get image data
	if( kNkfl_Code_None != m_ILCtrl.GetImageData( &m_StrImage ))
	{
		return false;
	}	

	return true;
}
// ReloadImage
///////////////////////////////////////////////////////////////////////

//====================================================================
// function name		：GetImageInfo
// function abstract	：get ImageInfo dialog Info 
// parameter			：pulFormat		pointer of FileFormat
//                        pImageInfo	pointer of ImageInfo structure
//                        pOrgImageInfo pointer of ImageInfo structure for Original
// return value			：none
//====================================================================
bool CNkILSampleDoc::GetImageInfo(unsigned long *pulFormat, NkIL_ImageInfo *pImageInfo, NkIL_ImageInfo *pOrgImageInfo)
{
	// check parameter
	if( NULL == pulFormat && NULL == pImageInfo && NULL == pOrgImageInfo )
	{
		return false;
	}

	// get parameter
	if( NULL != pulFormat )
	{
		// image format
		if( kNkfl_Code_None != m_ILCtrl.GetFileInfo( pulFormat ))
		{
			return false;
		}
	}
	if( NULL != pImageInfo )
	{
		// image information
		if( kNkfl_Code_None != m_ILCtrl.GetImageInfo( pImageInfo ))
		{
			return false;
		}
	}
	if( NULL != pOrgImageInfo )
	{
		// original image infomation
		if( kNkfl_Code_None != m_ILCtrl.GetOriginalInfo( pOrgImageInfo ))
		{
			return false;
		}
	}
	return true;
}
// GetImageInfo
///////////////////////////////////////////////////////////////////////

//====================================================================
// function name		：GetThumbInfo
// function abstract	：get ThumbnailInfo dialog Info 
// parameter			：pThumbInfo	pointer of vector of NkIL_ImageInfo for thumbnail
// return value			：true/false
//====================================================================
bool CNkILSampleDoc::GetThumbInfo(VECTTHUMBINFO *pThumbInfo)
{
	// check parameter
	if( NULL == pThumbInfo )
	{
		return false;
	}	
	
	pThumbInfo->clear();						// initialize thumbnail info

	// get thumbnail count
	unsigned long ulThumbCnt = 0;
	m_ILCtrl.GetThumbnailCount( &ulThumbCnt );
		
	// get all thumbnail info
	for( int i = 0; i < (int)ulThumbCnt; i++ )
	{
		NkIL_ImageInfo StrThumbInfo = {0};
		StrThumbInfo.ulThumbID		= i + 1;	// set thumbnail ID
		// get thumbnail info
		if( kNkfl_Code_None != m_ILCtrl.GetThumbnailInfo( &StrThumbInfo ))
		{
			return false;
		}
		
		pThumbInfo->push_back( StrThumbInfo );	// add thumbnail info
	}

	return true;
}
// GetThumbInfo
///////////////////////////////////////////////////////////////////////

//====================================================================
// function name		：GetCameraInfo
// function abstract	：get ShootingInfo dialog Info 
// parameter			：pCameraInfo	pointer of vector of NkIL_TagStringParam
// return value			：error code
//====================================================================
unsigned long CNkILSampleDoc::GetCameraInfo( VECTCAMERAINFO* pCameraInfo )
{
	// check parameter
	if( NULL == pCameraInfo )
	{
		return kNkfl_Code_Err_InvalidParam;
	}

	pCameraInfo->clear();					// initialize camerainfo

	// get lines and columns
	unsigned long ulLine, ulColumn, ulError;
	ulError = m_ILCtrl.GetTagStringInfo( &ulLine, &ulColumn );
	
	if( kNkfl_Code_None != ulError )
	{
		return ulError;
	}
	
	
	// only first line's info is displayed 
	for( int i = 0; i < (int)ulLine; i++)
	{
		NkIL_TagStringParam StrStringParam = {0};
		
		// get first column's data size
		StrStringParam.ulLines		= i;
		StrStringParam.ulColumns	= 0;
		if( kNkfl_Code_None != m_ILCtrl.GetTagString(&StrStringParam))
		{
			continue;
		}
		// allocate data buffer
		if( 0 == StrStringParam.ulLength )
		{
			continue;						// string length is 0, do nothing 
		}
		StrStringParam.pData = new char[StrStringParam.ulLength];
		if( NULL == StrStringParam.pData )
		{
			return kNkfl_Code_Err_OutofMemory;
		}
		// get data
		if( kNkfl_Code_None != m_ILCtrl.GetTagString(&StrStringParam))
		{
			delete [] StrStringParam.pData;
			continue;
		}
		CString strTemp = StrStringParam.pData;
		pCameraInfo->push_back( strTemp );	// add to camerainfo

		delete [] StrStringParam.pData;
	}
	
	return kNkfl_Code_None;
}
// GetCameraInfo
///////////////////////////////////////////////////////////////////////

//====================================================================
// function name		：GetSettings1Info
// function abstract	：get Settings1 dialog Info 
// parameter			：pImageInfo		pointer of vector of NkIL_ImageInfo
//						  pulRawQuality		pointer of RawQuality
//						  pOutputProfile	pointer of ILSample_OutputProfile
// return value			：true/false
//====================================================================
bool CNkILSampleDoc::GetSettings1Info(NkIL_ImageInfo *pImageInfo, unsigned long *pulRawQuality, ILSample_OutputProfile *pOutputProfile)
{
	// check parameter
	if( NULL == pImageInfo || NULL == pulRawQuality || NULL == pOutputProfile )
	{
		return false;
	}
	// set parameter
	if( kNkfl_Code_None != m_ILCtrl.GetImageInfo( pImageInfo ))
	{
		return false;
	}
	// set user orientation
	pImageInfo->ulOrientation = m_ulUserOrientation;
	// get raw quality info	
	if( kNkfl_Code_None != m_ILCtrl.GetRawQuality( pulRawQuality ))
	{
		return false;
	}	
	// get output profile info
	unsigned char ucProfile[260] = {0};
	if( kNkfl_Code_None != m_ILCtrl.GetOutputProfile( &pOutputProfile->ulRenderingIntent, ucProfile ))
	{
		pOutputProfile->ulRenderingIntent = kNkfl_RenderingIntent_Perceptual;
	}	
	pOutputProfile->strProfilePath = ucProfile;

	return true;
}
// GetSettings1Info
///////////////////////////////////////////////////////////////////////

//====================================================================
// function name		：SetSettings1Info
// function abstract	：get Settings1 dialog Info 
// parameter			：ulImageInfo	enum value of group in Settings1 dialog
//						  pData			pointer of each group's data
// return value			：true/false
//====================================================================
bool CNkILSampleDoc::SetSettings1Info(unsigned long ulImageInfo, void *pData)
{
	// check parameter
	if( NULL == pData )
	{
		return false;
	}

	bool bSuccess = true;
	// set data devide by enum value of ImageInfo
	switch( ulImageInfo )
	{
	case kILSample_Group_ImageInfo:	
		{
			NkIL_ImageInfo* pInfo  = (NkIL_ImageInfo*)pData;
			// check which of the size or the orientation changed  
			if( m_ulUserOrientation != pInfo->ulOrientation )
			{
				// orientation is changed
				m_ulUserOrientation	= pInfo->ulOrientation;	// update user orientation 
				pInfo->ulWidth		 = m_SetSize.cx;
				pInfo->ulHeight		 = m_SetSize.cy;

				// set to ImageSDKLib Ctrl
				if( kNkfl_Code_None != m_ILCtrl.SetImageInfo( pInfo ))				
					bSuccess =  false;				
			}
			else
			{
				switch( m_ulUserOrientation )
				{
				case kNkfl_Orientation_CW90:
				case kNkfl_Orientation_CW270:
				case kNkfl_Orientation_FlippedCW90:
				case kNkfl_Orientation_FlippedCW270:
					// need to reverse width and height
					unsigned long ulTemp = pInfo->ulWidth;
					pInfo->ulWidth	= pInfo->ulHeight;
					pInfo->ulHeight = ulTemp;										
					break;
				}
				// set to ImageSDKLib Ctrl
				if( kNkfl_Code_None != m_ILCtrl.SetImageInfo( pInfo ))
					bSuccess =  false;								

				// change size, update size to ImageSDK have
				if( kNkfl_Code_None != m_ILCtrl.GetImageInfo( pInfo ))			
					bSuccess =  false;
							
				switch( m_ulUserOrientation )
				{
				case kNkfl_Orientation_CW90:
				case kNkfl_Orientation_CW270:
				case kNkfl_Orientation_FlippedCW90:
				case kNkfl_Orientation_FlippedCW270:
					// if CW90 or CW270, need to reverse width and height
					m_SetSize.SetSize( pInfo->ulHeight, pInfo->ulWidth );
					break;
				default:
					// if CW0 or CW180, set normaly
					m_SetSize.SetSize( pInfo->ulWidth, pInfo->ulHeight );
					break;
				}
			}			
		}		
		break;
	case kILSample_Group_RawQuality:
		// set to ImageSDKLib Ctrl
		if( kNkfl_Code_None != m_ILCtrl.SetRawQuality((unsigned long)pData ))
		{
			bSuccess = false;
		}
		break;
	case kILSample_Group_OutputProfile:
		{
			// cast parameter and get data
			ILSample_OutputProfile* pProfile = (ILSample_OutputProfile*)pData;
			// set to ImageSDKLib Ctrl
			if( kNkfl_Code_None != m_ILCtrl.SetOutputProfile( pProfile->ulRenderingIntent, (unsigned char*)pProfile->strProfilePath.GetString() ))
			{
				bSuccess = false;
			}			
		}
		break;
	default:
		bSuccess = false;	// not supported parameter
	}

	if( bSuccess )
	{
		bSuccess = ReDisplayImage();
	}

	return bSuccess;
}
// SetSettings1Info
///////////////////////////////////////////////////////////////////////

//====================================================================
// function name		：GetSettings2Info
// function abstract	：get Settings2 dialog Info 
// parameter			：ulRawDevelopment	enum value of group in Settings2 dialog
//						  pData				pointer of each group's data
// return value			：true/false
//====================================================================
bool CNkILSampleDoc::GetSettings2Info(unsigned long ulRawDevelopment, void *pData)
{
	// check parameter
	if( NULL == pData )
	{
		return false;
	}

	// get data devide by enum value of ImageInfo
	switch( ulRawDevelopment )
	{	
	case kILSample_Group_ParamSet:
		// parameter settings		
		if( kNkfl_Code_None != m_ILCtrl.GetParamSettings( (unsigned long*)pData ))
		{
			return false;
		}			
		break;
	case kILSample_Group_Common:
		{		
			/////////////////////////////////////////////////
			// get data from ImageSDKLib control
			/////////////////////////////////////////////////

			// cast parameter
			ILSample_CommonGroup* pCommonInfo = ( ILSample_CommonGroup* )pData;		
			// get and set data
			if( kNkfl_Code_None != m_ILCtrl.GetExpComp( &pCommonInfo->dbExpComp ))
			{
				return false;
			}				
			// get WB data				
			if( kNkfl_Code_None != m_ILCtrl.GetWBInfo( &pCommonInfo->StrWBInfo ))
			{
				return false;
			}				
			// get tint data				
			if( kNkfl_Code_None != m_ILCtrl.GetTint( &pCommonInfo->lTint ))
			{
				return false;
			}			
			// get nr data				
			if( kNkfl_Code_None != m_ILCtrl.GetNR( &pCommonInfo->ulNRType, &pCommonInfo->bIsNR ))
			{
				return false;
			}	
			// get adl data				
			if( kNkfl_Code_None != m_ILCtrl.GetADL( &pCommonInfo->ulADLight, &pCommonInfo->bIsADLight ))
			{
				return false;
			}
		}
		break;
	case kILSample_Group_ColorMode:
		{
			/////////////////////////////////////////////////
			// get data from ImageSDKLib control
			/////////////////////////////////////////////////

			// cast parameter
			ILSample_ColorModeGroup* pColorMode = ( ILSample_ColorModeGroup* )pData;
			// get colormode data				
			if( kNkfl_Code_None != m_ILCtrl.GetColorMode( &pColorMode->ulColorMode, &pColorMode->bIsColorMode ))
			{
				return false;
			}				
			// get sharpness data				
			if( kNkfl_Code_None != m_ILCtrl.GetSharpness( &pColorMode->ulSharpness ))
			{
				return false;
			}				
			// get tonecomp data				
			if( kNkfl_Code_None != m_ILCtrl.GetToneComp( &pColorMode->ulToneComp ))
			{
				return false;
			}				
			// get saturation data				
			if( kNkfl_Code_None != m_ILCtrl.GetSaturation( &pColorMode->ulSaturation ))
			{
				return false;
			}					
			// get hueadj data				
			if( kNkfl_Code_None != m_ILCtrl.GetHueAdj( &pColorMode->lHueAdj ))
			{
				return false;
			}					
			// get filtereffect data				
			if( kNkfl_Code_None != m_ILCtrl.GetFiltEffect( &pColorMode->ulFilterEffect ))
			{
				return false;
			}				
		}
		break;
	case kILSample_Group_PictureCtrl:
		{			
			// cast parameter
			NkIL_PicCtrlParam* pPictureCtrl = ( NkIL_PicCtrlParam*)pData;			
			// get filtereffect data				
			if( kNkfl_Code_None != m_ILCtrl.GetPicCtrl( pPictureCtrl ))
			{
				return false;
			}						
		}
		break;	
	default:
		return false;	// not supported parameter
	}

	return true;
}
// GetSettings2Info
///////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////
// GetWBTempInfo
// get each WB parameter's temparature range and default value
bool CNkILSampleDoc::GetWBTempInfo(ILSample_WBRange *pStrWBTemp)
{
	// check parameter
	if( NULL == pStrWBTemp )
	{
		return false;
	}

	// white balance parameter table for need color temparature range
	unsigned long ulWBParam[WB_NEED_RANGE_NUM] =
	{ 
		kNkfl_WB_Auto, kNkfl_WB_Incandescent, kNkfl_WB_Flourescent,	kNkfl_WB_DirectSunLight, 
		kNkfl_WB_Flash, kNkfl_WB_Cloudy, kNkfl_WB_Shade, kNkfl_WB_HCFlourescent
	};

	for( int i = 0; i < WB_NEED_RANGE_NUM; i++ )
	{
		// get WB param
		pStrWBTemp->ulWBParam[i] = ulWBParam[i];
		// get colortemparature range
		if( kNkfl_Code_None != m_ILCtrl.GetColorTempRange( ulWBParam[i], &pStrWBTemp->ulDefault[i], &pStrWBTemp->ulMinColorTemp[i], &pStrWBTemp->ulMaxColorTemp[i] ))
		{
			return false;
		}
	}

	return true;
}
// GetWBTempInfo
///////////////////////////////////////////////////////////////////////


//====================================================================
// function name		：SetSettings2Info
// function abstract	：set Settings2 dialog Info 
// parameter			：ulRawDevelopment	enum value of group in Settings2 dialog
//						  pData				pointer of each group's data
// return value			：true/false
//====================================================================
bool CNkILSampleDoc::SetSettings2Info(unsigned long ulRawDevelopment, void *pData)
{
	// check parameter
	if( NULL == pData )
	{
		return false;
	}
	// get data devide by enum value of ImageInfo
	switch( ulRawDevelopment )
	{	
	case kILSample_Group_ParamSet:
		{
			// set to parameter settings 
			if( kNkfl_Code_None != m_ILCtrl.SetParamSettings((unsigned long)pData ))
			{
				return false;
			}
			if( kNkfl_RawParameterSet_AsShot == (unsigned long)pData )
			{
				// initialize size and orientation
				InitSet1DlgParam();
			}
			break;
		}
	case kILSample_Group_Common:
		{
			// get data
			ILSample_CommonGroup* pCommonInfo = ( ILSample_CommonGroup* )pData;

			/////////////////////////////////////////////////
			// set data to structure and set to ImageSDKLib control
			/////////////////////////////////////////////////

			// expcomp
			if( kNkfl_Code_None != m_ILCtrl.SetExpComp( pCommonInfo->dbExpComp ))
			{
				return false;
			}
			// white balance
			if( kNkfl_Code_None != m_ILCtrl.SetWBInfo( pCommonInfo->StrWBInfo ))
			{
				return false;
			}
			// tint
			if( kNkfl_Code_None != m_ILCtrl.SetTint( pCommonInfo->lTint ))
			{
				return false;
			}
			// noise reduction
			if( pCommonInfo->bIsNR && kNkfl_Code_None != m_ILCtrl.SetNR( pCommonInfo->ulNRType ))
			{
				return false;
			}			
			// active d-lighting
			if( pCommonInfo->bIsADLight && kNkfl_Code_None != m_ILCtrl.SetADL( pCommonInfo->ulADLight ))
			{
				return false;
			}
			break;
		}		
	case kILSample_Group_ColorMode:
		{
			// get data
			ILSample_ColorModeGroup* pColorMode = ( ILSample_ColorModeGroup* )pData;

			/////////////////////////////////////////////////
			// set data to structure and set to ImageSDKLib control
			/////////////////////////////////////////////////

			// colormode
			if( pColorMode->bIsColorMode && kNkfl_Code_None != m_ILCtrl.SetColorMode( pColorMode->ulColorMode ))
			{
				return false;
			}			
			// sharpening
			if( kNkfl_Code_None != m_ILCtrl.SetSharpness( pColorMode->ulSharpness ))
			{
				return false;
			}			
			// tonecomp
			if( kNkfl_Code_None != m_ILCtrl.SetToneComp( pColorMode->ulToneComp ))
			{
				return false;
			}			
			// hue adjustment
			if( kNkfl_Code_None != m_ILCtrl.SetHueAdj( pColorMode->lHueAdj ))
			{
				return false;
			}			
			// saturation
			if( kNkfl_Code_None != m_ILCtrl.SetSaturation( pColorMode->ulSaturation ))
			{
				return false;
			}			
			// filtereffect
			if( kNkfl_Code_None != m_ILCtrl.SetFiltEffect( pColorMode->ulFilterEffect ))
			{
				return false;
			}
			break;
		}
	case kILSample_Group_PictureCtrl:
		{
			/////////////////////////////////////////////////
			// set data to structure and set to ImageSDKLib control
			/////////////////////////////////////////////////

			NkIL_PicCtrlParam* pPictureCtrl = (NkIL_PicCtrlParam*)pData;
			if( kNkfl_Code_None != m_ILCtrl.SetPicCtrl( *pPictureCtrl ))
			{
				return false;
			}
			break;
		}
	default:
		return false;		// not supported parameter
	}
	// reload and redisplay image
	if( !ReDisplayImage() )				
	{
		return false;
	}	
	return true;
}
// SetSettings2Info
///////////////////////////////////////////////////////////////////////

//====================================================================
// function name		：GetImage
// function abstract	：return pointer of image data
// parameter			：none
// return value			：pointer of image data
//====================================================================
unsigned char* CNkILSampleDoc::GetImage()
{
	return (unsigned char*)m_StrImage.pData;	
}
// GetImage
///////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////
// IsOpenedFile
// check file opend or not
bool CNkILSampleDoc::IsOpenedFile()
{	
	return m_ILCtrl.IsOpen();	// check existance of image
}
// IsOpenedFile
///////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////
// IsApplyPictCtrl
// check apply picturecontrol to Image
bool CNkILSampleDoc::IsApplyPictCtrl()
{
	return m_ILCtrl.IsApplyPictCtrl();
}
// IsApplyPictCtrl
///////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////
// InitSet1DlgParam
// check apply picturecontrol to Image
void CNkILSampleDoc::InitSet1DlgParam()
{
	// get original info
	NkIL_ImageInfo StrOrgInfo = {0};
	m_ILCtrl.GetOriginalInfo( &StrOrgInfo );
	
	// initialize size and user orientation for setting1 dialog
	m_SetSize.SetSize( StrOrgInfo.ulWidth, StrOrgInfo.ulHeight );	
	m_ulUserOrientation	 = kNkfl_Orientation_CW0;
}
// InitSet1DlgParam
///////////////////////////////////////////////////////////////////////