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

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


#include  "stdafx.h"

#include  "Rinions.h"

#include  "BasicLib.h"
#include  "MathLib.h"
#include  "GraphLib.h"
#include  "MessageBoxDLG.h"
#include  "Rotation.h"

#include  "SensorFrame.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/SetOutData.h"




using namespace jbxl;
using namespace jbxwl;




/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// CRinionsApp メインクラス
//

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






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

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

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

	memset(&windowSize, -1, sizeof(RECT));
	appParam.init();

	isLoggedIn	 = FALSE;
	isRecvData	 = FALSE;

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

	configFilePath = NULL;
	lockFilePath   = NULL;

	cameraScale	 = 2;
	motorTilt	 = 0;
}





CRinionsApp::~CRinionsApp()
{
	DEBUG_ERR("DESTRUCTOR: CRinions");

	deleteLockFile();

	ShutdownNiDevice();
	Dx9ReleaseInterface();
	
	//
	if (configFilePath!=NULL) {
		::free(configFilePath);
		configFilePath = NULL;
	}
	if (lockFilePath!=NULL) {
		::free(lockFilePath);
		lockFilePath = NULL;
	}
}





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

CRinionsApp  theApp;



// CRinionsApp 初期化

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

	SetRegistryKey(_T("Rinions 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;


	///////////////////////////////////////////////////////////////////////////////////////////////
	// Locale
	setSystemLocale();


	///////////////////////////////////////////////////////////////////////////////////////////////
	// Lock File & Config File
	//
	BOOL ret;
	lockFilePath = makeLockFile(ret);
	if (!ret) return FALSE;

	configFilePath = makeConfigFilePath();


	///////////////////////////////////////////////////////////////////////////////////////////////
	// ウィンドウサイズ
	//
	int wx = RINIONS_WND_XSIZE;
	int wy = RINIONS_WND_YSIZE;
	int rx = GetSystemMetrics(SM_CXSCREEN);			// X方向の解像度
	int ry = GetSystemMetrics(SM_CYSCREEN) - 14;	// Y方向の解像度（-ツールバー）

	// Default Size
	windowSize.left   = rx/2 - wx/2;
	windowSize.right  = wx;
	windowSize.top    = ry/2 - wy/2;
	windowSize.bottom = wy;

	//
	readWindowSize();	// read  windowSize

	int sx, sy;
	if (windowSize.left<=rx) {
		sx = windowSize.left;
		wx = windowSize.right;
		if (wx<=0 || wx>=rx) wx = RINIONS_WND_XSIZE; 
	}
	else {
		sx = rx/2 - RINIONS_WND_XSIZE/2;
	}
	if (windowSize.top<=ry) {
		sy = windowSize.top;
		wy = windowSize.bottom;
		if (wy<=0 || wy>=ry) wy = RINIONS_WND_YSIZE;
	}
	else {
		sy = ry/2 - RINIONS_WND_YSIZE/2;
	}

	m_pMainWnd->SetWindowPos(NULL, sx, sy, wx, wy, 0);


	///////////////////////////////////////////////////////////////////////////////////////////////
	// メインフレームウィンドウの表示
	m_pMainWnd->ShowWindow(SW_SHOW);
	m_pMainWnd->UpdateWindow();


	///////////////////////////////////////////////////////////////////////////////////////////////
	// Rebooting
	//
	ret = WaitPidTerm(5);
	if (!ret) {
		MessageBoxDLG(IDS_STR_ERROR, IDS_STR_ERR_REBOOT, MB_OK, m_pMainWnd); // "プログラムの再起動に失敗しました"
		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  CRinionsApp::InitNiDevice(void)
{
	///////////////////////////////////////////////////////////////////////////////////////////////
	// NI デバイスの生成
	//
	niDevice = new CExNiDevice();
	if (niDevice==NULL) return FALSE;
	

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


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

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


	///////////////////////////////////////////////////////////////////////////////////////////////
	// NI Device インスタンスの初期化
	//

	// "NIデバイスの初期化中"
	CMessageBoxDLG* mesgBox = MessageBoxDLG(IDS_STR_INFO, IDS_STR_INIT_DEVICE, m_pMainWnd);
	//
	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(niDevice->nowSDKLib);
	niNetwork = new CExNiNetwork();
	sharedMem = new CExNiSHMemory();

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

	return TRUE;
}




void  CRinionsApp::ShutdownNiDevice(void)
{
	if (niNetwork!=NULL) {
		if (isLoggedIn) OnAppLogout();
	}

	//
	if (niDevice!=NULL) {
		niDevice->clearLocalAvgFPS();
		//
		if (niDevice->has_device) {
			if (dataSaving) {
				niDevice->stopRecorde();
				dataSaving = FALSE;
			}
		
			if (niDevice->getDevState()==NI_STATE_DETECT_EXEC) {
				niDevice->stopDetection();
			}
			if (niDevice->enableUSBDev) {
				niDevice->setLEDColor(NI_LED_BLINK_GREEN);
				niDevice->closeUSBDevice();
			}
		}
		delete(niDevice);
		niDevice = NULL;
	}
	//::Sleep(NIDEVICE_TERM_WAIT_TIME);

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

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

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

	cameraScale	 = 2;
	motorTilt	 = 0;
}




////////////////////////////////////////////////////////////////////////////////////////////
// アプリケーションのバージョン情報に使われる 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 CRinionsApp::OnAppAbout()
{
	CAboutDlg aboutDlg;
	aboutDlg.DoModal();
}





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

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

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

		//
		if (sharedMem!=NULL) sharedMem->isTracking = FALSE;
	}

	updateMenu();
}



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

	updateMenu();
}



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

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

	updateMenu();
}






///////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// CRinionsApp メニュー
//

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

//
// ログイン
//
void CRinionsApp::OnAppLogin()
{
	if (isLoggedIn) return;
	
	// "ログイン中 ..."
	CMessageBoxDLG* mesgBox = MessageBoxDLG(IDS_STR_INFO, IDS_STR_PROCSING_LOGIN, m_pMainWnd);	
	//unsigned char ret = niNetwork->serverLogin(appParam.animationSrvr, appParam.serverPort, appParam.groupID);
	unsigned char ret = niNetwork->serverLogin();
	if (mesgBox!=NULL) delete(mesgBox);

	//
	if (ret==ANM_COM_ERROR_SERVER_DOWN) {
		// "ログインサーバが応答しません"
		MessageBoxDLG(IDS_STR_ATTNSN, IDS_STR_NORSPNS_SERVER, MB_OK, m_pMainWnd);
		return;
	}
	if (ret==ANM_COM_ERROR_TIMEOUT) {
		// "中継プロセスが応答しません"
		MessageBoxDLG(IDS_STR_ATTNSN, IDS_STR_NORSPNS_RELAY, MB_OK, m_pMainWnd);
		return;
	}
	else if (ret==ANM_COM_ERROR_SOCKET) {
		// "通信ソケットをオープンできません"
		MessageBoxDLG(IDS_STR_ATTNSN, IDS_STR_NOTOPEN_SOCKET, MB_OK, m_pMainWnd);
		return;
	}
	else if (ret==ANM_COM_REPLY_FORBIDDEN) {
		// "このサーバを使用することはできません"
		MessageBoxDLG(IDS_STR_ATTNSN, IDS_STR_FRBDDN_SERVER, MB_OK, m_pMainWnd);
		return;
	}
	else if (ret==ANM_COM_REPLY_REGIST_DUPLI) {
		// "指定されたアニメーションUUIDは既に登録されています"
		MessageBoxDLG(IDS_STR_ATTNSN, IDS_STR_DUPLI_ANIM, MB_OK, m_pMainWnd);
		return;
	}
	else if (ret==ANM_COM_REPLY_REGIST_ALRDY) {
		// "既にログイン済みです"
		MessageBoxDLG(IDS_STR_ATTNSN, IDS_STR_ALREADY_LOGIN, MB_OK, m_pMainWnd);
		//return;
	}
	else if (ret!=ANM_COM_REPLY_OK) {
		TCHAR buf[32];
		sntprintf(buf, 32, _T("\nreturn code = 0x%02x"), ret);
		CString err;
		err.LoadString(IDS_STR_NOT_LOGIN);	// "サーバにログインできませんでした"
		err += buf;
		MessageBoxDLG(IDS_STR_ATTNSN, err, MB_OK, m_pMainWnd);
		return;
	}

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

	OnAppDataRecv();

	//
	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);

	updateStatusBar();
}



//
// ログアウト
//
void CRinionsApp::OnAppLogout()
{
	closeNetwork(TRUE);
}




void CRinionsApp::closeNetwork(BOOL logout)
{
	if (!isLoggedIn) return;
	isLoggedIn = FALSE;
	isRecvData = FALSE;

	if (niNetwork!=NULL) {
		if (logout) niNetwork->serverLogout();
		else        niNetwork->closeNetwork();
		::Sleep(NIDEVICE_WAIT_TIME);
	}

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

	CMenu* menu = NULL;
	if (pMainFrame!=NULL) menu = pMainFrame->GetMenu();
	if (menu!=NULL) {
		menu->EnableMenuItem(ID_APP_LOGOUT,   MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
		menu->EnableMenuItem(ID_APP_LOGIN,    MF_BYCOMMAND | MF_ENABLED);
		menu->CheckMenuItem(ID_APP_DATA_RECV, MF_BYCOMMAND | MF_UNCHECKED);
		menu->EnableMenuItem(ID_APP_DATA_RECV,MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
	}
	updateStatusBar();
}




//
// ネットワークからの Data 受信
//
void CRinionsApp::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);
		//
		// THREAD_PRIORITY_NORMAL, THREAD_PRIORITY_HIGHEST	
		AfxBeginThread(niNetworkRecieveLoop, (LPVOID)niNetwork, THREAD_PRIORITY_TIME_CRITICAL);
	}
	else {
		menu->CheckMenuItem(ID_APP_DATA_RECV, MF_BYCOMMAND | MF_UNCHECKED);
		sharedMem->clearNetworkAnimationIndex();
		sharedMem->clearNetworkAnimationData();
		niNetwork->closeRecvSocket();
		isRecvData = FALSE;
	}
	updateStatusBar();
}



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

	CMessageBoxDLG* mbox = MessageBoxDLG(IDS_STR_INFO, IDS_STR_RDNG_FILE, m_pMainWnd);
	BOOL ret   = niDevice->openLoadFile(fname);
	loadedData = niDevice->loaded_oni;			// TRUE or FALSE
	if (mbox!=NULL) delete(mbox);

	//
	if (!ret) {
		MessageBoxDLG(IDS_STR_WARN, niDevice->getErrorMessage(), MB_OK, m_pMainWnd);
		return;
	}
	
	// ONI
	if (loadedData) {
		cameraScale = 2;	// 1/2
		SensorWndOpen();
	}
	//
	else {
		niDevice->execFilePlayer(isLoggedIn, fname);
		//		
		appParam = niDevice->appParam;
		niDevice->setParameter(appParam);
		writeConfigFile();
	}

	return;
}



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

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

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

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



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

	writeConfigFile();
	RebootProgram();	// => WaitPidTerm()

	return;
}



//
// NIデバイスの初期化
//
void  CRinionsApp::OnAppInitialize()
{
//	OnAppReboot();
//	return;

	//
	int ret = MessageBoxDLG(IDS_STR_CNFRM, IDS_STR_CNFRM_INIT, MB_YESNO, m_pMainWnd);
	if (ret==IDNO) return;

	updateStatusBar(TRUE);
	writeConfigFile();

	// "NIデバイスのリセット中"
	CMessageBoxDLG* mesgBox = MessageBoxDLG(IDS_STR_INFO, IDS_STR_RESET_DEVICE, m_pMainWnd);
	ShutdownNiDevice();
	if (mesgBox!=NULL) delete(mesgBox);

	//
	InitNiDevice();

	updateStatusBar();
	return;
}






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

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

	CExFrame* pfrm = CreateDocFrmView(pDocTemplMDL, this);

	if (pfrm!=NULL) {
		pfrm->pDoc->Title		= _T("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 CRinionsApp::OnLogWndOpen()
{
	if (pLogFrame==NULL) {
		pLogFrame = ExecLogWnd(pDocTemplLOG, _T("Log Window"), this);
		pLogDoc = pLogFrame->pDoc;
		niNetwork->pLogDoc = pLogDoc;
		niDevice->setLogFramePtr((CExTextFrame*)pLogFrame);
	}

	updateMenu();
	return;
}




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



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



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

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



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



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



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



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

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



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




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

	CExFrame* pfrm = CreateDocFrmView(pDocTemplSNR, this);

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

		//
		((CSensorFrame*)pfrm)->thisApp = this;
		pfrm->pDoc->Title		= _T("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) {
			pfrm->toolBar->LoadToolBar(IDR_CALIB_TOOLBAR2);
		}
		else if (niDevice->inputDevice==NiDevice_File) {
			appParam.isMirroring = TRUE;
			niDevice->setParameter(appParam);
		}

		//
		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
//		AfxBeginThread(niDeviceEventLoop, (LPVOID)niDevice, THREAD_PRIORITY_TIME_CRITICAL);
	}
	//
	else {
		ExecDocFrmViewError(pMainFrame->m_hWnd, MSG_DFV_FR_NULL);	// Frameへのポインタが NULLです
	}

	updateMenu();
	return;
}



void  CRinionsApp::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 CRinionsApp::OnSettingDevice()
{
	CSetDevice* devdlg = new CSetDevice(niDevice, 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();
}



// モーション設定
void CRinionsApp::OnSettingMotion()
{
	CSetMotion* mtndlg = NULL;
	
	if (niDevice->nowSDKLib==NiSDK_OpenNI) {
		mtndlg = new CSetOpenNIMotion(appParam);
	}
	else if (niDevice->nowSDKLib==NiSDK_Kinect) {
		mtndlg = new CSetKinectMotion(appParam);
	}
	if (mtndlg==NULL) return;
	
	mtndlg->DoModal();
	appParam = mtndlg->getParameter();
	niDevice->setParameter(appParam);
	niJoints->setParameter(appParam);

	delete(mtndlg);
	writeConfigFile();
}



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

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

	delete(logdlg);
	writeConfigFile();
}



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

	niDevice->setParameter(appParam);

	delete(viwdlg);
	writeConfigFile();

	if (appParam.isUseImage) MakeCameraImage();
}



// データ出力
void CRinionsApp::OnSettingOutData()
{
	CSetOutData* smrdlg = new CSetOutData(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();
}



// ネットワーク
void CRinionsApp::OnSettingNetwork()
{
	CSetNetwork* netdlg = new CSetNetwork(appParam, isLoggedIn);
	if (netdlg==NULL) return;
	netdlg->DoModal();
	appParam = netdlg->getParameter();

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

	delete(netdlg);
	writeConfigFile();
}



// アニメーション UUID
void CRinionsApp::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();
}



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

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

	niDevice->setParameter(appParam);

	delete(datdlg);
	writeConfigFile();
}








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

void  CRinionsApp::readWindowSize(void)
{   
	if (configFilePath==NULL) return;

	tList* lt = read_index_tList_file(configFilePath, ' ');
	if (lt==NULL) return;

	//	
	windowSize.left   = (LONG)get_int_param_tList(lt, "windowsPosX",  (int)windowSize.left);
	windowSize.top	  = (LONG)get_int_param_tList(lt, "windowsPosY",  (int)windowSize.top);
	windowSize.right  = (LONG)get_int_param_tList(lt, "windowsSizeX", (int)windowSize.right);
	windowSize.bottom = (LONG)get_int_param_tList(lt, "windowsSizeY", (int)windowSize.bottom);

	del_all_tList(&lt);
	return;
}



void  CRinionsApp::readConfigFile(void)
{
	if (configFilePath==NULL) return;

	tList* lt = read_index_tList_file(configFilePath, ' ');
	if (lt==NULL) return;

	//
 	appParam.nextSDKLib		= (NiSDK_Lib)   get_int_param_tList(lt, "nextSDKLib",  (int)appParam.nextSDKLib);
 	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.mvavType		= (NiMvAvType)  get_int_param_tList(lt, "mvavType",    (int)appParam.mvavType);

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

	appParam.netFastMode	= get_bool_param_tList (lt, "netFastMode",	 appParam.netFastMode);
	appParam.inAutoBPS		= get_bool_param_tList (lt, "inAutoBPS",	 appParam.inAutoBPS);

	appParam.serverPort		= get_int_param_tList  (lt, "serverPort",	 appParam.serverPort);
	appParam.clientPort		= get_int_param_tList  (lt, "clientPort",	 appParam.clientPort);
	appParam.inMaxBPS		= get_int_param_tList  (lt, "inMaxBPS",		 appParam.inMaxBPS);

	appParam.saveBVHFormat	= get_int_param_tList  (lt, "saveBVHFormat", appParam.saveBVHFormat);
	appParam.saveBVHFPS		= get_int_param_tList  (lt, "saveBVHFPS",    appParam.saveBVHFPS);
	appParam.saveDivTime	= get_int_param_tList  (lt, "saveDivTime",   appParam.saveDivTime);
	appParam.saveSzScale	= get_float_param_tList(lt, "saveSzScale",   appParam.saveSzScale);

	appParam.animationUUID	= get_tstr_param_tList (lt, "animationUUID", (LPCTSTR)appParam.animationUUID);
	appParam.animationSrvr	= get_tstr_param_tList (lt, "animationSrvr", (LPCTSTR)appParam.animationSrvr);
	appParam.groupID		= get_tstr_param_tList (lt, "groupID",       (LPCTSTR)appParam.groupID);

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

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

	appParam.usePosData		= get_bool_param_tList (lt, "usePosData",    appParam.usePosData);
	appParam.useRotData		= get_bool_param_tList (lt, "useRotData",    appParam.useRotData);
	appParam.useJointConst	= get_bool_param_tList (lt, "useJointConst", appParam.useJointConst);

	appParam.useNiteSmooth	= get_bool_param_tList (lt, "useNiteSmooth", appParam.useNiteSmooth);
	appParam.useKnctSmooth  = get_bool_param_tList (lt, "useKnctSmooth", appParam.useKnctSmooth);
	appParam.useMvavSmooth	= get_bool_param_tList (lt, "useMvavSmooth", appParam.useMvavSmooth);

	appParam.confidence		= get_float_param_tList(lt, "confidence",	 appParam.confidence);
	appParam.smoothNITE		= get_float_param_tList(lt, "smoothNITE",	 appParam.smoothNITE);
	appParam.correction		= get_float_param_tList(lt, "correction",	 appParam.correction);
	appParam.smoothKNCT		= get_float_param_tList(lt, "smoothKNCT",	 appParam.smoothKNCT);
	appParam.YaxisCorrect	= get_float_param_tList(lt, "YaxisCorrect",	 appParam.YaxisCorrect);

	appParam.mvavNum		= get_int_param_tList  (lt, "mvavNum",		 appParam.mvavNum);
	appParam.detectParts	= get_int_param_tList  (lt, "detectParts",	 appParam.detectParts);

	appParam.outDataCoord	= get_bool_param_tList (lt, "outDataCoord",	 appParam.outDataCoord);
	appParam.outDataQuate	= get_bool_param_tList (lt, "outDataQuate",	 appParam.outDataQuate);
	appParam.outCtrlFPS		= get_bool_param_tList (lt, "outCtrlFPS",	 appParam.outCtrlFPS);
	appParam.outAutoFPS		= get_bool_param_tList (lt, "outAutoFPS",	 appParam.outAutoFPS);
	appParam.outDataFPS		= get_int_param_tList  (lt, "outDataFPS",	 appParam.outDataFPS);

	//
	del_all_tList(&lt);
	return;
}




void  CRinionsApp::writeConfigFile(void)
{   
	if (configFilePath==NULL) return;
	
	FILE* fp = fopen(configFilePath, "wb");
	if (fp==NULL) return;

	//
	if (pMainFrame!=NULL) {
		windowSize = pMainFrame->windowSize;
		int wx = windowSize.right  - windowSize.left;
		int wy = windowSize.bottom - windowSize.top;
		if (windowSize.left>0)   fprintf(fp, "windowsPosX  %d\n", windowSize.left);
		if (windowSize.top>0)    fprintf(fp, "windowsPosY  %d\n", windowSize.top);
		if (wx>0)                fprintf(fp, "windowsSizeX %d\n", wx);
		if (wy>0)                fprintf(fp, "windowsSizeY %d\n", wy);
	}

	//
	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");

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

	// CString
	Buffer tmp = make_Buffer(LNAME);
	copy_ts2Buffer(appParam.animationUUID, &tmp);
	fprintf(fp, "animationUUID %s\n", (char*)tmp.buf);
	copy_ts2Buffer(appParam.animationSrvr, &tmp);
	fprintf(fp, "animationSrvr %s\n", (char*)tmp.buf);
	copy_ts2Buffer(appParam.groupID, &tmp);
	fprintf(fp, "groupID %s\n", (char*)tmp.buf);
	free_Buffer(&tmp);

	fprintf(fp, "netOutMode %d\n", (int)appParam.netOutMode);
	fprintf(fp, "serverPort %d\n", appParam.serverPort);
	fprintf(fp, "clientPort %d\n", appParam.clientPort);
	fprintf(fp, "inMaxBPS %d\n",   appParam.inMaxBPS);

	fprintf(fp, "saveDataMode %d\n",  (int)appParam.saveDataMode);
	fprintf(fp, "saveBVHFormat %d\n", appParam.saveBVHFormat);
	fprintf(fp, "saveBVHFPS %d\n",    appParam.saveBVHFPS);
	fprintf(fp, "saveDivTime %d\n",   appParam.saveDivTime);
	fprintf(fp, "saveSzScale %f\n",   appParam.saveSzScale);

	//
	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");

	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.useNiteSmooth)	fprintf(fp, "useNiteSmooth %s\n", "TRUE");
	else						fprintf(fp, "useNiteSmooth %s\n", "FALSE");
	if (appParam.useKnctSmooth) fprintf(fp, "useKnctSmooth %s\n", "TRUE");
	else						fprintf(fp, "useKnctSmooth %s\n", "FALSE");
	if (appParam.useMvavSmooth) fprintf(fp, "useMvavSmooth %s\n", "TRUE");
	else						fprintf(fp, "useMvavSmooth %s\n", "FALSE");

	fprintf(fp, "confidence   %f\n", appParam.confidence);
	fprintf(fp, "smoothNITE   %f\n", appParam.smoothNITE);
	fprintf(fp, "correction   %f\n", appParam.correction);
	fprintf(fp, "smoothKNCT   %f\n", appParam.smoothKNCT);
	fprintf(fp, "YaxisCorrect %f\n", appParam.YaxisCorrect);

	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.outDataCoord) fprintf(fp, "outDataCoord %s\n", "TRUE");
	else                       fprintf(fp, "outDataCoord %s\n", "FALSE");
	if (appParam.outDataQuate) fprintf(fp, "outDataQuate %s\n", "TRUE");
	else                       fprintf(fp, "outDataQuate %s\n", "FALSE");
	if (appParam.outCtrlFPS)   fprintf(fp, "outCtrlFPS %s\n", "TRUE");
	else                       fprintf(fp, "outCtrlFPS %s\n", "FALSE");
	if (appParam.outAutoFPS)   fprintf(fp, "outAutoFPS %s\n", "TRUE");
	else                       fprintf(fp, "outAutoFPS %s\n", "FALSE");
	fprintf(fp, "outDataFPS %d\n", appParam.outDataFPS);

	//
	fflush(fp);
	fclose(fp);
	return;
}




void  CRinionsApp::updateMenu(CMenu* menu)
{
	if (menu==NULL) menu = pMainFrame->GetMenu();
	int state = niDevice->getDevState();


	// データ保存
	if (dataSaving) {
		menu->EnableMenuItem(ID_SETTING_SAVEDATA, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
	}
	else {
		menu->EnableMenuItem(ID_SETTING_SAVEDATA, 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 (state==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_SAVEDATA,  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_SAVEDATA,  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 (state!=NI_STATE_DETECT_STOPPED && state!=NI_STATE_UNKNOWN) {
			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  CRinionsApp::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  CRinionsApp::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  CRinionsApp::updateStatusBar(BOOL init)
{
	if (pMainFrame==NULL) return;

	CString rc;
	CString mesg = _T(" ");

	if (init) {
		mesg = mesg + LoadString_byID(IDS_STR_STATUSBAR_INIT);
		pMainFrame->SetStausBarLocalFPS(0.0);
		pMainFrame->SetStausBarNetworkFPS(0.0);
		pMainFrame->SetStausBarNetworkBPS(0.0);
	}

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

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

	pMainFrame->SetStausBarText(mesg);
}




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

char*  CRinionsApp::makeLockFile(BOOL& exec)
{
	exec = TRUE;

	// Local
	CString path = MakeWorkingFolderPath(_T(RINIONS_LOCK_FILE), TRUE, _T(RINIOMS_CONFIG_PATH), TRUE);

	if (file_exist_t(path)) {
		int ret = MessageBoxDLG(IDS_STR_CNFRM, IDS_STR_EXEC_MULTI, MB_YESNO, m_pMainWnd);
		if (ret==IDNO) {
			exec = FALSE;
			return NULL;
		}
	}
	else {
		FILE* fp = tfopen(path, _T("w"));
		if (fp!=NULL) fclose(fp);
	}

	char* pathstr = NULL;
	if (path!=_T("")) pathstr = ts2mbs(path);

	return pathstr;
}



void  CRinionsApp::deleteLockFile(void) 
{ 
	if (lockFilePath!=NULL) {
		unlink(lockFilePath);
		::free(lockFilePath);
		lockFilePath = NULL;
	}
	else {
		//DEBUG_ERR("CRinionsApp::deleteLockFile: ERROR: Lock File Path is NULL");
	}

	return;
}




char*  CRinionsApp::makeConfigFilePath(void)
{
	// Roming
	CString config = MakeWorkingFolderPath(_T(RINIONS_CONFIG_FILE), FALSE, _T(RINIOMS_CONFIG_PATH), TRUE);
	
	char* pathstr = NULL;
	if (config!=_T("")) pathstr = ts2mbs(config);

	return pathstr;
}