// 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 WM_IMON_DISPLAY_SET_VFD_TEXT	WM_APP + 1105

 //

 #define MAX_LOADSTRING 100

 const int BUFFER_SIZE = 256;

 // 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 gPipeNameInbound = TEXT("\\\\.\\pipe\\sga-inbound"); 

 LPTSTR gPipeNameOutbound = TEXT("\\\\.\\pipe\\sga-outbound"); 

 HANDLE gPipeInbound=INVALID_HANDLE_VALUE;

 HANDLE gPipeOutbound=INVALID_HANDLE_VALUE;

 char gBufferReceiver[256];

 char gBufferSender[256];

 //

 char gTextFirstLine[256];

 char gTextSecondLine[256];

 wchar_t gTextFirstLine16[256];

 wchar_t gTextSecondLine16[256];

 //

 HWND gWnd;

 //

 BOOL m_bVfdConnected;

 BOOL m_bLcdConnected;

 BOOL m_IsInit=FALSE;

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

 const char KMsgSetVfdText[]="set-vfd-text:";

 const char KMsgQuit[]="quit:";

 /**

 Create inbound pipe to receive messages.

 */

 bool CreateInboundPipe()

 	{

 	gPipeInbound = CreateNamedPipe(gPipeNameInbound, PIPE_ACCESS_INBOUND, PIPE_TYPE_BYTE, PIPE_UNLIMITED_INSTANCES, BUFFER_SIZE, BUFFER_SIZE, 0, NULL);

 	//could not create named pipe

     if (gPipeInbound==INVALID_HANDLE_VALUE)

         return false;

     //Will complete once a client connects

     int success = ConnectNamedPipe(gPipeInbound, NULL);

     //could not connect client

     if (success == 0)

         return false;

 	return true;

 	}

 /**

 Create outbound pipe to send message

 */

 bool CreateOutboundPipe()

 	{

 	gPipeOutbound = CreateNamedPipe(gPipeNameOutbound, PIPE_ACCESS_OUTBOUND /*| FILE_FLAG_OVERLAPPED*/, PIPE_TYPE_BYTE, PIPE_UNLIMITED_INSTANCES, BUFFER_SIZE, BUFFER_SIZE, 0, NULL);

 	//could not create named pipe

     if (gPipeOutbound==INVALID_HANDLE_VALUE)

         return false;

     //Will complete once a client connects

     int success = ConnectNamedPipe(gPipeOutbound, NULL);

     //could not connect client

     if (success == 0)

         return false;

 	return true;

 	}

 /**

 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(gPipeOutbound, aResponse, strlen(aResponse), &cbWritten, NULL);

 	if (strlen(aResponse)!=cbWritten)

 		{

 		int err = GetLastError();

 		OutputDebugStringA("ERROR: WriteFile failure!\n");

 		}

 	}

 /**

 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 if (strcmp(aMsg,KMsgQuit)==0)

 		{

 		//gQuit=TRUE;

 		SendMessageToServer(KRspDone);

 		DestroyWindow(gWnd);

 		}

 	else if (strstr(aMsg,KMsgSetVfdText)==aMsg)

 		{

 		int textLen=strlen(aMsg)-strlen(KMsgSetVfdText);

 		strncpy(gTextFirstLine,aMsg+strlen(KMsgSetVfdText),textLen);

 		gTextFirstLine[textLen]='\0';

 		//Check if we have a second line

 		char* ptr=strchr(gTextFirstLine,'\n');

 		if (ptr!=NULL)

 			{

 			*ptr='\0'; //Terminate our first line here

 			ptr++;

 			//Get our second line

 			textLen=strlen(ptr);

 			strncpy(gTextSecondLine,ptr,textLen);

 			gTextSecondLine[textLen]='\0';

 			}

 		else

 			{

 			//No second line specified

 			gTextSecondLine[0]='\0';

 			gTextSecondLine16[0]='\0';

 			}

 		//Convert first line

 		OutputDebugStringA(gTextFirstLine);

 		//int convertedChars = MultiByteToWideChar(CP_UTF8, 0, gTextFirstLine, -1, gTextFirstLine16, sizeof(gTextFirstLine16));

 		for (int i=0;i<=strlen(gTextFirstLine);i++)

 			{

 			unsigned char myChar=(unsigned char)gTextFirstLine[i];

 			gTextFirstLine16[i]=myChar;

 			}

 		OutputDebugStringW(gTextFirstLine16);

 		//Convert second line

 		OutputDebugStringA(gTextSecondLine);

 		//convertedChars = MultiByteToWideChar(CP_UTF8, 0, gTextSecondLine, -1, gTextSecondLine16, sizeof(gTextSecondLine16));

 		for (int i=0;i<=strlen(gTextSecondLine);i++)

 			{

 			unsigned char myChar=(unsigned char)gTextSecondLine[i];

 			gTextSecondLine16[i]=myChar;

 			}

 		OutputDebugStringW(gTextSecondLine16);

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

 		SendMessageToServer(KRspPending);

 		if (!m_IsInit)

 			{

 			PostMessage(gWnd,WM_IMON_INIT,0,0);		

 			}

 		PostMessage(gWnd,WM_IMON_DISPLAY_SET_VFD_TEXT,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 (gPipeInbound==INVALID_HANDLE_VALUE && !gQuit)

 		{

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

 		gPipeInbound=CreateFile(gPipeNameInbound,	GENERIC_READ ,0,NULL,OPEN_EXISTING,0,NULL);

 		Sleep(1000);

 		}

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

 	//Now try connecting on our write pipe

 	gPipeOutbound=CreateFile(gPipeNameOutbound,	GENERIC_WRITE ,0,NULL,OPEN_EXISTING,0,NULL);

 	if (gPipeOutbound==INVALID_HANDLE_VALUE)

 		{

 		int err=GetLastError();

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

 		//gQuit=TRUE;

 		}

 	else

 		{

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

 		OutputDebugStringA("Connected.\n");

 		SendMessageToServer(KRspOpen);

 		}

 	//

 	*/

 	CreateOutboundPipe();

 	CreateInboundPipe();

 	while(!gQuit)

 		{

 		DWORD cbRead;

 		BOOL success=ReadFile(gPipeInbound,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

 	DisconnectNamedPipe(gPipeInbound);

 	CloseHandle(gPipeInbound);

 	gPipeInbound=INVALID_HANDLE_VALUE;

 	DisconnectNamedPipe(gPipeOutbound);

 	CloseHandle(gPipeOutbound);	

 	gPipeOutbound=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);

 	gTextFirstLine[0]='\0';

 	gTextSecondLine[0]='\0';

 	gTextFirstLine16[0]='\0';

 	gTextSecondLine16[0]='\0';

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

 			}

 		m_IsInit=TRUE;

 		}

 	//

 	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 (gPipeOutbound!=INVALID_HANDLE_VALUE)

 			{

 			DisconnectNamedPipe(gPipeOutbound);

 			CloseHandle(gPipeOutbound);

 			gPipeOutbound=INVALID_HANDLE_VALUE;

 			}

 		//To complete read op

 		if (gPipeInbound!=INVALID_HANDLE_VALUE)

 			{

 			DisconnectNamedPipe(gPipeInbound);

 			CloseHandle(gPipeInbound);

 			gPipeInbound=INVALID_HANDLE_VALUE;

 			}

 		WaitForSingleObject(gThreadReceiver,INFINITE);

 		CloseHandle(gThreadReceiver);

 		//IMON_Display_Uninit();

 		PostQuitMessage(0);

 		break;

 	case WM_IMON_UNINIT:

 		m_IsInit=FALSE;

 		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_IMON_DISPLAY_SET_VFD_TEXT:

 #ifdef _UNICODE

 		if (DSP_SUCCEEDED==IMON_Display_SetVfdText(gTextFirstLine16,gTextSecondLine16))

 #else

 		if (DSP_SUCCEEDED==IMON_Display_SetVfdText(gTextFirstLine,gTextSecondLine))

 #endif

 			{

 			SendMessageToServer(KRspDone);

 			}

 		else

 			{

 			SendMessageToServer(KRspError);

 			}

 		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;

 }