#include "SunClientPrecompiledHeader.h"
#include "Application.h"
#include "OptionSoundDialog.h"
#include "ResourceManager.h"
#include "InterfaceManager.h"
#include "Map.h"
#include "Sound.h"
#include "SoundBGM.h"
#include "globalfunc.h"

const int	c_iSoundMinVolume = 0;
const int	c_iSoundMaxVolume = 100;

#pragma warning ( push )
#pragma warning(disable : 4800)

#ifdef _NA_000000_20130114_RENEWER_UI
#else

WzID OptionSoundDialog::m_wzId[OPTION_SOUND_MAX] = 
{ 
	StrToWzID("B999"),	//	¹öÆ° - Á¾·á
	StrToWzID("TI06"),	//	ÃʱâÈ­ ¹öÆ°
	StrToWzID("TI07"),	//	OK 

	StrToWzID("H000"),	//	¹è°æÀ½¾Ç ½ºÅ©·Ñ
	StrToWzID("H001"),	//	¹è°æÈ¿°úÀ½ ½ºÅ©·Ñ
	StrToWzID("H002"),	//	È¿°úÀ½ ½ºÅ©·Ñ

	StrToWzID("H003"),	//	OPTION_SOUND_SYSTEM,				// ½Ã½ºÅÛ º¼·ý ½ºÅ©·Ñ
	StrToWzID("H004"),	//	OPTION_SOUND_SPEAKER,				// ½ºÇÇÄ¿ ½ºÅ©·Ñ
	StrToWzID("H005"),	// OPTION_SOUND_MIC,					// ¸¶ÀÌÅ© ½ºÅ©·Ñ

	StrToWzID("C005"),	//	½Ã½ºÅÛ À½¼º üũ¹Ú½º
	StrToWzID("C006"),	//	NPC À½¼º üũ¹Ú½º

	StrToWzID("T102"),  // À½¼ºÃ¤Æà ÅؽºÆ® 
	
};




OptionSoundDialog::OptionSoundDialog( InterfaceManager * pUIMan )
:uiBase( pUIMan )
{
	int		i;
	for( i = 0 ; i < OCB_MAX ; ++i )
	{
		m_pCheckBox[i] = NULL;
	}
	for( i = 0 ; i < OHS_MAX ; ++i )
	{
		m_pHScroll[i] = NULL;
	}
}

OptionSoundDialog::~OptionSoundDialog( void )
{
}

VOID OptionSoundDialog::Init( CDrawBase * pDrawBase )
{
	//UpdatePosition();

	TCHAR	szMessage[INTERFACE_STRING_LENGTH]	= {0,};
	TCHAR	szText[INTERFACE_STRING_LENGTH]		= {0,};

	DWORD	dwTextColor	= RGBA( 235, 192, 38, 255 );
	DWORD	dwWideTextColor	= RGBA( 245, 166, 46, 255 );
	DWORD	dwSelectColor = RGBA( 0, 0, 255,255 );
	DWORD	dwBGColor = RGBA( 32, 32, 32, 0 );
	DWORD	dwSetColorSelBarOnText = RGBA( 255, 255, 255, 255 );

	//	üũ ¹Ú½º ¾ò¾î¿À±â( È¿°ú ²ô°í Äѱâ )
	m_pCheckBox[OCB_SYSTEM_VOICE]= static_cast<CCtrlButtonCheckWZ *>(getControl(OPTION_SOUND_CHECKBOX_SYSTEM_VOICE));
	m_pCheckBox[OCB_NPC_VOICE]= static_cast<CCtrlButtonCheckWZ *>(getControl(OPTION_SOUND_CHECKBOX_NPC_VOICE));

	//TODO: À½¼ºÃ¤Æÿë ÄÁÆ®·ÑÀÌ UI¿¡¼­ Á¦°ÅµÇ¸é ÀÌ Äڵ嵵 Á¦°ÅÇØ¾ß ÇÔ
	CCtrlStaticWZ *pStaticCtrl = static_cast<CCtrlStaticWZ *>(getControl(OPTION_SOUND_STATIC_VOICE_CHAT_CATEGORY));
	if(pStaticCtrl)
		pStaticCtrl->ShowWindowWZ(WZ_HIDE);
	


	//	»ç¿îµå º¼·ý ½ºÅ©·Ñ ¹Ù ¾ò¾î¿À±â
	m_pHScroll[OHS_BGM] = static_cast<CCtrlHScrollWZ *>(getControl(OPTION_SOUND_BG_MUSIC));
    if (m_pHScroll[OHS_BGM])
    {
        if (m_pHScroll[OHS_BGM])
            m_pHScroll[OHS_BGM]->SetScrollRangeWZ( c_iSoundMinVolume, c_iSoundMaxVolume );
    }

	m_pHScroll[OHS_AMBIENT_EFFECT] = static_cast<CCtrlHScrollWZ *>(getControl(OPTION_SOUND_AMBIENT_EFFECT_SOUND));
    if (m_pHScroll[OHS_AMBIENT_EFFECT])
    {
        m_pHScroll[OHS_AMBIENT_EFFECT]->SetScrollRangeWZ( c_iSoundMinVolume, c_iSoundMaxVolume );
    }

	m_pHScroll[OHS_EFFECT] = static_cast<CCtrlHScrollWZ *>(getControl(OPTION_SOUND_EFFECT_SOUND));
    if (m_pHScroll[OHS_EFFECT])
    {
        m_pHScroll[OHS_EFFECT]->SetScrollRangeWZ( c_iSoundMinVolume, c_iSoundMaxVolume );
    }

	m_pHScroll[OHS_SYSTEM] = static_cast<CCtrlHScrollWZ *>(getControl(OPTION_SOUND_SYSTEM));
    if (m_pHScroll[OHS_SYSTEM])
    {
        m_pHScroll[OHS_SYSTEM]->SetScrollRangeWZ( c_iSoundMinVolume, c_iSoundMaxVolume );
    }

	m_pHScroll[OHS_SPEAKER] = static_cast<CCtrlHScrollWZ *>(getControl(OPTION_SOUND_SPEAKER));
    if (m_pHScroll[OHS_SPEAKER])
    {
        m_pHScroll[OHS_SPEAKER]->SetScrollRangeWZ( c_iSoundMinVolume, c_iSoundMaxVolume );
    }

	m_pHScroll[OHS_MIC] = static_cast<CCtrlHScrollWZ *>(getControl(OPTION_SOUND_MIC));

	if (m_pHScroll[OHS_MIC])
	{
		//TODO: À½¼ºÃ¤Æÿë ÄÁÆ®·ÑÀÌ UI¿¡¼­ Á¦°ÅµÇ¸é ÀÌ Äڵ嵵 Á¦°ÅÇØ¾ß ÇÔ
		m_pHScroll[OHS_MIC]->ShowWindowWZ(WZ_HIDE); //¸¶ÀÌÅ© º¼·ý ½ºÅ©·Ñ Á¦°Å 
	}


	//-------------------------------------------------------------------------
	//		¿É¼Ç µ¥ÀÌÅÍ ¼³Á¤
	//-------------------------------------------------------------------------

	m_OptionParam = GAMEOPTION->GetGameOption();
    m_OptionParam.SetOptionValue( nOptionType::SYSTEM_VOLUME, Sound::Instance()->GetMasterVolume() );
    m_OptionParam.SetOptionValue( nOptionType::SPEAKER_VOLUME, Sound::Instance()->GetWaveVolume() );

	m_InitOptionParam = m_OptionParam;

	//	ÄÁÆ®·Ñ¿¡ Àû¿ë
	ApplyControl();
}


VOID OptionSoundDialog::Release()
{
}


VOID OptionSoundDialog::MessageProc( SI_MESSAGE * pMessage )
{
	int		iIndex = -1;
	TCHAR	szMessage[INTERFACE_STRING_LENGTH] = {0,};
	TCHAR	szText[INTERFACE_STRING_LENGTH] = {0,};
	TCHAR	*pszTRUE = _T("TRUE");
	TCHAR	*pszFALSE = _T("FALSE");

	int		iScrollPos;
	float	fSoundVolume = 0.0f;
	float	fVolumeStep = 0.15f;

	switch( pMessage->eResultMsg ) 
	{
		//-----------------------------------------------------------------------------------------
		//		»ç¿îµå ½ºÅ©·Ñ ¹Ù ¸¶¿ì½º·Î ²ø¾î¶¯±â±â
		//-----------------------------------------------------------------------------------------
	case RT_MSG_SB_THUMBPOSITION:
		{
			switch( getCtrlIDToPos( pMessage->dwCtrlID ) )
			{
			case OPTION_SOUND_BG_MUSIC:
				{
					iScrollPos = m_pHScroll[OHS_BGM]->GetScrollPosWZ();
					if( iScrollPos <= 0 )
					{
						g_SoundBGM.SetVolume( 0.0f );
					}
					else
					{
						fSoundVolume = (float)iScrollPos / (float)c_iSoundMaxVolume;
						g_SoundBGM.SetVolume( fSoundVolume );
					}

					//	»ç¿îµå ÀúÀå
                    m_OptionParam.SetOptionValue( nOptionType::BGM_VOLUME, iScrollPos );
				}
				break;

			case OPTION_SOUND_AMBIENT_EFFECT_SOUND:
				{
					iScrollPos = m_pHScroll[OHS_AMBIENT_EFFECT]->GetScrollPosWZ();
					if( iScrollPos <= 0 )
					{
					}
					else
					{
						fSoundVolume = (float)iScrollPos / (float)c_iSoundMaxVolume;
					}

					//	»ç¿îµå ÀúÀå
                    m_OptionParam.SetOptionValue( nOptionType::AMBIENT_VOLUME, iScrollPos );

                    if (g_pMap)
					    g_pMap->SetAmbientVolume(fSoundVolume);
				}
				break;

			case OPTION_SOUND_EFFECT_SOUND:
				{
                    iScrollPos = m_pHScroll[OHS_EFFECT]->GetScrollPosWZ();
                    
					if( iScrollPos <= 0 )
					{
					}
					else
					{
						fSoundVolume = (float)iScrollPos / (float)c_iSoundMaxVolume;
					}

					//	»ç¿îµå ÀúÀå
                    m_OptionParam.SetOptionValue( nOptionType::EFFECT_VOLUME, iScrollPos );
				}
				break;

			case OPTION_SOUND_SYSTEM:				// ¸¶½ºÅÍ º¼·ý ½ºÅ©·Ñ
				{
					iScrollPos = m_pHScroll[OHS_SYSTEM]->GetScrollPosWZ();
					
					if( iScrollPos > 0 )
					{
						fSoundVolume = (float)iScrollPos / (float)c_iSoundMaxVolume;
					}

					Sound::Instance()->SetMasterVolume( fSoundVolume, FALSE );
					
					//	»ç¿îµå ÀúÀå
                    m_OptionParam.SetOptionValue( nOptionType::SYSTEM_VOLUME, iScrollPos );
				}
				break;

			case OPTION_SOUND_SPEAKER:				// ¿þÀÌºê ½ºÅ©·Ñ
				{
					iScrollPos = m_pHScroll[OHS_SPEAKER]->GetScrollPosWZ();
					
					if( iScrollPos > 0 )
					{
						fSoundVolume = (float)iScrollPos / (float)c_iSoundMaxVolume;
					}

					Sound::Instance()->SetWaveVolume( fSoundVolume, FALSE );
					
					//	»ç¿îµå ÀúÀå
                    m_OptionParam.SetOptionValue( nOptionType::SPEAKER_VOLUME, iScrollPos );
				}
				break;

			}
			
		}
		break;

		//-----------------------------------------------------------------------------------------
		//		»ç¿îµå ½ºÅ©·Ñ ¹Ù ¿ÞÂÊ ¹öÆ° Ŭ¸¯
		//-----------------------------------------------------------------------------------------
	case RT_MSG_SB_LINELEFT:
		{
			switch( getCtrlIDToPos( pMessage->dwCtrlID ) )
			{
			case OPTION_SOUND_BG_MUSIC:
				{
                    int OldBGMVolume = m_OptionParam.GetOptionValue(nOptionType::BGM_VOLUME);
                    int SoundVolume = max(0, OldBGMVolume - 15 );

                    g_SoundBGM.SetVolume( (float)SoundVolume*0.01f );

                    if (m_pHScroll[OHS_BGM])
					    m_pHScroll[OHS_BGM]->SetScrollPosWZ( SoundVolume );

					//	»ç¿îµå ÀúÀå
                    m_OptionParam.SetOptionValue(nOptionType::BGM_VOLUME, SoundVolume );
				}
				break;

			case OPTION_SOUND_AMBIENT_EFFECT_SOUND:
				{
                    int OldAmbientVolume = m_OptionParam.GetOptionValue(nOptionType::AMBIENT_VOLUME);
                    int SoundVolume = max(0, OldAmbientVolume - 15 );

                    if (m_pHScroll[OHS_AMBIENT_EFFECT])
    					m_pHScroll[OHS_AMBIENT_EFFECT]->SetScrollPosWZ( SoundVolume );

					//	»ç¿îµå ÀúÀå
                    m_OptionParam.SetOptionValue(nOptionType::AMBIENT_VOLUME, SoundVolume );

                    if (g_pMap)
					    g_pMap->SetAmbientVolume((float)SoundVolume*0.01f);
				}
				break;

			case OPTION_SOUND_EFFECT_SOUND:
				{
                    int OldVolume = m_OptionParam.GetOptionValue(nOptionType::EFFECT_VOLUME);
                    int Volume = max(0, OldVolume - 15 );

                    if (m_pHScroll[OHS_EFFECT])
					    m_pHScroll[OHS_EFFECT]->SetScrollPosWZ( Volume );

					//	»ç¿îµå ÀúÀå
                    m_OptionParam.SetOptionValue(nOptionType::EFFECT_VOLUME, Volume );
				}
				break;

			case OPTION_SOUND_SYSTEM:				// ¸¶½ºÅÍ º¼·ý ½ºÅ©·Ñ
				{
                    int OldVolume = m_OptionParam.GetOptionValue(nOptionType::SYSTEM_VOLUME);
                    int Volume = max(0, OldVolume - 15 );

                    if (m_pHScroll[OHS_SYSTEM])
                        m_pHScroll[OHS_SYSTEM]->SetScrollPosWZ( Volume );

                    //	»ç¿îµå ÀúÀå
                    m_OptionParam.SetOptionValue(nOptionType::SYSTEM_VOLUME, Volume );

					Sound::Instance()->SetMasterVolume( (float)Volume, FALSE );
				}
				break;

			case OPTION_SOUND_SPEAKER:				// ¿þÀÌºê ½ºÅ©·Ñ
				{
                    int OldVolume = m_OptionParam.GetOptionValue(nOptionType::SPEAKER_VOLUME);
                    int Volume = max(0, OldVolume - 15 );

                    if (m_pHScroll[OHS_SPEAKER])
                        m_pHScroll[OHS_SPEAKER]->SetScrollPosWZ( Volume );

                    //	»ç¿îµå ÀúÀå
                    m_OptionParam.SetOptionValue(nOptionType::SPEAKER_VOLUME, Volume );

					Sound::Instance()->SetWaveVolume( (float)Volume * 0.01f, FALSE );
				}
				break;

			}
		}
		break;


		//-----------------------------------------------------------------------------------------
		//		»ç¿îµå ½ºÅ©·Ñ ¹Ù ¿À¸¥ÂÊ ¹öÆ° Ŭ¸¯
		//-----------------------------------------------------------------------------------------
	case RT_MSG_SB_LINERIGHT:
		{
			switch( getCtrlIDToPos( pMessage->dwCtrlID ) )
			{
			case OPTION_SOUND_BG_MUSIC:
				{
                    int OldVolume = m_OptionParam.GetOptionValue(nOptionType::BGM_VOLUME);
                    int Volume = min(100, OldVolume + 15 );

                    if (m_pHScroll[OHS_BGM])
                        m_pHScroll[OHS_BGM]->SetScrollPosWZ( Volume );

                    m_OptionParam.SetOptionValue( nOptionType::BGM_VOLUME, Volume );

					g_SoundBGM.SetVolume( (float)Volume * 0.01f );

				}
				break;

			case OPTION_SOUND_AMBIENT_EFFECT_SOUND:
				{
                    int OldVolume = m_OptionParam.GetOptionValue(nOptionType::AMBIENT_VOLUME);
                    int Volume = min(100, OldVolume + 15 );

                    if (m_pHScroll[OHS_AMBIENT_EFFECT])
                        m_pHScroll[OHS_AMBIENT_EFFECT]->SetScrollPosWZ( Volume );

                    m_OptionParam.SetOptionValue( nOptionType::AMBIENT_VOLUME, Volume );

                    if (g_pMap)
					    g_pMap->SetAmbientVolume((float)Volume * 0.01f);
				}
				break;

			case OPTION_SOUND_EFFECT_SOUND:
				{
                    int OldVolume = m_OptionParam.GetOptionValue(nOptionType::EFFECT_VOLUME);
                    int Volume = min(100, OldVolume + 15 );

                    if (m_pHScroll[OHS_EFFECT])
                        m_pHScroll[OHS_EFFECT]->SetScrollPosWZ( Volume );

                    m_OptionParam.SetOptionValue( nOptionType::EFFECT_VOLUME, Volume );
				}
				break;

			case OPTION_SOUND_SYSTEM:				// ¸¶½ºÅÍ º¼·ý ½ºÅ©·Ñ
				{
                    int OldVolume = m_OptionParam.GetOptionValue(nOptionType::SYSTEM_VOLUME);
                    int Volume = min(100, OldVolume + 15 );

                    if (m_pHScroll[OHS_SYSTEM])
                        m_pHScroll[OHS_SYSTEM]->SetScrollPosWZ( Volume );

                    m_OptionParam.SetOptionValue( nOptionType::SYSTEM_VOLUME, Volume );

					Sound::Instance()->SetMasterVolume( (float)Volume * 0.01f, FALSE );
				}
				break;

			case OPTION_SOUND_SPEAKER:				// ¿þÀÌºê ½ºÅ©·Ñ
				{	
                    int OldVolume = m_OptionParam.GetOptionValue(nOptionType::SPEAKER_VOLUME);
                    int Volume = min(100, OldVolume + 15 );

                    if (m_pHScroll[OHS_SPEAKER])
                        m_pHScroll[OHS_SPEAKER]->SetScrollPosWZ( Volume );

                    m_OptionParam.SetOptionValue( nOptionType::SPEAKER_VOLUME, Volume );

                    Sound::Instance()->SetWaveVolume( (float)Volume * 0.01f, FALSE );
					
				}
				break;
			}
		}
		break;


		//-----------------------------------------------------------------------------------------
		//		¸¶¿ì½º ¿ÞÂÊ Å¬¸¯ À̺¥Æ®°¡ ÀϾÀ» ¶§, ¾îµð³Ä?
		//-----------------------------------------------------------------------------------------
	case RT_MSG_LBUTTONCLICK:
		{
			switch( getCtrlIDToPos( pMessage->dwCtrlID ) )
			{
				//---------------------------------------------------------------------------------
				//		üũ ¹Ú½ºµé~
				//---------------------------------------------------------------------------------
			case OPTION_SOUND_CHECKBOX_SYSTEM_VOICE:
				{
					if (m_pCheckBox[OCB_SYSTEM_VOICE])
                        m_OptionParam.SetOptionValue( nOptionType::USE_SYSTEM_VOICE, m_pCheckBox[OCB_SYSTEM_VOICE]->GetCheckState() );
				}
				break;

			case OPTION_SOUND_CHECKBOX_NPC_VOICE:
				{
					if (m_pCheckBox[OCB_NPC_VOICE])
                        m_OptionParam.SetOptionValue( nOptionType::USE_NPC_VOICE, m_pCheckBox[OCB_NPC_VOICE]->GetCheckState() );
				}
				break;


				//---------------------------------------------------------------------------------
				//		¾Æ·¡ ¼¼°³ ¹öÆ°°ú X Á¾·á ¹öÆ°
				//---------------------------------------------------------------------------------
			case OPTION_SOUND_BT_INIT:	//	ÃʱâÈ­ - óÀ½ â ¿­¾úÀ» ¶§·Î Àû¿ë
				{
					m_OptionParam = m_InitOptionParam;
					ApplyControl();
					SoundSetting();
				}
				break;

			case OPTION_SOUND_BT_OK:		//	OK ¹öÆ° - Àû¿ëÀÇ ÀǹÌ
				{
					ApplyScroll();
					ApplyControl();
					Apply();
					ShowDialog(FALSE);
				}
				break;

			case OPTION_SOUND_BT_EXIT:	//	Á¾·á ¹öÆ° - Ãë¼ÒÀÇ ÀǹÌ
				{
					m_OptionParam = m_InitOptionParam;
					ApplyControl();
					SoundSetting();
					ShowDialog(FALSE);
				}
				break;
			}

		}
		break;

	default:
		{
			SolarDialog::MessageProc( pMessage );
		}
		break;
	}

}

VOID OptionSoundDialog::NetworkProc( MSG_BASE * pMsg )
{
}


CControlWZ*  OptionSoundDialog::getControl( POSTYPE AtPos )
{
	assert( AtPos < OPTION_SOUND_MAX );

	return GetControlWZ( m_wzId[AtPos] );
}


POSTYPE OptionSoundDialog::getCtrlIDToPos( WzID wzId )
{
	for( POSTYPE i = 0 ; i < OPTION_SOUND_MAX ; ++i )
	{
		if( m_wzId[i] == wzId )
		{
			return i;
		}
	}

	return OPTION_SOUND_MAX;
}


VOID OptionSoundDialog::OnShowWindow( BOOL val )
{

	if( val == TRUE )
	{
		ApplyControl();

		keyMsg msg;
		ZeroMemory(&msg,sizeof(msg));
		msg.dwType=eDoType_dialog_Option_Sound;
		msg.wParam=InterfaceManager::DIALOG_OPTION_SOUND;
		msg.DoSomething=GlobalFunc::DoShowWindow;
		g_KeyQueueManager.PushBack(msg);

	}
	else
	{
		ApplyControl();
		g_KeyQueueManager.DeleteMsg(eDoType_dialog_Option_Sound);
	}

}

void OptionSoundDialog::ApplyControl( void )
{
	//-------------------------------------------------------------------------
	//		üũ ¹öÆ°µé °ª ¼³Á¤
	//-------------------------------------------------------------------------
    if (m_pCheckBox[OCB_SYSTEM_VOICE])
        m_pCheckBox[OCB_SYSTEM_VOICE]->SetCheckState( (bool)m_OptionParam.GetOptionValue(nOptionType::USE_SYSTEM_VOICE) );
    if (m_pCheckBox[OCB_NPC_VOICE])
        m_pCheckBox[OCB_NPC_VOICE]->SetCheckState( (bool)m_OptionParam.GetOptionValue(nOptionType::USE_NPC_VOICE) );


	//-------------------------------------------------------------------------
	//		»ç¿îµå º¼·ý Á¶Àý ¹Ù ÃʱâÈ­
	//-------------------------------------------------------------------------

	//	¹è°æ À½¾Ç º¼·ý Á¶Àý ¹Ù ÃʱâÈ­
    if (m_pHScroll[OHS_BGM])
	{
        m_pHScroll[OHS_BGM]->SetScrollPosWZ( m_OptionParam.GetOptionValue(nOptionType::BGM_VOLUME) );
	}

	//	¹è°æ È¿°úÀ½ º¼·ý Á¶Àý ¹Ù ÃʱâÈ­
    if (m_pHScroll[OHS_AMBIENT_EFFECT])
	{
        m_pHScroll[OHS_AMBIENT_EFFECT]->SetScrollPosWZ( m_OptionParam.GetOptionValue(nOptionType::AMBIENT_VOLUME) );
	}

	//	ÀÏ¹Ý È¿°úÀ½ º¼·ý Á¶Àý ¹Ù ÃʱâÈ­
    if (m_pHScroll[OHS_EFFECT])
	{
        m_pHScroll[OHS_EFFECT]->SetScrollPosWZ( m_OptionParam.GetOptionValue(nOptionType::EFFECT_VOLUME) );
	}

	// ¸¶½ºÅÍ
	if (m_pHScroll[OHS_SYSTEM])
	{
        m_pHScroll[OHS_SYSTEM]->SetScrollPosWZ( m_OptionParam.GetOptionValue(nOptionType::SYSTEM_VOLUME) );
	}

	// ¿þÀ̺ê
	if (m_pHScroll[OHS_SPEAKER])
	{
        m_pHScroll[OHS_SPEAKER]->SetScrollPosWZ( m_OptionParam.GetOptionValue(nOptionType::SPEAKER_VOLUME) );
	}

}

void OptionSoundDialog::ApplyScroll()
{
	//	¹è°æ À½¾Ç º¼·ý Á¶Àý ¹Ù ÃʱâÈ­
	if (m_pHScroll[OHS_BGM])
	{
        m_OptionParam.SetOptionValue( nOptionType::BGM_VOLUME, m_pHScroll[OHS_BGM]->GetScrollPosWZ() );
	}

	//	¹è°æ È¿°úÀ½ º¼·ý Á¶Àý ¹Ù ÃʱâÈ­
	if (m_pHScroll[OHS_AMBIENT_EFFECT])
	{
        m_OptionParam.SetOptionValue( nOptionType::AMBIENT_VOLUME, m_pHScroll[OHS_AMBIENT_EFFECT]->GetScrollPosWZ() );
	}

	//	ÀÏ¹Ý È¿°úÀ½ º¼·ý Á¶Àý ¹Ù ÃʱâÈ­
	if (m_pHScroll[OHS_EFFECT])
	{
        m_OptionParam.SetOptionValue( nOptionType::EFFECT_VOLUME, m_pHScroll[OHS_EFFECT]->GetScrollPosWZ() );
	}

	// ¸¶½ºÅÍ
	if (m_pHScroll[OHS_SYSTEM])
	{
        m_OptionParam.SetOptionValue( nOptionType::SYSTEM_VOLUME, m_pHScroll[OHS_SYSTEM]->GetScrollPosWZ() );
	}

	// ¿þÀ̺ê
	if (m_pHScroll[OHS_SPEAKER])
	{
        m_OptionParam.SetOptionValue( nOptionType::SPEAKER_VOLUME, m_pHScroll[OHS_SPEAKER]->GetScrollPosWZ() );
	}
}

BOOL OptionSoundDialog::Apply( BOOL bCheckApply ,BOOL bProgramInit)
{
	//---------------------------------------------------------------------------------------------
	//		ÀÌ ¾Æ·¡·Î °¢Á¾ ¼³Á¤ ±â´ÉÀ» ÀÛ¾÷ÇØ ÁֽÿÀ.
	//---------------------------------------------------------------------------------------------
	SoundSetting();

    // Copy
	OptionParam tempOption = GAMEOPTION->GetGameOption();

    tempOption.SetOptionValue( nOptionType::USE_NPC_VOICE,      m_OptionParam.GetOptionValue(nOptionType::USE_NPC_VOICE ) );    
    tempOption.SetOptionValue( nOptionType::USE_SYSTEM_VOICE,   m_OptionParam.GetOptionValue(nOptionType::USE_SYSTEM_VOICE ) ); 
                                                                                                          
    tempOption.SetOptionValue( nOptionType::BGM_VOLUME,         m_OptionParam.GetOptionValue(nOptionType::BGM_VOLUME ) );       
    tempOption.SetOptionValue( nOptionType::AMBIENT_VOLUME,     m_OptionParam.GetOptionValue(nOptionType::AMBIENT_VOLUME ) );   
    tempOption.SetOptionValue( nOptionType::EFFECT_VOLUME,      m_OptionParam.GetOptionValue(nOptionType::EFFECT_VOLUME ) );    
    tempOption.SetOptionValue( nOptionType::SYSTEM_VOLUME,      m_OptionParam.GetOptionValue(nOptionType::SYSTEM_VOLUME ) );    
    tempOption.SetOptionValue( nOptionType::SPEAKER_VOLUME,     m_OptionParam.GetOptionValue(nOptionType::SPEAKER_VOLUME ) );   
	
	m_InitOptionParam = tempOption;
	GAMEOPTION->SetGameOption( tempOption );

	if( bProgramInit == FALSE )
	{
		GAMEOPTION->Save();
	}

	return TRUE;
}

void OptionSoundDialog::SoundSetting()
{
	//	»ç¿îµå º¼·ý Á¶Àý
    Sound::Instance()->SetBGMVolume( m_OptionParam.GetOptionValueFloat( nOptionType::BGM_VOLUME ) );
    g_SoundBGM.SetVolume( m_OptionParam.GetOptionValueFloat( nOptionType::BGM_VOLUME) );

    Sound::Instance()->SetAmbientEffectVolume( m_OptionParam.GetOptionValueFloat( nOptionType::AMBIENT_VOLUME ) );
	if (g_pMap)
	{
        g_pMap->SetAmbientVolume(m_OptionParam.GetOptionValueFloat( nOptionType::AMBIENT_VOLUME) );
	}

    Sound::Instance()->SetEffectVolume( m_OptionParam.GetOptionValueFloat( nOptionType::EFFECT_VOLUME ) );
    Sound::Instance()->SetMasterVolume( m_OptionParam.GetOptionValueFloat( nOptionType::SYSTEM_VOLUME), TRUE );
    Sound::Instance()->SetWaveVolume( m_OptionParam.GetOptionValueFloat( nOptionType::SPEAKER_VOLUME), TRUE );

}
#endif
#pragma warning ( pop )