/**
	SLKinect.cpp  by Fumi.Iseki (c)

		http://www.nsl.tuis.ac.jp/
*/



#include  "stdafx.h"

#include  "SLKinect.h"

#include  "BasicLib.h"
#include  "MathLib.h"
#include  "GraphLib.h"
#include  "WinBaseLib.h"
#include  "DLGBoxLib.h"
#include  "Rotation.h"

#include  "SensorFrame.h"
#include  "MainFrm.h"

#include  "Dialog/SetLogMode.h"
#include  "Dialog/SetViewMode.h"
#include  "Dialog/SetNetwork.h"
#include  "Dialog/SetAnimation.h"
#include  "Dialog/SetDataSave.h"
#include  "Dialog/SetDevice.h"
#include  "Dialog/SetMotion.h"
#include  "Dialog/SetSMemory.h"


using namespace jbxl;
using namespace jbxwl;




/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// CSLKinectApp メインクラス
//

BEGIN_MESSAGE_MAP(CSLKinectApp, CWinApp)
	ON_COMMAND(ID_APP_ABOUT, &CSLKinectApp::OnAppAbout)
	// 標準のファイル基本ドキュメント コマンド
	ON_COMMAND(ID_MODEL_WND_OPEN, &CSLKinectApp::OnModelingWndOpen)
	ON_COMMAND(ID_LOG_WND_OPEN, &CSLKinectApp::OnLogWndOpen)
	ON_COMMAND(ID_SNSR_WND_OPEN_1, &CSLKinectApp::OnSnsrWndOpen_x1)
	ON_COMMAND(ID_SNSR_WND_OPEN_2, &CSLKinectApp::OnSnsrWndOpen_x2)
	ON_COMMAND(ID_SNSR_WND_OPEN_3, &CSLKinectApp::OnSnsrWndOpen_x3)
	ON_COMMAND(ID_SNSR_WND_OPEN_4, &CSLKinectApp::OnSnsrWndOpen_x4)
	ON_COMMAND(ID_LOAD_WND_OPEN_1, &CSLKinectApp::OnLddWndOpen_x1)
	ON_COMMAND(ID_LOAD_WND_OPEN_2, &CSLKinectApp::OnLddWndOpen_x2)
	ON_COMMAND(ID_LOAD_WND_OPEN_3, &CSLKinectApp::OnLddWndOpen_x3)
	ON_COMMAND(ID_LOAD_WND_OPEN_4, &CSLKinectApp::OnLddWndOpen_x4)
	ON_COMMAND(ID_SETTING_LOGINGMODE, &CSLKinectApp::OnSettingLogingMode)
	ON_COMMAND(ID_SETTING_VIEWMODE, &CSLKinectApp::OnSettingViewMode)
	ON_COMMAND(ID_SETTING_OUT_SMEMORY, &CSLKinectApp::OnSettingOutSMemory)
	ON_COMMAND(ID_SETTING_NETWORK, &CSLKinectApp::OnSettingNetwork)
	ON_COMMAND(ID_SETTING_ANIMATION, &CSLKinectApp::OnSettingAnimation)
	ON_COMMAND(ID_SETTING_DATA_SAVE, &CSLKinectApp::OnSettingDataSave)
	ON_COMMAND(ID_SETTING_DEVICE, &CSLKinectApp::OnSettingDevice)
	ON_COMMAND(ID_SETTING_MOTION, &CSLKinectApp::OnSettingMotion)
	ON_COMMAND(ID_APP_LOGIN, &CSLKinectApp::OnAppLogin)
	ON_COMMAND(ID_APP_LOGOUT, &CSLKinectApp::OnAppLogout)
	ON_COMMAND(ID_APP_DATA_LOAD, &CSLKinectApp::OnAppDataLoad)
	ON_COMMAND(ID_APP_DATA_SAVE, &CSLKinectApp::OnAppDataSave)
	ON_COMMAND(ID_APP_DATA_RECV, &CSLKinectApp::OnAppDataRecv)
	ON_COMMAND(ID_APP_REBOOT, &CSLKinectApp::OnAppReboot)
END_MESSAGE_MAP()






// CSLKinectApp コンストラクション
CSLKinectApp::CSLKinectApp()
{
	pDocTemplLOG = NULL;
	pDocTemplSNR = NULL;
	pDocTemplMDL = NULL;
	pMainFrame	 = NULL;

	pLogFrame	 = NULL;
	pLogDoc		 = NULL;
	pSensorView	 = NULL;
	pModelView	 = NULL;

	niDevice	 = NULL;
	niJoints	 = NULL;
	niNetwork	 = NULL;
	sharedMem	 = NULL;

	appParam.init();

	isLoggedIn	 = FALSE;
	isRecvData	 = FALSE;

	dataSaving	 = FALSE;
	savedData	 = FALSE;
	loadedData	 = FALSE;

	cameraScale	 = 2;
	motorTilt	 = 0;
}





CSLKinectApp::~CSLKinectApp()
{
	DEBUG_ERR("DESTRUCTOR: CSLKinect");

	deleteLockFile();

	if (niDevice!=NULL) {
		if (niDevice->has_device) {
			if (dataSaving) niDevice->stopRecorde();
		
			if (niDevice->getDevState()==NI_STATE_DETECT_EXEC) {
				niDevice->stopDetection();
			}
			if (niDevice->enableUSBDev) {
				//motorTilt = 0;
				//niDevice->setTiltMotor(motorTilt);
				niDevice->setLEDColor(NI_LED_BLINK_GREEN);
				niDevice->closeUSBDevice();
			}
		}
		delete(niDevice);
		niDevice = NULL;
	}

	if (niNetwork!=NULL) {
		delete(niNetwork);
		niNetwork = NULL;
	}
	if (sharedMem!=NULL) {
		delete(sharedMem);
		sharedMem = NULL;
	}

	Dx9ReleaseInterface();
}





// 唯一の CSLKinectApp オブジェクトです。

CSLKinectApp  theApp;



// CSLKinectApp 初期化

BOOL  CSLKinectApp::InitInstance()
{
	CWinApp::InitInstance();

	SetRegistryKey(_T("SLKinect by Fumi.Iseki and NSL"));
	LoadStdProfileSettings(4);  // 標準の INI ファイルのオプションをロードします (MRU を含む)

	//
	CMultiDocTemplate* pDocTemplate;

	pDocTemplate = new CMultiDocTemplate(
		IDR_MAINFRAME,
		RUNTIME_CLASS(CLogWndDoc),
		RUNTIME_CLASS(CLogWndFrame),
		RUNTIME_CLASS(CLogWndView));
	if (!pDocTemplate) return FALSE;
	AddDocTemplate(pDocTemplate);
	pDocTemplLOG = pDocTemplate;

	pDocTemplate = new CMultiDocTemplate(
		IDR_MAINFRAME,
		RUNTIME_CLASS(CExDocument),
		RUNTIME_CLASS(CSensorFrame), 
		RUNTIME_CLASS(CDxDirectView));
	if (!pDocTemplate) return FALSE;
	AddDocTemplate(pDocTemplate);
	pDocTemplSNR = pDocTemplate;

	pDocTemplate = new CMultiDocTemplate(
		IDR_MAINFRAME,
		RUNTIME_CLASS(CExDocument),
		RUNTIME_CLASS(CExFrame), 
		RUNTIME_CLASS(CDx3DDirectView));
	if (!pDocTemplate) return FALSE;
	AddDocTemplate(pDocTemplate);
	pDocTemplMDL = pDocTemplate;


	// メインフレーム ウィンドウを作成
	pMainFrame = new CMainFrame;
	pMainFrame->pApp = this;
	if (!pMainFrame->LoadFrame(IDR_MAINFRAME)) return FALSE;
	m_pMainWnd = pMainFrame;

	// メインフレーム ウィンドウのサイズ
	int sx = GetSystemMetrics(SM_CXSCREEN)/2;	// X方向の解像度
	int sy = GetSystemMetrics(SM_CYSCREEN)/2;	// Y方向の解像度
	m_pMainWnd->SetWindowPos(NULL, sx-SLKINECT_WND_XSIZE/2, sy-SLKINECT_WND_YSIZE/2, SLKINECT_WND_XSIZE, SLKINECT_WND_YSIZE, 0);
	
	// メインフレームウィンドウの表示
	m_pMainWnd->ShowWindow(SW_SHOW);
	m_pMainWnd->UpdateWindow();


	///////////////////////////////////////////////////////////////////////////////////////////////
	// Rebooting
	//
	BOOL ret = WaitPidTerm(5);
	if (!ret) {
		MessageBoxDLG(IDS_STR_ERROR, IDS_STR_ERR_REBOOT, MB_OK, m_pMainWnd); // "プログラムの再起動に失敗しました"
		return FALSE;
	}


	///////////////////////////////////////////////////////////////////////////////////////////////
	// Lock File
	//
	lockFilePath = makeLockFile();
	if (lockFilePath.vldsz<=0) return FALSE;
	

	///////////////////////////////////////////////////////////////////////////////////////////////
	// DirectX9 の初期化
	//
	ret = Dx9CreateInterface(this);
	if (!ret) {
		MessageBoxDLG(IDS_STR_ERROR, IDS_STR_FAIL_GET_DX9DEV, MB_OK, m_pMainWnd); // "DirectX9の初期化に失敗しました"
		return FALSE;
	}


	///////////////////////////////////////////////////////////////////////////////////////////////
	// NI の初期化
	//
	ret = InitNiDevice();


	return ret;
}






BOOL  CSLKinectApp::InitNiDevice(void)
{
	///////////////////////////////////////////////////////////////////////////////////////////////
	// NI デバイスの生成
	//
	niDevice = new CNiDevice();
	if (niDevice==NULL) return FALSE;
	

	///////////////////////////////////////////////////////////////////////////////////////////////
	// 設定ファイルの読み込み
	//
	readConfigFile(SLKINECT_CONFIG_FILE);


	///////////////////////////////////////////////////////////////////////////////////////////////
	// 初期設定
	//
	BOOL use_image = appParam.isUseImage;	// Backup
	appParam.isUseImage = FALSE;
	niDevice->setParameter(appParam);		// デバイスに関する設定は反映されない

	niDevice->hWnd		= m_pMainWnd->m_hWnd;
	niDevice->nowSDKLib = appParam.nextSDKLib;


	///////////////////////////////////////////////////////////////////////////////////////////////
	// NI Device インスタンスの初期化
	//
	CMessageBoxDLG* mesgBox = MessageBoxDLG(IDS_STR_INFO, IDS_STR_INIT_DEVICE, m_pMainWnd);	// "NIデバイスの初期化中"
	//
	BOOL ret = niDevice->init();
	updateStatusBar();
	if (mesgBox!=NULL) delete(mesgBox);
	if (!ret) MessageBoxDLG(IDS_STR_INFO, niDevice->getErrorMessage(), MB_OK, m_pMainWnd);

	appParam.isUseImage = use_image;		// Restore
	appParam.nextSDKLib = niDevice->nowSDKLib;
	niDevice->setParameter(appParam);

	if (ret && appParam.isUseImage) MakeCameraImage();


	///////////////////////////////////////////////////////////////////////////////////////////////
	// リングバッファの初期化
	//
	ret = niDevice->initRingBuffer();
	if (!ret) MessageBoxDLG(IDS_STR_WARN, niDevice->getErrorMessage(), MB_OK, m_pMainWnd);
	

	///////////////////////////////////////////////////////////////////////////////////////////////
	// メニューの設定
	//
	updateMenu();
	updateStatusBar();


	///////////////////////////////////////////////////////////////////////////////////////////////
	// ネットワークと共有メモリ，ジョイント制約クラスの生成
	//
	niJoints  = new CNiJoints();
	niNetwork = new CNiNetwork();
	sharedMem = new CNiSMemory();

	niDevice ->setNetwork(niNetwork);
	niDevice ->setSharedMem(sharedMem);
	niDevice ->setJointConst(niJoints);
	niNetwork->setParameter(appParam);
	niNetwork->setSharedMem(sharedMem);
	sharedMem->setParameter(appParam);
	sharedMem->setLocalAnimationIndex();
	niJoints->setParameter(appParam);


	return TRUE;
}






////////////////////////////////////////////////////////////////////////////////////////////
// アプリケーションのバージョン情報に使われる CAboutDlg ダイアログ

class CAboutDlg : public CDialog
{
public:
	CAboutDlg();

// ダイアログ データ
	enum { IDD = IDD_ABOUTBOX };

protected:
	virtual void DoDataExchange(CDataExchange* pDX);

// 実装
protected:
	DECLARE_MESSAGE_MAP()
};



CAboutDlg::CAboutDlg() : CDialog(CAboutDlg::IDD)
{
}



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



BEGIN_MESSAGE_MAP(CAboutDlg, CDialog)
END_MESSAGE_MAP()



//////////////////////////////////////////////////////////////////
// ダイアログを実行するためのアプリケーション コマンド
void CSLKinectApp::OnAppAbout()
{
	CAboutDlg aboutDlg;
	aboutDlg.DoModal();
}





//////////////////////////////////////////////////////////////////
// Destruction of child window
//

// センサー ビュー
void CSLKinectApp::ViewDistructor(CExView* view)
{
	if (view==pSensorView) {
		DEBUG_ERR("CSLKinectApp::ViewDistructor: STOP SENSOR VIEW");

		if (niDevice->pSensorFrame!=NULL) {
			niDevice->setSensorFramePtr(NULL);
			::Sleep(NIDEVICE_WAIT_TIME);
		}
		pSensorView = NULL;
	}

	updateMenu();
}



// ログ ビュー
void CSLKinectApp::ViewDistructor(CExTextView* view)
{
	if (view==pLogFrame->pView) {
		DEBUG_ERR("CSLKinectApp::ViewDistructor: STOP LOG VIEW");
		niDevice->clearLogDocPtr();
		niNetwork->pLogDoc = NULL;
		pLogDoc = NULL;
		::Sleep(NIDEVICE_WAIT_TIME);
	}

	updateMenu();
}



// ログ フレーム
void CSLKinectApp::FrameDistructor(CExTextFrame* frm)
{
	if (frm==pLogFrame) {
		DEBUG_ERR("CSLKinectApp::FrameDistructor: STOP LOG FRAME");

		niDevice->setLogFramePtr(NULL);
		pLogFrame = NULL;
	}

	updateMenu();
}







///////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// CSLKinectApp メニュー
//

/////////////////////////////////////////////////////////////////
// ファイル メニュー
//

//
// ログイン
//
void CSLKinectApp::OnAppLogin()
{
	if (isLoggedIn) return;
	
	char ret = niNetwork->serverLogin(appParam.animationSrvr, appParam.serverPort, appParam.groupID);
	
	if (ret==ANM_COM_REPLY_FORBIDDEN) {
		MessageBoxDLG(IDS_STR_ATTNSN, IDS_STR_FORBIDDEN_SERVER, MB_OK, m_pMainWnd); // "注意", "このサーバを使用することはできません"
		return;
	}
	else if (ret!=ANM_COM_REPLY_OK) {
		MessageBoxDLG(IDS_STR_ATTNSN, IDS_STR_NOT_LOGIN, MB_OK, m_pMainWnd);		// "注意", "サーバにログインできませんでした"
		return;
	}

	isLoggedIn = TRUE;

	CMenu* menu = pMainFrame->GetMenu();
	menu->EnableMenuItem(ID_APP_LOGIN,     MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
	menu->EnableMenuItem(ID_APP_LOGOUT,    MF_BYCOMMAND | MF_ENABLED);
	menu->EnableMenuItem(ID_APP_DATA_RECV, MF_BYCOMMAND | MF_ENABLED);

	if (sharedMem!=NULL) {
		if (appParam.netOutMode==NETonly) sharedMem->clearLocalAnimationIndex();
	}

	//
	OnAppDataRecv();
	AfxBeginThread(niNetworkKeepAlive, (LPVOID)niNetwork, THREAD_PRIORITY_LOWEST);

	//MessageBoxDLG(IDS_STR_INFO, IDS_STR_SUCCESS_LOGIN, m_pMainWnd);
	updateStatusBar();
}



//
// ログアウト
//
void CSLKinectApp::OnAppLogout()
{
	if (!isLoggedIn) return;

	niNetwork->serverLogout();
	niNetwork->closeSendSocket();
	isLoggedIn = FALSE;

	CMenu* menu = pMainFrame->GetMenu();
	menu->EnableMenuItem(ID_APP_LOGOUT, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
	menu->EnableMenuItem(ID_APP_LOGIN,  MF_BYCOMMAND | MF_ENABLED);

	// Data Recieve
	if (isRecvData) {
		menu->CheckMenuItem(ID_APP_DATA_RECV, MF_BYCOMMAND | MF_UNCHECKED);
		niNetwork->closeRecvSocket();
		isRecvData = FALSE;
	}

	if (niDevice->pSensorFrame!=NULL) {
		((CSensorFrame*)niDevice->pSensorFrame)->OnCalibrationStop();
	}
	sharedMem->setLocalAnimationIndex();


	menu->EnableMenuItem(ID_APP_DATA_RECV, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
	updateStatusBar();
}



//
// ネットワークからの Data 受信
//
void CSLKinectApp::OnAppDataRecv()
{
	if (niNetwork==NULL) return;

	CMenu* menu = pMainFrame->GetMenu();

	if (!isRecvData) {
		niNetwork->openRecvSocket();
		if (niNetwork->recvSocket<=0) {
			MessageBoxDLG(IDS_STR_ATTNSN, IDS_STR_FAIL_RSCV, MB_OK, m_pMainWnd); // "注意", "データの受信ができません"
			return;
		}
		isRecvData = TRUE;
		menu->CheckMenuItem(ID_APP_DATA_RECV, MF_BYCOMMAND | MF_CHECKED);
		//
		AfxBeginThread(niNetworkRecieveLoop, (LPVOID)niNetwork, THREAD_PRIORITY_HIGHEST);	// or THREAD_PRIORITY_NORMAL
	}
	else {
		menu->CheckMenuItem(ID_APP_DATA_RECV, MF_BYCOMMAND | MF_UNCHECKED);
		sharedMem->clearNetworkAnimationIndex();
		sharedMem->clearNetworkAnimationData();
		niNetwork->closeRecvSocket();
		isRecvData = FALSE;
	}
	updateStatusBar();
}



//
// Data 読み込み
//
void  CSLKinectApp::OnAppDataLoad()
{
	CString mesg  = LoadString_byID(IDS_STR_SPECIFY_LOAD_FILE);
	CString fname = EasyGetOpenFileName(mesg, m_pMainWnd->m_hWnd);
	if (fname.IsEmpty()) return;

	CMessageBoxDLG* mesgBox = MessageBoxDLG(IDS_STR_INFO, IDS_STR_RDNG_FILE, m_pMainWnd);
	//
	BOOL ret = niDevice->openLoadFile((char*)(LPCSTR)fname);
	loadedData = niDevice->loaded_data;
	
	if (mesgBox!=NULL) delete(mesgBox);
	if (!ret) {
		MessageBoxDLG(IDS_STR_WARN, niDevice->getErrorMessage(), MB_OK, m_pMainWnd);
		return;
	}
	
	cameraScale = 2;	// 1/2
	SensorWndOpen();
	return;
}



//
// Data 保存
//
void  CSLKinectApp::OnAppDataSave()
{
//	if (!niDevice->has_device) return;

	//
	CString mesg  = LoadString_byID(IDS_STR_SPECIFY_SAVE_FILE);
	CString fname = EasyGetSaveFileName(mesg, "", m_pMainWnd->m_hWnd);
	if (fname.IsEmpty()) return;

	//
	int ret = niDevice->backupRecordeTempFile((char*)(LPCSTR)fname);

	if (ret>0) {
		niDevice->deleteRecordeTempFile();
	}
	else {
		// "エラー", "ファイルの読み込みに失敗しました"
		MessageBoxDLG(IDS_STR_ERROR, IDS_STR_ERR_WRITE_FILE, MB_OK, NULL);
	}
	
	savedData = FALSE;
	return;
}



//
// プログラムの再起動
//
void  CSLKinectApp::OnAppReboot()
{
	int ret = MessageBoxDLG(IDS_STR_CNFRM, IDS_STR_CNFRM_REBOOT, MB_YESNO, m_pMainWnd);
	if (ret==IDNO) return;

	RebootProgram();	// -> WaitPidTerm()

	return;
}






/////////////////////////////////////////////////////////////////
//  ウィンドウ メニュー
//

void CSLKinectApp::OnModelingWndOpen()
{
	if (pModelView!=NULL) return;

	CExFrame* pfrm = CreateDocFrmView(pDocTemplMDL, this);

	if (pfrm!=NULL) {
		pfrm->pDoc->Title		= "Modeling Window";
		pfrm->pDoc->hasReadData = TRUE;                                           
		pfrm->pDoc->hasViewData = TRUE;                                        
		pfrm->pView->cnstXYRate = TRUE;
   		pfrm->pView->colorMode  = GRAPH_COLOR_BGRA;
		pfrm->pView->xsize		= niDevice->image_xsize;
		pfrm->pView->ysize		= niDevice->image_ysize;
		pModelView = (CDx3DDirectView*)pfrm->pView;

		int ret = ExecDocFrmView(pfrm);
		if (ret==0) {

		}
		else if (ret>0) {
			ExecDocFrmViewError(pMainFrame->m_hWnd, ret);
		}
	}
	else {
		ExecDocFrmViewError(pMainFrame->m_hWnd, MSG_DFV_FR_NULL);	// Frameへのポインタが NULLです
	}

	return;
}



// Log Window
void CSLKinectApp::OnLogWndOpen()
{
	if (pLogFrame==NULL) {
		pLogFrame = ExecLogWnd(pDocTemplLOG, "Log Window", this);
		pLogDoc = pLogFrame->pDoc;
		niNetwork->pLogDoc = pLogDoc;
		niDevice->setLogFramePtr((CExFrame*)pLogFrame);
	}

	updateMenu();
	return;
}




void CSLKinectApp::OnSnsrWndOpen_x1()
{
	cameraScale = 1;	// 1/1
	
	niDevice->prvNiInputDevice = niDevice->inputDevice;
	niDevice->inputDevice = NiDevice_NI;
	SensorWndOpen();
	return;
}



void CSLKinectApp::OnSnsrWndOpen_x2()
{
	cameraScale = 2;	// 1/2
	
	niDevice->prvNiInputDevice = niDevice->inputDevice;
	niDevice->inputDevice = NiDevice_NI;
	SensorWndOpen();
	return;
}



void CSLKinectApp::OnSnsrWndOpen_x3()
{
	cameraScale = 3;	// 1/3

	niDevice->prvNiInputDevice = niDevice->inputDevice;
	niDevice->inputDevice = NiDevice_NI;
	SensorWndOpen();
	return;
}



void CSLKinectApp::OnSnsrWndOpen_x4()
{
	cameraScale = 4;	// 1/4
	
	niDevice->prvNiInputDevice = niDevice->inputDevice;
	niDevice->inputDevice = NiDevice_NI;
	SensorWndOpen();
	return;
}



void CSLKinectApp::OnLddWndOpen_x1()
{
	cameraScale = 1;	// 1/1
	
	niDevice->prvNiInputDevice = niDevice->inputDevice;
	niDevice->inputDevice = NiDevice_File;
	SensorWndOpen();
	return;
}



void CSLKinectApp::OnLddWndOpen_x2()
{
	cameraScale = 2;	// 1/2
	
	niDevice->prvNiInputDevice = niDevice->inputDevice;
	niDevice->inputDevice = NiDevice_File;
	SensorWndOpen();
	return;
}



void CSLKinectApp::OnLddWndOpen_x3()
{
	cameraScale = 3;	// 1/3

	niDevice->prvNiInputDevice = niDevice->inputDevice;
	niDevice->inputDevice = NiDevice_File;
	SensorWndOpen();
	return;
}



void CSLKinectApp::OnLddWndOpen_x4()
{
	cameraScale = 4;	// 1/4
	
	niDevice->prvNiInputDevice = niDevice->inputDevice;
	niDevice->inputDevice = NiDevice_File;
	SensorWndOpen();
	return;
}




void CSLKinectApp::SensorWndOpen()
{
	if (pSensorView!=NULL) return;

	CExFrame* pfrm = CreateDocFrmView(pDocTemplSNR, this);

	if (pfrm!=NULL) {
		//		
		if (niDevice->prvNiInputDevice!=niDevice->inputDevice) {
			if (niDevice->prvNiInputDevice==NiDevice_File) loadedData = FALSE;
			if (niDevice->inputDevice==NiDevice_NI) {
				niDevice->restoreDevice();
				if (!niDevice->hasImage() && appParam.isUseImage) {
					MakeCameraImage();
				}
			}
		}

		//
		((CSensorFrame*)pfrm)->thisApp = this;
		pfrm->pDoc->Title		= "Sensor Window";
		pfrm->pDoc->hasReadData = TRUE;                                           
		pfrm->pDoc->hasViewData = TRUE;                                        
		pfrm->pView->cnstXYRate	= TRUE;
   		pfrm->pView->colorMode  = GRAPH_COLOR_BGRA;		// for faster with Little Endian
		pfrm->pView->xsize		= niDevice->image_xsize/cameraScale;
		pfrm->pView->ysize		= niDevice->image_ysize/cameraScale;
		pSensorView = (CDxDirectView*)pfrm->pView;
		pfrm->toolBar->LoadToolBar(IDR_CALIB_TOOLBAR);	// Tool Bar

		// Tool Bar
		if (niDevice->inputDevice==NiDevice_NI) {
			//if (appParam.useDevMotor) 
			pfrm->toolBar->LoadToolBar(IDR_CALIB_TOOLBAR2);
		}

		//
		int ret = ExecDocFrmView(pfrm);
		if (ret==0) {
			niDevice->setViewScale(cameraScale);
			niDevice->setSensorFramePtr(pfrm);
			if (niDevice->hasImage() && niDevice->hasDepth()) niDevice->setViewPoint();
			// Thread
			AfxBeginThread(niDeviceEventLoop, (LPVOID)niDevice, THREAD_PRIORITY_HIGHEST);	// or THREAD_PRIORITY_NORMAL
		}
		else if (ret>0) {
			ExecDocFrmViewError(pMainFrame->m_hWnd, ret);
		}
	}
	else {
		ExecDocFrmViewError(pMainFrame->m_hWnd, MSG_DFV_FR_NULL);	// Frameへのポインタが NULLです
	}

	updateMenu();
	return;
}



void  CSLKinectApp::MakeCameraImage()
{
	// イメージの作成
	if (niDevice->has_device && !niDevice->hasImage() && niDevice->appParam.isUseImage) {
		CMessageBoxDLG* mesgBox = MessageBoxDLG(IDS_STR_INFO, IDS_STR_CREATE_IMAGE, m_pMainWnd);
		niDevice->createImage();
		if (mesgBox!=NULL) delete(mesgBox);
	}
}





/////////////////////////////////////////////////////////////////
//　設定 メニュー
//

// NI デバイス
void CSLKinectApp::OnSettingDevice()
{
	CSetDevice* devdlg = new CSetDevice(niDevice->nowSDKLib, appParam);
	if (devdlg==NULL) return;
	devdlg->DoModal();
	appParam = devdlg->getParameter();

	niDevice->setParameter(appParam);

	niDevice->setUseLED(TRUE);
	if (appParam.useDevLED) {
		niDevice->setLEDColor(NI_LED_GREEN);
	}
	else {
		niDevice->setLEDColor(NI_LED_BLINK_GREEN);
	}
	
	niDevice->setUseMotor(appParam.useDevMotor);
	niDevice->setUseLED(appParam.useDevLED);

	delete(devdlg);
	writeConfigFile(SLKINECT_CONFIG_FILE);
}



// モーション設定
void CSLKinectApp::OnSettingMotion()
{
	CSetMotion* mtndlg = new CSetMotion(niDevice->nowSDKLib, appParam);
	if (mtndlg==NULL) return;
	mtndlg->DoModal();

	appParam = mtndlg->getParameter();
	niDevice->setParameter(appParam);
	niJoints->setParameter(appParam);

	delete(mtndlg);
	writeConfigFile(SLKINECT_CONFIG_FILE);
}




// ログ ウィンドウ
void CSLKinectApp::OnSettingLogingMode()
{
	CSetLogMode* logdlg = new CSetLogMode(niDevice->nowSDKLib, appParam);
	if (logdlg==NULL) return;
	logdlg->DoModal();
	appParam = logdlg->getParameter();

	niDevice ->setParameter(appParam);	
	niNetwork->setParameter(appParam);

	delete(logdlg);
	writeConfigFile(SLKINECT_CONFIG_FILE);
}



// センサー ウィンドウ
void CSLKinectApp::OnSettingViewMode()
{
	CSetViewMode* viwdlg = new CSetViewMode(appParam);
	if (viwdlg==NULL) return;
	viwdlg->DoModal();
	appParam = viwdlg->getParameter();
	niDevice->setParameter(appParam);

	delete(viwdlg);
	writeConfigFile(SLKINECT_CONFIG_FILE);

	if (appParam.isUseImage) MakeCameraImage();
}



// 共有メモリ出力
void CSLKinectApp::OnSettingOutSMemory()
{
	CSetSMemory* smrdlg = new CSetSMemory(appParam);
	if (smrdlg==NULL) return;
	smrdlg->DoModal();
	appParam =smrdlg->getParameter();

	niDevice->setParameter(appParam);
	if (niNetwork!=NULL) niNetwork->setParameter(appParam);
	if (sharedMem!=NULL) sharedMem->setParameter(appParam);

	delete(smrdlg);
	writeConfigFile(SLKINECT_CONFIG_FILE);
}



// ネットワーク
void CSLKinectApp::OnSettingNetwork()
{
//	NiNetOutMode prvNetOutMode = appParam.netOutMode;

	CSetNetwork* netdlg = new CSetNetwork(appParam, isLoggedIn);
	if (netdlg==NULL) return;
	netdlg->DoModal();
	appParam = netdlg->getParameter();

	niDevice ->setParameter(appParam);	
	niNetwork->setParameter(appParam);
	
//	if (appParam.netOutMode!=prvNetOutMode && sharedMem!=NULL) {
//		if (appParam.netOutMode==NETandLOCAL) {
//			sharedMem->setLocalAnimationIndex();
//		}
//		else {
//			sharedMem->clearLocalAnimationIndex();
//			sharedMem->clearLocalAnimationData();
//		}
//	}

	delete(netdlg);
	writeConfigFile(SLKINECT_CONFIG_FILE);
}



// アニメーション UUID
void CSLKinectApp::OnSettingAnimation()
{
	CSetAnimation* anmdlg = new CSetAnimation(appParam, isLoggedIn);
	if (anmdlg==NULL) return;
	anmdlg->DoModal();
	appParam = anmdlg->getParameter();

	if (niNetwork!=NULL) niNetwork->setParameter(appParam);
	if (sharedMem!=NULL) {
		sharedMem->setParameter(appParam);
		sharedMem->setLocalAnimationIndex();
	}

	delete(anmdlg);
	writeConfigFile(SLKINECT_CONFIG_FILE);
}



// データ保存
void CSLKinectApp::OnSettingDataSave()
{
	BOOL fexst = (BOOL)file_exist(SLKINECT_BVH_TEMPLATE);

	CSetDataSave* datdlg = new CSetDataSave(niDevice->nowSDKLib, appParam, fexst);
	if (datdlg==NULL) return;
	datdlg->DoModal();
	appParam = datdlg->getParameter();

	niDevice->setParameter(appParam);

	delete(datdlg);
	writeConfigFile(SLKINECT_CONFIG_FILE);
}








/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Tools
//

void  CSLKinectApp::readConfigFile(char* fn)
{   
	Buffer config = MakeWorkingFolderPath(fn, "\\NSL\\SLKinect\\");
	tList* lt = read_index_tList_file((char*)config.buf, ' ');
	free_Buffer(&config);

	if (lt!=NULL) {
 		appParam.nextSDKLib		= (NiSDK_Lib)get_int_param_tList(lt, "nextSDKLib", (int)appParam.nextSDKLib);

		appParam.isForcePose	= (BOOL)get_bool_param_tList(lt, "forcePose", (int)appParam.isForcePose);
		appParam.isMirroring	= (BOOL)get_bool_param_tList(lt, "mirroring", (int)appParam.isMirroring);
		appParam.isUseImage	    = (BOOL)get_bool_param_tList(lt, "useImage",  (int)appParam.isUseImage);

		appParam.netFastMode	= (BOOL)get_bool_param_tList(lt, "netFastMode", (int)appParam. netFastMode);
 		appParam.netOutMode		= (NiNetOutMode)get_int_param_tList(lt, "netOutMode", (int)appParam.netOutMode);

		appParam.saveDataMode 	= (NiFileType)get_int_param_tList(lt, "saveDataMode", (int)appParam.saveDataMode);
		appParam.savePosMode	= (BOOL)get_bool_param_tList(lt, "savePosMode", (int)appParam.savePosMode);
		appParam.saveRotMode	= (BOOL)get_bool_param_tList(lt, "saveRotMode", (int)appParam.saveRotMode);
		appParam.saveQutMode	= (BOOL)get_bool_param_tList(lt, "saveQutMode", (int)appParam.saveQutMode);

		appParam.printPosMode	= (BOOL)get_bool_param_tList(lt, "printPosMode", (int)appParam.printPosMode);
		appParam.printRotMode	= (BOOL)get_bool_param_tList(lt, "printRotMode", (int)appParam.printRotMode);
		appParam.printQutMode	= (BOOL)get_bool_param_tList(lt, "printQutMode", (int)appParam.printQutMode);
		appParam.printNetMode	= (BOOL)get_bool_param_tList(lt, "printNetMode", (int)appParam.printNetMode);
		appParam.printChkMode	= (BOOL)get_bool_param_tList(lt, "printChkMode", (int)appParam.printChkMode);

		appParam.useDevLED		= (BOOL)get_bool_param_tList(lt, "useDevLED",   (int)appParam.useDevLED);
		appParam.useDevMotor	= (BOOL)get_bool_param_tList(lt, "useDevMotor", (int)appParam.useDevMotor);

		appParam.animationUUID	= get_str_param_tList(lt, "animationUUID", (char*)(LPCSTR)appParam.animationUUID);
		appParam.animationSrvr	= get_str_param_tList(lt, "animationSrvr", (char*)(LPCSTR)appParam.animationSrvr);
		appParam.serverPort		= get_int_param_tList(lt, "serverPort", appParam.serverPort);
		appParam.clientPort		= get_int_param_tList(lt, "clientPort", appParam.clientPort);
		appParam.groupID		= get_str_param_tList(lt, "groupID", (char*)(LPCSTR)appParam.groupID);

		appParam.usePosData		= (BOOL)get_bool_param_tList(lt, "usePosData", (int)appParam.usePosData);
		appParam.useRotData		= (BOOL)get_bool_param_tList(lt, "useRotData", (int)appParam.useRotData);
		appParam.useNiteSmooth	= (BOOL)get_bool_param_tList(lt, "useNiteSmooth", (int)appParam.useNiteSmooth);
		appParam.useMvavSmooth	= (BOOL)get_bool_param_tList(lt, "useMvavSmooth", (int)appParam.useMvavSmooth);
		appParam.useJointConst	= (BOOL)get_bool_param_tList(lt, "useJointConst", (int)appParam.useJointConst);

		appParam.confidence		= (float)get_double_param_tList(lt, "confidence", (double)appParam.confidence);
		appParam.smoothNITE		= (float)get_double_param_tList(lt, "smoothNITE", (double)appParam.smoothNITE);
		appParam.mvavType		= (NiMvAvType)get_int_param_tList(lt, "mvavType", (int)appParam.mvavType);
		appParam.mvavNum		= get_int_param_tList(lt, "mvavNum", appParam.mvavNum);
		appParam.detectParts	= get_int_param_tList(lt, "detectParts", appParam.detectParts);

		appParam.outSMemoryCord	= (BOOL)get_bool_param_tList(lt, "outSMemoryCord", (int)appParam.outSMemoryCord);
		appParam.outSMemoryQuat	= (BOOL)get_bool_param_tList(lt, "outSMemoryQuat", (int)appParam.outSMemoryQuat);

		del_all_tList(&lt);
    }
}




void  CSLKinectApp::writeConfigFile(char* fn)
{   
	Buffer config = MakeWorkingFolderPath(fn, "\\NSL\\SLKinect\\", TRUE);
	
	FILE* fp = fopen((char*)config.buf, "wb");
	free_Buffer(&config);
	if (fp==NULL) return;

	fprintf(fp, "nextSDKLib %d\n", (int)appParam.nextSDKLib);

	if (appParam.isForcePose)	fprintf(fp, "forcePose %s\n", "TRUE");
	else						fprintf(fp, "forcePose %s\n", "FALSE");
	if (appParam.isMirroring)	fprintf(fp, "mirroring %s\n", "TRUE");
	else						fprintf(fp, "mirroring %s\n", "FALSE");
	if (appParam.isUseImage)	fprintf(fp, "useImage  %s\n", "TRUE");
	else						fprintf(fp, "useImage  %s\n", "FALSE");

	fprintf(fp, "netOutMode %d\n", (int)appParam.netOutMode);
	fprintf(fp, "animationUUID %s\n", (char*)(LPCSTR)appParam.animationUUID);
	fprintf(fp, "animationSrvr %s\n", (char*)(LPCSTR)appParam.animationSrvr);
	fprintf(fp, "serverPort %d\n", appParam.serverPort);
	fprintf(fp, "clientPort %d\n", appParam.clientPort);
	fprintf(fp, "groupID %s\n", (char*)(LPCSTR)appParam.groupID);

	if (appParam.netFastMode)	fprintf(fp, "netFastMode %s\n", "TRUE");
	else						fprintf(fp, "netFastMode %s\n", "FALSE");

	fprintf(fp, "saveDataMode %d\n", (int)appParam.saveDataMode);
	if (appParam.savePosMode)	fprintf(fp, "savePosMode %s\n", "TRUE");
	else						fprintf(fp, "savePosMode %s\n", "FALSE");
	if (appParam.saveRotMode)	fprintf(fp, "saveRotMode %s\n", "TRUE");
	else						fprintf(fp, "saveRotMode %s\n", "FALSE");
	if (appParam.saveQutMode)	fprintf(fp, "saveQutMode %s\n", "TRUE");
	else						fprintf(fp, "saveQutMode %s\n", "FALSE");

	if (appParam.printPosMode)	fprintf(fp, "printPosMode %s\n", "TRUE");
	else						fprintf(fp, "printPosMode %s\n", "FALSE");
	if (appParam.printRotMode)	fprintf(fp, "printRotMode %s\n", "TRUE");
	else						fprintf(fp, "printRotMode %s\n", "FALSE");
	if (appParam.printQutMode)	fprintf(fp, "printQutMode %s\n", "TRUE");
	else						fprintf(fp, "printQutMode %s\n", "FALSE");
	if (appParam.printNetMode)	fprintf(fp, "printNetMode %s\n", "TRUE");
	else						fprintf(fp, "printNetMode %s\n", "FALSE");
	if (appParam.printChkMode)	fprintf(fp, "printChkMode %s\n", "TRUE");
	else						fprintf(fp, "printChkMode %s\n", "FALSE");

	if (appParam.useDevLED)		fprintf(fp, "useDevLED %s\n",   "TRUE");
	else						fprintf(fp, "useDevLED %s\n",   "FALSE");
	if (appParam.useDevMotor)	fprintf(fp, "useDevMotor %s\n", "TRUE");
	else						fprintf(fp, "useDevMotor %s\n", "FALSE");

	fprintf(fp, "confidence  %f\n", appParam.confidence);
	fprintf(fp, "smoothNITE  %f\n", appParam.smoothNITE);
	fprintf(fp, "mvavType %d\n", (int)appParam.mvavType);
	fprintf(fp, "mvavNum %d\n",  (int)appParam.mvavNum);
	fprintf(fp, "detectParts %d\n", (int)appParam.detectParts);

	if (appParam.usePosData)	fprintf(fp, "usePosData %s\n", "TRUE");
	else						fprintf(fp, "usePosData %s\n", "FALSE");
	if (appParam.useRotData)	fprintf(fp, "useRotData %s\n", "TRUE");
	else						fprintf(fp, "useRotData %s\n", "FALSE");
	if (appParam.useJointConst)	fprintf(fp, "useJointConst %s\n", "TRUE");
	else						fprintf(fp, "useJointConst %s\n", "FALSE");
	if (appParam.useMvavSmooth)	fprintf(fp, "useMvavSmooth %s\n", "TRUE");
	else						fprintf(fp, "useMvavSmooth %s\n", "FALSE");
	if (appParam.useNiteSmooth)	fprintf(fp, "useNiteSmooth %s\n", "TRUE");
	else						fprintf(fp, "useNiteSmooth %s\n", "FALSE");

	if (appParam.outSMemoryCord)fprintf(fp, "outSMemoryCord %s\n", "TRUE");
	else                        fprintf(fp, "outSMemoryCord %s\n", "FALSE");
	if (appParam.outSMemoryQuat)fprintf(fp, "outSMemoryQuat %s\n", "TRUE");
	else                        fprintf(fp, "outSMemoryQuat %s\n", "FALSE");


	fclose(fp);
}




void  CSLKinectApp::updateMenu(CMenu* menu)
{
	if (menu==NULL) menu = pMainFrame->GetMenu();


	// データ保存
	if (dataSaving) {
		menu->EnableMenuItem(ID_SETTING_DATA_SAVE, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
	}
	else {
		menu->EnableMenuItem(ID_SETTING_DATA_SAVE, MF_BYCOMMAND | MF_ENABLED);
	}

	if (savedData) {
		menu->EnableMenuItem(ID_APP_DATA_SAVE, MF_BYCOMMAND | MF_ENABLED);
	}
	else {
		menu->EnableMenuItem(ID_APP_DATA_SAVE, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
	}

	//
	if (niDevice->getDevState()==NI_STATE_DETECT_STOPPED) {
		menu->EnableMenuItem(ID_SETTING_MOTION,    MF_BYCOMMAND | MF_ENABLED);		
		menu->EnableMenuItem(ID_SETTING_ANIMATION, MF_BYCOMMAND | MF_ENABLED);
	}
	else {
		menu->EnableMenuItem(ID_SETTING_MOTION,    MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		menu->EnableMenuItem(ID_SETTING_ANIMATION, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
	}


	// No NI Devce
	if (!niDevice->has_device) {
		if (niDevice->nowSDKLib==NiSDK_None) {
			menu->EnableMenuItem(ID_SETTING_VIEWMODE,  MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
			menu->EnableMenuItem(ID_SETTING_MOTION,    MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
			menu->EnableMenuItem(ID_SETTING_DATA_SAVE, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
			menu->EnableMenuItem(ID_SETTING_DEVICE,    MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		}
		else if (niDevice->nowSDKLib==NiSDK_Kinect) {
			menu->EnableMenuItem(ID_SETTING_VIEWMODE,  MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
			menu->EnableMenuItem(ID_SETTING_MOTION,    MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
			menu->EnableMenuItem(ID_SETTING_DATA_SAVE, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
			//menu->EnableMenuItem(ID_APP_DATA_SAVE,     MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		}
		enableSensorWndMenu(menu, FALSE);
	}

	//
	else {
		if (pSensorView!=NULL) {
			enableSensorWndMenu(menu, FALSE);
		}
		else {
			enableSensorWndMenu(menu, TRUE);
		}
	}
	
	//
	if (pSensorView!=NULL) {
		enableLoadedWndMenu(menu, FALSE);
		menu->EnableMenuItem(ID_APP_DATA_LOAD, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
	}
	else {
		enableLoadedWndMenu(menu, loadedData);
		menu->EnableMenuItem(ID_APP_DATA_LOAD, MF_BYCOMMAND | MF_ENABLED);
	}


	// ログウィンドウ
	if (pLogFrame!=NULL) {
		menu->EnableMenuItem(ID_LOG_WND_OPEN, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
	}
	else {
		menu->EnableMenuItem(ID_LOG_WND_OPEN, MF_BYCOMMAND | MF_ENABLED);
	}


	// ログイン
	if (isLoggedIn) {
		menu->EnableMenuItem(ID_APP_LOGIN,  MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		menu->EnableMenuItem(ID_APP_LOGOUT, MF_BYCOMMAND | MF_ENABLED);
		menu->EnableMenuItem(ID_APP_DATA_RECV, MF_BYCOMMAND | MF_ENABLED);
		if (isRecvData) menu->CheckMenuItem(ID_APP_DATA_RECV, MF_BYCOMMAND | MF_CHECKED);
		else            menu->CheckMenuItem(ID_APP_DATA_RECV, MF_BYCOMMAND | MF_UNCHECKED);
		menu->EnableMenuItem(ID_SETTING_ANIMATION, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		menu->EnableMenuItem(ID_SETTING_NETWORK, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
	}
	//
	else {
		if (niDevice->getDevState()!=NI_STATE_DETECT_STOPPED) {
			menu->EnableMenuItem(ID_APP_LOGIN, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		}
		else {
			menu->EnableMenuItem(ID_APP_LOGIN, MF_BYCOMMAND | MF_ENABLED);
		}
		menu->EnableMenuItem(ID_APP_LOGOUT, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		menu->EnableMenuItem(ID_APP_DATA_RECV, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
//		menu->EnableMenuItem(ID_SETTING_ANIMATION, MF_BYCOMMAND | MF_ENABLED);
		menu->EnableMenuItem(ID_SETTING_NETWORK, MF_BYCOMMAND | MF_ENABLED);
	}
}



//
void  CSLKinectApp::enableSensorWndMenu(CMenu* menu, BOOL enable)
{
	CMenu* winmn = GetMenu_byStringID(menu, IDS_STR_MENU_WINDOW);

	if (enable) {
		if (winmn!=NULL) winmn->EnableMenuItem(0, MF_BYPOSITION | MF_ENABLED);
		menu->EnableMenuItem(ID_SNSR_WND_OPEN_1, MF_BYCOMMAND | MF_ENABLED);
		menu->EnableMenuItem(ID_SNSR_WND_OPEN_2, MF_BYCOMMAND | MF_ENABLED);
		menu->EnableMenuItem(ID_SNSR_WND_OPEN_3, MF_BYCOMMAND | MF_ENABLED);
		menu->EnableMenuItem(ID_SNSR_WND_OPEN_4, MF_BYCOMMAND | MF_ENABLED);
	}
	else {
		if (winmn!=NULL) winmn->EnableMenuItem(0, MF_BYPOSITION | MF_DISABLED | MF_GRAYED);
		menu->EnableMenuItem(ID_SNSR_WND_OPEN_1,   MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		menu->EnableMenuItem(ID_SNSR_WND_OPEN_2,   MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		menu->EnableMenuItem(ID_SNSR_WND_OPEN_3,   MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		menu->EnableMenuItem(ID_SNSR_WND_OPEN_4,   MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
	}
}




void  CSLKinectApp::enableLoadedWndMenu(CMenu* menu, BOOL enable)
{
	CMenu* winmn = GetMenu_byStringID(menu, IDS_STR_MENU_WINDOW);

	if (enable) {
		if (winmn!=NULL) winmn->EnableMenuItem(1, MF_BYPOSITION | MF_ENABLED);
		menu->EnableMenuItem(ID_LOAD_WND_OPEN_1, MF_BYCOMMAND | MF_ENABLED);
		menu->EnableMenuItem(ID_LOAD_WND_OPEN_2, MF_BYCOMMAND | MF_ENABLED);
		menu->EnableMenuItem(ID_LOAD_WND_OPEN_3, MF_BYCOMMAND | MF_ENABLED);
		menu->EnableMenuItem(ID_LOAD_WND_OPEN_4, MF_BYCOMMAND | MF_ENABLED);
	}
	else {
		if (winmn!=NULL) winmn->EnableMenuItem(1, MF_BYPOSITION | MF_DISABLED | MF_GRAYED);
		menu->EnableMenuItem(ID_LOAD_WND_OPEN_1,   MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		menu->EnableMenuItem(ID_LOAD_WND_OPEN_2,   MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		menu->EnableMenuItem(ID_LOAD_WND_OPEN_3,   MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		menu->EnableMenuItem(ID_LOAD_WND_OPEN_4,   MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
	}
}








void  CSLKinectApp::updateStatusBar(BOOL init)
{
	CString rc;
	CString mesg = " ";

	if (init) {
		mesg = mesg + LoadString_byID(IDS_STR_STATUSBAR_INIT);
	}

	//
	else {
		if (niDevice->nowSDKLib==NiSDK_OpenNI) {
			mesg = mesg + "OpenNI";
		}
		else if (niDevice->nowSDKLib==NiSDK_Kinect) {
			mesg = mesg + "Kinect SDK";
		}
		else {	// NiSDK_None
			mesg = mesg + "No NI Library";
		}

		if (isLoggedIn) {
			rc.LoadString(IDS_STR_LOGGING_IN);					// ログイン中
			mesg = mesg + " | " + rc;		
			if (isRecvData) {
				rc.LoadString(IDS_STR_RECEIVING_DATA);			// データ受信中
				mesg = mesg + " | " + rc;
			}
		}
	}

	pMainFrame->SetSTausBarText(mesg);
}



//#include <imagehlp.h>
//#pragma comment(lib, "imagehlp.lib")

Buffer  CSLKinectApp::makeLockFile(void)
{
	Buffer path = GetDefaultUserHomeFolder();

	cat_s2Buffer("\\AppData\\Local\\NSL\\SLKinect\\", &path);
	MakeSureDirectoryPathExists((LPSTR)path.buf);
	cat_s2Buffer(SLKINECT_LOCK_FILE, &path);

	if (::file_exist((char*)path.buf)) {
		int ret = MessageBoxDLG(IDS_STR_CNFRM, IDS_STR_EXEC_MULTI, MB_YESNO, m_pMainWnd);
		if (ret==IDNO) free_Buffer(&path);
	}
	else {
		FILE* fp = fopen((char*)path.buf, "w");
		if (fp!=NULL) fclose(fp);
	}

	return path;
}



void  CSLKinectApp::deleteLockFile(void)
{
	unlink((char*)lockFilePath.buf);
	free_Buffer(&lockFilePath);
	return;
}