// SoundGraphAccess.cpp : Defines the entry point for the application.

 //

 #include "stdafx.h"

 #include "SoundGraphAccess.h"

 #include "iMONDisplayAPI.h"

 #include <stdio.h>

 #define WM_DSP_PLUGIN_NOTIFY			WM_APP + 1100

 #define WM_IMON_INIT					WM_APP + 1101

 #define WM_IMON_UNINIT					WM_APP + 1102

 #define WM_IMON_IS_INIT					WM_APP + 1103

 #define WM_IMON_IS_PLUGIN_MODE_ENABLED	WM_APP + 1104

 //

 #define MAX_LOADSTRING 100

 // Global Variables:

 HINSTANCE hInst = 0;								// current instance

 TCHAR szTitle[MAX_LOADSTRING];					// The title bar text

 TCHAR szWindowClass[MAX_LOADSTRING];			// the main window class name

 HANDLE gThreadReceiver = INVALID_HANDLE_VALUE;

 //HANDLE gThreadSender = INVALID_HANDLE_VALUE;

 BOOL gQuit=FALSE;

 LPTSTR gPipeNameSender = TEXT("\\\\.\\pipe\\sga-sender"); 

 LPTSTR gPipeNameReceiver = TEXT("\\\\.\\pipe\\sga-receiver"); 

 HANDLE gPipeSender=INVALID_HANDLE_VALUE;

 HANDLE gPipeReceiver=INVALID_HANDLE_VALUE;

 char gBufferReceiver[256];

 char gBufferSender[256];

 //

 HWND gWnd;

 //

 BOOL m_bVfdConnected;

 BOOL m_bLcdConnected;

 // Forward declarations of functions included in this code module:

 ATOM				MyRegisterClass(HINSTANCE hInstance);

 BOOL				InitInstance(HINSTANCE, int);

 LRESULT CALLBACK	WndProc(HWND, UINT, WPARAM, LPARAM);

 INT_PTR CALLBACK	About(HWND, UINT, WPARAM, LPARAM);

 //Supported responses

 const char KRspDone[]="done:";

 const char KRspPending[]="pending:";

 const char KRspError[]="error:";

 const char KRspClose[]="close:";

 const char KRspOpen[]="open:";

 const char KRspUnknown[]="unknown:";

 const char KRspTrue[]="true:";

 const char KRspFalse[]="false:";

 //Supported incoming messages

 const char KMsgInit[]="init:";

 const char KMsgUninit[]="uninit:";

 const char KMsgIsInit[]="is-init:";

 const char KMsgIsPluginModeEnabled[]="is-plugin-mode-enabled:";

 /**

 Send a message to our server.

 */

 void SendMessageToServer(const char* aResponse)

 	{

 	DWORD cbWritten=0;

 	char msg[512];

 	sprintf(msg,"%s\n",aResponse);

 	OutputDebugStringA(msg);

 	WriteFile(gPipeSender, aResponse, strlen(aResponse), &cbWritten, NULL);		

 	}

 /**

 Handle messages from our server.

 */

 void MessageReceived(const char* aMsg)

 	{

 	//

 	if (strcmp(aMsg,KMsgInit)==0)

 		{

 		//IMON API call need to be done from window thread for some reason

 		SendMessageToServer(KRspPending);

 		PostMessage(gWnd,WM_IMON_INIT,0,0);

 		}

 	else if (strcmp(aMsg,KMsgUninit)==0)

 		{

 		//IMON API call need to be done from window thread for some reason

 		SendMessageToServer(KRspPending);

 		PostMessage(gWnd,WM_IMON_UNINIT,0,0);		

 		}

 	else if (strcmp(aMsg,KMsgIsPluginModeEnabled)==0)

 		{

 		//IMON API call need to be done from window thread for some reason

 		SendMessageToServer(KRspPending);

 		PostMessage(gWnd,WM_IMON_IS_PLUGIN_MODE_ENABLED,0,0);		

 		}

 	else if (strcmp(aMsg,KMsgIsInit)==0)

 		{

 		//IMON API call need to be done from window thread for some reason

 		SendMessageToServer(KRspPending);

 		PostMessage(gWnd,WM_IMON_IS_INIT,0,0);		

 		}

 	else

 		{		

 		SendMessageToServer(KRspUnknown);

 		}

 	}

 /**

 Connect our named pipes from here.

 First connect our read pipe then our write pipe.

 Then notify our server we are connected.

 Then keep on waiting for incoming messages.

 */

 DWORD WINAPI ThreadReceiver( LPVOID lpParam )

 	{

 	//Keep on trying to connect on our read pipe

 	while (gPipeReceiver==INVALID_HANDLE_VALUE && !gQuit)

 		{

 		OutputDebugStringA("Trying to connect...\n");

 		gPipeReceiver=CreateFile(gPipeNameReceiver,	GENERIC_READ ,0,NULL,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL);

 		Sleep(1000);

 		}

 	OutputDebugStringA("Read pipe open!\n");

 	//Now try connecting on our write pipe

 	gPipeSender=CreateFile(gPipeNameSender,	GENERIC_WRITE ,0,NULL,OPEN_EXISTING,FILE_FLAG_OVERLAPPED,NULL);

 	if (gPipeSender==INVALID_HANDLE_VALUE)

 		{

 		OutputDebugStringA("ERROR: Write pipe failure!\n");

 		gQuit=TRUE;

 		}

 	else

 		{

 		OutputDebugStringA("Write pipe opened.\n");

 		OutputDebugStringA("Connected.\n");

 		SendMessageToServer(KRspOpen);

 		}

 	//

 	while(!gQuit)

 		{

 		DWORD cbRead;

 		BOOL success=ReadFile(gPipeReceiver,gBufferReceiver,sizeof(gBufferReceiver),&cbRead, NULL); 

 		if(success)

 			{

 			gBufferReceiver[cbRead]='\0';

 			OutputDebugStringA(gBufferReceiver);

 			MessageReceived(gBufferReceiver);

 			}

 		//if (!success && GetLastError() != ERROR_MORE_DATA) 

 		//	{

 		//	OutputDebugStringA("Can't Read\n");

 		//	}

 		//

 		//Sleep(500);

 		if (!success)

 			{

 			gQuit=TRUE;

 			}

 		}

 	//Try tell our server

 	SendMessageToServer(KRspClose);

 	//Close our pipes

 	CloseHandle(gPipeReceiver);	

 	gPipeReceiver=INVALID_HANDLE_VALUE;

 	CloseHandle(gPipeSender);	

 	gPipeSender=INVALID_HANDLE_VALUE;

 	//Quit our application

 	PostMessage(gWnd,WM_CLOSE,0,0);

 	return 0;

 	}

 /**

 */

 int APIENTRY _tWinMain(HINSTANCE hInstance,

                      HINSTANCE hPrevInstance,

                      LPTSTR    lpCmdLine,

                      int       nCmdShow)

 {

 	UNREFERENCED_PARAMETER(hPrevInstance);

 	UNREFERENCED_PARAMETER(lpCmdLine);

 	// TODO: Place code here.

 	MSG msg;

 	HACCEL hAccelTable;

 	// Initialize global strings

 	LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);

 	LoadString(hInstance, IDC_SOUNDGRAPHACCESS, szWindowClass, MAX_LOADSTRING);

 	MyRegisterClass(hInstance);

 	// Perform application initialization:

 	if (!InitInstance (hInstance, /*SW_HIDE*/ nCmdShow))

 		{

 		return FALSE;

 		}

 	hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_SOUNDGRAPHACCESS));

 	// Main message loop:

 	while (GetMessage(&msg, NULL, 0, 0))

 		{

 		if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))

 			{

 			TranslateMessage(&msg);

 			DispatchMessage(&msg);

 			}

 		}

 	return (int) msg.wParam;

 	}

 /**

 */

 void DisplayPluginMessage(UINT uErrCode, BOOL bError)

 	{

 	char* strErrMsg = "";

 	if(bError)

 		{

 		switch(uErrCode)

 			{

 			case DSPN_ERR_IN_USED:			strErrMsg = ("Display Plug-in is Already Used by Other Application.");		break;

 			case DSPN_ERR_HW_DISCONNECTED:	strErrMsg = ("iMON HW is Not Connected.");									break;

 			case DSPN_ERR_NOT_SUPPORTED_HW:	strErrMsg = ("The Connected iMON HW doesn't Support Display Plug-in.");		break;

 			case DSPN_ERR_PLUGIN_DISABLED:	strErrMsg = ("Display Plug-in Mode Option is Disabled.");					break;

 			case DSPN_ERR_IMON_NO_REPLY:	strErrMsg = ("The Latest iMON is Not Installed or iMON Not Running.");		break;

 			case DSPN_ERR_UNKNOWN:			strErrMsg = ("Unknown Failure.");											break;

 			}

 		}

 	else

 		{

 		switch(uErrCode)

 			{

 			case DSPNM_PLUGIN_SUCCEED:		strErrMsg = ("Plug-in Mode Inited Successfully.");			break;

 			case DSPNM_IMON_RESTARTED:		strErrMsg = ("iMON Started and Plug-in Mode Inited.");		break;

 			case DSPNM_HW_CONNECTED:		strErrMsg = ("iMON HW Connected and Plug-in Mode Inited.");	break;

 			}

 		}

 	//

 	OutputDebugStringA(strErrMsg);

 	char msg[256];

 	if (bError)

 		{

 		sprintf(msg,"error:%s",strErrMsg);

 		}

 	else

 		{

 		sprintf(msg,"done:%s",strErrMsg);	

 		}	

 	SendMessageToServer(msg);

 	}

 //

 //  FUNCTION: MyRegisterClass()

 //

 //  PURPOSE: Registers the window class.

 //

 //  COMMENTS:

 //

 //    This function and its usage are only necessary if you want this code

 //    to be compatible with Win32 systems prior to the 'RegisterClassEx'

 //    function that was added to Windows 95. It is important to call this function

 //    so that the application will get 'well formed' small icons associated

 //    with it.

 //

 ATOM MyRegisterClass(HINSTANCE hInstance)

 {

 	WNDCLASSEX wcex;

 	wcex.cbSize = sizeof(WNDCLASSEX);

 	wcex.style			= CS_HREDRAW | CS_VREDRAW;

 	wcex.lpfnWndProc	= WndProc;

 	wcex.cbClsExtra		= 0;

 	wcex.cbWndExtra		= 0;

 	wcex.hInstance		= hInstance;

 	wcex.hIcon			= LoadIcon(hInstance, MAKEINTRESOURCE(IDI_SOUNDGRAPHACCESS));

 	wcex.hCursor		= LoadCursor(NULL, IDC_ARROW);

 	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);

 	wcex.lpszMenuName	= MAKEINTRESOURCE(IDC_SOUNDGRAPHACCESS);

 	wcex.lpszClassName	= szWindowClass;

 	wcex.hIconSm		= LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

 	return RegisterClassEx(&wcex);

 }

 //

 //   FUNCTION: InitInstance(HINSTANCE, int)

 //

 //   PURPOSE: Saves instance handle and creates main window

 //

 //   COMMENTS:

 //

 //        In this function, we save the instance handle in a global variable and

 //        create and display the main program window.

 //

 BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)

 {

    hInst = hInstance; // Store instance handle in our global variable

    gWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,

       CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

    if (!gWnd)

    {

       return FALSE;

    }

    ShowWindow(gWnd, nCmdShow);

    UpdateWindow(gWnd);

    return TRUE;

 }

 //

 //  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)

 //

 //  PURPOSE:  Processes messages for the main window.

 //

 //  WM_COMMAND	- process the application menu

 //  WM_PAINT	- Paint the main window

 //  WM_DESTROY	- post a quit message and return

 //

 //

 LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)

 {

 	int wmId, wmEvent;

 	PAINTSTRUCT ps;

 	HDC hdc;

 	switch (message)

 	{

 	case WM_CREATE:

 		//IMON_Display_Uninit();

 		//IMON_Display_Init(hWnd, WM_DSP_PLUGIN_NOTIFY);

 		gThreadReceiver = CreateThread( NULL, 0, ThreadReceiver, NULL/*data pointer*/, 0, NULL);

 		break;

 	case WM_COMMAND:

 		wmId    = LOWORD(wParam);

 		wmEvent = HIWORD(wParam);

 		// Parse the menu selections:

 		switch (wmId)

 		{

 		case IDM_ABOUT:

 			DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);

 			break;

 		case IDM_EXIT:

 			DestroyWindow(hWnd);

 			break;

 		default:

 			return DefWindowProc(hWnd, message, wParam, lParam);

 		}

 		break;

 	case WM_PAINT:

 		hdc = BeginPaint(hWnd, &ps);

 		// TODO: Add any drawing code here...

 		EndPaint(hWnd, &ps);

 		break;

 	case WM_DESTROY:

 		gQuit=TRUE;

 		//To complete write op

 		if (gPipeSender!=INVALID_HANDLE_VALUE)

 			{

 			CloseHandle(gPipeSender);

 			gPipeSender=INVALID_HANDLE_VALUE;

 			}

 		//To complete read op

 		if (gPipeReceiver!=INVALID_HANDLE_VALUE)

 			{

 			CloseHandle(gPipeReceiver);

 			gPipeReceiver=INVALID_HANDLE_VALUE;

 			}

 		WaitForSingleObject(gThreadReceiver,INFINITE);

 		CloseHandle(gThreadReceiver);

 		//IMON_Display_Uninit();

 		PostQuitMessage(0);

 		break;

 	case WM_IMON_UNINIT:

 		IMON_Display_Uninit();

 		SendMessageToServer(KRspDone);

 		break;

 	case WM_IMON_INIT:

 		IMON_Display_Uninit();

 		IMON_Display_Init(hWnd, WM_DSP_PLUGIN_NOTIFY);

 		break;

 	//

 	case WM_IMON_IS_PLUGIN_MODE_ENABLED:

 		if (IMON_Display_IsPluginModeEnabled()==DSP_S_IN_PLUGIN_MODE)

 			{

 			SendMessageToServer(KRspTrue);

 			}

 		else

 			{

 			SendMessageToServer(KRspFalse);

 			}

 		break;

 	//

 	case WM_IMON_IS_INIT:

 		if (IMON_Display_IsInited()==DSP_S_INITED)

 			{

 			SendMessageToServer(KRspTrue);

 			}

 		else

 			{

 			SendMessageToServer(KRspFalse);

 			}

 		break;

 	case WM_DSP_PLUGIN_NOTIFY:

 		switch(wParam)

 			{

 			case DSPNM_PLUGIN_SUCCEED:

 			case DSPNM_IMON_RESTARTED:

 			case DSPNM_HW_CONNECTED:

 				{

 				//GetDlgItem(IDC_BUTTON1)->EnableWindow(TRUE);

 				m_bVfdConnected = FALSE;

 				m_bLcdConnected = FALSE;

 				if((lParam & DSPN_DSP_VFD) == DSPN_DSP_VFD)		m_bVfdConnected = TRUE;

 				if((lParam & DSPN_DSP_LCD) == DSPN_DSP_LCD)		m_bLcdConnected = TRUE;

 				//UpdateControlUI();

 				DisplayPluginMessage(wParam, FALSE);

 				}

 				break;

 			case DSPNM_PLUGIN_FAILED:

 			case DSPNM_HW_DISCONNECTED:

 			case DSPNM_IMON_CLOSED:

 				{

 				//GetDlgItem(IDC_BUTTON1)->EnableWindow(TRUE);

 				m_bVfdConnected = FALSE;

 				m_bLcdConnected = FALSE;

 				//UpdateControlUI();

 				DisplayPluginMessage(lParam, TRUE);

 				}

 				break;

 			case DSPNM_LCD_TEXT_SCROLL_DONE:

 				{

 				//TRACE(_T("LCD Text Scroll Finished.\n"));

 				}

 				break;

 			}

 		return 0;

 		break;

 	default:

 		return DefWindowProc(hWnd, message, wParam, lParam);

 	}

 	return 0;

 }

 // Message handler for about box.

 INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)

 {

 	UNREFERENCED_PARAMETER(lParam);

 	switch (message)

 	{

 	case WM_INITDIALOG:

 		return (INT_PTR)TRUE;

 	case WM_COMMAND:

 		if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)

 		{

 			EndDialog(hDlg, LOWORD(wParam));

 			return (INT_PTR)TRUE;

 		}

 		break;

 	}

 	return (INT_PTR)FALSE;

 }