git.zerfleddert.de Git - linexec-j720/blob - tester1.cpp

   1 // tester1.cpp : Defines the entry point for the application.
   2 //
   3
   4 #include "stdafx.h"
   5 #include "tester1.h"
   6 #include <commctrl.h>
   7 //#include <aygshell.h>
   8 #include <sipapi.h>
   9 #include "setup.h"
  10
  11 #define MAX_LOADSTRING 100
  12
  13 // Global Variables:
  14 HINSTANCE                       hInst;                                  // The current instance
  15 HWND                            hwndCB;                                 // The command bar handle
  16
  17 //static SHACTIVATEINFO s_sai;
  18
  19 ATOM                            MyRegisterClass (HINSTANCE, LPTSTR);
  20 BOOL                            InitInstance    (HINSTANCE, int);
  21 LRESULT CALLBACK        WndProc                 (HWND, UINT, WPARAM, LPARAM);
  22 LRESULT CALLBACK        About                   (HWND, UINT, WPARAM, LPARAM);
  23 HWND                            CreateRpCommandBar(HWND);
  24
  25
  26 #pragma warning(disable: 4100 4710 4189; error: 4701)
  27 /* who cares?!
  28         4100: whining about parameters not being used.
  29         4710: whining about screwing up inlining.
  30         4189: initialized but not used. make that an error: later.
  31         4701: usage w/o initialization.
  32         */
  33
  34 int WINAPI WinMain(     HINSTANCE hInstance,
  35                                         HINSTANCE hPrevInstance,
  36                                         LPTSTR    lpCmdLine,
  37                                         int       nCmdShow)
  38 {
  39         MSG msg;
  40         HACCEL hAccelTable;
  41
  42         // Perform application initialization:
  43         if (!InitInstance (hInstance, nCmdShow))
  44         {
  45                 return FALSE;
  46         }
  47
  48         hAccelTable = LoadAccelerators(hInstance, (LPCTSTR)IDC_TESTER1);
  49
  50         // Main message loop:
  51         while (GetMessage(&msg, NULL, 0, 0))
  52         {
  53                 if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
  54                 {
  55                         TranslateMessage(&msg);
  56                         DispatchMessage(&msg);
  57                 }
  58         }
  59
  60         return msg.wParam;
  61 }
  62
  63 //
  64 //  FUNCTION: MyRegisterClass()
  65 //
  66 //  PURPOSE: Registers the window class.
  67 //
  68 //  COMMENTS:
  69 //
  70 //    It is important to call this function so that the application
  71 //    will get 'well formed' small icons associated with it.
  72 //
  73 ATOM MyRegisterClass(HINSTANCE hInstance, LPTSTR szWindowClass)
  74 {
  75         WNDCLASS        wc;
  76
  77     wc.style                    = CS_HREDRAW | CS_VREDRAW;
  78     wc.lpfnWndProc              = (WNDPROC) WndProc;
  79     wc.cbClsExtra               = 0;
  80     wc.cbWndExtra               = 0;
  81     wc.hInstance                = hInstance;
  82     wc.hIcon                    = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_TESTER1));
  83     wc.hCursor                  = 0;
  84     wc.hbrBackground    = (HBRUSH) GetStockObject(WHITE_BRUSH);
  85     wc.lpszMenuName             = 0;
  86     wc.lpszClassName    = szWindowClass;
  87
  88         return RegisterClass(&wc);
  89 }
  90
  91 HANDLE OpenCOM1() {
  92
  93         static HANDLE COM1handle = INVALID_HANDLE_VALUE;
  94         const char msg[] = "\r\n--------linexec--------\r\n";
  95         unsigned long wrote;
  96         int speed = CBR_115200;
  97         HANDLE h;
  98
  99         if (COM1handle != INVALID_HANDLE_VALUE)
 100                 return (COM1handle);
 101
 102         h = CreateFile(TEXT("COM1:"),
 103             GENERIC_READ | GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0,
 104             NULL);
 105         if (h == INVALID_HANDLE_VALUE)
 106                 return (h);
 107
 108         DCB dcb;
 109         if (!GetCommState(h, &dcb))
 110                 goto bad;
 111
 112         dcb.BaudRate = speed;
 113         if (!SetCommState(h, &dcb))
 114                 goto bad;
 115
 116         // Print banner on serial console.
 117         WriteFile(h, msg, sizeof msg, &wrote, 0);
 118
 119         COM1handle = h;
 120
 121         return (h);
 122  bad:
 123         CloseHandle(h);
 124         return (INVALID_HANDLE_VALUE);
 125 }
 126
 127 //
 128 //  FUNCTION: InitInstance(HANDLE, int)
 129 //
 130 //  PURPOSE: Saves instance handle and creates main window
 131 //
 132 //  COMMENTS:
 133 //
 134 //    In this function, we save the instance handle in a global variable and
 135 //    create and display the main program window.
 136 //
 137
 138 BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
 139 {
 140         HWND    hWnd = NULL;
 141         TCHAR   szTitle[MAX_LOADSTRING];                        // The title bar text
 142         TCHAR   szWindowClass[MAX_LOADSTRING];          // The window class name
 143
 144         hInst = hInstance;              // Store instance handle in our global variable
 145         // Initialize global string
 146         LoadString(hInstance, IDC_TESTER1, szWindowClass, MAX_LOADSTRING);
 147         LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
 148
 149         //If it is already running, then focus on the window
 150         hWnd = FindWindow(szWindowClass, szTitle);
 151         if (hWnd)
 152         {
 153                 SetForegroundWindow ((HWND) (((DWORD)hWnd) | 0x01));
 154                 return 0;
 155         }
 156
 157         MyRegisterClass(hInstance, szWindowClass);
 158
 159         RECT    rect;
 160         GetClientRect(hWnd, &rect);
 161
 162         OpenCOM1();
 163         load_boot("\\My Documents\\params.txt");
 164         load_boot("\\Storage Card\\params.txt");
 165         load_boot("\\ÒÓØ ¶°ÄÞ\\params.txt");
 166
 167         hWnd = CreateWindow(szWindowClass, szTitle, WS_VISIBLE,
 168                 CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL);
 169         if (!hWnd)
 170         {
 171                 return FALSE;
 172         }
 173
 174
 175
 176         //When the main window is created using CW_USEDEFAULT the height of the menubar (if one
 177         // is created is not taken into account). So we resize the window after creating it
 178         // if a menubar is present
 179         {
 180                 RECT rc;
 181                 GetWindowRect(hWnd, &rc);
 182                 rc.bottom -= MENU_HEIGHT;
 183                 if (hwndCB)
 184                         MoveWindow(hWnd, rc.left, rc.top, rc.right, rc.bottom, FALSE);
 185         }
 186
 187
 188         ShowWindow(hWnd, nCmdShow);
 189         UpdateWindow(hWnd);
 190
 191         return TRUE;
 192 }
 193
 194 //
 195 //  FUNCTION: WndProc(HWND, unsigned, WORD, LONG)
 196 //
 197 //  PURPOSE:  Processes messages for the main window.
 198 //
 199 //  WM_COMMAND  - process the application menu
 200 //  WM_PAINT    - Paint the main window
 201 //  WM_DESTROY  - post a quit message and return
 202 //
 203 //
 204 LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 205 {
 206
 207         HDC hdc;
 208
 209         int wmId, wmEvent;
 210
 211         PAINTSTRUCT ps;
 212
 213         TCHAR szHello[MAX_LOADSTRING];
 214
 215
 216
 217         switch (message)
 218
 219         {
 220
 221                 case WM_COMMAND:
 222
 223                         wmId    = LOWORD(wParam);
 224
 225                         wmEvent = HIWORD(wParam);
 226
 227                         // Parse the menu selections:
 228
 229                         switch (wmId)
 230
 231                         {
 232
 233                                 case IDM_HELP_ABOUT:
 234
 235                                         DialogBox(hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, (DLGPROC)About);
 236
 237                                     break;
 238
 239                                 case IDOK:
 240
 241                                         SendMessage(hWnd, WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, 0), (LPARAM)hWnd);
 242
 243                                         SendMessage (hWnd, WM_CLOSE, 0, 0);
 244
 245                                         break;
 246
 247                                 default:
 248
 249                                    return DefWindowProc(hWnd, message, wParam, lParam);
 250
 251                         }
 252
 253                         break;
 254
 255                 case WM_CREATE:
 256
 257                         hwndCB = CreateRpCommandBar(hWnd);
 258
 259                         break;
 260
 261                 case WM_PAINT:
 262
 263                         RECT rt;
 264
 265                         hdc = BeginPaint(hWnd, &ps);
 266
 267                         GetClientRect(hWnd, &rt);
 268
 269                         LoadString(hInst, IDS_HELLO, szHello, MAX_LOADSTRING);
 270
 271                         DrawText(hdc, szHello, _tcslen(szHello), &rt,
 272
 273                                 DT_SINGLELINE | DT_VCENTER | DT_CENTER);
 274
 275                         EndPaint(hWnd, &ps);
 276
 277                         break;
 278
 279                 case WM_DESTROY:
 280
 281                         CommandBar_Destroy(hwndCB);
 282
 283                         PostQuitMessage(0);
 284
 285                         break;
 286
 287                 case WM_SETTINGCHANGE:
 288
 289 //                      SHHandleWMSettingChange(hWnd, wParam, lParam, &s_sai);
 290
 291                 break;
 292
 293                 default:
 294
 295                         return DefWindowProc(hWnd, message, wParam, lParam);
 296
 297    }
 298
 299    return 0;
 300
 301 }
 302
 303
 304
 305 HWND CreateRpCommandBar(HWND hwnd)
 306
 307 {
 308 /*
 309         SHMENUBARINFO mbi;
 310
 311
 312
 313         memset(&mbi, 0, sizeof(SHMENUBARINFO));
 314
 315         mbi.cbSize     = sizeof(SHMENUBARINFO);
 316
 317         mbi.hwndParent = hwnd;
 318
 319         mbi.nToolBarId = IDM_MENU;
 320
 321         mbi.hInstRes   = hInst;
 322
 323         mbi.nBmpId     = 0;
 324
 325         mbi.cBmpImages = 0;
 326
 327
 328
 329         if (!SHCreateMenuBar(&mbi))
 330
 331                 return NULL;
 332
 333
 334
 335         return mbi.hwndMB;
 336 */
 337         return NULL;
 338 }
 339
 340
 341
 342 // Mesage handler for the About box.
 343
 344 LRESULT CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
 345
 346 {
 347
 348 //      SHINITDLGINFO shidi;
 349
 350
 351
 352         switch (message)
 353
 354         {
 355
 356                 case WM_INITDIALOG:
 357
 358                         // Create a Done button and size it.
 359
 360 //                      shidi.dwMask = SHIDIM_FLAGS;
 361
 362 //                       shidi.dwFlags = SHIDIF_DONEBUTTON | SHIDIF_SIPDOWN | SHIDIF_SIZEDLGFULLSCREEN;
 363
 364 //                      shidi.hDlg = hDlg;
 365
 366 //                      SHInitDialog(&shidi);
 367
 368                         return TRUE;
 369
 370
 371
 372                 case WM_COMMAND:
 373
 374                         if (LOWORD(wParam) == IDOK) {
 375
 376                                 EndDialog(hDlg, LOWORD(wParam));
 377
 378                                 return TRUE;
 379
 380                         }
 381
 382                         break;
 383
 384         }
 385
 386     return FALSE;
 387
 388 }
 389