Create a branch for header work.
[reactos.git] / base / applications / mplay32 / mplay32.c
1 /*
2 * PROJECT: ReactOS Multimedia Player
3 * FILE: base\applications\mplay32\mplay32.c
4 * PROGRAMMERS: Dmitry Chapyshev (dmitry@reactos.org)
5 */
6
7 #include "mplay32.h"
8
9 #define MAIN_WINDOW_HEIGHT 125
10 #define MAIN_WINDOW_MIN_WIDTH 250
11
12 HINSTANCE hInstance = NULL;
13 HWND hTrackBar = NULL;
14 HWND hToolBar = NULL;
15 TCHAR szAppTitle[256] = _T("");
16 TCHAR szPrevFile[MAX_PATH] = _T("\0");
17 WORD wDeviceId;
18 BOOL bIsOpened = FALSE;
19 BOOL bIsPaused = FALSE;
20 UINT MaxFilePos = 0;
21
22 /* Known types table */
23 static const TYPEBYEXT ExtTypes[] =
24 {
25 { _T(".wav"), WAVE_FILE },
26 { _T(".wave"), WAVE_FILE },
27 { _T(".mid"), MIDI_FILE },
28 { _T(".midi"), MIDI_FILE },
29 { _T(".cda"), AUDIOCD_FILE },
30 { _T(".avi"), AVI_FILE },
31 { _T("\0"), 0 }
32 };
33
34 /* ToolBar Buttons */
35 static const TBBUTTON Buttons[] =
36 { /* iBitmap, idCommand, fsState, fsStyle, bReserved[2], dwData, iString */
37 {TBICON_PLAY, IDC_PLAY, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0},
38 {TBICON_STOP, IDC_STOP, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0},
39 {TBICON_EJECT, IDC_EJECT, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0},
40 {15, 0, TBSTATE_ENABLED, BTNS_SEP, {0}, 0, 0},
41 {TBICON_BACKWARD, IDC_BACKWARD, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0},
42 {TBICON_SEEKBACK, IDC_SEEKBACK, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0},
43 {TBICON_SEEKFORW, IDC_SEEKFORW, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0},
44 {TBICON_FORWARD, IDC_FORWARD, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0}
45 };
46
47 static VOID
48 SetImageList(HWND hwnd)
49 {
50 HIMAGELIST hImageList;
51
52 hImageList = ImageList_Create(16, 16, ILC_MASK | ILC_COLOR24, 1, 1);
53
54 if (!hImageList)
55 {
56 MessageBox(hwnd, _T("ImageList it is not created!"), NULL, MB_OK);
57 return;
58 }
59
60 ImageList_AddMasked(hImageList,
61 LoadImage(hInstance, MAKEINTRESOURCE(IDB_PLAYICON), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR),
62 RGB(255, 255, 255));
63
64 ImageList_AddMasked(hImageList,
65 LoadImage(hInstance, MAKEINTRESOURCE(IDB_STOPICON), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR),
66 RGB(255, 255, 255));
67
68 ImageList_AddMasked(hImageList,
69 LoadImage(hInstance, MAKEINTRESOURCE(IDB_EJECTICON), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR),
70 RGB(255, 255, 255));
71
72 ImageList_AddMasked(hImageList,
73 LoadImage(hInstance, MAKEINTRESOURCE(IDB_BACKWARDICON), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR),
74 RGB(255, 255, 255));
75
76 ImageList_AddMasked(hImageList,
77 LoadImage(hInstance, MAKEINTRESOURCE(IDB_SEEKBACKICON), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR),
78 RGB(255, 255, 255));
79
80 ImageList_AddMasked(hImageList,
81 LoadImage(hInstance, MAKEINTRESOURCE(IDB_SEEKFORWICON), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR),
82 RGB(255, 255, 255));
83
84 ImageList_AddMasked(hImageList,
85 LoadImage(hInstance, MAKEINTRESOURCE(IDB_FORWARDICON), IMAGE_BITMAP, 16, 16, LR_DEFAULTCOLOR),
86 RGB(255, 255, 255));
87
88 ImageList_Destroy((HIMAGELIST)SendMessage(hToolBar,
89 TB_SETIMAGELIST,
90 0,
91 (LPARAM)hImageList));
92 }
93
94 static VOID
95 InitControls(HWND hwnd)
96 {
97 INT NumButtons = sizeof(Buttons) / sizeof(Buttons[0]);
98
99 InitCommonControls();
100
101 /* Create trackbar */
102 hTrackBar = CreateWindowEx(0,
103 TRACKBAR_CLASS,
104 NULL,
105 TBS_ENABLESELRANGE | WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_CLIPSIBLINGS,
106 0,
107 0,
108 340,
109 20,
110 hwnd,
111 NULL,
112 hInstance,
113 NULL);
114 if (!hTrackBar)
115 {
116 MessageBox(hwnd, _T("TrackBar it is not created!"), NULL, MB_OK);
117 return;
118 }
119
120 /* Create toolbar */
121 hToolBar = CreateWindowEx(0,
122 TOOLBARCLASSNAME,
123 NULL,
124 WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_CLIPSIBLINGS |
125 TBSTYLE_FLAT | CCS_BOTTOM | TBSTYLE_TOOLTIPS,
126 0,
127 40,
128 340,
129 30,
130 hwnd,
131 NULL,
132 hInstance,
133 NULL);
134 if (!hToolBar)
135 {
136 MessageBox(hwnd, _T("ToolBar it is not created!"), NULL, MB_OK);
137 return;
138 }
139
140 SetImageList(hwnd);
141 SendMessage(hToolBar, TB_ADDBUTTONS, NumButtons, (LPARAM)Buttons);
142 }
143
144 static UINT
145 IsSupportedFileExtension(LPTSTR lpFileName)
146 {
147 TCHAR szExt[MAX_PATH];
148 INT DotPos = 0, i, j;
149
150 for (i = _tcslen(lpFileName); i >= 0; --i)
151 {
152 if (lpFileName[i] == '.')
153 {
154 DotPos = _tcslen(lpFileName) - i;
155 break;
156 }
157 }
158
159 if (!DotPos) return UNSUPPORTED_FILE;
160
161 szExt[DotPos + 1] = _T('\0');
162 for (i = _tcslen(lpFileName), j = DotPos; j >= 0; --i, --j)
163 {
164 szExt[j] = lpFileName[i];
165 }
166
167 for (i = 0; ; i++)
168 {
169 if (ExtTypes[i].uType == UNSUPPORTED_FILE)
170 {
171 return UNSUPPORTED_FILE;
172 }
173
174 if (_tcscmp(ExtTypes[i].szExt, szExt) == 0)
175 {
176 return ExtTypes[i].uType;
177 }
178 }
179
180 return UNSUPPORTED_FILE;
181 }
182
183 static DWORD
184 CloseMciDevice(VOID)
185 {
186 MCI_GENERIC_PARMS mciGeneric;
187 DWORD dwError;
188
189 if (bIsOpened)
190 {
191 dwError = mciSendCommand(wDeviceId, MCI_CLOSE, MCI_WAIT, (DWORD_PTR)&mciGeneric);
192 if (dwError) return dwError;
193 bIsOpened = FALSE;
194 }
195
196 return TRUE;
197 }
198
199 static DWORD
200 OpenMciDevice(HWND hwnd, LPTSTR lpType, LPTSTR lpFileName)
201 {
202 MCI_STATUS_PARMS mciStatus;
203 MCI_OPEN_PARMS mciOpen;
204 TCHAR szNewTitle[MAX_PATH];
205 DWORD dwError;
206
207 if (bIsOpened)
208 {
209 CloseMciDevice();
210 }
211
212 mciOpen.lpstrDeviceType = lpType;
213 mciOpen.lpstrElementName = lpFileName;
214 mciOpen.dwCallback = 0;
215 mciOpen.wDeviceID = 0;
216 mciOpen.lpstrAlias = NULL;
217
218 dwError = mciSendCommand(0, MCI_OPEN, MCI_OPEN_TYPE | MCI_OPEN_ELEMENT | MCI_WAIT, (DWORD_PTR)&mciOpen);
219 if (dwError != 0)
220 {
221 MessageBox(0, _T("Can't open device! (1)"), NULL, MB_OK);
222 return dwError;
223 }
224
225 mciStatus.dwItem = MCI_STATUS_LENGTH;
226
227 dwError = mciSendCommand(mciOpen.wDeviceID, MCI_STATUS, MCI_STATUS_ITEM | MCI_WAIT, (DWORD_PTR)&mciStatus);
228 if (dwError != 0)
229 {
230 MessageBox(0, _T("Can't open device! (2)"), NULL, MB_OK);
231 return dwError;
232 }
233
234 SendMessage(hTrackBar, TBM_SETRANGE, (WPARAM) TRUE, (LPARAM) MAKELONG(1, mciStatus.dwReturn));
235 SendMessage(hTrackBar, TBM_SETPAGESIZE, 0, 10);
236 SendMessage(hTrackBar, TBM_SETLINESIZE, 0, 1);
237 SendMessage(hTrackBar, TBM_SETPOS, (WPARAM) TRUE, (LPARAM) 1);
238
239 if (mciStatus.dwReturn < 10000)
240 {
241 SendMessage(hTrackBar, TBM_SETTICFREQ, (WPARAM) 100, (LPARAM) 0);
242 }
243 else if (mciStatus.dwReturn < 100000)
244 {
245 SendMessage(hTrackBar, TBM_SETTICFREQ, (WPARAM) 1000, (LPARAM) 0);
246 }
247 else if (mciStatus.dwReturn < 1000000)
248 {
249 SendMessage(hTrackBar, TBM_SETTICFREQ, (WPARAM) 10000, (LPARAM) 0);
250 }
251 else
252 {
253 SendMessage(hTrackBar, TBM_SETTICFREQ, (WPARAM) 100000, (LPARAM) 0);
254 }
255
256 _stprintf(szNewTitle, _T("%s - %s"), szAppTitle, lpFileName);
257 SetWindowText(hwnd, szNewTitle);
258
259 MaxFilePos = mciStatus.dwReturn;
260 wDeviceId = mciOpen.wDeviceID;
261 bIsOpened = TRUE;
262 _tcscpy(szPrevFile, lpFileName);
263 return TRUE;
264 }
265
266 static VOID
267 StopPlayback(HWND hwnd)
268 {
269 if (bIsOpened)
270 {
271 SendMessage(hTrackBar, TBM_SETPOS, (WPARAM) TRUE, (LPARAM) 1);
272 KillTimer(hwnd, IDT_PLAYTIMER);
273 CloseMciDevice();
274 }
275 }
276
277 static VOID
278 SeekPlayback(HWND hwnd, DWORD dwNewPos)
279 {
280 MCI_SEEK_PARMS mciSeek;
281 MCI_PLAY_PARMS mciPlay;
282 DWORD dwError;
283
284 if (bIsOpened)
285 {
286 mciSeek.dwTo = (DWORD_PTR)dwNewPos;
287 dwError = mciSendCommand(wDeviceId, MCI_SEEK, MCI_WAIT | MCI_TO, (DWORD_PTR)&mciSeek);
288 if (dwError != 0)
289 {
290 MessageBox(hwnd, _T("SeekPlayback: Can't seek!"), NULL, MB_OK);
291 }
292
293 mciPlay.dwCallback = (DWORD_PTR)hwnd;
294 dwError = mciSendCommand(wDeviceId, MCI_PLAY, MCI_NOTIFY, (DWORD_PTR)&mciPlay);
295 if (dwError != 0)
296 {
297 MessageBox(hwnd, _T("SeekPlayback: Can't play!"), NULL, MB_OK);
298 }
299 }
300 }
301
302 static VOID
303 SeekBackPlayback(HWND hwnd)
304 {
305 MCI_STATUS_PARMS mciStatus;
306 DWORD dwNewPos;
307
308 if (!bIsOpened) return;
309
310 mciStatus.dwItem = MCI_STATUS_POSITION;
311 mciSendCommand(wDeviceId, MCI_STATUS, MCI_STATUS_ITEM, (DWORD_PTR)&mciStatus);
312
313 dwNewPos = mciStatus.dwReturn - 1;
314
315 if((UINT)dwNewPos <= 1)
316 {
317 StopPlayback(hwnd);
318 }
319 else
320 {
321 SeekPlayback(hwnd, dwNewPos);
322 }
323 }
324
325 static VOID
326 SeekForwPlayback(HWND hwnd)
327 {
328 MCI_STATUS_PARMS mciStatus;
329 DWORD dwNewPos;
330
331 if (!bIsOpened) return;
332
333 mciStatus.dwItem = MCI_STATUS_POSITION;
334 mciSendCommand(wDeviceId, MCI_STATUS, MCI_STATUS_ITEM, (DWORD_PTR)&mciStatus);
335
336 dwNewPos = mciStatus.dwReturn + 1;
337
338 if((UINT)dwNewPos >= MaxFilePos)
339 {
340 StopPlayback(hwnd);
341 }
342 else
343 {
344 SeekPlayback(hwnd, dwNewPos);
345 }
346 }
347
348 static VOID
349 PausePlayback(HWND hwnd)
350 {
351 MCI_GENERIC_PARMS mciGeneric;
352 DWORD dwError;
353
354 if (bIsOpened)
355 {
356 dwError = mciSendCommand(wDeviceId, MCI_PAUSE, MCI_WAIT, (DWORD_PTR)&mciGeneric);
357 if (dwError != 0)
358 {
359 MessageBox(hwnd, _T("Can't pause!"), NULL, MB_OK);
360 }
361 bIsPaused = TRUE;
362 }
363 }
364
365 static VOID
366 ResumePlayback(HWND hwnd)
367 {
368 MCI_GENERIC_PARMS mciGeneric;
369 DWORD dwError;
370
371 if (bIsPaused)
372 {
373 dwError = mciSendCommand(wDeviceId, MCI_RESUME, MCI_WAIT, (DWORD_PTR)&mciGeneric);
374 if (dwError != 0)
375 {
376 MessageBox(hwnd, _T("Can't resume!"), NULL, MB_OK);
377 }
378 bIsPaused = FALSE;
379 }
380 }
381
382 VOID CALLBACK
383 PlayTimerProc(HWND hwnd, UINT uMsg, UINT_PTR idEvent, DWORD dwTime)
384 {
385 MCI_STATUS_PARMS mciStatus;
386 DWORD dwPos;
387
388 if (!bIsOpened) KillTimer(hwnd, IDT_PLAYTIMER);
389
390 mciStatus.dwItem = MCI_STATUS_POSITION;
391 mciSendCommand(wDeviceId, MCI_STATUS, MCI_STATUS_ITEM, (DWORD_PTR)&mciStatus);
392 dwPos = mciStatus.dwReturn;
393
394 if((UINT)dwPos >= MaxFilePos)
395 {
396 StopPlayback(hwnd);
397 }
398 else
399 {
400 SendMessage(hTrackBar, TBM_SETPOS, (WPARAM) TRUE, (LPARAM) dwPos);
401 }
402 }
403
404 static VOID
405 PlayFile(HWND hwnd, LPTSTR lpFileName)
406 {
407 MCI_PLAY_PARMS mciPlay;
408 TCHAR szLocalFileName[MAX_PATH];
409 UINT FileType;
410 DWORD dwError;
411
412 if (lpFileName == NULL)
413 {
414 if (szPrevFile[0] == _T('\0'))
415 return;
416
417 _tcscpy(szLocalFileName, szPrevFile);
418 }
419 else
420 {
421 _tcscpy(szLocalFileName, lpFileName);
422 }
423
424 if (GetFileAttributes(szLocalFileName) == INVALID_FILE_ATTRIBUTES)
425 {
426 return;
427 }
428
429 FileType = IsSupportedFileExtension(szLocalFileName);
430
431 switch (FileType)
432 {
433 case UNSUPPORTED_FILE:
434 MessageBox(hwnd, _T("Unsupported format!"), NULL, MB_OK);
435 return;
436 case WAVE_FILE:
437 OpenMciDevice(hwnd, _T("waveaudio"), szLocalFileName);
438 break;
439 case MIDI_FILE:
440 OpenMciDevice(hwnd, _T("sequencer"), szLocalFileName);
441 break;
442 case AUDIOCD_FILE:
443 OpenMciDevice(hwnd, _T("cdaudio"), szLocalFileName);
444 break;
445 case AVI_FILE:
446 OpenMciDevice(hwnd, _T("avivideo"), szLocalFileName);
447 break;
448 }
449
450 SetTimer(hwnd, IDT_PLAYTIMER, 100, (TIMERPROC) PlayTimerProc);
451
452 dwError = mciSendCommand(wDeviceId, MCI_SEEK, MCI_WAIT | MCI_SEEK_TO_START, 0);
453
454 mciPlay.dwCallback = (DWORD_PTR)hwnd;
455 mciPlay.dwFrom = 0;
456 mciPlay.dwTo = MaxFilePos;
457
458 dwError = mciSendCommand(wDeviceId, MCI_PLAY, MCI_NOTIFY | MCI_FROM | MCI_TO, (DWORD_PTR)&mciPlay);
459 if (dwError != 0)
460 {
461 MessageBox(hwnd, _T("Can't play!"), NULL, MB_OK);
462 }
463 }
464
465 static VOID
466 OpenFileDialog(HWND hwnd)
467 {
468 OPENFILENAME OpenFileName;
469 TCHAR szFile[MAX_PATH + 1] = _T("\0");
470 TCHAR szFilter[MAX_PATH], szCurrentDir[MAX_PATH];
471
472 ZeroMemory(&OpenFileName, sizeof(OpenFileName));
473
474 LoadString(hInstance, IDS_ALL_TYPES_FILTER, szFilter, sizeof(szFilter) / sizeof(TCHAR));
475
476 if (!GetCurrentDirectory(sizeof(szCurrentDir) / sizeof(TCHAR), szCurrentDir))
477 {
478 _tcscpy(szCurrentDir, _T("c:\\"));
479 }
480
481 OpenFileName.lStructSize = sizeof(OpenFileName);
482 OpenFileName.hwndOwner = hwnd;
483 OpenFileName.hInstance = hInstance;
484 OpenFileName.lpstrFilter = szFilter;
485 OpenFileName.lpstrFile = szFile;
486 OpenFileName.nMaxFile = sizeof(szFile) / sizeof((szFile)[0]);
487 OpenFileName.lpstrInitialDir = szCurrentDir;
488 OpenFileName.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_SHAREAWARE;
489 OpenFileName.lpstrDefExt = _T("\0");
490
491 if (GetOpenFileName(&OpenFileName))
492 {
493 PlayFile(hwnd, OpenFileName.lpstrFile);
494 }
495 }
496
497 LRESULT CALLBACK
498 MainWndProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam)
499 {
500 switch (Message)
501 {
502 case WM_CREATE:
503 InitControls(hwnd);
504 break;
505
506 case WM_NOTIFY:
507 {
508 LPNMHDR pnmhdr = (LPNMHDR)lParam;
509
510 switch (pnmhdr->code)
511 {
512 case TTN_GETDISPINFO:
513 {
514 LPTOOLTIPTEXT lpttt = (LPTOOLTIPTEXT)lParam;
515 UINT idButton = (UINT)lpttt->hdr.idFrom;
516
517 switch (idButton)
518 {
519 case IDC_PLAY:
520 lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_PLAY);
521 break;
522 case IDC_STOP:
523 lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_STOP);
524 break;
525 case IDC_EJECT:
526 lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_EJECT);
527 break;
528 case IDC_BACKWARD:
529 lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_BACKWARD);
530 break;
531 case IDC_SEEKBACK:
532 lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_SEEKBACK);
533 break;
534 case IDC_SEEKFORW:
535 lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_SEEKFORW);
536 break;
537 case IDC_FORWARD:
538 lpttt->lpszText = MAKEINTRESOURCE(IDS_TOOLTIP_FORWARD);
539 break;
540 }
541 break;
542 }
543 }
544 }
545 break;
546
547 case WM_SIZING:
548 {
549 LPRECT pRect = (LPRECT)lParam;
550
551 if (pRect->right - pRect->left < MAIN_WINDOW_MIN_WIDTH)
552 pRect->right = pRect->left + MAIN_WINDOW_MIN_WIDTH;
553
554 if (pRect->bottom - pRect->top != MAIN_WINDOW_HEIGHT)
555 pRect->bottom = pRect->top + MAIN_WINDOW_HEIGHT;
556
557 return TRUE;
558 }
559
560 case WM_SIZE:
561 {
562 RECT Rect;
563 UINT Size;
564
565 if (hToolBar && hTrackBar)
566 {
567 SendMessage(hToolBar, TB_AUTOSIZE, 0, 0);
568 SendMessage(hToolBar, TB_GETITEMRECT, 1, (LPARAM)&Rect);
569
570 Size = GetSystemMetrics(SM_CYMENU) + Rect.bottom;
571 MoveWindow(hTrackBar, 0, 0, LOWORD(lParam), HIWORD(lParam) - Size, TRUE);
572 }
573 return 0L;
574 }
575
576 case WM_HSCROLL:
577 {
578 if (hTrackBar == (HWND) lParam)
579 {
580 if (bIsOpened)
581 {
582 DWORD dwNewPos = (DWORD) SendMessage(hTrackBar, TBM_GETPOS, 0, 0);
583 SeekPlayback(hwnd, dwNewPos);
584 }
585 else
586 {
587 SendMessage(hTrackBar, TBM_SETPOS, TRUE, 0);
588 }
589 }
590 }
591 break;
592
593 case WM_COMMAND:
594 switch (LOWORD(wParam))
595 {
596 case IDC_PLAY:
597 if (bIsOpened)
598 {
599 if (bIsPaused)
600 ResumePlayback(hwnd);
601 else
602 PausePlayback(hwnd);
603 }
604 else
605 {
606 if (szPrevFile[0] == _T('\0'))
607 OpenFileDialog(hwnd);
608 else
609 PlayFile(hwnd, NULL);
610 }
611 break;
612
613 case IDC_STOP:
614 StopPlayback(hwnd);
615 break;
616
617 case IDC_EJECT:
618 break;
619
620 case IDC_BACKWARD:
621 break;
622
623 case IDC_SEEKBACK:
624 SeekBackPlayback(hwnd);
625 break;
626
627 case IDC_SEEKFORW:
628 SeekForwPlayback(hwnd);
629 break;
630
631 case IDC_FORWARD:
632 break;
633
634 case IDM_OPEN_FILE:
635 OpenFileDialog(hwnd);
636 return 0;
637
638 case IDM_CLOSE_FILE:
639 StopPlayback(hwnd);
640 _tcscpy(szPrevFile, _T("\0"));
641 break;
642
643 case IDM_ABOUT:
644 {
645 HICON mplayIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MAIN));
646 ShellAbout(hwnd, szAppTitle, 0, mplayIcon);
647 DeleteObject(mplayIcon);
648 break;
649 }
650 case IDM_EXIT:
651 PostMessage(hwnd, WM_CLOSE, 0, 0);
652 return 0;
653 }
654 break;
655
656 case WM_DESTROY:
657 StopPlayback(hwnd);
658 PostQuitMessage(0);
659 return 0;
660 }
661
662 return DefWindowProc(hwnd, Message, wParam, lParam);
663 }
664
665 INT WINAPI
666 _tWinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPTSTR lpCmdLine, INT nCmdShow)
667 {
668 WNDCLASSEX WndClass = {0};
669 TCHAR szClassName[] = _T("ROSMPLAY32");
670 HWND hwnd;
671 MSG msg;
672
673 hInstance = hInst;
674
675 LoadString(hInstance, IDS_APPTITLE, szAppTitle, sizeof(szAppTitle) / sizeof(TCHAR));
676
677 WndClass.cbSize = sizeof(WNDCLASSEX);
678 WndClass.lpszClassName = szClassName;
679 WndClass.lpfnWndProc = MainWndProc;
680 WndClass.hInstance = hInstance;
681 WndClass.style = CS_HREDRAW | CS_VREDRAW;
682 WndClass.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MAIN));
683 WndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
684 WndClass.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
685 WndClass.lpszMenuName = MAKEINTRESOURCE(IDR_MAINMENU);
686
687 RegisterClassEx(&WndClass);
688
689 hwnd = CreateWindow(szClassName,
690 szAppTitle,
691 WS_SYSMENU | WS_MINIMIZEBOX | WS_THICKFRAME | WS_OVERLAPPED | WS_CAPTION | WS_CLIPCHILDREN,
692 CW_USEDEFAULT,
693 CW_USEDEFAULT,
694 350,
695 MAIN_WINDOW_HEIGHT,
696 NULL,
697 NULL,
698 hInstance,
699 NULL);
700
701 /* Show it */
702 ShowWindow(hwnd, SW_SHOW);
703 UpdateWindow(hwnd);
704
705 PlayFile(hwnd, lpCmdLine);
706
707 /* Message Loop */
708 while (GetMessage(&msg, NULL, 0, 0))
709 {
710 TranslateMessage(&msg);
711 DispatchMessage(&msg);
712 }
713
714 return 0;
715 }