[linexec-j720] / tester1.cpp

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

#include "stdafx.h"
#include "tester1.h"
#include <commctrl.h>
//#include <aygshell.h>
#include <sipapi.h>
#include "setup.h"

#define MAX_LOADSTRING 100

// Global Variables:
HINSTANCE                       hInst;                                  // The current instance
HWND                            hwndCB;                                 // The command bar handle

//static SHACTIVATEINFO s_sai;

ATOM                            MyRegisterClass (HINSTANCE, LPTSTR);
BOOL                            InitInstance    (HINSTANCE, int);
LRESULT CALLBACK        WndProc                 (HWND, UINT, WPARAM, LPARAM);
LRESULT CALLBACK        About                   (HWND, UINT, WPARAM, LPARAM);
HWND                            CreateRpCommandBar(HWND);


#pragma warning(disable: 4100 4710 4189; error: 4701)
/* who cares?! 
        4100: whining about parameters not being used.
        4710: whining about screwing up inlining.
        4189: initialized but not used. make that an error: later.
        4701: usage w/o initialization.
        */

int WINAPI WinMain(     HINSTANCE hInstance,
                                        HINSTANCE hPrevInstance,
                                        LPTSTR    lpCmdLine,
                                        int       nCmdShow)
{
        MSG msg;
        HACCEL hAccelTable;

        // Perform application initialization:
        if (!InitInstance (hInstance, nCmdShow)) 
        {
                return FALSE;
        }

        hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_TESTER1);

        // Main message loop:
        while (GetMessage(&msg, NULL, 0, 0)) 
        {
                if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) 
                {
                        TranslateMessage(&msg);
                        DispatchMessage(&msg);
                }
        }

        return msg.wParam;
}

//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
//  COMMENTS:
//
//    It is important to call this function so that the application 
//    will get 'well formed' small icons associated with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance, LPTSTR szWindowClass)
{
        WNDCLASS        wc;

    wc.style                    = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc              = (WNDPROC) WndProc;
    wc.cbClsExtra               = 0;
    wc.cbWndExtra               = 0;
    wc.hInstance                = hInstance;
    wc.hIcon                    = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_TESTER1));
    wc.hCursor                  = 0;
    wc.hbrBackground    = (HBRUSH) GetStockObject(WHITE_BRUSH);
    wc.lpszMenuName             = 0;
    wc.lpszClassName    = szWindowClass;

        return RegisterClass(&wc);
}

HANDLE OpenCOM1() {

        static HANDLE COM1handle = INVALID_HANDLE_VALUE;
        const char msg[] = "\r\n--------linexec--------\r\n";
        unsigned long wrote;
        int speed = CBR_115200;
        HANDLE h;

        if (COM1handle != INVALID_HANDLE_VALUE)
                return (COM1handle);

        h = CreateFile(TEXT("COM1:"),
            GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0,
            NULL);
        if (h == INVALID_HANDLE_VALUE)
                return (h);

        DCB dcb;
        if (!GetCommState(h, &dcb))
                goto bad;

        dcb.BaudRate = speed;
        if (!SetCommState(h, &dcb))
                goto bad;

        // Print banner on serial console.
        WriteFile(h, msg, sizeof msg, &wrote, 0);

        COM1handle = h;

        return (h);
 bad:
        CloseHandle(h);
        return (INVALID_HANDLE_VALUE);
}

//
//  FUNCTION: InitInstance(HANDLE, 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)
{
        HWND    hWnd = NULL;
        TCHAR   szTitle[MAX_LOADSTRING];                        // The title bar text
        TCHAR   szWindowClass[MAX_LOADSTRING];          // The window class name

        hInst = hInstance;              // Store instance handle in our global variable
        // Initialize global string
        LoadString(hInstance, IDC_TESTER1, szWindowClass, MAX_LOADSTRING);
        LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);

        //If it is already running, then focus on the window
        hWnd = FindWindow(szWindowClass, szTitle);      
        if (hWnd) 
        {
                SetForegroundWindow ((HWND) (((DWORD)hWnd) | 0x01));    
                return 0;
        } 

        MyRegisterClass(hInstance, szWindowClass);
        
        RECT    rect;
        GetClientRect(hWnd, &rect);

        OpenCOM1();
        load_boot("\\My Documents\\params.txt");
        load_boot("\\Storage Card\\params.txt");
        load_boot("\\ÒÓØ ¶°ÄÞ\\params.txt");

        hWnd = CreateWindow(szWindowClass, szTitle, WS_VISIBLE,
                CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL);
        if (!hWnd)
        {       
                return FALSE;
        }

        
        
        //When the main window is created using CW_USEDEFAULT the height of the menubar (if one
        // is created is not taken into account). So we resize the window after creating it
        // if a menubar is present
        {
                RECT rc;
                GetWindowRect(hWnd, &rc);
                rc.bottom -= MENU_HEIGHT;
                if (hwndCB)
                        MoveWindow(hWnd, rc.left, rc.top, rc.right, rc.bottom, FALSE);
        }


        ShowWindow(hWnd, nCmdShow);
        UpdateWindow(hWnd);

        return TRUE;
}

//
//  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
//
//  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)
{

        HDC hdc;

        int wmId, wmEvent;

        PAINTSTRUCT ps;

        TCHAR szHello[MAX_LOADSTRING];



        switch (message) 

        {

                case WM_COMMAND:

                        wmId    = LOWORD(wParam); 

                        wmEvent = HIWORD(wParam); 

                        // Parse the menu selections:

                        switch (wmId)

                        {       

                                case IDM_HELP_ABOUT:

                                        DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);

                                    break;

                                case IDOK:

                                        SendMessage(hWnd, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), (LPARAM)hWnd);

                                        SendMessage (hWnd, WM_CLOSE, 0, 0);

                                        break;

                                default:

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

                        }

                        break;

                case WM_CREATE:

                        hwndCB = CreateRpCommandBar(hWnd);

                        break;

                case WM_PAINT:

                        RECT rt;

                        hdc = BeginPaint(hWnd, &ps);

                        GetClientRect(hWnd, &rt);

                        LoadString(hInst, IDS_HELLO, szHello, MAX_LOADSTRING);

                        DrawText(hdc, szHello, _tcslen(szHello), &rt, 

                                DT_SINGLELINE | DT_VCENTER | DT_CENTER);

                        EndPaint(hWnd, &ps);

                        break; 

                case WM_DESTROY:

                        CommandBar_Destroy(hwndCB);

                        PostQuitMessage(0);

                        break;

                case WM_SETTINGCHANGE:

//                      SHHandleWMSettingChange(hWnd, wParam, lParam, &s_sai);

                break;

                default:

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

   }

   return 0;

}



HWND CreateRpCommandBar(HWND hwnd)

{
/*
        SHMENUBARINFO mbi;



        memset(&mbi, 0, sizeof(SHMENUBARINFO));

        mbi.cbSize     = sizeof(SHMENUBARINFO);

        mbi.hwndParent = hwnd;

        mbi.nToolBarId = IDM_MENU;

        mbi.hInstRes   = hInst;

        mbi.nBmpId     = 0;

        mbi.cBmpImages = 0;



        if (!SHCreateMenuBar(&mbi)) 

                return NULL;



        return mbi.hwndMB;
*/
        return NULL;
}



// Mesage handler for the About box.

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

{

//      SHINITDLGINFO shidi;



        switch (message)

        {

                case WM_INITDIALOG:

                        // Create a Done button and size it.  

//                      shidi.dwMask = SHIDIM_FLAGS;

//                       shidi.dwFlags = SHIDIF_DONEBUTTON | SHIDIF_SIPDOWN | SHIDIF_SIZEDLGFULLSCREEN;

//                      shidi.hDlg = hDlg;

//                      SHInitDialog(&shidi);

                        return TRUE; 



                case WM_COMMAND:

                        if (LOWORD(wParam) == IDOK) {

                                EndDialog(hDlg, LOWORD(wParam));

                                return TRUE;

                        }

                        break;

        }

    return FALSE;

}