#include "StdAfx.h"
#include "resource.h"
#include "Application.h"

#include "commondefines.h"
#include "number.ini"

#include "DXVersion.h"
#include "AppWindow.h"
#include "AppTimer.h"

#include "RenderSystem.h"
#include "InputSystem.h"
#include "FilePackSystem.h"
#include "SoundSystem.h"

#include "OptionManager.h"
#include "ResourceManager.h"
#include "CameraManager.h"
#include "SceneManager.h"
#include "UIManager.h"
#include "StageManager.h"

#include "UICursor.h"

#ifdef _GMTOOL
	#include "GMTool.h"
#endif


#if (defined(_DEVSYS) || defined(_DEBUG))
#include "DevSystem.h"
#endif

#pragma data_seg("shared")
long mUsageCnt = 0;
#pragma data_seg()
#pragma comment(linker, " /section:shared,rws")

cApplication* cApplication::mpSingleton = 0;
cString cApplication::mLangaugeFolder = "";
cStringW cApplication::mLangaugeFolderW = L"";

/// directx version data size
const unsigned int BUFSIZE = 80;

cApplication::cApplication()
: mpFileSystem( 0 )
, mpOptionManager( 0 )
, mpRenderSystem( 0 )
, mpSoundSystem( 0 )
, mpInputSystem( 0 )
, mpResourceManager( 0 )
, mpCameraManager( 0 )
, mpSceneManager( 0 )
, mpInstance( 0 )
, mpStageManager( 0 )
, mpCursor(0)
#ifdef _GMTOOL
, mGMTool( 0 )
#endif
#if (defined(_DEVSYS) || defined(_DEBUG))
, mpDevSystem( 0 )
#endif
, mSaveScreenShot( false )
, mResetFlag( false )
, mAuthCode(-1)
{

	assert( mpSingleton == 0 && "bad singleton!" );
	mpSingleton = this;

	mIsActive = false;
	mIsMinimze = false;

	mpWindow = new cAppWindow;		
	
	mpTimer = NULL;
	/// 070110 PKH µ¿±âÈ­¿ë ŸÀ̸Ó
	mAccumTime = 0;
	mDeltaTime = 0;
}

cApplication::~cApplication()
{
#ifdef _GMTOOL
	SAFE_DELETE( mGMTool );
#endif
#if (defined(_DEVSYS) || defined(_DEBUG))
	SAFE_DELETE( mpDevSystem );
#endif

	SAFE_DELETE( mpCursor );
	if( mpStageManager )
	{
		mpStageManager->Exit();
		delete mpStageManager;
		mpStageManager = 0;
	}
	SAFE_DELETE( mpSceneManager );
	SAFE_DELETE( mpCameraManager );
	SAFE_DELETE( mpTimer );
	SAFE_DELETE( mpInputSystem );
	SAFE_DELETE( mpResourceManager );
	SAFE_DELETE( mpRenderSystem );
	SAFE_DELETE( mpOptionManager );
	SAFE_DELETE( mpSoundSystem );
	SAFE_DELETE( mpFileSystem );

	/// À©µµ¿ìÀÇ Á¦°Å´Â ÀÓÀÇ·Î ¸ÕÀú ÇÑ´Ù.
	SAFE_DELETE( mpWindow );

	mpSingleton = 0;
}

HWND cApplication::GetHWND()
{ 
	return (mpWindow)? mpWindow->GetHWND():NULL; 
}

HINSTANCE cApplication::GetWindowInstance()
{
	return mpInstance;
}

cApplication* cApplication::Create()
{
	return new cApplication;
}

bool cApplication::Init( NiInstanceRef hi, cString ip, long authcode )
{
	mpInstance = hi;
	mIP = ip;
	mAuthCode = authcode;

	/// ÆÄÀÏ ÆÑ ½Ã½ºÅÛÀ» »ý¼º
	mpFileSystem = new cFilePackSystem;
	if( !mpFileSystem || !mpFileSystem->Init() )
	{
		NiMessageBox( "Failed to Init FileSystem", "Error" );
		return false;
	}

	/// »ç¿îµå ½Ã½ºÅÛ »ý¼º ¹× ÃʱâÈ­
	mpSoundSystem = new cSoundSystem;
	if( mpSoundSystem == 0 )
	{
		assert( 0 && "failed to init sound system" );
		NiMessageBox( "Failed to Init SoundSystem", "Error" );
		return false;
	}
	else
	{
		mpSoundSystem->Init();
	}

	/// À©µµ¿ì¸¦ »ý¼º
	if( CreateMainWindow() == false )
	{
		NiMessageBox( "Failed to create window.", "Error" );
		return false;
	}

	mpSoundSystem->SetHWND( mpWindow->GetHWND() );

	/// option file load
	mpOptionManager = new cOptionManager;
	if( !mpOptionManager || !mpOptionManager->Init() )
	{
		NiMessageBox( "Failed option file load/save.", "Error" );
		return false;
	}

	/// ·»´õ¸µ ½Ã½ºÅÛÀ» »ý¼º ¹× ÃʱâÈ­
	mpRenderSystem = new cRenderSystem( mpWindow );
	if( !mpRenderSystem || !mpRenderSystem->Init() )
	{
		assert( 0 && "failed to init render system" );
		NiMessageBox( "Failed to Init RenderSystem", "Error" );
		return false;
	}

	/// ÀÚ¿ø °ü¸®ÀÚ¸¦ »ý¼º ¹× ÃʱâÈ­
	mpResourceManager = new cResourceManager;
	if( !mpResourceManager || !mpResourceManager->Init() )
	{
		assert( 0 && "failed to init resource manager" );
		NiMessageBox( "Failed to Init Resource manager", "Error" );
		return false;
	}

	/// Ä¿¼­
	mpCursor = new cUICursor;
	if( !mpCursor || !mpCursor->Init() )
	{
		assert( 0 && "failed to Init mouse cursor" );
		return false;
	}

	/// ÀÔ·Â ½Ã½ºÅÛÀ» »ý¼º ¹× ÃʱâÈ­
	mpInputSystem = new cInputSystem;
	if( !mpInputSystem || !mpInputSystem->Init( mpInstance, mpWindow->GetHWND() ) )
	{
		assert( 0 && "failed to init input system" );
		NiMessageBox( "Failed to Init InputSystem", "Error" );
		return false;
	}

	/// ŸÀ̸Ӹ¦ »ý¼º ¹× ÃʱâÈ­
	mpTimer = new cAppTimer;
	if( !mpTimer )
	{
		return false;
	}
	mpTimer->Reset();

	/// Ä«¸Þ¶ó °ü¸®ÀÚ¸¦ »ý¼º ¹× ÃʱâÈ­
	mpCameraManager = new cCameraManager;
	if( !mpCameraManager || !mpCameraManager->Init() )
	{
		assert( 0 && "failed to init camera manager" );
		NiMessageBox( "Failed to Init Camera manager", "Error" );
		return false;
	}

	/// Àå¸é °ü¸®ÀÚ¸¦ »ý¼º
	mpSceneManager = new cSceneManager;
	if( !mpSceneManager || !mpSceneManager->Init() )
	{
		assert( 0 && "failed to init scene manager");
		NiMessageBox( "Failed to Init Scene manager", "Error" );
		return false;
	}

	/// stage manager »ý¼º ¹× ÃʱâÈ­
	mpStageManager = new cStageManager;
	if( !mpStageManager || !mpStageManager->Init( mpWindow->GetHWND(), mpRenderSystem->GetScreenWidth(), mpRenderSystem->GetScreenHeight() ) )
	{
		assert( 0 && "failed to init stage manager");
		NiMessageBox( "Failed to Init Stage manager", "Error" );
		return false;
	}

#if (defined(_DEVSYS) || defined(_DEBUG))
	mpDevSystem = new cDevSystem();
	if( !mpDevSystem || !mpDevSystem->Init() )
	{
		return false;
	}
#endif

	/// System Timer Start..
	mpTimer->Start();

	mpWindow->AdjustWindowForChange( mpRenderSystem->IsFullScreenMode() );
	mpWindow->AdjustWindowRect( mpRenderSystem->GetScreenWidth(), mpRenderSystem->GetScreenHeight(), true );

	UpdateScreenSize( mpRenderSystem->GetScreenWidth(), mpRenderSystem->GetScreenHeight(), mpRenderSystem->GetScreenBpp(), !mpRenderSystem->IsFullScreenMode() );

	//
	::ShowWindow( THEAPP->GetHWND(), SW_SHOW );

	DWORD topID = GetWindowThreadProcessId( GetForegroundWindow(), NULL );
	DWORD curID = GetCurrentThreadId();

	if( topID != curID )
	{
		if( AttachThreadInput( topID, curID, TRUE ) )
		{
			BringWindowToTop( THEAPP->GetHWND() );
			AttachThreadInput( topID, curID, FALSE );
		}
	}
	else
	{
		BringWindowToTop( THEAPP->GetHWND() );
	}


	return true;
}

void cApplication::Run()
{
	MSG  msg;
	ZeroMemory( &msg, sizeof(msg) );

	while( msg.message != WM_QUIT )
	{
		if( ::PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) )
		{
			/// alt + f4 Å° ±â´ÉÀ» ¸·´Â´Ù.
 			if( msg.message == WM_SYSCOMMAND && msg.wParam == SC_CLOSE )
 				continue;

			::TranslateMessage( &msg );
			::DispatchMessage( &msg );
		}
		else
		{
			if ( NETWORK != NULL )
				NETWORK->Process( (WPARAM)ICT_RECV, (LPARAM)NULL );
			MainLoop();
		}
	}
}

/// ¸ñÀû: °¢Á¾ ½Ã½ºÅÛ ¹× °ü¸®ÀÚµéÀ» Á¦°Å
/// ÁÖÀÇ: »ý¼ºÀÇ ¿ª¼øÀ¸·Î Á¦°ÅÇÏ´Â ±ÔÄ¢À» ÁöÄÑÁÖ¼¼¿ä.
void cApplication::Exit()
{
	if(mpStageManager)
	{
		mpStageManager->Exit();
		delete mpStageManager;
		mpStageManager = 0;
	}

	if( mpSceneManager )
		mpSceneManager->Exit();


	if( mpResourceManager )
		mpResourceManager->Exit();


#if (defined(_DEVSYS) || defined(_DEBUG))
	if( mpDevSystem )
		mpDevSystem->Exit();
#endif

	if( mpInputSystem )
		mpInputSystem->Exit();

	if( mpRenderSystem )
		mpRenderSystem->Exit();

#ifdef _GMTOOL
	if( mGMTool )
		mGMTool->Exit();
#endif

	/// ŸÀ̸Ӹ¦ Á¤Áö
	if( mpTimer )
		mpTimer->Stop();
}

/// ¸ñÀû: ¸ðµå Àüȯ½Ã ±×·¡ÇÈ ¸Þ¸ð¸®ÀÇ ÃʱâÈ­
/// ÁÖÀÇ: °ÔÀӺ긮¿À ³»ºÎ ·çƾ¿¡¼­ Áö¿øÇÏ´Â ºÎºÐÀÌÁö¸¸,
/// ¹®Á¦ ¹ß»ý½Ã ·çƾ¼öÁ¤¾øÀÌ Á¦¾îÇϱâ À§ÇÑ ÇÔ¼ö
void cApplication::Invalidate()
{
	if( mpRenderSystem )
		mpRenderSystem->Invalidate();

#if (defined(_DEVSYS) || defined(_DEBUG))
	if(mpDevSystem)
		mpDevSystem->Invalidate();
#endif
}

/// ¸ñÀû: ¸ðµå Àüȯ½Ã ±×·¡ÇÈ ¸Þ¸ð¸®ÀÇ Àç»ý»ê
/// ÁÖÀÇ: °ÔÀӺ긮¿À ³»ºÎ ·çƾ¿¡¼­ Áö¿øÇÏ´Â ºÎºÐÀÌÁö¸¸,
/// ¹®Á¦ ¹ß»ý½Ã ·çƾ¼öÁ¤¾øÀÌ Á¦¾îÇϱâ À§ÇÑ ÇÔ¼ö
void cApplication::Restore()
{
#if (defined(_DEVSYS) || defined(_DEBUG))
	if(mpDevSystem)
		mpDevSystem->Restore();
#endif

	if( mpRenderSystem )
		mpRenderSystem->Restore();
}

void cApplication::UpdateScreenSize( unsigned int width, unsigned int height, unsigned char bpp, bool windowed )
{
	mpRenderSystem->Reset( width, height, bpp, windowed );
}

#include "XPerformanceGuard.h"

void cApplication::MainLoop()
{

	/// À©µµ¿ì°¡ ºñÈ°¼ºÈ­ µÇ¾úÀ»¶§ ´Ù¸¥ Application¿¡ CPU ŸÀÓÀ» ÇÒ´ç
	if( mIsActive == false )
		NiSleep( 1 );

	/// °æ°ú ½Ã°£ ¹× ´©Àû ½Ã°£À» °è»ê
	mDeltaTime = mpTimer->GetDeltaTime();
	mAccumTime += mDeltaTime;

	XPG_SET( "Performance Test", 200 );

	/// ÇÁ·Î¼¼½Ì
	mpInputSystem->Process( mDeltaTime );
	XPG_DO( "mpInputSystem" );

	mpResourceManager->Process();
	XPG_DO( "mpResourceManager" );

	mpStageManager->Process( mDeltaTime, mAccumTime );
	XPG_DO( "mpStageManager(Process)" );

	mpCameraManager->Process( mDeltaTime, mAccumTime );
	XPG_DO( "mpCameraManager" );

	mpSceneManager->Process( mDeltaTime, mAccumTime );
	XPG_DO( "mpSceneManager" );

	mpSoundSystem->Process( mDeltaTime, mAccumTime );
	XPG_DO( "mpSoundSystem" );

	mpStageManager->ProcessWorld( mDeltaTime, mAccumTime );
	XPG_DO( "mpStageManager(ProcessWorld)" );

#if (defined(_DEVSYS) || defined(_DEBUG))
	mpDevSystem->Process( mAccumTime );
	XPG_DO( "mpDevSystem" );
#endif

	/// ·»´õ¸µ
	mpRenderSystem->Render();
	XPG_DO( "mpRenderSystem" );

	/// ½ºÅ©¸°¼¦
	if( mSaveScreenShot )
	{
		mSaveScreenShot = false;
		mpRenderSystem->SaveScreenShot();
//		SaveScreenShot();
	}

}

void cApplication::Process()
{
	
}

void cApplication::Render()
{

}

bool cApplication::CreateMainWindow()
{
	/// À©µµ¿ì¸¦ µî·Ï
	WNDCLASS wndclass;
	wndclass.style         = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
	wndclass.lpfnWndProc   = cApplication::WinProc;
	wndclass.cbClsExtra    = 0;
	wndclass.cbWndExtra    = 0;
	wndclass.hInstance     = mpInstance;
	wndclass.hIcon         = ::LoadIcon(mpInstance, MAKEINTRESOURCE(IDR_MAINFRAME));
	wndclass.hCursor       = ::LoadCursor(mpInstance, IDC_ARROW);
	wndclass.hbrBackground = (HBRUSH)::GetStockObject(NULL_BRUSH);
	wndclass.lpszClassName = cAppWindow::GetWindowClassName();
	wndclass.lpszMenuName  = 0;

	if( ::RegisterClass(&wndclass) == 0 )
	{
		NiMessageBox( "Can't Create Window!", "Error!!" );
		return false;
	}

	NiWindowRef hWnd = mpWindow->Create( mpInstance, 0, 0 );

	mVersion.Format( _T("v%d.%.2d.%d"), LOBYTE(VERSION_HEADER), HIBYTE(VERSION_HEADER), BUILD_NUM );

	cStringT str;
	str.Format( _T("IRIS ONLINE %s"), mVersion.Cstr() );
	::SetWindowText( hWnd, str.Cstr() );

	return true;
}

bool cApplication::CheckEnoughMemory()
{
	return true;
}

bool cApplication::CheckEnoughHardDisk()
{
	return true;
}

bool cApplication::CheckDirectXVersion()
{
	/// ½ÇÁ¦ GetDXVersion() ÇÔ¼öÀÇ ¼Óµµ°¡ ´À¸°ºÎºÐ ¶§¹®¿¡, ·¹Áö½ºÆ®¸® Á¤º¸¸¦ ¹Ï¾îº»´Ù.
	/// À̺κÐÀº óÀ½ ½ÇÇà½Ã Çѹø °Ë»ç¸¦ ÇÏ°í, ±× °ªÀ» ÆÄÀÏ¿¡ ÀúÀå½ÃÅ°°í,
	/// ´ÙÀ½ ½ÇÇà½Ã´Â ·¹Áö½ºÆ®¸®¸¦ ¸ÕÀú °Ë»çÇÏ´Â ¹æ½ÄÀ¸·Î º¯°æÇÑ´Ù.
	HKEY hkey;
	char producttype[BUFSIZE];
	unsigned long buflen = BUFSIZE;
	long ret;

	/// ·¹Áö½ºÆ®¸®¿¡ ÀÖ´Â Á¤º¸¸¦ ½Å·ÚÇÑ´Ù.
	ret = ::RegOpenKeyEx( HKEY_LOCAL_MACHINE, _T("SOFTWARE\\Microsoft\\DirectX"), 0, KEY_QUERY_VALUE, &hkey );
	if( ret == ERROR_SUCCESS )
	{
		ret = ::RegQueryValueEx( hkey, _T("Version"), NULL, NULL, (LPBYTE) producttype, &buflen);
		if( (ret == ERROR_SUCCESS) && (buflen <= BUFSIZE) )
		{
			if( producttype[2] == '0' && producttype[3] < '9' )
			{
				/// Version Check Fail!
				NiMessageBox( "ÃÖ½ÅÀÇ DirectX ¹öÁ¯À» ¼³Ä¡Çϼ¼¿ä.\n\n¹®Á¦°¡ °è¼ÓµÉ °æ¿ì À缳ġ ÇϽñ⠹ٶø´Ï´Ù.", "Error Info" );
				::RegCloseKey( hkey );
				return false;
			}
			else
			{
				/// Version Check Succeed!
				::RegCloseKey( hkey );
				return true;
			}
		}

		::RegCloseKey( hkey );
	}

	/// DxDialog¿Í File¹öÁ¯À» üũÇÑ´Ù.
	HRESULT hr = E_FAIL;
	unsigned long dxver = 0;
	TCHAR dxvertext[10];

	CDXVersion kVer;
	hr = kVer.GetDXVersion( &dxver, dxvertext, 10 );

	if( SUCCEEDED(hr) )
	{
		/// 9.0~ 9.0c±îÁö Åë°ú.
		if( HIWORD(dxver) < 9 )
		{
			NiMessageBox( "ÃÖ½ÅÀÇ DirectX ¹öÁ¯À» ¼³Ä¡Çϼ¼¿ä.", "Error Info" );
			return false;
		}
	}
	else
	{
		/// Dx ¹öÁ¯¿¡ ´ëÇÑ Ã¼Å© ½ÇÆÐ.
		NiMessageBox( "DirectX¼³Ä¡¿¡ ¹®Á¦°¡ ÀÖ½À´Ï´Ù.\n\n¹®Á¦°¡ °è¼ÓµÉ °æ¿ì À缳ġ ÇϽñ⠹ٶø´Ï´Ù.", "Error Check" );
		return false;
	}

	return true;
}

/* ------------------------------------------------------------------
* ÇÔ¼öÀ̸§ :	CheckExecutionApplication()
* ¸ñ    Àû :	¹ÂÅؽº¸¦ ÅëÇؼ­ ApplicationÀÇ Áߺ¹ ½ÇÇàÀ» Á¦ÇÑÇÑ´Ù.
* ÁÖÀÇ»çÇ× :	
* ------------------------------------------------------------------ */
bool cApplication::CheckExecutionApplication()
{
	cAppWindow::mMutexHandle = ::CreateMutex( NULL, TRUE, cAppWindow::GetWindowClassName() );
	unsigned long err = ::GetLastError();
	if( err != ERROR_SUCCESS )
	{
		NiMessageBox( "Application already running...", "Error Info" );
		return false;
	}

	mUsageCnt++;
	if( mUsageCnt > 1 )
	{
		NiMessageBox( "Application already running...", "Error Info" );
		return false;
	}

	if( ::FindWindow( cAppWindow::mWindowClassName, NULL ) )
	{
		NiMessageBox( "Application already running...", "Error Info" );
		return false;
	}

	return true;
}

void cApplication::SetActive( bool active )
{
	if( mIsMinimze == true )
		mIsActive = false;
	else
		mIsActive = active;

	if( SOUNDSYS )
		SOUNDSYS->ActiveSound( mIsActive );

	if( mpWindow )
	{
		if( mIsActive )
			mpWindow->ChangeWindowOrder( true );
		else
			mpWindow->ChangeWindowOrder( false );
	}
}

/* ------------------------------------------------------------------
* ÇÔ¼öÀ̸§ :	WinProc()
* ¸ñ    Àû :	»ý¼ºµÈ System¹× ÇÔ¼ö¸¦ ÀÏ°ý Á¦°ÅÇÑ´Ù.
* ÁÖÀÇ»çÇ× :	»ý¼ºÀÇ ¿ª¼øÀ¸·Î Á¦°ÅÇÏ´Â ±ÔÄ¢À» ÁöÄÑÁÖ¼¼¿ä.
* ------------------------------------------------------------------ */
LRESULT CALLBACK cApplication::WinProc( HWND wnd, UINT msg, WPARAM wparam, LPARAM lparam )
{
	/// window message parsing !!
	if( INPUTSYS && INPUTSYS->WindowMessageParser( wnd, msg, wparam, lparam ) )
	{
		/// Æ÷Ä¿½º°´Ã¼¿¡¼­ »ç¿ëÇÏ´Â °æ¿ì
		/// DX_INPUT Å°º¸µå Á¤º¸ ºñ¿î´Ù..
		INPUTSYS->KeyInfoClear();
		return 0;
	}

	switch( msg ) 
	{
	case WM_CREATE:
		{
			::SetTimer( wnd, 0, 60000, NULL );

	/*		HIMC hImc = ImmGetContext( wnd );
			DWORD dwConversion, dwSentence;
			ImmGetConversionStatus( hImc, &dwConversion, &dwSentence );
			dwSentence |= IME_SMODE_SINGLECONVERT;
			ImmSetConversionStatus( hImc, dwConversion, dwSentence );
			ImmReleaseContext( wnd, hImc );
			*/
		}
		break;
	case WM_CHAR:
	case WM_IME_CHAR:
		return 0;
	case WM_IME_STARTCOMPOSITION:
		{
			if( UIMAN && !UIMAN->GetFocusedNode() )
			{
				HIMC hImc = ImmGetContext( wnd );
				ImmNotifyIME( hImc, NI_COMPOSITIONSTR, CPS_CANCEL, 0 );
				ImmReleaseContext( wnd, hImc );
			}
		}
		return 0;
	case WM_TIMER:
		{
			///
			NETWORK->SendHeartbeat();
		}
		break;
	case WM_SOCKEVENTMSG2:
		NETWORK->Process( wparam, lparam );
		break;
	case WM_ACTIVATEAPP:
		{
			if( THEAPP )
			{
				if( wparam == TRUE )
				{
					THEAPP->SetActive( true );
				}
				else 
				{
					THEAPP->SetActive( false );
#if !(defined(_DEVSYS) || defined(_DEBUG))
					if( GetForegroundWindow() != wnd )
						::SetWindowPos( wnd, GetForegroundWindow(), 0,0,0,0,SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE );
#endif
				}
			}
		}
		break;
	case WM_ACTIVATE:
		{
			if( THEAPP )
			{
				if( wparam == WA_INACTIVE )
				{
					THEAPP->SetActive( false );

#if !(defined(_DEVSYS) || defined(_DEBUG))
					if( GetForegroundWindow() != wnd )
						::SetWindowPos( wnd, GetForegroundWindow(), 0,0,0,0,SWP_NOSIZE|SWP_NOMOVE|SWP_NOACTIVATE );
#endif
				}
				else 
				{
					THEAPP->SetActive( true );
				}
			}
		}
		break;
	case WM_SETCURSOR:
		{ 
			if( CURSOR != NULL )
			{
				CURSOR->Process(0);
			}
		}
		break;
	//case WM_IME_SETCONTEXT:
	//	{
	////		// ¹Ýµå½Ã DefWindowProc·Î º¸³»¾ßÇÑ´Ù ( Èĺ¸À©µµ¿ì Ãâ·ÂÀ» À§ÇØ )
	////		/*if( wparam == TRUE )
	////		{
	//			lparam &= ~( ISC_SHOWUICOMPOSITIONWINDOW );
	////		}

	//		::DefWindowProc( wnd, WM_IME_SETCONTEXT, wparam, lparam);

	//		//::DefWindowProc( wnd, WM_IME_SETCONTEXT, true, ISC_SHOWUICANDIDATEWINDOW );
	//		return 0;
	//	}
	//	break;
	case WM_SYSCOMMAND:
		switch( wparam )
		{
		case SC_MOVE:
		case SC_SIZE:
		case SC_MAXIMIZE:
		case SC_MONITORPOWER:
			{
				if( RENDERSYS && RENDERSYS->IsFullScreenMode() )
				{
					return 1;
				}
			}
			return 0;
		case SC_KEYMENU:
			{
				return 1;
			}
		case SC_MINIMIZE:
			{
				THEAPP->SetMinimize( true );
			}
			break;
		case SC_RESTORE:
			{
				THEAPP->SetMinimize( false );
			}
			break;
		case SC_PREVWINDOW: /// alt + f6 ±â´ÉÀ» ¸·´Â´Ù.
			return 0;
		}
		break;
		/// ÈÞ´ë¿ë PC¿¡¼­ °ÔÀÓÀ» ÇÏ´Â °æ¿ì¿¡ ´ëÇÑ Ã³¸®
	case WM_POWERBROADCAST:	
		{
			switch( wparam )
			{
#ifndef	PBT_APMQUERYSUSPEND
#define	PBT_APMQUERYSUSPEND 0x0000
#endif
	case PBT_APMQUERYSUSPEND:
		return true;
#ifndef	PBT_APMRESUMESUSPEND
#define PBT_APMRESUMESUSPEND 0x0007
#endif
	case PBT_APMRESUMESUSPEND:
		return true;
			}
		}
		break;
	case WM_MOVE:
		{
#ifdef _GMTOOL
			if( GMTOOL )
				GMTOOL->OnMove();
#endif
		}
		break;

	case WM_CLOSE:
	case WM_DESTROY:
		{
			::PostQuitMessage( 0 );
		}
		return 0;
	case WM_DISPLAYCHANGE:
		{
			/// ½ÇÇàÁß ÇØ»óµµ º¯°æ üũ
			unsigned int width = LOWORD(lparam);
			unsigned int height = HIWORD(lparam);
			unsigned int bpp = wparam;

			if( RENDERSYS )
				RENDERSYS->SetMonitorDisplay( width, height, bpp );
		}
		break;
	}

	return ::DefWindowProc( wnd, msg, wparam, lparam );
}

/*
bool cApplication::SaveScreenShot()
{
	NiDX9Renderer* renderer = NiDX9Renderer::GetRenderer();
	if( renderer == 0 )
		return false;

	/// ¹é¹öÆÛ¸¦ ÆÄÀÏ·Î ÀúÀå
	LPDIRECT3DDEVICE9 device = renderer->GetD3DDevice();
	if( device == 0 )
		return false;

	IDirect3DSurface9* buffer = 0;
	if( device->GetBackBuffer( 0, 0, D3DBACKBUFFER_TYPE_MONO, &buffer ) != D3D_OK )
		return false;

	if( buffer == 0 )
		return false;

	///
	if( ::FileExist( "ScreenShot" ) == false )
	{
		::CreateDirectory( L"ScreenShot", 0 );
	}

	///
	SYSTEMTIME tm;
	::GetLocalTime( &tm );

	cStringT pathName;
	pathName.Format( L"ScreenShot/iris_screenshot_%d_%02d_%02d_%02d_%02d_%02d.jpg", tm.wYear, tm.wMonth, tm.wDay, tm.wHour, tm.wMinute, tm.wSecond );

	HRESULT ret = D3DXSaveSurfaceToFile( pathName.Cstr(), D3DXIFF_JPG, buffer, 0, 0 );
	buffer->Release();

	if( ret == D3D_OK )
		mpStageManager->AddScreenShotMsg( pathName.Cstr() );

	return ret == D3D_OK;
}
*/

#ifdef _GMTOOL
bool cApplication::InitGMTool()
{
	mGMTool = new cGMTool();
	if( mGMTool == 0 || mGMTool->Init( mpInstance, mpWindow->GetHWND() ) == false )
		return false;

	return true;
}
#endif