1 /*
2 TiMidity++ -- MIDI to WAVE converter and player
3 Copyright (C) 1999-2018 Masanao Izumo <iz@onicos.co.jp>
4 Copyright (C) 1995 Tuukka Toivonen <tt@cgs.fi>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
20 w32g_main.c: Written by Daisuke Aoki <dai@y7.net>
21 Modified by Masanao Izumo <iz@onicos.co.jp>
22 */
23
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif /* HAVE_CONFIG_H */
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <process.h>
30 #include <stddef.h>
31 #include <windows.h>
32 #undef RC_NONE
33 #include <shlobj.h>
34 // #include <prsht.h>
35 #if defined(__CYGWIN32__) || defined(__MINGW32__)
36 #ifndef HAVE_NEW_MMSYSTEM
37 #include <commdlg.h>
38 #ifndef TPM_TOPALIGN
39 #define TPM_TOPALIGN 0x0000L /* for old version of cygwin */
40 #endif
41 #define TIME_ONESHOT 0
42 #define TIME_PERIODIC 1
43 int WINAPI timeSetEvent(UINT uDelay, UINT uResolution,
44 void *fptc, DWORD dwUser, UINT fuEvent);
45 int WINAPI timeKillEvent(UINT uTimerID);
46 #endif
47 #else
48 #include <commctrl.h>
49 #endif /* __CYGWIN32__ */
50
51 #include <commctrl.h>
52 #ifndef NO_STRING_H
53 #include <string.h>
54 #else
55 #include <strings.h>
56 #endif
57 #include <shlobj.h>
58
59 #include <windowsx.h> /* There is no <windowsx.h> on CYGWIN.
60 * Edit_* and ListBox_* are defined in
61 * <windowsx.h>
62 */
63 #include "timidity.h"
64 #include "common.h"
65 #include "instrum.h"
66 #include "playmidi.h"
67 #include "readmidi.h"
68 #include "output.h"
69 #include "controls.h"
70
71 #include "wrd.h"
72
73 #include "w32g.h"
74 #include "w32g_res.h"
75 #include "w32g_utl.h"
76 #include "w32g_ut2.h"
77 #include "w32g_pref.h"
78 #include "w32g_subwin.h"
79
80 #if defined(__CYGWIN32__) || defined(__MINGW32__)
81 #define WIN32GCC
82 WINAPI void InitCommonControls(void);
83 #endif
84
85 #if 0
86 #define GDI_LOCK() { \
87 ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "GDI_LOCK(%s: %d)", __FILE__, __LINE__ ); \
88 gdi_lock(); \
89 }
90 #define GDI_UNLOCK() { \
91 ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "GDI_UNLOCK(%s: %d)", __FILE__, __LINE__ ); \
92 gdi_unlock(); \
93 }
94 #else
95 #define GDI_LOCK() { gdi_lock(); }
96 #define GDI_UNLOCK() { gdi_unlock(); }
97 #endif
98
99 static void InitMainWnd(HWND hStartWnd);
100
101 static void ConsoleWndVerbosityApplyIncDec(int num);
102 void ConsoleWndVerbosityApply(void);
103
104 void CanvasPaintAll(void);
105 void CanvasReset(void);
106 void CanvasClear(void);
107 void CanvasUpdate(int flag);
108 void CanvasReadPanelInfo(int flag);
109 void CanvasChange(int mode);
110 void MPanelPaintAll(void);
111 void MPanelReadPanelInfo(int flag);
112 void MPanelReset(void);
113 void MPanelUpdateAll(void);
114 void ClearConsoleWnd(void);
115 void InitListWnd(HWND hParentWnd);
116 void InitTracerWnd(HWND hParentWnd);
117 void InitWrdWnd(HWND hParentWnd);
118 void InitDocWnd(HWND hParentWnd);
119 void InitListSearchWnd(HWND hParentWnd);
120 void PutsDocWnd(char *str);
121 void ClearDocWnd(void);
122 static void DlgPlaylistSave(HWND hwnd);
123 static void DlgPlaylistOpen(HWND hwnd);
124 static void DlgDirOpen(HWND hwnd);
125 static void DlgMidiFileOpen(HWND hwnd);
126 void VprintfEditCtlWnd(HWND hwnd, char *fmt, va_list argList);
127 void PutsEditCtlWnd(HWND hwnd, char *str);
128 void ClearEditCtlWnd(HWND hwnd);
129
130 int w32gSaveDefaultPlaylist(void);
131
132
133 #ifndef CLR_INVALID
134 #define CLR_INVALID 0xffffffff
135 #endif /* CLR_INVALID */
136 extern int optind;
137
138 HINSTANCE hInst;
139 static int progress_jump = -1;
140 static HWND hMainWndScrollbarProgressWnd;
141 static HWND hMainWndScrollbarVolumeWnd;
142 #define W32G_VOLUME_MAX 200
143
144 // HWND
145 HWND hMainWnd = 0;
146 HWND hDebugWnd = 0;
147 HWND hConsoleWnd = 0;
148 HWND hTracerWnd = 0;
149 HWND hDocWnd = 0;
150 HWND hListWnd = 0;
151 HWND hWrdWnd = 0;
152 HWND hSoundSpecWnd = 0;
153 HWND hDebugEditWnd = 0;
154 HWND hDocEditWnd = 0;
155
156 // Process.
157 HANDLE hProcess = 0;
158
159 // Main Thread.
160 HANDLE hMainThread = 0;
161 HANDLE hPlayerThread = 0;
162 HANDLE hMainThreadInfo = 0;
163 DWORD dwMainThreadID = 0;
164 static volatile int wait_thread_flag = 1;
165 typedef struct MAINTHREAD_ARGS_ {
166 int *pArgc;
167 char ***pArgv;
168 } MAINTHREAD_ARGS;
169 void WINAPI MainThread(void *arglist);
170
171 // Window Thread
172 HANDLE hWindowThread = 0;
173 HANDLE hWindowThreadInfo = 0;
174
175 // Thread
176 volatile int ThreadNumMax = 0;
177
178 // Debug Thread
179 volatile int DebugThreadExit = 1;
180 volatile HANDLE hDebugThread = 0;
181 void DebugThreadInit(void);
182 void PrintfDebugWnd(char *fmt, ...);
183 void ClearDebugWnd(void);
184 void InitDebugWnd(HWND hParentWnd);
185
186 // Flags
187 int InitMinimizeFlag = 0;
188 int DebugWndStartFlag = 1;
189 int ConsoleWndStartFlag = 0;
190 int ListWndStartFlag = 0;
191 int TracerWndStartFlag = 0;
192 int DocWndStartFlag = 0;
193 int WrdWndStartFlag = 0;
194
195 int DebugWndFlag = 1;
196 int ConsoleWndFlag = 1;
197 int ListWndFlag = 1;
198 int TracerWndFlag = 0;
199 int DocWndFlag = 1;
200 int WrdWndFlag = 0;
201 int SoundSpecWndFlag = 0;
202
203 int WrdGraphicFlag;
204 int TraceGraphicFlag;
205
206 char *IniFile;
207 char *ConfigFile;
208 char *PlaylistFile;
209 char *PlaylistHistoryFile;
210 char *MidiFileOpenDir;
211 char *ConfigFileOpenDir;
212 char *PlaylistFileOpenDir;
213
214 // Priority
215 int PlayerThreadPriority;
216 int MidiPlayerThreadPriority;
217 int MainThreadPriority;
218 int GUIThreadPriority;
219 int TracerThreadPriority;
220 int WrdThreadPriority;
221
222 // dir
223 int SeachDirRecursive = 0; // �ċA�I�f�B���N�g������
224
225 // Ini File
226 int IniFileAutoSave = 1; // INI �t�@�C���̎����Z�[�u
227
228 // misc
229 int DocMaxSize;
230 char *DocFileExt;
231
232 int AutoloadPlaylist = 0;
233 int AutosavePlaylist = 0;
234 int volatile save_playlist_once_before_exit_flag = 1;
235
236 static volatile int w32g_wait_for_init;
237 void w32g_send_rc(int rc, ptr_size_t value);
238 int w32g_lock_open_file = 0;
239
240 void TiMidityHeapCheck(void);
241
242 volatile DWORD dwWindowThreadID = -1;
w32g_i_init(void)243 void w32g_i_init(void)
244 {
245 ThreadNumMax++;
246 hProcess = GetCurrentProcess();
247 hWindowThread = GetCurrentThread();
248 dwWindowThreadID = GetCurrentThreadId();
249
250 InitCommonControls();
251
252 #ifdef W32GUI_DEBUG
253 DebugThreadInit();
254 #endif
255 }
256
257 int PlayerLanguage = LANGUAGE_ENGLISH;
258 //int PlayerLanguage = LANGUAGE_JAPANESE;
259 #define PInfoOK 1
SetValue(int32 value,int32 min,int32 max)260 long SetValue(int32 value, int32 min, int32 max)
261 {
262 int32 v = value;
263 if(v < min) v = min;
264 else if( v > max) v = max;
265 return v;
266 }
267
268 int w32gSecondTiMidity(int opt, int argc, char **argv);
269 int w32gSecondTiMidityExit(void);
270 int SecondMode = 0;
271 void FirstLoadIniFile(void);
272
273 #ifndef WIN32GCC
274 extern void CmdLineToArgv(LPSTR lpCmdLine, int *argc, CHAR ***argv);
275 extern int win_main(int argc, char **argv); /* timidity.c */
276 int WINAPI
WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR lpCmdLine,int nCmdShow)277 WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
278 LPSTR lpCmdLine, int nCmdShow)
279 {
280 int argc;
281 CHAR **argv = NULL;
282 CmdLineToArgv(lpCmdLine,&argc,&argv);
283 #if 0
284 FirstLoadIniFile();
285 if(w32gSecondTiMidity(SecondMode,argc,argv)==TRUE){
286 int res = win_main(argc, argv);
287 w32gSecondTiMidityExit();
288 return res;
289 } else
290 return -1;
291 #else
292 wrdt=wrdt_list[0];
293 return win_main(argc, argv);
294 #endif
295 }
296 #endif /* WIN32GCC */
297
298 // ***************************************************************************
299 // System Function
300
KillProcess(UINT IDEvent,UINT uReserved,DWORD dwUser,DWORD dwReserved1,DWORD dwReserved2)301 void CALLBACK KillProcess(UINT IDEvent, UINT uReserved, DWORD dwUser,
302 DWORD dwReserved1, DWORD dwReserved2)
303 {
304 exit(0);
305 // ExitProcess(0);
306 }
307
OnExit(void)308 void OnExit(void)
309 {
310 #ifdef W32GUI_DEBUG
311 PrintfDebugWnd("PostQuitMessage\n");
312 Sleep(200);
313 #endif
314 PostQuitMessage(0);
315 }
316
317 static int OnExitReadyWait = 200;
OnExitReady(void)318 void OnExitReady(void)
319 {
320 int i;
321 #ifdef W32GUI_DEBUG
322 PrintfDebugWnd("OnExitReady: Start.\n");
323 #endif
324 w32g_send_rc(RC_STOP, 0);
325
326 /* Exit after 10 sec. */
327
328 timeSetEvent(10000, 1000, KillProcess, 0, TIME_ONESHOT);
329
330 /* Wait really stopping to play */
331 i = 1000/OnExitReadyWait; /* 1 sec. */
332 while(w32g_play_active && i-- > 0)
333 {
334 Sleep(OnExitReadyWait);
335 VOLATILE_TOUCH(w32g_play_active);
336 }
337
338 #ifdef W32GUI_DEBUG
339 PrintfDebugWnd("OnExitReady: End.\n");
340 #endif
341 }
342
OnQuit(void)343 void OnQuit(void)
344 {
345 SendMessage(hMainWnd, WM_CLOSE, 0, 0);
346 }
347
348
349 // ***************************************************************************
350 // Start Window
351 // �匳�̃E�B���h�E�̒n�ʂ�Main Window�ɏ���A���ł͂����̏�������
352
InitStartWnd(int nCmdShow)353 void InitStartWnd(int nCmdShow)
354 {
355 InitMainWnd(NULL);
356 InitConsoleWnd(hMainWnd);
357 InitListWnd(hMainWnd);
358 InitTracerWnd(hMainWnd);
359 InitDocWnd(hMainWnd);
360 InitWrdWnd(hMainWnd);
361 InitSoundSpecWnd(hMainWnd);
362
363 hMainWndScrollbarProgressWnd = GetDlgItem(hMainWnd, IDC_SCROLLBAR_PROGRESS);
364 hMainWndScrollbarVolumeWnd = GetDlgItem(hMainWnd, IDC_SCROLLBAR_VOLUME);
365 EnableScrollBar(hMainWndScrollbarVolumeWnd, SB_CTL,ESB_ENABLE_BOTH);
366 SetScrollRange(hMainWndScrollbarVolumeWnd, SB_CTL,
367 0, W32G_VOLUME_MAX, TRUE);
368 SetScrollPos(hMainWndScrollbarVolumeWnd, SB_CTL,
369 W32G_VOLUME_MAX - amplification, TRUE);
370 }
371
372 /*****************************************************************************/
373 // Main Window
374
375 #define SWS_EXIST 0x0001
376 #define SWS_ICON 0x0002
377 #define SWS_HIDE 0x0004
378 typedef struct SUBWINDOW_ {
379 HWND *hwnd;
380 int status;
381 } SUBWINDOW;
382 SUBWINDOW subwindow[] =
383 {
384 {&hConsoleWnd,0},
385 {&hListWnd,0},
386 {&hTracerWnd,0},
387 {&hDocWnd,0},
388 {&hWrdWnd,0},
389 {&hSoundSpecWnd,0},
390 {NULL,0}
391 };
392
393 int SubWindowMax = 5;
394 SUBWINDOW SubWindowHistory[] =
395 {
396 {&hConsoleWnd,0},
397 {&hListWnd,0},
398 {&hTracerWnd,0},
399 {&hDocWnd,0},
400 {&hWrdWnd,0},
401 {&hSoundSpecWnd,0},
402 {NULL,0}
403 };
404
405 MAINWNDINFO MainWndInfo;
406
407 BOOL CALLBACK MainProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam);
408
409 void update_subwindow(void);
410 void OnShow(void);
411 void OnHide(void);
412
413 static int MainWndInfoReset(HWND hwnd);
414 static int MainWndInfoApply(void);
415
416 extern void reload_cfg(void);
417 // OUTPUT MENU
418 #define IDM_OUTPUT 0x4000
419 static HMENU outputMenu;
420
InitOutputMenu(HWND hWnd)421 static void InitOutputMenu(HWND hWnd)
422 {
423 HMENU hMenu;
424 MENUITEMINFO mii;
425 int i;
426
427 hMenu = GetMenu(hWnd);
428 if (outputMenu != NULL) {DestroyMenu (outputMenu);}
429 outputMenu = CreateMenu();
430
431 mii.cbSize = sizeof (MENUITEMINFO);
432 mii.fMask = MIIM_TYPE | MIIM_SUBMENU;
433 mii.fType = MFT_STRING;
434 mii.hSubMenu = outputMenu;
435 if (PlayerLanguage == LANGUAGE_JAPANESE) {
436 mii.dwTypeData = TEXT("�o��(&O)");
437 } else {
438 mii.dwTypeData = TEXT("Output(&O)");
439 }
440 InsertMenuItem(hMenu, GetMenuItemCount(hMenu) - 1, TRUE, &mii);
441
442 for (i = 0; play_mode_list[i] != 0; i++) {
443 mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
444 mii.wID = IDM_OUTPUT + i;
445 mii.fType = MFT_STRING;
446 if (st_temp->opt_playmode[0] == play_mode_list[i]->id_character) {
447 mii.fState = MFS_CHECKED;
448 } else {
449 mii.fState = MFS_UNCHECKED;
450 }
451 mii.dwTypeData = play_mode_list[i]->id_name;
452 InsertMenuItem(outputMenu, i, TRUE, &mii);
453 }
454
455 SetMenu(hWnd , hMenu);
456 }
457
UpdateOutputMenu(HWND hWnd,UINT wId)458 static void UpdateOutputMenu(HWND hWnd, UINT wId)
459 {
460 MENUITEMINFO mii;
461 int i, num = -1, oldnum;
462
463 for (i = 0; play_mode_list[i] != 0; i++) {
464 mii.cbSize = sizeof (MENUITEMINFO);
465 mii.fMask = MIIM_STATE | MIIM_ID;
466 GetMenuItemInfo(outputMenu, i, TRUE, &mii);
467 if (wId == mii.wID) {
468 mii.fState = MFS_CHECKED;
469 num = i;
470 } else {mii.fState = MFS_UNCHECKED;}
471 SetMenuItemInfo(outputMenu, i, TRUE, &mii);
472 if (st_temp->opt_playmode[0] == play_mode_list[i]->id_character) {
473 oldnum = i;
474 }
475 }
476 if (!w32g_play_active && num != oldnum) {
477 if (num >= 0) {st_temp->opt_playmode[0] = play_mode_list[num]->id_character;}
478 else {st_temp->opt_playmode[0] = 'd';}
479 PrefSettingApplyReally();
480 }
481 }
482
InitMainWnd(HWND hParentWnd)483 static void InitMainWnd(HWND hParentWnd)
484 {
485 HICON hIcon = LoadImage(hInst, MAKEINTRESOURCE(IDI_ICON_TIMIDITY), IMAGE_ICON, 16, 16, 0);
486 if ( hMainWnd != NULL ) {
487 DestroyWindow ( hMainWnd );
488 hMainWnd = NULL;
489 }
490 INILoadMainWnd();
491 if (PlayerLanguage == LANGUAGE_JAPANESE)
492 hMainWnd = CreateDialog(hInst,MAKEINTRESOURCE(IDD_DIALOG_MAIN),hParentWnd,MainProc);
493 else
494 hMainWnd = CreateDialog(hInst,MAKEINTRESOURCE(IDD_DIALOG_MAIN_EN),hParentWnd,MainProc);
495 InitOutputMenu(hMainWnd);
496
497 if (hIcon!=NULL) SendMessage(hMainWnd,WM_SETICON,FALSE,(LPARAM)hIcon);
498 { // Set the title of the main window again.
499 char buffer[256];
500 SendMessage( hMainWnd, WM_GETTEXT, (WPARAM)255, (LPARAM)buffer);
501 SendMessage( hMainWnd, WM_SETTEXT, (WPARAM)0, (LPARAM)buffer);
502 }
503 MainWndInfoApply();
504 }
505
MainWndInfoReset(HWND hwnd)506 static int MainWndInfoReset(HWND hwnd)
507 {
508 memset(&MainWndInfo,0,sizeof(MAINWNDINFO));
509 MainWndInfo.PosX = - 1;
510 MainWndInfo.PosY = - 1;
511 return 0;
512 }
513
MainWndInfoApply(void)514 static int MainWndInfoApply(void)
515 {
516 return 0;
517 }
518
519 void MainCmdProc(HWND hwnd, int wId, HWND hwndCtl, UINT wNotifyCode);
520
521 void MainWndSetPauseButton(int flag);
522 void MainWndSetPlayButton(int flag);
523
524 void MainWndToggleConsoleButton(void);
525 void MainWndUpdateConsoleButton(void);
526 void MainWndToggleTracerButton(void);
527 void MainWndUpdateTracerButton(void);
528 void MainWndToggleListButton(void);
529 void MainWndUpdateListButton(void);
530 void MainWndToggleDocButton(void);
531 void MainWndUpdateDocButton(void);
532 void MainWndToggleWrdButton(void);
533 void MainWndUpdateWrdButton(void);
534 void MainWndToggleSoundSpecButton(void);
535 void MainWndUpdateSoundSpecButton(void);
536
537 void ShowSubWindow(HWND hwnd,int showflag);
538 void ToggleSubWindow(HWND hwnd);
539
540 static void VersionWnd(HWND hParentWnd);
541 static void TiMidityWnd(HWND hParentWnd);
542 static void SupplementWnd(HWND hParentWnd);
543
544 static void InitCanvasWnd(HWND hwnd);
545 static void CanvasInit(HWND hwnd);
546 static void InitPanelWnd(HWND hwnd);
547 static void MPanelInit(HWND hwnd);
548
549 static void InitMainToolbar(HWND hwnd);
550 static void InitSubWndToolbar(HWND hwnd);
551
552 static UINT PlayerForwardAndBackwardEventID = 0;
PlayerForward(UINT IDEvent,UINT uReserved,DWORD dwUser,DWORD dwReserved1,DWORD dwReserved2)553 static void CALLBACK PlayerForward(UINT IDEvent, UINT uReserved, DWORD dwUser,
554 DWORD dwReserved1, DWORD dwReserved2)
555 {
556 w32g_send_rc(RC_FORWARD, play_mode->rate);
557 }
558
PlayerBackward(UINT IDEvent,UINT uReserved,DWORD dwUser,DWORD dwReserved1,DWORD dwReserved2)559 static void CALLBACK PlayerBackward(UINT IDEvent, UINT uReserved, DWORD dwUser,
560 DWORD dwReserved1, DWORD dwReserved2)
561 {
562 w32g_send_rc(RC_BACK, play_mode->rate);
563 }
564
565 extern void ShowPrefWnd ( void );
566 extern void HidePrefWnd ( void );
567 extern BOOL IsVisiblePrefWnd ( void );
568
569 BOOL CALLBACK
MainProc(HWND hwnd,UINT uMess,WPARAM wParam,LPARAM lParam)570 MainProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam)
571 {
572 static BOOL PrefWndShow;
573 // PrintfDebugWnd("MainProc: Mess%lx WPARAM%lx LPARAM%lx\n",uMess,wParam,lParam);
574 switch (uMess)
575 {
576 case WM_INITDIALOG:
577 PrefWndShow = FALSE;
578 update_subwindow();
579 MainWndUpdateConsoleButton();
580 MainWndUpdateTracerButton();
581 MainWndUpdateListButton();
582 MainWndUpdateDocButton();
583 MainWndUpdateWrdButton();
584 MainWndUpdateSoundSpecButton();
585 InitPanelWnd(hwnd);
586 InitCanvasWnd(hwnd);
587 InitMainToolbar(hwnd);
588 InitSubWndToolbar(hwnd);
589 {
590 HMENU hMenu = GetSystemMenu(hwnd, FALSE);
591 #if 1
592 RemoveMenu(hMenu,SC_MAXIMIZE,MF_BYCOMMAND);
593 RemoveMenu(hMenu,SC_SIZE,MF_BYCOMMAND);
594 #else
595 EnableMenuItem(hMenu, SC_MAXIMIZE, MF_BYCOMMAND | MF_GRAYED);
596 EnableMenuItem(hMenu, SC_SIZE, MF_BYCOMMAND | MF_GRAYED);
597 #endif
598 EnableMenuItem(hMenu, SC_MOVE, MF_BYCOMMAND | MF_GRAYED);
599 InsertMenu(hMenu, 0, MF_BYPOSITION | MF_SEPARATOR, 0, 0);
600 InsertMenu(hMenu, 0, MF_BYPOSITION, SC_SCREENSAVE, "Screen Saver");
601 InsertMenu(hMenu, 0, MF_BYPOSITION | MF_SEPARATOR, 0, 0);
602 InsertMenu(hMenu, 0, MF_BYPOSITION | MF_STRING, IDM_STOP, "Stop");
603 InsertMenu(hMenu, 0, MF_BYPOSITION | MF_STRING, IDM_PAUSE, "Pause");
604 InsertMenu(hMenu, 0, MF_BYPOSITION | MF_STRING, IDM_PREV, "Prev");
605 InsertMenu(hMenu, 0, MF_BYPOSITION | MF_STRING, IDM_NEXT, "Next");
606 InsertMenu(hMenu, 0, MF_BYPOSITION | MF_STRING, IDM_PLAY, "Play");
607 DrawMenuBar(hwnd);
608 }
609 {
610 RECT d_rc, w_rc;
611 GetClientRect ( GetDesktopWindow (), &d_rc );
612 GetWindowRect ( hwnd, &w_rc );
613 d_rc.right -= w_rc.right - w_rc.left;
614 d_rc.bottom -= w_rc.bottom - w_rc.top;
615 if ( MainWndInfo.PosX < d_rc.left ) MainWndInfo.PosX = d_rc.left;
616 if ( MainWndInfo.PosX > d_rc.right ) MainWndInfo.PosX = d_rc.right;
617 if ( MainWndInfo.PosY < d_rc.top ) MainWndInfo.PosY = d_rc.top;
618 if ( MainWndInfo.PosY > d_rc.bottom ) MainWndInfo.PosY = d_rc.bottom;
619 SetWindowPosSize(GetDesktopWindow(),hwnd,MainWndInfo.PosX, MainWndInfo.PosY );
620 }
621 return FALSE;
622 HANDLE_MSG(hwnd,WM_COMMAND,MainCmdProc);
623
624 case WM_DESTROY:
625 if(save_playlist_once_before_exit_flag) {
626 save_playlist_once_before_exit_flag = 0;
627 w32gSaveDefaultPlaylist();
628 }
629 INISaveMainWnd();
630 PostQuitMessage(0);
631 break;
632 case WM_CLOSE:
633 if(save_playlist_once_before_exit_flag) {
634 save_playlist_once_before_exit_flag = 0;
635 w32gSaveDefaultPlaylist();
636 }
637 DestroyWindow(hwnd);
638 break;
639
640 case WM_SIZE:
641 if(wParam == SIZE_MINIMIZED){
642 if ( IsVisiblePrefWnd () )
643 PrefWndShow = TRUE;
644 else
645 PrefWndShow = FALSE;
646 HidePrefWnd ();
647 update_subwindow();
648 OnHide();
649 } else if ( wParam == SIZE_RESTORED ) {
650 if ( PrefWndShow ) {
651 ShowPrefWnd ();
652 }
653 }
654 return FALSE;
655 case WM_MOVE:
656 if ( ! IsIconic(hwnd) ) {
657 RECT rc;
658 GetWindowRect(hwnd,&rc);
659 MainWndInfo.PosX = rc.left;
660 MainWndInfo.PosY = rc.top;
661 }
662 break;
663 case WM_QUERYOPEN:
664 OnShow();
665 return FALSE;
666 case WM_DROPFILES:
667 w32g_send_rc(RC_EXT_DROP, (ptr_size_t)wParam);
668 return FALSE;
669 case WM_HSCROLL: {
670 int nScrollCode = (int)LOWORD(wParam);
671 int nPos = (int) HIWORD(wParam);
672 HWND bar = (HWND)lParam;
673
674 if(bar != hMainWndScrollbarProgressWnd)
675 break;
676
677 switch(nScrollCode)
678 {
679 case SB_THUMBTRACK:
680 case SB_THUMBPOSITION:
681 progress_jump = nPos;
682 break;
683 case SB_LINELEFT:
684 progress_jump = GetScrollPos(bar, SB_CTL) - 1;
685 if(progress_jump < 0)
686 progress_jump = 0;
687 break;
688 case SB_PAGELEFT:
689 progress_jump = GetScrollPos(bar, SB_CTL) - 10;
690 if(progress_jump < 0)
691 progress_jump = 0;
692 break;
693 case SB_LINERIGHT:
694 progress_jump = GetScrollPos(bar, SB_CTL) + 1;
695 break;
696 case SB_PAGERIGHT:
697 progress_jump = GetScrollPos(bar, SB_CTL) + 10;
698 break;
699 case SB_ENDSCROLL:
700 if(progress_jump != -1)
701 {
702 w32g_send_rc(RC_JUMP, progress_jump * play_mode->rate);
703 SetScrollPos(hMainWndScrollbarProgressWnd, SB_CTL,
704 progress_jump, TRUE);
705 progress_jump = -1;
706 }
707 break;
708 }
709 break;
710 }
711 break;
712
713 case WM_VSCROLL: {
714 int nScrollCode = (int) LOWORD(wParam);
715 int nPos = (int) HIWORD(wParam);
716 HWND bar = (HWND) lParam;
717 static int pos = -1;
718
719 if(bar != hMainWndScrollbarVolumeWnd)
720 break;
721
722 switch(nScrollCode)
723 {
724 case SB_THUMBTRACK:
725 case SB_THUMBPOSITION:
726 pos = nPos;
727 break;
728 case SB_LINEUP:
729 case SB_PAGEUP:
730 pos = GetScrollPos(bar, SB_CTL) - 5;
731 if(pos < 0)
732 pos = 0;
733 break;
734 case SB_LINEDOWN:
735 case SB_PAGEDOWN:
736 pos = GetScrollPos(bar, SB_CTL) + 5;
737 if(pos > W32G_VOLUME_MAX)
738 pos = W32G_VOLUME_MAX;
739 break;
740 case SB_ENDSCROLL:
741 if(pos != -1)
742 {
743 w32g_send_rc(RC_CHANGE_VOLUME,
744 (W32G_VOLUME_MAX - pos) - amplification);
745 SetScrollPos(bar, SB_CTL, pos, TRUE);
746 pos = -1;
747 }
748 break;
749 }
750 }
751 break;
752
753 case WM_SYSCOMMAND:
754 switch(wParam){
755 case IDM_STOP:
756 case IDM_PAUSE:
757 case IDM_PREV:
758 case IDM_PLAY:
759 case IDM_NEXT:
760 case IDM_FOREWARD:
761 case IDM_BACKWARD:
762 SendMessage(hwnd,WM_COMMAND,wParam,(LPARAM)NULL);
763 break;
764 default:
765 break;
766 }
767 return FALSE;
768 case WM_NOTIFY:
769 switch(wParam) {
770 case IDC_TOOLBARWINDOW_MAIN:{
771 LPTBNOTIFY TbNotify = (LPTBNOTIFY)lParam;
772 switch(TbNotify->iItem){
773 case IDM_BACKWARD:
774 if(TbNotify->hdr.code==TBN_BEGINDRAG){
775 #ifdef W32GUI_DEBUG
776 //PrintfDebugWnd("IDM_BACKWARD: BUTTON ON\n");
777 #endif
778 PlayerBackward(0,0,0,0,0);
779 PlayerForwardAndBackwardEventID =
780 timeSetEvent(100, 100, PlayerBackward, 0, TIME_PERIODIC);
781 }
782 if(PlayerForwardAndBackwardEventID != 0)
783 if(TbNotify->hdr.code==TBN_ENDDRAG){
784 #ifdef W32GUI_DEBUG
785 //PrintfDebugWnd("IDM_BACKWARD: BUTTON OFF\n");
786 #endif
787 timeKillEvent(PlayerForwardAndBackwardEventID);
788 PlayerForwardAndBackwardEventID = 0;
789 }
790 break;
791 case IDM_FOREWARD:
792 if(TbNotify->hdr.code ==TBN_BEGINDRAG &&
793 PlayerForwardAndBackwardEventID == 0){
794 #ifdef W32GUI_DEBUG
795 //PrintfDebugWnd("IDM_FOREWARD: BUTTON ON\n");
796 #endif
797 PlayerForward(0,0,0,0,0);
798 PlayerForwardAndBackwardEventID =
799 timeSetEvent(100,300,PlayerForward,0,TIME_PERIODIC);
800 }
801 else if((TbNotify->hdr.code == TBN_ENDDRAG ||
802 TbNotify->hdr.code == NM_CLICK ||
803 TbNotify->hdr.code == NM_RCLICK) &&
804 PlayerForwardAndBackwardEventID != 0)
805 {
806 #ifdef W32GUI_DEBUG
807 //PrintfDebugWnd("IDM_FOREWARD: BUTTON OFF\n");
808 #endif
809 timeKillEvent(PlayerForwardAndBackwardEventID);
810 PlayerForwardAndBackwardEventID = 0;
811 }
812 break;
813 default:
814 break;
815 }
816 }
817 break; /* end of case IDC_TOOLBARWINDOW_MAIN */
818 default:
819 break;
820 }
821 return FALSE;
822 case WM_SHOWWINDOW:
823 {
824 BOOL fShow = (BOOL)wParam;
825 if ( fShow ) {
826 if ( PrefWndShow ) {
827 ShowPrefWnd ();
828 } else {
829 HidePrefWnd ();
830 }
831 } else {
832 if ( IsVisiblePrefWnd () )
833 PrefWndShow = TRUE;
834 else
835 PrefWndShow = FALSE;
836 HidePrefWnd ();
837 }
838 break;
839 }
840 break;
841 default:
842 if (uMess == RegisterWindowMessage("TaskbarCreated")) {
843 ShowWindow(hMainWnd, SW_HIDE);
844 ShowWindow(hMainWnd, SW_SHOWNOACTIVATE);
845 return 0;
846 }
847 return FALSE;
848 }
849 return FALSE;
850 }
851
MainCmdProc(HWND hwnd,int wId,HWND hwndCtl,UINT wNotifyCode)852 void MainCmdProc(HWND hwnd, int wId, HWND hwndCtl, UINT wNotifyCode)
853 {
854 // PrintfDebugWnd("WM_COMMAND: ID%lx HWND%lx CODE%lx\n",wId,hwndCtl,wNotifyCode);
855 switch(wId)
856 {
857 case IDM_STOP:
858 w32g_send_rc(RC_STOP, 0);
859 break;
860 case IDM_PAUSE:
861 SendDlgItemMessage(hMainWnd, IDC_TOOLBARWINDOW_MAIN,
862 TB_CHECKBUTTON, IDM_PAUSE,
863 (LPARAM)MAKELONG(!play_pause_flag, 0));
864 w32g_send_rc(RC_TOGGLE_PAUSE, 0);
865 break;
866 case IDM_PREV:
867 w32g_send_rc(RC_REALLY_PREVIOUS, 0);
868 break;
869 case IDM_BACKWARD:
870 /* Do nothing here. See WM_NOTIFY in MainProc() */
871 break;
872 case IDM_PLAY:
873 if(play_pause_flag)
874 {
875 SendDlgItemMessage(hMainWnd, IDC_TOOLBARWINDOW_MAIN,
876 TB_CHECKBUTTON, IDM_PAUSE,
877 (LPARAM)MAKELONG(FALSE, 0));
878 w32g_send_rc(RC_TOGGLE_PAUSE, 0);
879 }
880 if(!w32g_play_active)
881 w32g_send_rc(RC_LOAD_FILE, 0);
882 break;
883 case IDM_FOREWARD:
884 /* Do nothing here. See WM_NOTIFY in MainProc() */
885 break;
886 case IDM_NEXT:
887 w32g_send_rc(RC_NEXT, 0);
888 break;
889 case IDM_CONSOLE:
890 case IDM_MWCONSOLE:
891 ToggleSubWindow(hConsoleWnd);
892 break;
893 case IDM_TRACER:
894 case IDM_MWTRACER:
895 ToggleSubWindow(hTracerWnd);
896 // MainWndUpdateTracerButton();
897 // MessageBox(hwnd, "Not Supported.","Warning!",MB_OK);
898 break;
899 case IDM_LIST:
900 case IDM_MWPLAYLIST:
901 ToggleSubWindow(hListWnd);
902 if(IsWindowVisible(hListWnd))
903 w32g_send_rc(RC_EXT_UPDATE_PLAYLIST, 0);
904 break;
905 case IDM_DOC:
906 case IDM_MWDOCUMENT:
907 ToggleSubWindow(hDocWnd);
908 // if(IsWindowVisible(hDocWnd))
909 // w32g_send_rc(RC_EXT_DOC, 0);
910 break;
911 case IDM_WRD:
912 case IDM_MWWRDTRACER:
913 ToggleSubWindow(hWrdWnd);
914 // MainWndUpdateWrdButton();
915 // MessageBox(hwnd, "Not Supported.","Warning!",MB_OK);
916 break;
917 case IDM_SOUNDSPEC:
918 case IDM_MWSOUNDSPEC:
919 MainWndUpdateSoundSpecButton();
920 MessageBox(hwnd, "Not Supported.","Warning!",MB_OK);
921 break;
922 case IDOK:
923 break;
924 case IDCANCEL:
925 OnQuit();
926 break;
927 case IDM_MFOPENFILE:
928 DlgMidiFileOpen(hwnd);
929 break;
930 case IDM_MFOPENDIR:
931 DlgDirOpen(hwnd);
932 break;
933 case IDM_MFLOADPLAYLIST:
934 DlgPlaylistOpen(hwnd);
935 break;
936 case IDM_MFSAVEPLAYLISTAS:
937 DlgPlaylistSave(hwnd);
938 break;
939 case IDM_MFEXIT:
940 OnQuit();
941 break;
942
943 case IDM_SETTING:
944 PrefWndCreate(hMainWnd);
945 break;
946
947 case IDM_MCSAVEINIFILE:
948 VOLATILE_TOUCH(PrefWndDoing);
949 if(PrefWndDoing){
950 MessageBox(hMainWnd, "Can't Save Ini file while preference dialog.",
951 "Warning", MB_OK);
952 break;
953 }
954 SaveIniFile(sp_current, st_current);
955 break;
956 case IDM_MCLOADINIFILE:
957 if(!w32g_has_ini_file) {
958 MessageBox(hMainWnd, "Can't load Ini file.",
959 "Warning", MB_OK);
960 break;
961 }
962
963 VOLATILE_TOUCH(PrefWndDoing);
964 if(PrefWndDoing){
965 MessageBox(hMainWnd, "Can't load Ini file while preference dialog.",
966 "Warning", MB_OK);
967 break;
968 }
969 LoadIniFile(sp_temp,st_temp);
970 PrefWndCreate(hMainWnd);
971 break;
972 case IDM_MWDEBUG:
973 #ifdef W32GUI_DEBUG
974 if(IsWindowVisible(hDebugWnd))
975 ShowWindow(hDebugWnd,SW_HIDE);
976 else
977 ShowWindow(hDebugWnd,SW_SHOW);
978 #endif
979 break;
980 case IDM_MHTOPIC:
981 MessageBox(hwnd, "Not Supported.","Warning!",MB_OK);
982 break;
983 case IDM_MHHELP:
984 MessageBox(hwnd, "Not Supported.","Warning!",MB_OK);
985 break;
986 case IDM_MHONLINEHELP:
987 if (PlayerLanguage == LANGUAGE_JAPANESE) {
988 ShellExecute(HWND_DESKTOP, NULL, "http://timidity-docs.sourceforge.jp/", NULL, NULL, SW_SHOWNORMAL);
989 } else {
990 ShellExecute(HWND_DESKTOP, NULL, "http://timidity.sourceforge.net/index.html.en", NULL, NULL, SW_SHOWNORMAL);
991 }
992 break;
993 case IDM_MHBTS:
994 if (PlayerLanguage == LANGUAGE_JAPANESE) {
995 ShellExecute(HWND_DESKTOP, NULL, "http://timidity-docs.sourceforge.jp/cgi-bin/kagemai-ja/guest.cgi", NULL, NULL, SW_SHOWNORMAL);
996 } else {
997 ShellExecute(HWND_DESKTOP, NULL, "http://timidity-docs.sourceforge.jp/cgi-bin/kagemai-en/guest.cgi", NULL, NULL, SW_SHOWNORMAL);
998 }
999 break;
1000 case IDM_MHONLINEHELPCFG:
1001 ShellExecute(HWND_DESKTOP, NULL, "http://timidity-docs.sourceforge.jp/cgi-bin/hiki/hiki.cgi?%28ja%29timidity.cfg", NULL, NULL, SW_SHOWNORMAL);
1002 break;
1003 case IDM_MHVERSION:
1004 VersionWnd(hwnd);
1005 break;
1006 case IDM_MHTIMIDITY:
1007 TiMidityWnd(hwnd);
1008 break;
1009 case IDM_FORCE_RELOAD:
1010 if (!w32g_play_active) {reload_cfg();}
1011 break;
1012 case IDM_MHSUPPLEMENT:
1013 SupplementWnd(hwnd);
1014 break;
1015 default:
1016 UpdateOutputMenu(hwnd, wId);
1017 break;
1018 }
1019 }
1020
1021
1022
update_subwindow(void)1023 void update_subwindow(void)
1024 {
1025 SUBWINDOW *s = subwindow;
1026 int i;
1027 for(i=0;s[i].hwnd!=NULL;i++){
1028 if(IsWindow(*(s[i].hwnd)))
1029 s[i].status |= SWS_EXIST;
1030 else {
1031 s[i].status = 0;
1032 continue;
1033 }
1034 if(IsIconic(*(s[i].hwnd)))
1035 s[i].status |= SWS_ICON;
1036 else
1037 s[i].status &= ~ SWS_ICON;
1038 if(IsWindowVisible(*(s[i].hwnd)))
1039 s[i].status &= ~ SWS_HIDE;
1040 else
1041 s[i].status |= SWS_HIDE;
1042 }
1043 }
1044
MainWndSetPauseButton(int flag)1045 void MainWndSetPauseButton(int flag)
1046 {
1047 if(flag)
1048 SendDlgItemMessage(hMainWnd, IDC_TOOLBARWINDOW_MAIN,
1049 TB_CHECKBUTTON, IDM_PAUSE, (LPARAM)MAKELONG(TRUE, 0));
1050 else
1051 SendDlgItemMessage(hMainWnd, IDC_TOOLBARWINDOW_MAIN,
1052 TB_CHECKBUTTON, IDM_PAUSE, (LPARAM)MAKELONG(FALSE, 0));
1053 }
1054
MainWndSetPlayButton(int flag)1055 void MainWndSetPlayButton(int flag)
1056 {
1057 return;
1058 }
1059
MainWndUpdateConsoleButton(void)1060 void MainWndUpdateConsoleButton(void)
1061 {
1062 if(IsWindowVisible(hConsoleWnd))
1063 SendDlgItemMessage(hMainWnd, IDC_TOOLBARWINDOW_SUBWND,
1064 TB_CHECKBUTTON, IDM_CONSOLE, (LPARAM)MAKELONG(TRUE, 0));
1065 else
1066 SendDlgItemMessage(hMainWnd, IDC_TOOLBARWINDOW_SUBWND,
1067 TB_CHECKBUTTON, IDM_CONSOLE, (LPARAM)MAKELONG(FALSE, 0));
1068 }
1069
MainWndUpdateListButton(void)1070 void MainWndUpdateListButton(void)
1071 {
1072 if(IsWindowVisible(hListWnd))
1073 SendDlgItemMessage(hMainWnd, IDC_TOOLBARWINDOW_SUBWND,
1074 TB_CHECKBUTTON, IDM_LIST, (LPARAM)MAKELONG(TRUE, 0));
1075 else
1076 SendDlgItemMessage(hMainWnd, IDC_TOOLBARWINDOW_SUBWND,
1077 TB_CHECKBUTTON, IDM_LIST, (LPARAM)MAKELONG(FALSE, 0));
1078 }
1079
MainWndUpdateDocButton(void)1080 void MainWndUpdateDocButton(void)
1081 {
1082 if(IsWindowVisible(hDocWnd))
1083 SendDlgItemMessage(hMainWnd, IDC_TOOLBARWINDOW_SUBWND,
1084 TB_CHECKBUTTON, IDM_DOC, (LPARAM)MAKELONG(TRUE, 0));
1085 else
1086 SendDlgItemMessage(hMainWnd, IDC_TOOLBARWINDOW_SUBWND,
1087 TB_CHECKBUTTON, IDM_DOC, (LPARAM)MAKELONG(FALSE, 0));
1088 }
1089
MainWndUpdateTracerButton(void)1090 void MainWndUpdateTracerButton(void)
1091 {
1092 if(IsWindowVisible(hTracerWnd))
1093 SendDlgItemMessage(hMainWnd, IDC_TOOLBARWINDOW_SUBWND,
1094 TB_CHECKBUTTON, IDM_TRACER,
1095 (LPARAM)MAKELONG(TRUE, 0));
1096 else
1097 SendDlgItemMessage(hMainWnd, IDC_TOOLBARWINDOW_SUBWND,
1098 TB_CHECKBUTTON, IDM_TRACER,
1099 (LPARAM)MAKELONG(FALSE, 0));
1100 }
1101
MainWndUpdateWrdButton(void)1102 void MainWndUpdateWrdButton(void)
1103 {
1104 if(IsWindowVisible(hWrdWnd))
1105 SendDlgItemMessage(hMainWnd, IDC_TOOLBARWINDOW_SUBWND,
1106 TB_CHECKBUTTON, IDM_WRD, (LPARAM)MAKELONG(TRUE, 0));
1107 else
1108 SendDlgItemMessage(hMainWnd, IDC_TOOLBARWINDOW_SUBWND,
1109 TB_CHECKBUTTON, IDM_WRD, (LPARAM)MAKELONG(FALSE, 0));
1110 }
1111
MainWndUpdateSoundSpecButton(void)1112 void MainWndUpdateSoundSpecButton(void)
1113 {
1114 }
1115
1116 #undef SUBWINDOW_POS_IS_OLD_CLOSED_WINDOW
ShowSubWindow(HWND hwnd,int showflag)1117 void ShowSubWindow(HWND hwnd,int showflag)
1118 {
1119 int i, num;
1120 RECT rc;
1121 #ifdef SUBWINDOW_POS_IS_OLD_CLOSED_WINDOW
1122 RECT rc2;
1123 #endif
1124 int max = 0;
1125 if(showflag){
1126 if(IsWindowVisible(hwnd))
1127 return;
1128 for(i=0;SubWindowHistory[i].hwnd!=NULL;i++)
1129 if(*(SubWindowHistory[i].hwnd)==hwnd)
1130 num = i;
1131 for(i=0;SubWindowHistory[i].hwnd!=NULL;i++)
1132 if(*(SubWindowHistory[i].hwnd)!=hwnd){
1133 if(SubWindowHistory[i].status > 0)
1134 SubWindowHistory[i].status += 1;
1135 if(SubWindowHistory[i].status>SubWindowMax){
1136 if(SubWindowHistory[i].status>max){
1137 GetWindowRect(*(SubWindowHistory[i].hwnd), &rc);
1138 max = SubWindowHistory[i].status;
1139 }
1140 ShowWindow(*(SubWindowHistory[i].hwnd),SW_HIDE);
1141 SubWindowHistory[i].status = 0;
1142 }
1143 }
1144 #ifdef SUBWINDOW_POS_IS_OLD_CLOSED_WINDOW
1145 // �T�u�E�C���h�E���ő吔���z���ĕ‚�����Â��E�C���h�E�ɍ��킹��d�l�͎~�߂邱�Ƃɂ����B
1146 if(max>0){
1147 GetWindowRect(hwnd, &rc2);
1148 MoveWindow(hwnd,rc.left,rc.top,rc2.right-rc2.left,rc2.bottom-rc2.top,TRUE);
1149 }
1150 #endif
1151 ShowWindow(hwnd,SW_SHOW);
1152 SubWindowHistory[num].status = 1;
1153 } else {
1154 if(!IsWindowVisible(hwnd))
1155 return;
1156 for(i=0;SubWindowHistory[i].hwnd!=NULL;i++)
1157 if(*(SubWindowHistory[i].hwnd)==hwnd)
1158 num = i;
1159 for(i=0;SubWindowHistory[i].hwnd!=NULL;i++)
1160 if(i!=num)
1161 if(SubWindowHistory[i].status>=SubWindowHistory[num].status)
1162 SubWindowHistory[i].status -= 1;
1163 ShowWindow(hwnd,SW_HIDE);
1164 SubWindowHistory[num].status = 0;
1165 }
1166 MainWndUpdateConsoleButton();
1167 MainWndUpdateListButton();
1168 MainWndUpdateTracerButton();
1169 MainWndUpdateDocButton();
1170 MainWndUpdateWrdButton();
1171 MainWndUpdateSoundSpecButton();
1172 }
1173
ToggleSubWindow(HWND hwnd)1174 void ToggleSubWindow(HWND hwnd)
1175 {
1176 if(IsWindowVisible(hwnd))
1177 ShowSubWindow(hwnd,0);
1178 else
1179 ShowSubWindow(hwnd,1);
1180 }
1181
OnShow(void)1182 void OnShow(void)
1183 {
1184 SUBWINDOW *s = subwindow;
1185 int i;
1186 for(i=0;s[i].hwnd!=NULL;i++)
1187 if(s[i].status & SWS_EXIST) {
1188 if(s[i].status & SWS_HIDE)
1189 ShowWindow(*(s[i].hwnd),SW_HIDE);
1190 else
1191 ShowWindow(*(s[i].hwnd),SW_SHOW);
1192 }
1193 }
1194
OnHide(void)1195 void OnHide(void)
1196 {
1197 SUBWINDOW *s = subwindow;
1198 int i;
1199 for(i=0;s[i].hwnd!=NULL;i++){
1200 if(s[i].status & SWS_EXIST)
1201 ShowWindow(*(s[i].hwnd),SW_HIDE);
1202 }
1203 }
1204
1205 #ifdef W32GUI_DEBUG
DebugThread(void * args)1206 void DebugThread(void *args)
1207 {
1208 MSG msg;
1209 DebugThreadExit = 0;
1210 InitDebugWnd(NULL);
1211 AttachThreadInput(GetWindowThreadProcessId(hDebugThread,NULL),
1212 GetWindowThreadProcessId(hWindowThread,NULL),TRUE);
1213 AttachThreadInput(GetWindowThreadProcessId(hWindowThread,NULL),
1214 GetWindowThreadProcessId(hDebugThread,NULL),TRUE);
1215 while( GetMessage(&msg,NULL,0,0) ){
1216 TranslateMessage(&msg);
1217 DispatchMessage(&msg);
1218 }
1219 DebugThreadExit = 1;
1220 crt_endthread();
1221 }
1222
DebugThreadInit(void)1223 void DebugThreadInit(void)
1224 {
1225 DWORD dwThreadID;
1226 if(!DebugThreadExit)
1227 return;
1228 hDebugThread = crt_beginthreadex(NULL,0,DebugThread,0,0,&dwThreadID);
1229 }
1230 #endif
1231
1232
1233
1234
1235
1236 //-----------------------------------------------------------------------------
1237 // Toolbar Main
1238
1239 static TBBUTTON MainTbb[] = {
1240 {4, IDM_STOP, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
1241 {3, IDM_PAUSE, TBSTATE_ENABLED, TBSTYLE_CHECK, 0, 0},
1242 {0, IDM_PREV, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
1243 {1, IDM_BACKWARD, TBSTATE_ENABLED,TBSTYLE_BUTTON, 0, 0},
1244 {2, IDM_PLAY, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
1245 {5, IDM_FOREWARD, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
1246 {6, IDM_NEXT, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0}
1247 };
1248
InitMainToolbar(HWND hwnd)1249 static void InitMainToolbar(HWND hwnd)
1250 {
1251 TBADDBITMAP MainTbab;
1252 SendDlgItemMessage(hwnd, IDC_TOOLBARWINDOW_MAIN,
1253 TB_BUTTONSTRUCTSIZE, (WPARAM)sizeof(TBBUTTON), 0);
1254 SendDlgItemMessage(hwnd, IDC_TOOLBARWINDOW_MAIN,
1255 TB_SETBUTTONSIZE, (WPARAM)0, (LPARAM)MAKELONG(16,16));
1256 MainTbab.hInst = hInst;
1257 MainTbab.nID =(int)IDB_BITMAP_MAIN_BUTTON;
1258 SendDlgItemMessage(hwnd, IDC_TOOLBARWINDOW_MAIN,
1259 TB_ADDBITMAP, 7, (LPARAM)&MainTbab);
1260 SendDlgItemMessage(hwnd, IDC_TOOLBARWINDOW_MAIN,
1261 TB_ADDBUTTONS, (WPARAM)7,(LPARAM)&MainTbb);
1262 SendDlgItemMessage(hwnd, IDC_TOOLBARWINDOW_MAIN,
1263 TB_AUTOSIZE, 0, 0);
1264 }
1265
1266 //-----------------------------------------------------------------------------
1267 // Toolbar SubWnd
1268
1269 static TBBUTTON SubWndTbb[] = {
1270 {3, IDM_CONSOLE, TBSTATE_ENABLED, TBSTYLE_CHECK, 0, 0},
1271 {1, IDM_LIST, TBSTATE_ENABLED, TBSTYLE_CHECK, 0, 0},
1272 {2, IDM_TRACER, TBSTATE_ENABLED, TBSTYLE_CHECK, 0, 0},
1273 {0, IDM_DOC, TBSTATE_ENABLED, TBSTYLE_CHECK, 0, 0},
1274 {4, IDM_WRD, TBSTATE_ENABLED, TBSTYLE_CHECK, 0, 0},
1275 };
1276
InitSubWndToolbar(HWND hwnd)1277 static void InitSubWndToolbar(HWND hwnd)
1278 {
1279 TBADDBITMAP SubWndTbab;
1280 SendDlgItemMessage(hwnd, IDC_TOOLBARWINDOW_SUBWND,
1281 TB_BUTTONSTRUCTSIZE, (WPARAM)sizeof(TBBUTTON), 0);
1282 SendDlgItemMessage(hwnd, IDC_TOOLBARWINDOW_SUBWND,
1283 TB_SETBUTTONSIZE, (WPARAM)0, (LPARAM)MAKELONG(16,16));
1284 SubWndTbab.hInst = hInst;
1285 SubWndTbab.nID =(int)IDB_BITMAP_SUBWND_BUTTON;
1286 SendDlgItemMessage(hwnd, IDC_TOOLBARWINDOW_SUBWND,
1287 TB_ADDBITMAP, 5, (LPARAM)&SubWndTbab);
1288 SendDlgItemMessage(hwnd, IDC_TOOLBARWINDOW_SUBWND,
1289 TB_ADDBUTTONS, (WPARAM)5,(LPARAM)&SubWndTbb);
1290 SendDlgItemMessage(hwnd, IDC_TOOLBARWINDOW_SUBWND,
1291 TB_AUTOSIZE, 0, 0);
1292 }
1293
1294
1295
1296 //-----------------------------------------------------------------------------
1297 // Canvas Window
1298
1299 #define MAPBAR_LIKE_TMIDI // note bar view like tmidi
1300 #define TM_CANVAS_XMAX 160
1301 #define TM_CANVAS_YMAX 160
1302 #define TM_CANVASMAP_XMAX 16
1303 #define TM_CANVASMAP_YMAX 16
1304 #define CANVAS_XMAX 160
1305 #define CANVAS_YMAX 160
1306 #define CMAP_XMAX 16
1307 #define CMAP_YMAX 16
1308 #define CK_MAX_CHANNELS 16
1309 #define CMAP_MODE_16 1
1310 #define CMAP_MODE_32 2
1311 #define CMAP_MAX_CHANNELS 32
1312 struct Canvas_ {
1313 HWND hwnd;
1314 HWND hParentWnd;
1315 RECT rcMe;
1316 int Mode;
1317 HDC hdc;
1318 HDC hmdc;
1319 HGDIOBJ hgdiobj_hmdcprev;
1320 int UpdateAll;
1321 int PaintDone;
1322 HANDLE hPopupMenu;
1323 HANDLE hPopupMenuKeyboard;
1324 // Sleep mode
1325 RECT rcSleep;
1326 HBITMAP hbitmap;
1327 HBITMAP hBitmapSleep;
1328 int SleepUpdateFlag;
1329 // Map mode
1330 RECT rcMap;
1331 char MapMap[CMAP_MAX_CHANNELS][CMAP_YMAX];
1332 char MapMapOld[CMAP_MAX_CHANNELS][CMAP_YMAX];
1333 char MapBar[CMAP_MAX_CHANNELS];
1334 char MapBarOld[CMAP_MAX_CHANNELS];
1335 int MapDelay;
1336 int MapResidual;
1337 int MapUpdateFlag;
1338 int MapMode;
1339 int MapBarWidth;
1340 int MapBarMax;
1341 int MapCh;
1342 int MapPan[CMAP_MAX_CHANNELS];
1343 int MapPanOld[CMAP_MAX_CHANNELS];
1344 int MapSustain[CMAP_MAX_CHANNELS];
1345 int MapSustainOld[CMAP_MAX_CHANNELS];
1346 int MapExpression[CMAP_MAX_CHANNELS];
1347 int MapExpressionOld[CMAP_MAX_CHANNELS];
1348 int MapVolume[CMAP_MAX_CHANNELS];
1349 int MapVolumeOld[CMAP_MAX_CHANNELS];
1350 int MapPitchbend[CMAP_MAX_CHANNELS];
1351 int MapPitchbendOld[CMAP_MAX_CHANNELS];
1352 int MapChChanged;
1353 ChannelBitMask DrumChannel;
1354 RECT rcMapMap;
1355 RECT rcMapSub;
1356 // Keyboard mode
1357 RECT rcKeyboard;
1358 uint32 CKxnote[MAX_W32G_MIDI_CHANNELS][4];
1359 uint32 CKxnote_old[MAX_W32G_MIDI_CHANNELS][4];
1360 int CKNoteFrom;
1361 int CKNoteTo;
1362 int CKCh;
1363 int CKPart;
1364 RECT rcGSLCD;
1365 int8 GSLCD[16][16];
1366 int8 GSLCD_old[16][16];
1367 int KeyboardUpdateFlag;
1368 int xnote_reset;
1369 // misc
1370 Channel channel[MAX_W32G_MIDI_CHANNELS];
1371 } volatile Canvas;
1372
1373 #define IDC_CANVAS 4242
1374
1375 static HWND hCanvasWnd;
1376 static char CanvasWndClassName[] = "TiMidity Canvas";
1377 static LRESULT CALLBACK CanvasWndProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam);
1378 static void CanvasPaintDo(void);
1379
1380 #define IDM_CANVAS_SLEEP 2321
1381 #define IDM_CANVAS_MAP 2322
1382 #define IDM_CANVAS_KEYBOARD 2323
1383 #define IDM_CANVAS_REDRAW 2324
1384 #define IDM_CANVAS_MAP16 2325
1385 #define IDM_CANVAS_MAP32 2326
1386 #define IDM_CANVAS_KEYBOARD_A 2327
1387 #define IDM_CANVAS_KEYBOARD_B 2328
1388 #define IDM_CANVAS_KEYBOARD_C 2329
1389 #define IDM_CANVAS_GSLCD 2330
InitCanvasWnd(HWND hwnd)1390 static void InitCanvasWnd(HWND hwnd)
1391 {
1392 WNDCLASS wndclass ;
1393 hCanvasWnd = 0;
1394 wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | CS_CLASSDC;
1395 wndclass.lpfnWndProc = CanvasWndProc ;
1396 wndclass.cbClsExtra = 0 ;
1397 wndclass.cbWndExtra = 0 ;
1398 wndclass.hInstance = hInst ;
1399 wndclass.hIcon = NULL;
1400 wndclass.hCursor = LoadCursor(0,IDC_ARROW) ;
1401 wndclass.hbrBackground = (HBRUSH)(COLOR_SCROLLBAR + 1);
1402 wndclass.lpszMenuName = NULL;
1403 wndclass.lpszClassName = CanvasWndClassName;
1404 RegisterClass(&wndclass);
1405 hCanvasWnd = CreateWindowEx(0,CanvasWndClassName,0,WS_CHILD,CW_USEDEFAULT,
1406 0,CANVAS_XMAX,CANVAS_YMAX,GetDlgItem(hwnd,IDC_RECT_CANVAS),0,hInst,0);
1407 CanvasInit(hCanvasWnd);
1408 CanvasReset();
1409 CanvasClear();
1410 CanvasReadPanelInfo(1);
1411 CanvasUpdate(1);
1412 CanvasPaintAll();
1413 ShowWindow(hCanvasWnd,SW_SHOW);
1414 UpdateWindow(hCanvasWnd);
1415 }
1416
1417 static LRESULT CALLBACK
CanvasWndProc(HWND hwnd,UINT uMess,WPARAM wParam,LPARAM lParam)1418 CanvasWndProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam)
1419 {
1420 switch (uMess)
1421 {
1422 case WM_CREATE:
1423 Canvas.hPopupMenuKeyboard = CreatePopupMenu();
1424 AppendMenu(Canvas.hPopupMenuKeyboard,MF_STRING,IDM_CANVAS_KEYBOARD_A,"A Part");
1425 AppendMenu(Canvas.hPopupMenuKeyboard,MF_STRING,IDM_CANVAS_KEYBOARD_B,"B Part");
1426 Canvas.hPopupMenu = CreatePopupMenu();
1427 AppendMenu(Canvas.hPopupMenu,MF_STRING,IDM_CANVAS_GSLCD,"LCD Mode");
1428 AppendMenu(Canvas.hPopupMenu,MF_STRING,IDM_CANVAS_MAP16,"Map16 Mode");
1429 AppendMenu(Canvas.hPopupMenu,MF_STRING,IDM_CANVAS_MAP32,"Map32 Mode");
1430 // AppendMenu(Canvas.hPopupMenu,MF_STRING,IDM_CANVAS_KEYBOARD,"Keyboard Mode");
1431 AppendMenu(Canvas.hPopupMenu,MF_POPUP,(UINT)Canvas.hPopupMenuKeyboard,"Keyboard Mode");
1432 AppendMenu(Canvas.hPopupMenu,MF_STRING,IDM_CANVAS_SLEEP,"Sleep Mode");
1433 AppendMenu(Canvas.hPopupMenu,MF_SEPARATOR,0,0);
1434 AppendMenu(Canvas.hPopupMenu,MF_STRING,IDM_CANVAS_REDRAW,"Redraw");
1435 break;
1436 case WM_DESTROY:
1437 DestroyMenu ( Canvas.hPopupMenuKeyboard );
1438 Canvas.hPopupMenuKeyboard = NULL;
1439 break;
1440 case WM_PAINT:
1441 CanvasPaintDo();
1442 return 0;
1443 case WM_LBUTTONDBLCLK:
1444 w32g_send_rc(RC_EXT_MODE_CHANGE, 0);
1445 break;
1446 case WM_RBUTTONDOWN:
1447 {
1448 RECT rc;
1449 GetWindowRect(Canvas.hwnd,(RECT *)&rc);
1450 SetForegroundWindow ( Canvas.hwnd );
1451 TrackPopupMenu(Canvas.hPopupMenu,TPM_TOPALIGN|TPM_LEFTALIGN,
1452 rc.left+(int)LOWORD(lParam),rc.top+(int)HIWORD(lParam),
1453 0,Canvas.hwnd,NULL);
1454 PostMessage ( Canvas.hwnd, WM_NULL, 0, 0 );
1455 }
1456 break;
1457 case WM_COMMAND:
1458 switch (LOWORD(wParam)) {
1459 case IDM_CANVAS_GSLCD:
1460 CanvasChange(CANVAS_MODE_GSLCD);
1461 break;
1462 case IDM_CANVAS_MAP16:
1463 Canvas.MapMode = CMAP_MODE_16;
1464 CanvasChange(CANVAS_MODE_MAP16);
1465 break;
1466 case IDM_CANVAS_MAP32:
1467 Canvas.MapMode = CMAP_MODE_32;
1468 CanvasChange(CANVAS_MODE_MAP32);
1469 break;
1470 case IDM_CANVAS_KEYBOARD:
1471 CanvasChange(CANVAS_MODE_KBD_A);
1472 break;
1473 case IDM_CANVAS_KEYBOARD_A:
1474 Canvas.CKPart = 1;
1475 CanvasChange(CANVAS_MODE_KBD_A);
1476 break;
1477 case IDM_CANVAS_KEYBOARD_B:
1478 Canvas.CKPart = 2;
1479 CanvasChange(CANVAS_MODE_KBD_B);
1480 break;
1481 case IDM_CANVAS_SLEEP:
1482 CanvasChange(CANVAS_MODE_SLEEP);
1483 break;
1484 case IDM_CANVAS_REDRAW:
1485 // PanelResetPart(PANELRESET_CHANNEL);
1486 CanvasReset();
1487 CanvasClear();
1488 CanvasReadPanelInfo(1);
1489 CanvasUpdate(1);
1490 CanvasPaintAll();
1491 break;
1492 }
1493 break;
1494 default:
1495 return DefWindowProc(hwnd,uMess,wParam,lParam) ;
1496 }
1497 return 0L;
1498 }
1499
1500 // Color
1501 #define CCR_FORE RGB(0x00,0x00,0x00)
1502 #define CCR_BACK RGB(0x00,0xf0,0x00)
1503 #define CCR_DFORE RGB(0x70,0x00,0x00)
1504 #define CCR_DBACK RGB(0x00,0xf0,0x00)
1505 #define CCR_LOW RGB(0x80,0xd0,0x00)
1506 #define CCR_MIDDLE RGB(0xb0,0xb0,0x00)
1507 #define CCR_HIGH RGB(0xe0,0x00,0x00)
1508 // �F�� m : n �ō�����
HalfColorMN(COLORREF fc,COLORREF bc,int m,int n)1509 static COLORREF HalfColorMN(COLORREF fc, COLORREF bc, int m, int n)
1510 {
1511 return fc*m/(m+n) + bc*n/(m+n);
1512 }
HalfColor23(COLORREF fc,COLORREF bc)1513 static COLORREF HalfColor23(COLORREF fc, COLORREF bc)
1514 {
1515 return HalfColorMN(fc,bc,2,3);
1516 }
HalfColor15(COLORREF fc,COLORREF bc)1517 static COLORREF HalfColor15(COLORREF fc, COLORREF bc)
1518 {
1519 return HalfColorMN(fc,bc,1,5);
1520 }
1521 #define CC_BACK 0
1522 #define CC_FORE 1
1523 #define CC_LOW 2
1524 #define CC_MIDDLE 3
1525 #define CC_HIGH 4
1526 #define CC_FORE_HALF 11
1527 #define CC_LOW_HALF 12
1528 #define CC_MIDDLE_HALF 13
1529 #define CC_HIGH_HALF 14
1530 #define CC_FORE_WEAKHALF 15
1531 #define CC_DBACK 21
1532 #define CC_DFORE 22
1533 #define CC_DFORE_HALF 23
1534 #define CC_DFORE_WEAKHALF 24
CanvasColor(int c)1535 static COLORREF CanvasColor(int c)
1536 {
1537 switch(c){
1538 case CC_BACK:
1539 return CCR_BACK;
1540 case CC_FORE:
1541 return CCR_FORE;
1542 case CC_FORE_HALF:
1543 return HalfColor15(CCR_FORE,CCR_BACK);
1544 case CC_FORE_WEAKHALF:
1545 return HalfColor23(CCR_FORE,CCR_BACK);
1546 case CC_DBACK:
1547 return CCR_DBACK;
1548 case CC_DFORE:
1549 return CCR_DFORE;
1550 case CC_DFORE_HALF:
1551 return HalfColor15(CCR_DFORE,CCR_DBACK);
1552 case CC_DFORE_WEAKHALF:
1553 return HalfColor23(CCR_DFORE,CCR_DBACK);
1554 case CC_LOW:
1555 return CCR_LOW;
1556 case CC_MIDDLE:
1557 return CCR_MIDDLE;
1558 case CC_HIGH:
1559 return CCR_HIGH;
1560 case CC_LOW_HALF:
1561 return HalfColor23(CCR_LOW,CCR_BACK);
1562 case CC_MIDDLE_HALF:
1563 return HalfColor23(CCR_MIDDLE,CCR_BACK);
1564 case CC_HIGH_HALF:
1565 return HalfColor23(CCR_HIGH,CCR_BACK);
1566 default:
1567 return CCR_BACK;
1568 }
1569 }
1570
1571 static int CanvasOK = 0;
CanvasInit(HWND hwnd)1572 static void CanvasInit(HWND hwnd)
1573 {
1574 RECT rc;
1575
1576 GDI_LOCK(); // gdi_lock
1577 Canvas.hwnd = hwnd;
1578 Canvas.hParentWnd = GetParent(Canvas.hwnd);
1579 GetClientRect(Canvas.hParentWnd,&rc);
1580 MoveWindow(Canvas.hwnd,0,0,rc.right-rc.left,rc.bottom-rc.top,FALSE);
1581 GetClientRect(Canvas.hwnd,(RECT *)&(Canvas.rcMe));
1582 Canvas.hdc = GetDC(Canvas.hwnd);
1583 Canvas.hbitmap = CreateCompatibleBitmap(Canvas.hdc,CANVAS_XMAX,CANVAS_YMAX);
1584 Canvas.hmdc = CreateCompatibleDC(Canvas.hdc);
1585 ReleaseDC(Canvas.hwnd,Canvas.hdc);
1586 Canvas.hBitmapSleep = LoadBitmap(hInst,MAKEINTRESOURCE(IDB_BITMAP_SLEEP));
1587 Canvas.hgdiobj_hmdcprev = SelectObject(Canvas.hmdc,Canvas.hbitmap);
1588
1589 SetRect((RECT *)&(Canvas.rcSleep),0,0,96,64);
1590 SetRect((RECT *)&(Canvas.rcMap),3,2+2,0,0);
1591 SetRect((RECT *)&(Canvas.rcKeyboard),1,1,0,0);
1592 SetRect((RECT *)&(Canvas.rcGSLCD),3,4,99,68);
1593 Canvas.rcMapMap.left = Canvas.rcMap.left;
1594 Canvas.rcMapMap.top = Canvas.rcMap.top;
1595 Canvas.rcMapMap.right = Canvas.rcMapMap.left + 6*16 - 1;
1596 Canvas.rcMapMap.bottom = Canvas.rcMapMap.top + 3*16 - 1;
1597 Canvas.rcMapSub.left = Canvas.rcMapMap.left;
1598 Canvas.rcMapSub.top = Canvas.rcMapMap.bottom + 2;
1599 Canvas.rcMapSub.right = Canvas.rcMapSub.left + 6*16 - 1;
1600 Canvas.rcMapSub.bottom = Canvas.rcMapSub.top +4+3+3+3+4 - 1;
1601 Canvas.MapDelay = 1;
1602 Canvas.MapResidual = 0;
1603 Canvas.MapMode = (MainWndInfo.CanvasMode == CANVAS_MODE_MAP32)
1604 ? CMAP_MODE_32 : CMAP_MODE_16;
1605 Canvas.MapBarMax = 16;
1606 // Canvas.CKNoteFrom = 24;
1607 // Canvas.CKNoteTo = 24 + 96;
1608 Canvas.CKNoteFrom = 12;
1609 Canvas.CKNoteTo = Canvas.CKNoteFrom + 96 + 3;
1610 Canvas.CKCh = 16;
1611 Canvas.CKPart = (MainWndInfo.CanvasMode == CANVAS_MODE_KBD_B) ? 2 : 1;
1612 Canvas.UpdateAll = 0;
1613 Canvas.Mode = (MainWndInfo.CanvasMode < CANVAS_MODE_GSLCD
1614 || MainWndInfo.CanvasMode > CANVAS_MODE_SLEEP)
1615 ? 1 : MainWndInfo.CanvasMode;
1616 Canvas.PaintDone = 0;
1617 GDI_UNLOCK(); // gdi_lock
1618 CanvasReset();
1619 CanvasOK = 1;
1620 }
1621
1622 // Canvas Map
1623
CanvasMapClear(void)1624 static void CanvasMapClear(void)
1625 {
1626 HPEN hPen;
1627 HBRUSH hBrush;
1628 HGDIOBJ hgdiobj_hpen, hgdiobj_hbrush;
1629 if(!CanvasOK)
1630 return;
1631 GDI_LOCK(); // gdi_lock
1632 hPen = CreatePen(PS_SOLID,1,CanvasColor(CC_BACK));
1633 hBrush = CreateSolidBrush(CanvasColor(CC_BACK));
1634 hgdiobj_hpen = SelectObject(Canvas.hmdc, hPen);
1635 hgdiobj_hbrush = SelectObject(Canvas.hmdc, hBrush);
1636 Rectangle(Canvas.hmdc,
1637 Canvas.rcMe.left,Canvas.rcMe.top,Canvas.rcMe.right,Canvas.rcMe.bottom);
1638 SelectObject(Canvas.hmdc, hgdiobj_hpen);
1639 DeleteObject(hPen);
1640 SelectObject(Canvas.hmdc, hgdiobj_hbrush);
1641 DeleteObject(hBrush);
1642 GDI_UNLOCK(); // gdi_lock
1643 InvalidateRect(hCanvasWnd, NULL, FALSE);
1644 }
1645
CanvasMapReset(void)1646 static void CanvasMapReset(void)
1647 {
1648 int i,j,ch;
1649 if(!CanvasOK)
1650 return;
1651 switch(Canvas.MapMode){
1652 case CMAP_MODE_32:
1653 Canvas.MapCh = 32;
1654 #ifdef MAPBAR_LIKE_TMIDI
1655 Canvas.MapBarWidth = 5;
1656 Canvas.MapBarMax = 10+1;
1657 Canvas.rcMapMap.bottom = Canvas.rcMapMap.top + 3*Canvas.MapBarMax*2 + 6 - 1;
1658 #else
1659 Canvas.MapBarWidth = 2;
1660 Canvas.MapBarMax = 16;
1661 Canvas.rcMapMap.bottom = Canvas.rcMapMap.top + 3*Canvas.MapBarMax - 1;
1662 #endif
1663 break;
1664 default:
1665 case CMAP_MODE_16:
1666 Canvas.MapCh = 16;
1667 Canvas.MapBarWidth = 5;
1668 Canvas.MapBarMax = 16;
1669 Canvas.rcMapMap.bottom = Canvas.rcMapMap.top + 3*Canvas.MapBarMax - 1;
1670 break;
1671 }
1672 for(i=0;i<Canvas.MapCh;i++){
1673 for(j=0;j<Canvas.MapBarMax;j++){
1674 Canvas.MapMap[i][j] = CC_FORE_HALF;
1675 Canvas.MapMapOld[i][j] = -1;
1676 }
1677 Canvas.MapBar[i] = -1;
1678 Canvas.MapBarOld[i] = -1;
1679 }
1680 for(ch=0;ch<Canvas.MapCh;ch++){
1681 Canvas.MapPan[ch] = Canvas.MapPanOld[ch] = 2;
1682 Canvas.MapSustain[ch] = Canvas.MapSustainOld[ch] = 0;
1683 Canvas.MapExpression[ch] = Canvas.MapExpressionOld[ch] = 0;
1684 Canvas.MapVolume[ch] = Canvas.MapVolumeOld[ch] = 0;
1685 Canvas.MapPitchbend[ch] = Canvas.MapPitchbendOld[ch] = 0x2000;
1686 }
1687 Canvas.MapResidual = -1;
1688 Canvas.MapUpdateFlag = 1;
1689 Canvas.PaintDone = 0;
1690 }
1691
CanvasMapReadPanelInfo(int flag)1692 static void CanvasMapReadPanelInfo(int flag)
1693 {
1694 int ch,v;
1695
1696 if(!CanvasOK)
1697 return;
1698 if(!PInfoOK)
1699 return;
1700 if(Canvas.UpdateAll)
1701 flag = 1;
1702 if(!Panel->changed && !flag)
1703 return;
1704 // Bar
1705 Canvas.DrumChannel = drumchannels;
1706 for(ch=0;ch<Canvas.MapCh;ch++){
1707 Canvas.MapBarOld[ch] = Canvas.MapBar[ch];
1708 if(Panel->v_flags[ch] == FLAG_NOTE_ON){
1709 #if 0
1710 v = Panel->ctotal[ch]/8;
1711 #else
1712 v = (int) Panel->ctotal[ch] * Canvas.MapBarMax / 128;
1713 #endif
1714 } else {
1715 v = 0;
1716 }
1717 if(v<0) v = 0; else if(v>Canvas.MapBarMax-1) v = Canvas.MapBarMax-1;
1718 if(v != Canvas.MapBar[ch]){
1719 // �x��
1720 if(Canvas.MapDelay){
1721 int old = Canvas.MapBar[ch];
1722 if(Canvas.MapBar[ch]<0)
1723 Canvas.MapBar[ch] = v;
1724 else
1725 Canvas.MapBar[ch] = (old*10*1/3 + v*10*2/3)/10;
1726 if(old == Canvas.MapBar[ch]){
1727 if(v>old)
1728 Canvas.MapBar[ch] = old + 1;
1729 else if(v<old)
1730 Canvas.MapBar[ch] = old - 1;
1731 }
1732 } else
1733 Canvas.MapBar[ch] = v;
1734 }
1735 if(Canvas.MapBarOld[ch] != Canvas.MapBar[ch])
1736 Canvas.MapResidual = -1;
1737 }
1738 // Sub
1739 if(Canvas.MapMode==CMAP_MODE_16){
1740 Canvas.MapChChanged = 0;
1741 for(ch=0;ch<Canvas.MapCh;ch++){
1742 int changed = 0;
1743 Canvas.MapPanOld[ch] = Canvas.MapPan[ch];
1744 Canvas.MapSustainOld[ch] = Canvas.MapSustain[ch];
1745 Canvas.MapExpressionOld[ch] = Canvas.MapExpression[ch];
1746 Canvas.MapVolumeOld[ch] = Canvas.MapVolume[ch];
1747 Canvas.MapPitchbendOld[ch] = Canvas.MapPitchbend[ch];
1748 if(Panel->channel[ch].panning==NO_PANNING)
1749 Canvas.MapPan[ch] = -1;
1750 else {
1751 Canvas.MapPan[ch] = ( Panel->channel[ch].panning - 64 ) * 3 /128;
1752 // Canvas.MapPan[ch] = ( 64 - Panel->channel[ch].panning ) * 3 /128;
1753 Canvas.MapPan[ch] = SetValue(Canvas.MapPan[ch],-2,2) + 2;
1754 }
1755 if(Panel->channel[ch].sustain)
1756 Canvas.MapSustain[ch] = 5;
1757 else
1758 Canvas.MapSustain[ch] = 0;
1759 //Canvas.MapSustain[ch] = SetValue(Canvas.MapSustain[ch],0,10);
1760 #if 0
1761 Canvas.MapExpression[ch] = (Panel->channel[ch].expression * 11) >>8;
1762 #else
1763 Canvas.MapExpression[ch] = (Panel->channel[ch].expression * 11) >>7;
1764 #endif
1765 Canvas.MapExpression[ch] = SetValue(Canvas.MapExpression[ch],0,10);
1766 #if 0
1767 Canvas.MapVolume[ch] = (Panel->channel[ch].volume * 11) >>8;
1768 #else
1769 Canvas.MapVolume[ch] = (Panel->channel[ch].volume * 11) >>7;
1770 #endif
1771 Canvas.MapVolume[ch] = SetValue(Canvas.MapVolume[ch],0,10);
1772 Canvas.MapPitchbend[ch] = Panel->channel[ch].pitchbend;
1773 if(Canvas.MapPanOld[ch]!=Canvas.MapPan[ch]) changed = 1;
1774 if(Canvas.MapSustainOld[ch]!=Canvas.MapSustain[ch]) changed = 1;
1775 if(Canvas.MapExpressionOld[ch]!=Canvas.MapExpression[ch]) changed = 1;
1776 if(Canvas.MapVolumeOld[ch]!=Canvas.MapVolume[ch]) changed = 1;
1777 if(Canvas.MapPitchbendOld[ch]!=Canvas.MapPitchbend[ch]) changed = 1;
1778 if(changed)
1779 Canvas.MapChChanged |= 1 << ch;
1780 }
1781 }
1782 }
1783
CanvasMapDrawMapBar(int flag)1784 static void CanvasMapDrawMapBar(int flag)
1785 {
1786 int i,ch;
1787
1788 if(!CanvasOK)
1789 return;
1790 if(Canvas.UpdateAll)
1791 flag = 1;
1792 if(!Canvas.MapResidual && !flag)
1793 return;
1794 Canvas.MapResidual = 0;
1795 for(ch=0;ch<Canvas.MapCh;ch++){
1796 int drumflag = IS_SET_CHANNELMASK(Canvas.DrumChannel,ch);
1797 char color1,color2,color3;
1798 if(drumflag){
1799 color1 = CC_DFORE;
1800 color2 = CC_DFORE_WEAKHALF;
1801 color3 = CC_DFORE_HALF;
1802 } else {
1803 color1 = CC_FORE;
1804 color2 = CC_FORE_WEAKHALF;
1805 color3 = CC_FORE_HALF;
1806 }
1807 for(i=0;i<Canvas.MapBarMax;i++){
1808 int y = Canvas.MapBarMax-1-i;
1809 Canvas.MapMapOld[ch][y] = Canvas.MapMap[ch][y];
1810 if(i<=Canvas.MapBar[ch]){
1811 Canvas.MapMap[ch][y] = color1;
1812 Canvas.MapResidual = 1;
1813 #if 1 // �c��
1814 } else if(i<=Canvas.MapBarOld[ch]){
1815 Canvas.MapMap[ch][y] = color2;
1816 Canvas.MapResidual = 1;
1817 #endif
1818 } else {
1819 Canvas.MapMap[ch][y] = color3;
1820 }
1821 }
1822 }
1823 if(Canvas.MapResidual==0)
1824 Canvas.MapResidual = -1;
1825 }
1826
1827 // #define CMAP_ALL_UPDATE
CanvasMapUpdate(int flag)1828 static void CanvasMapUpdate(int flag)
1829 {
1830 RECT rc;
1831 int i,j;
1832 int change_flag = 0;
1833 if(!CanvasOK)
1834 return;
1835 CanvasMapDrawMapBar(flag);
1836 if(Canvas.UpdateAll)
1837 flag = 1;
1838 if(PInfoOK && Canvas.MapMode==CMAP_MODE_16){
1839 if(flag || Panel->changed){
1840 int ch;
1841 GDI_LOCK();
1842 for(ch=0;ch<Canvas.MapCh;ch++){
1843 int x,y;
1844 COLORREF color;
1845 COLORREF colorFG, colorBG;
1846 int drumflag = IS_SET_CHANNELMASK(Canvas.DrumChannel,ch);
1847 if(!flag && !(Canvas.MapChChanged & (1<<ch)))
1848 continue;
1849 if(drumflag){
1850 colorFG = CanvasColor(CC_DFORE);
1851 colorBG = CanvasColor(CC_DFORE_HALF);
1852 } else {
1853 colorFG = CanvasColor(CC_FORE);
1854 colorBG = CanvasColor(CC_FORE_HALF);
1855 }
1856 rc.left = Canvas.rcMapSub.left + (5 + 1) * ch;
1857 rc.right = rc.left + 5 - 1;
1858 // PAN
1859 rc.top = Canvas.rcMapSub.top;
1860 rc.bottom = rc.top + 3 - 1;
1861 for(x=rc.left;x<=rc.right;x++){
1862 for(y=rc.top;y<=rc.bottom;y++)
1863 SetPixelV(Canvas.hmdc,x,y,colorBG);
1864 }
1865 if(Canvas.MapPan[ch]>=0){
1866 x = rc.left + Canvas.MapPan[ch];
1867 for(y=rc.top;y<=rc.bottom;y++)
1868 SetPixelV(Canvas.hmdc,x,y,colorFG);
1869 }
1870 // SUSTAIN
1871 rc.top = rc.bottom + 2;
1872 rc.bottom = rc.top + 2 - 1;
1873 if(Canvas.MapSustain[ch]){
1874 for(x=rc.left;x<=rc.right;x++){
1875 for(y=rc.top;y<=rc.bottom;y++)
1876 SetPixelV(Canvas.hmdc,x,y,colorFG);
1877 }
1878 } else {
1879 for(x=rc.left;x<=rc.right;x++){
1880 for(y=rc.top;y<=rc.bottom;y++)
1881 SetPixelV(Canvas.hmdc,x,y,colorBG);
1882 }
1883 // EXPRESSION
1884 rc.top = rc.bottom + 2;
1885 rc.bottom = rc.top + 2 - 1;
1886 for(i=1;i<=10;i++){
1887 if(i <= Canvas.MapExpression[ch])
1888 color = colorFG;
1889 else
1890 color = colorBG;
1891 x = rc.left + (i-1)/2;
1892 y = rc.top + (i+1)%2;
1893 SetPixelV(Canvas.hmdc,x,y,color);
1894 }
1895 // VOLUME
1896 rc.top = rc.bottom + 2;
1897 rc.bottom = rc.top + 2 - 1;
1898 for(i=1;i<=10;i++){
1899 if(i <= Canvas.MapVolume[ch])
1900 color = colorFG;
1901 else
1902 color = colorBG;
1903 x = rc.left + (i-1)/2;
1904 y = rc.top + (i+1)%2;
1905 SetPixelV(Canvas.hmdc,x,y,color);
1906 }
1907 // PITCH_BEND
1908 rc.top = rc.bottom + 2;
1909 rc.bottom = rc.top + 3 - 1;
1910 for(x=rc.left;x<=rc.right;x++){
1911 for(y=rc.top;y<=rc.bottom;y++)
1912 SetPixelV(Canvas.hmdc,x,y,colorBG);
1913 }
1914 if(Canvas.MapPitchbend[ch]==-2){
1915 y = rc.top + 1;
1916 for(x=rc.left;x<=rc.right;x++)
1917 SetPixelV(Canvas.hmdc,x,y,colorFG);
1918 y++;
1919 for(x=rc.left;x<=rc.right;x++)
1920 SetPixelV(Canvas.hmdc,x,y,colorFG);
1921 } else if(Canvas.MapPitchbend[ch]>0x2000){
1922 y = rc.top;
1923 for(x=rc.left;x<=rc.left;x++)
1924 SetPixelV(Canvas.hmdc,x,y,colorFG);
1925 y++;
1926 for(x=rc.left;x<=rc.left+2;x++)
1927 SetPixelV(Canvas.hmdc,x,y,colorFG);
1928 y++;
1929 for(x=rc.left;x<=rc.left+4;x++)
1930 SetPixelV(Canvas.hmdc,x,y,colorFG);
1931 } else if(Canvas.MapPitchbend[ch]<0x2000){
1932 y = rc.top;
1933 for(x=rc.right;x<=rc.right;x++)
1934 SetPixelV(Canvas.hmdc,x,y,colorFG);
1935 y++;
1936 for(x=rc.right-2;x<=rc.right;x++)
1937 SetPixelV(Canvas.hmdc,x,y,colorFG);
1938 y++;
1939 for(x=rc.right-4;x<=rc.right;x++)
1940 SetPixelV(Canvas.hmdc,x,y,colorFG);
1941 }
1942 }
1943 }
1944 InvalidateRect(hCanvasWnd,(RECT *)&(Canvas.rcMapSub),FALSE);
1945 GDI_UNLOCK();
1946 }
1947 }
1948 if(!Canvas.MapResidual && !flag)
1949 return;
1950 change_flag = 0;
1951 #ifndef MAPBAR_LIKE_TMIDI
1952 GDI_LOCK();
1953 for(i=0;i<Canvas.MapCh;i++){
1954 for(j=0;j<Canvas.MapBarMax;j++){
1955 if(Canvas.MapMap[i][j]!=Canvas.MapMapOld[i][j] || flag){
1956 int x,y;
1957 COLORREF color = CanvasColor(Canvas.MapMap[i][j]);
1958 rc.left = Canvas.rcMap.left + (Canvas.MapBarWidth + 1) * i;
1959 rc.right = rc.left -1 + Canvas.MapBarWidth;
1960 rc.top = Canvas.rcMap.top + (2 + 1) * j;
1961 rc.bottom = rc.top -1 + 2;
1962 for(x=rc.left;x<=rc.right;x++)
1963 for(y=rc.top;y<=rc.bottom;y++)
1964 SetPixelV(Canvas.hmdc,x,y,color);
1965 change_flag = 1;
1966 }
1967 }
1968 }
1969 GDI_UNLOCK();
1970 #else
1971 GDI_LOCK();
1972 if(Canvas.MapMode==CMAP_MODE_16){
1973 for(i=0;i<Canvas.MapCh;i++){
1974 for(j=0;j<Canvas.MapBarMax;j++){
1975 if(Canvas.MapMap[i][j]!=Canvas.MapMapOld[i][j] || flag){
1976 int x,y;
1977 COLORREF color = CanvasColor(Canvas.MapMap[i][j]);
1978 rc.left = Canvas.rcMap.left + (Canvas.MapBarWidth + 1) * i;
1979 rc.right = rc.left -1 + Canvas.MapBarWidth;
1980 rc.top = Canvas.rcMap.top + (2 + 1) * j;
1981 rc.bottom = rc.top -1 + 2;
1982 for(x=rc.left;x<=rc.right;x++){
1983 for(y=rc.top;y<=rc.bottom;y++)
1984 SetPixelV(Canvas.hmdc,x,y,color);
1985 }
1986 change_flag = 1;
1987 }
1988 }
1989 }
1990 } else {
1991 for(i=0;i<Canvas.MapCh;i++){
1992 for(j=0;j<Canvas.MapBarMax;j++){
1993 if(Canvas.MapMap[i][j]!=Canvas.MapMapOld[i][j] || flag){
1994 int x,y;
1995 COLORREF color = CanvasColor(Canvas.MapMap[i][j]);
1996 if(i<=15){
1997 rc.left = Canvas.rcMap.left + (Canvas.MapBarWidth + 1) * i;
1998 rc.right = rc.left -1 + Canvas.MapBarWidth;
1999 rc.top = -1 + Canvas.rcMap.top + (2 + 1) * j;
2000 rc.bottom = rc.top -1 + 2;
2001 } else {
2002 rc.left = Canvas.rcMap.left + (Canvas.MapBarWidth + 1) * (i-16);
2003 rc.right = rc.left -1 + Canvas.MapBarWidth;
2004 rc.top = -1 + Canvas.rcMap.top + (2 + 1) * j + Canvas.MapBarMax*(2+1) + 2 ;
2005 rc.bottom = rc.top -1 + 2;
2006 }
2007 for(x=rc.left;x<=rc.right;x++)
2008 for(y=rc.top;y<=rc.bottom;y++)
2009 SetPixelV(Canvas.hmdc,x,y,color);
2010 change_flag = 1;
2011 }
2012 }
2013 }
2014 }
2015 GDI_UNLOCK();
2016 #endif
2017 #ifdef CMAP_ALL_UPDATE
2018 if(change_flag)
2019 InvalidateRect(hCanvasWnd,NULL,FALSE);
2020 #else
2021 if(change_flag)
2022 InvalidateRect(hCanvasWnd,(RECT *)&(Canvas.rcMapMap),FALSE);
2023 #endif
2024 if(Canvas.UpdateAll)
2025 InvalidateRect(hCanvasWnd,NULL,FALSE);
2026 if(Canvas.MapResidual<0)
2027 Canvas.MapResidual = 0;
2028 }
2029
CanvasSleepClear(void)2030 static void CanvasSleepClear(void)
2031 {
2032 RECT rc;
2033 HPEN hPen;
2034 HBRUSH hBrush;
2035 HGDIOBJ hgdiobj_hpen, hgdiobj_hbrush;
2036 GDI_LOCK(); // gdi_lock
2037 hPen = CreatePen(PS_SOLID,1,GetSysColor(COLOR_SCROLLBAR));
2038 hBrush = CreateSolidBrush(GetSysColor(COLOR_SCROLLBAR));
2039 hgdiobj_hpen = SelectObject(Canvas.hmdc, hPen);
2040 hgdiobj_hbrush = SelectObject(Canvas.hmdc, hBrush);
2041 GetClientRect(Canvas.hwnd, &rc);
2042 Rectangle(Canvas.hmdc,rc.left,rc.top,rc.right,rc.bottom);
2043 SelectObject(Canvas.hmdc, hgdiobj_hpen);
2044 DeleteObject(hPen);
2045 SelectObject(Canvas.hmdc, hgdiobj_hbrush);
2046 DeleteObject(hBrush);
2047 GDI_UNLOCK(); // gdi_lock
2048 InvalidateRect(hCanvasWnd, NULL, FALSE);
2049 }
2050
CanvasSleepReset(void)2051 static void CanvasSleepReset(void)
2052 {
2053 Canvas.PaintDone = 0;
2054 }
2055
CanvasSleepReadPanelInfo(int flag)2056 static void CanvasSleepReadPanelInfo(int flag)
2057 {
2058 }
2059
2060 static int CanvasSleepDone = 0;
CanvasSleepUpdate(int flag)2061 static void CanvasSleepUpdate(int flag)
2062 {
2063 HDC hdc;
2064 RECT rc;
2065 int x,y;
2066 CanvasSleepReset();
2067 GDI_LOCK(); // gdi_lock
2068 hdc = CreateCompatibleDC(Canvas.hmdc);
2069 SelectObject(hdc,Canvas.hBitmapSleep);
2070 GetClientRect(Canvas.hwnd, &rc);
2071 x = (rc.right - rc.left - Canvas.rcSleep.right)/2;
2072 y = (rc.bottom - rc.top - Canvas.rcSleep.bottom)/2;
2073 if(x<0) x = 0;
2074 if(y<0) y = 0;
2075 BitBlt(Canvas.hmdc,x,y,Canvas.rcSleep.right,Canvas.rcSleep.bottom,hdc,0,0,SRCCOPY);
2076 DeleteDC(hdc);
2077 GDI_UNLOCK(); // gdi_lock
2078 }
2079
2080 // Canvas GSLCD
2081
CanvasGSLCDReset(void)2082 static void CanvasGSLCDReset(void)
2083 {
2084 int i, j;
2085 for(i = 0; i < 16; i++) {
2086 for(j = 0; j < 16; j++) {
2087 Canvas.GSLCD[i][j] = 0;
2088 Canvas.GSLCD_old[i][j] = 0;
2089 }
2090 }
2091 Canvas.PaintDone = 0;
2092 }
2093
CanvasGSLCDReadPanelInfo(int flag)2094 static void CanvasGSLCDReadPanelInfo(int flag)
2095 {
2096 int i, j;
2097 if (!CanvasOK) {return;}
2098 if (!PInfoOK) {return;}
2099 if (Canvas.UpdateAll) {flag = 1;}
2100 if (!Panel->changed && !flag) {return;}
2101 for(i = 0; i < 16; i++) {
2102 for(j = 0; j < 16; j++) {
2103 Canvas.GSLCD_old[i][j] = Canvas.GSLCD[i][j];
2104 Canvas.GSLCD[i][j] = Panel->GSLCD[i][j];
2105 }
2106 }
2107 }
2108
2109 #define CGSLCD_BG RGB(0x00,0xf0,0x00)
2110 #define CGSLCD_ON RGB(0x00,0x00,0x00)
2111 #define CGSLCD_OFF RGB(0x00,0xc0,0x00)
CanvasGSLCDUpdate(int flag)2112 static void CanvasGSLCDUpdate(int flag)
2113 {
2114 int i, j, x, y, changed = 0;
2115 COLORREF colorON = CGSLCD_ON, colorOFF = CGSLCD_OFF;
2116 HPEN hPen;
2117 HBRUSH hBrush;
2118 HGDIOBJ hgdiobj_hpen, hgdiobj_hbrush;
2119
2120 if(!PInfoOK) {return;}
2121 if(Canvas.UpdateAll) {flag = 1;}
2122 if(!Panel->changed && !flag) {return;}
2123 GDI_LOCK(); // gdi_lock
2124 for (i = 0; i < 16; i++) {
2125 for (j = 0; j < 16; j++) {
2126 x = Canvas.rcGSLCD.left + i * 6;
2127 y = Canvas.rcGSLCD.top + j * 4;
2128 if (flag || Canvas.GSLCD[i][j] != Canvas.GSLCD_old[i][j]) {
2129 changed = 1;
2130 if (Canvas.GSLCD[i][j] == 1) {
2131 hPen = CreatePen(PS_SOLID, 1, colorON);
2132 hBrush = CreateSolidBrush(colorON);
2133 }
2134 else {
2135 hPen = CreatePen(PS_SOLID, 1, colorOFF);
2136 hBrush = CreateSolidBrush(colorOFF);
2137 }
2138 hgdiobj_hpen = SelectObject(Canvas.hmdc, hPen);
2139 hgdiobj_hbrush = SelectObject(Canvas.hmdc, hBrush);
2140 Rectangle(Canvas.hmdc, x, y, x + 5, y + 3);
2141 SelectObject(Canvas.hmdc, hgdiobj_hpen);
2142 DeleteObject(hPen);
2143 SelectObject(Canvas.hmdc, hgdiobj_hbrush);
2144 DeleteObject(hBrush);
2145 }
2146 }
2147 }
2148 if (changed) {
2149 GDI_UNLOCK();
2150 InvalidateRect(Canvas.hwnd, (RECT *)&Canvas.rcGSLCD, FALSE);
2151 GDI_LOCK();
2152 }
2153 GDI_UNLOCK(); // gdi_lock
2154 if(flag) {InvalidateRect(hCanvasWnd, NULL, FALSE);}
2155 }
2156
CanvasGSLCDClear(void)2157 static void CanvasGSLCDClear(void)
2158 {
2159 HPEN hPen;
2160 HBRUSH hBrush;
2161 HGDIOBJ hgdiobj_hpen, hgdiobj_hbrush;
2162 COLORREF BGcolor;
2163 if(!CanvasOK)
2164 return;
2165 GDI_LOCK(); // gdi_lock
2166 BGcolor = RGB(0,0,0);
2167 hPen = CreatePen(PS_SOLID,1,BGcolor);
2168 hBrush = CreateSolidBrush(BGcolor);
2169 hgdiobj_hpen = SelectObject(Canvas.hmdc, hPen);
2170 hgdiobj_hbrush = SelectObject(Canvas.hmdc, hBrush);
2171 Rectangle(Canvas.hmdc,
2172 Canvas.rcMe.left,Canvas.rcMe.top,Canvas.rcMe.right,Canvas.rcMe.bottom);
2173 SelectObject(Canvas.hmdc, hgdiobj_hpen);
2174 DeleteObject(hPen);
2175 SelectObject(Canvas.hmdc, hgdiobj_hbrush);
2176 DeleteObject(hBrush);
2177 BGcolor = CGSLCD_BG;
2178 hPen = CreatePen(PS_SOLID,1,BGcolor);
2179 hBrush = CreateSolidBrush(BGcolor);
2180 hgdiobj_hpen = SelectObject(Canvas.hmdc, hPen);
2181 hgdiobj_hbrush = SelectObject(Canvas.hmdc, hBrush);
2182 Rectangle(Canvas.hmdc,
2183 Canvas.rcMe.left + 1,Canvas.rcMe.top + 1,Canvas.rcMe.right - 1,Canvas.rcMe.bottom - 1);
2184 SelectObject(Canvas.hmdc, hgdiobj_hpen);
2185 DeleteObject(hPen);
2186 SelectObject(Canvas.hmdc, hgdiobj_hbrush);
2187 DeleteObject(hBrush);
2188 GDI_UNLOCK(); // gdi_lock
2189
2190 CanvasGSLCDReset();
2191 CanvasGSLCDReadPanelInfo(1);
2192 CanvasGSLCDUpdate(1);
2193 InvalidateRect(hCanvasWnd, NULL, FALSE);
2194 }
2195
2196 // Canvas Keyboard
2197
CanvasKeyboardReset(void)2198 static void CanvasKeyboardReset(void)
2199 {
2200 int i,j;
2201 int ChFrom = (Canvas.CKPart - 1) * Canvas.CKCh;
2202 int ChTo = Canvas.CKPart * Canvas.CKCh - 1;
2203 for(i=ChFrom;i<=ChTo;i++){
2204 for(j=0;j<4;j++){
2205 Canvas.CKxnote[i][j] = 0;
2206 Canvas.CKxnote_old[i][j] = 0;
2207 }
2208 }
2209 Canvas.PaintDone = 0;
2210 }
2211
CanvasKeyboardReadPanelInfo(int flag)2212 static void CanvasKeyboardReadPanelInfo(int flag)
2213 {
2214 int i,j;
2215 int ChFrom, ChTo;
2216 if(!CanvasOK)
2217 return;
2218 if(!PInfoOK)
2219 return;
2220 ChFrom = (Canvas.CKPart - 1) * Canvas.CKCh;
2221 ChTo = Canvas.CKPart * Canvas.CKCh - 1;
2222 if(Canvas.UpdateAll)
2223 flag = 1;
2224 if(!Panel->changed && !flag)
2225 return;
2226 for(i=ChFrom;i<=ChTo;i++)
2227 for(j=0;j<4;j++){
2228 Canvas.CKxnote_old[i][j] = Canvas.CKxnote[i][j];
2229 Canvas.CKxnote[i][j] = Panel->xnote[i][j];
2230 }
2231 }
2232
2233 #define CK_KEY_BLACK 1
2234 #define CK_KEY_WHITE 2
2235 #define CK_ON RGB(0xff,0x00,0x00)
2236 #define CK_OFF_WHITE RGB(0xff,0xff,0xff)
2237 #define CK_OFF_BLACK RGB(0x00,0x00,0x00)
2238 #define CK_DOFF_WHITE RGB(0xcc,0xcc,0xcc)
2239 #define CK_DOFF_BLACK RGB(0x00,0x00,0x00)
CanvasKeyboardUpdate(int flag)2240 static void CanvasKeyboardUpdate(int flag)
2241 {
2242 int j,k,l;
2243 int channel;
2244 int ChFrom, ChTo;
2245
2246 if(!PInfoOK)
2247 return;
2248 if(Canvas.UpdateAll)
2249 flag = 1;
2250 if(!COMPARE_CHANNELMASK(Canvas.DrumChannel,drumchannels))
2251 flag = 1;
2252 if(!Panel->changed && !flag)
2253 return;
2254 ChFrom = (Canvas.CKPart - 1) * Canvas.CKCh;
2255 ChTo = Canvas.CKPart * Canvas.CKCh - 1;
2256 GDI_LOCK(); // gdi_lock
2257 for(channel=ChFrom;channel<=ChTo;channel++){
2258 int change_flag = 0;
2259 int drumflag = IS_SET_CHANNELMASK(drumchannels,channel);
2260 COLORREF colorON, colorOFF_WHITE, colorOFF_BLACK;
2261 if(drumflag){
2262 colorON = CK_ON;
2263 colorOFF_WHITE = CK_DOFF_WHITE;
2264 colorOFF_BLACK = CK_OFF_BLACK;
2265 } else {
2266 colorON = CK_ON;
2267 colorOFF_WHITE = CK_OFF_WHITE;
2268 colorOFF_BLACK = CK_OFF_BLACK;
2269 }
2270 for(j=0;j<4;j++){
2271 int32 xnote, xnote_diff;
2272 xnote = Canvas.CKxnote[channel][j];
2273 xnote_diff = Canvas.CKxnote[channel][j] ^ Canvas.CKxnote_old[channel][j];
2274 if(!flag && xnote_diff == 0)
2275 continue;
2276 for(k=0;k<32;k++){
2277 int key = 0;
2278 int KeyOn = 0;
2279 int note = j*32+k;
2280 int reff = (int32)1 << k;
2281 int x,y;
2282 if(note < Canvas.CKNoteFrom || note > Canvas.CKNoteTo)
2283 continue;
2284 if(!flag && !(xnote_diff & reff))
2285 continue;
2286 if(xnote & reff)
2287 KeyOn = 1;
2288 note = note % 12;
2289 if(note == 1 || note == 3 || note == 6 || note == 8 || note == 10)
2290 key = CK_KEY_BLACK;
2291 else
2292 key = CK_KEY_WHITE;
2293 x = Canvas.rcKeyboard.left + j * 32 + k - Canvas.CKNoteFrom;
2294 y = Canvas.rcKeyboard.top + (channel - ChFrom) * 4;
2295 switch(key){
2296 case CK_KEY_BLACK:
2297 if(KeyOn){
2298 for(l=0;l<2;l++)
2299 SetPixelV(Canvas.hmdc,x,y+l,colorON);
2300 SetPixelV(Canvas.hmdc,x,y+2,colorOFF_WHITE);
2301 } else {
2302 for(l=0;l<2;l++)
2303 SetPixelV(Canvas.hmdc,x,y+l,colorOFF_BLACK);
2304 SetPixelV(Canvas.hmdc,x,y+2,colorOFF_WHITE);
2305 }
2306 break;
2307 case CK_KEY_WHITE:
2308 if(KeyOn){
2309 SetPixelV(Canvas.hmdc,x,y,colorOFF_WHITE);
2310 for(l=1;l<3;l++)
2311 SetPixelV(Canvas.hmdc,x,y+l,colorON);
2312 } else {
2313 SetPixelV(Canvas.hmdc,x,y,colorOFF_WHITE);
2314 for(l=1;l<3;l++)
2315 SetPixelV(Canvas.hmdc,x,y+l,colorOFF_WHITE);
2316 }
2317 break;
2318 default:
2319 break;
2320 }
2321 change_flag = 1;
2322 }
2323 }
2324 if(change_flag){
2325 RECT rc;
2326 GDI_UNLOCK();
2327 GetClientRect(Canvas.hwnd,&rc);
2328 rc.top = Canvas.rcKeyboard.top + (channel - ChFrom) * 4;
2329 rc.bottom = rc.top + 4;
2330 InvalidateRect(Canvas.hwnd, &rc, FALSE);
2331 GDI_LOCK();
2332 }
2333 }
2334 GDI_UNLOCK(); // gdi_lock
2335 if(flag)
2336 InvalidateRect(hCanvasWnd, NULL, FALSE);
2337 Canvas.DrumChannel = drumchannels;
2338 }
2339
CanvasKeyboardClear(void)2340 static void CanvasKeyboardClear(void)
2341 {
2342 int i;
2343 HPEN hPen;
2344 HBRUSH hBrush;
2345 HGDIOBJ hgdiobj_hpen, hgdiobj_hbrush;
2346 COLORREF FGcolor, BGcolor;
2347 HFONT hfont;
2348 HGDIOBJ hgdiobj;
2349 RECT rc;
2350 char buffer[16];
2351 if(!CanvasOK)
2352 return;
2353 GDI_LOCK(); // gdi_lock
2354 #if 0
2355 hPen = CreatePen(PS_SOLID,1,CanvasColor(CC_BACK));
2356 hBrush = CreateSolidBrush(CanvasColor(CC_BACK));
2357 #else
2358 FGcolor = RGB(0xff,0xff,0xff);
2359 BGcolor = RGB(0x00,0x00,0x00);
2360 hPen = CreatePen(PS_SOLID,1,BGcolor);
2361 hBrush = CreateSolidBrush(BGcolor);
2362 #endif
2363 hgdiobj_hpen = SelectObject(Canvas.hmdc, hPen);
2364 hgdiobj_hbrush = SelectObject(Canvas.hmdc, hBrush);
2365 Rectangle(Canvas.hmdc,
2366 Canvas.rcMe.left,Canvas.rcMe.top,Canvas.rcMe.right,Canvas.rcMe.bottom);
2367 SelectObject(Canvas.hmdc, hgdiobj_hpen);
2368 DeleteObject(hPen);
2369 SelectObject(Canvas.hmdc, hgdiobj_hbrush);
2370 DeleteObject(hBrush);
2371
2372 hfont = CreateFont(7,7,0,0,FW_DONTCARE,FALSE,FALSE,FALSE,
2373 DEFAULT_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,
2374 DEFAULT_PITCH | FF_DONTCARE,"Arial Bold");
2375 hgdiobj = SelectObject(Canvas.hmdc,hfont);
2376 SetTextAlign(Canvas.hmdc, TA_LEFT | TA_TOP | TA_NOUPDATECP);
2377 rc.left = Canvas.rcMe.left+1 ;
2378 rc.top = Canvas.rcMe.bottom-7;
2379 rc.right = Canvas.rcMe.left+1 + 40;
2380 rc.bottom = Canvas.rcMe.bottom;
2381 SetTextColor(Canvas.hmdc,RGB(0xff,0xff,0xff));
2382 SetBkColor(Canvas.hmdc,RGB(0x00,0x00,0x00));
2383 strcpy(buffer," ");
2384 ExtTextOut(Canvas.hmdc,rc.left,rc.top,ETO_CLIPPED|ETO_OPAQUE,&rc,
2385 buffer,strlen(buffer),NULL);
2386 for(i=1;i<=3;i++){
2387 if(i==Canvas.CKPart){
2388 SetTextColor(Canvas.hmdc,RGB(0xff,0xff,0xff));
2389 SetBkColor(Canvas.hmdc,RGB(0x00,0x00,0x00));
2390 } else {
2391 SetTextColor(Canvas.hmdc,RGB(0x80,0x80,0x80));
2392 SetBkColor(Canvas.hmdc,RGB(0x00,0x00,0x00));
2393 }
2394 rc.left = Canvas.rcMe.left+1 + 0 + (i-1)*24;
2395 rc.top = Canvas.rcMe.bottom-7;
2396 rc.right = Canvas.rcMe.left+1 + 0 + (i)*24 - 1;
2397 rc.bottom = Canvas.rcMe.bottom;
2398 sprintf(buffer,"[%c]",i+'A'-1);
2399 ExtTextOut(Canvas.hmdc,rc.left,rc.top,ETO_CLIPPED|ETO_OPAQUE,&rc,
2400 buffer,strlen(buffer),NULL);
2401 }
2402 if((HGDIOBJ)hgdiobj!=(HGDIOBJ)NULL && (HGDIOBJ)hgdiobj!=(HGDIOBJ)GDI_ERROR)
2403 SelectObject(Canvas.hmdc,hgdiobj);
2404 DeleteObject(hfont);
2405 GDI_UNLOCK(); // gdi_lock
2406
2407 CanvasKeyboardReset();
2408 CanvasKeyboardReadPanelInfo(1);
2409 CanvasKeyboardUpdate(1);
2410 InvalidateRect(hCanvasWnd, NULL, FALSE);
2411 }
2412
2413 // Canvas All
2414
CanvasPaintDo(void)2415 static void CanvasPaintDo(void)
2416 {
2417 RECT rc;
2418 if ( GetUpdateRect(Canvas.hwnd, &rc, FALSE) ) {
2419 PAINTSTRUCT ps;
2420 GDI_LOCK(); // gdi_lock
2421 Canvas.hdc = BeginPaint(Canvas.hwnd, &ps);
2422 BitBlt(Canvas.hdc,rc.left,rc.top,rc.right,rc.bottom,Canvas.hmdc,rc.left,rc.top,SRCCOPY);
2423 EndPaint(Canvas.hwnd, &ps);
2424 GDI_UNLOCK(); // gdi_lock
2425 }
2426 }
CanvasPaint(void)2427 void CanvasPaint(void)
2428 {
2429 Canvas.PaintDone = 0;
2430 UpdateWindow(hCanvasWnd);
2431 }
CanvasPaintAll(void)2432 void CanvasPaintAll(void)
2433 {
2434 InvalidateRect(hCanvasWnd, NULL, FALSE);
2435 CanvasPaint();
2436 }
2437
CanvasReset(void)2438 void CanvasReset(void)
2439 {
2440 if (! CanvasOK)
2441 return;
2442 switch (Canvas.Mode) {
2443 case CANVAS_MODE_GSLCD:
2444 CanvasGSLCDReset();
2445 break;
2446 case CANVAS_MODE_MAP16:
2447 case CANVAS_MODE_MAP32:
2448 CanvasMapReset();
2449 break;
2450 case CANVAS_MODE_KBD_A:
2451 case CANVAS_MODE_KBD_B:
2452 CanvasKeyboardReset();
2453 break;
2454 case CANVAS_MODE_SLEEP:
2455 CanvasSleepReset();
2456 break;
2457 }
2458 }
2459
CanvasClear(void)2460 void CanvasClear(void)
2461 {
2462 if (! CanvasOK)
2463 return;
2464 switch (Canvas.Mode) {
2465 case CANVAS_MODE_GSLCD:
2466 CanvasGSLCDClear();
2467 break;
2468 case CANVAS_MODE_MAP16:
2469 case CANVAS_MODE_MAP32:
2470 CanvasMapClear();
2471 break;
2472 case CANVAS_MODE_KBD_A:
2473 case CANVAS_MODE_KBD_B:
2474 CanvasKeyboardClear();
2475 break;
2476 case CANVAS_MODE_SLEEP:
2477 CanvasSleepClear();
2478 break;
2479 }
2480 }
2481
CanvasUpdate(int flag)2482 void CanvasUpdate(int flag)
2483 {
2484 if (! CanvasOK)
2485 return;
2486 switch (Canvas.Mode) {
2487 case CANVAS_MODE_GSLCD:
2488 CanvasGSLCDUpdate(flag);
2489 break;
2490 case CANVAS_MODE_MAP16:
2491 case CANVAS_MODE_MAP32:
2492 CanvasMapUpdate(flag);
2493 break;
2494 case CANVAS_MODE_KBD_A:
2495 case CANVAS_MODE_KBD_B:
2496 CanvasKeyboardUpdate(flag);
2497 break;
2498 case CANVAS_MODE_SLEEP:
2499 CanvasSleepUpdate(flag);
2500 break;
2501 }
2502 }
2503
CanvasReadPanelInfo(int flag)2504 void CanvasReadPanelInfo(int flag)
2505 {
2506 if (! CanvasOK)
2507 return;
2508 switch (Canvas.Mode) {
2509 case CANVAS_MODE_GSLCD:
2510 CanvasGSLCDReadPanelInfo(flag);
2511 break;
2512 case CANVAS_MODE_MAP16:
2513 case CANVAS_MODE_MAP32:
2514 CanvasMapReadPanelInfo(flag);
2515 break;
2516 case CANVAS_MODE_KBD_A:
2517 case CANVAS_MODE_KBD_B:
2518 CanvasKeyboardReadPanelInfo(flag);
2519 break;
2520 case CANVAS_MODE_SLEEP:
2521 // CanvasSleepReadPanelInfo(flag);
2522 break;
2523 }
2524 }
2525
CanvasChange(int mode)2526 void CanvasChange(int mode)
2527 {
2528 if (mode != 0)
2529 Canvas.Mode = mode;
2530 else {
2531 if (Canvas.Mode == CANVAS_MODE_SLEEP)
2532 Canvas.Mode = CANVAS_MODE_GSLCD;
2533 else if (Canvas.Mode == CANVAS_MODE_GSLCD) {
2534 Canvas.MapMode = CMAP_MODE_16;
2535 Canvas.Mode = CANVAS_MODE_MAP16;
2536 } else if (Canvas.Mode == CANVAS_MODE_MAP16) {
2537 Canvas.MapMode = CMAP_MODE_32;
2538 Canvas.Mode = CANVAS_MODE_MAP32;
2539 } else if (Canvas.Mode == CANVAS_MODE_MAP32) {
2540 Canvas.CKPart = 1;
2541 Canvas.Mode = CANVAS_MODE_KBD_A;
2542 } else if (Canvas.Mode == CANVAS_MODE_KBD_A) {
2543 Canvas.CKPart = 2;
2544 Canvas.Mode = CANVAS_MODE_KBD_B;
2545 } else if (Canvas.Mode == CANVAS_MODE_KBD_B)
2546 Canvas.Mode = CANVAS_MODE_SLEEP;
2547 }
2548 MainWndInfo.CanvasMode = Canvas.Mode;
2549 CanvasReset();
2550 CanvasClear();
2551 CanvasReadPanelInfo(1);
2552 CanvasUpdate(1);
2553 CanvasPaintAll();
2554 }
2555
CanvasGetMode(void)2556 int CanvasGetMode(void)
2557 {
2558 return Canvas.Mode;
2559 }
2560
2561
2562
2563
2564
2565
2566
2567
2568
2569
2570
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583
2584
2585
2586
2587
2588
2589
2590
2591 //-----------------------------------------------------------------------------
2592 // Main Panel
2593 // ���C���p�l���E�C���h�E�֘A
2594 //
2595 //
2596 //
2597 //
2598 //
2599 //
2600 //
2601
2602 #define MPANEL_XMAX 440
2603 #define MPANEL_YMAX 88
2604
2605 // update flag.
2606 #define MP_UPDATE_ALL 0xffffL
2607 #define MP_UPDATE_NONE 0x0000L
2608 #define MP_UPDATE_TITLE 0x0001L
2609 #define MP_UPDATE_FILE 0x0002L
2610 #define MP_UPDATE_TIME 0x0004L
2611 #define MP_UPDATE_METRONOME 0x0008L
2612 #define MP_UPDATE_VOICES 0x0010L
2613 #define MP_UPDATE_MVOLUME 0x0020L
2614 #define MP_UPDATE_RATE 0x0040L
2615 #define MP_UPDATE_PLAYLIST 0x0080L
2616 #define MP_UPDATE_MISC 0x0200L
2617 #define MP_UPDATE_MESSAGE 0x0400L
2618 #define MP_UPDATE_BACKGROUND 0x0800L
2619 #define MP_UPDATE_KEYSIG 0x1000L
2620 #define MP_UPDATE_TEMPO 0x2000L
2621
2622 #define MP_TITLE_MAX 256
2623 #define MP_FILE_MAX 256
2624 struct MPanel_ {
2625 HWND hwnd;
2626 HWND hParentWnd;
2627 HDC hdc;
2628 HDC hmdc;
2629 HGDIOBJ hgdiobj_hmdcprev;
2630 HBITMAP hbitmap;
2631 HBITMAP hbitmapBG; /* the background bitmap */
2632 HBITMAP hbitmapBGFilter; /* the background bitmap filter */
2633 HFONT hfont;
2634 char Font[256];
2635 char FontLang[256];
2636 char FontLangFixed[256];
2637 RECT rcMe;
2638 RECT rcTitle;
2639 RECT rcFile;
2640 RECT rcTime;
2641 RECT rcVoices;
2642 RECT rcMVolume;
2643 RECT rcRate;
2644 RECT rcMetronome;
2645 RECT rcKeysig;
2646 RECT rcTempo;
2647 RECT rcList;
2648 RECT rcMisc;
2649 RECT rcMessage;
2650 char Title[MP_TITLE_MAX+1];
2651 char File[MP_FILE_MAX+1];
2652 int CurTime_h; int CurTime_m; int CurTime_s; int CurTime_ss;
2653 int TotalTime_h; int TotalTime_m; int TotalTime_s; int TotalTime_ss;
2654 int CurVoices;
2655 int MaxVoices;
2656 int MVolume;
2657 int Rate;
2658 int Meas;
2659 int Beat;
2660 char Keysig[7];
2661 int Key_offset;
2662 int Tempo;
2663 int Tempo_ratio;
2664 int PlaylistNum;
2665 int PlaylistMax;
2666 HFONT hFontTitle;
2667 HFONT hFontFile;
2668 HFONT hFontTime;
2669 HFONT hFontVoices;
2670 HFONT hFontMVolume;
2671 HFONT hFontRate;
2672 HFONT hFontMetronome;
2673 HFONT hFontKeysig;
2674 HFONT hFontTempo;
2675 HFONT hFontList;
2676 HFONT hFontMisc;
2677 HFONT hFontMessage;
2678 long UpdateFlag;
2679 COLORREF FGColor;
2680 COLORREF BGColor;
2681 COLORREF BGBGColor;
2682 enum play_system_modes play_system_mode;
2683 int current_file_info_file_type;
2684 int current_file_info_max_channel;
2685 } MPanel;
2686 extern volatile int MPanelOK;
2687
2688 static struct MPanelMessageData_ {
2689 int len; // ���b�Z�[�W�{�b�N�X�̒����B
2690 char buff[1024]; // ���o�b�t�@�B
2691 DWORD prevtime;
2692 int msec; // ���c��b�B
2693 int pointer; // ���݂̃|�C���^�B
2694
2695 char curbuff[1024];
2696 int curbuffsize;
2697 int curmode; // ���݃��b�Z�[�W�̃��[�h�B
2698 int curmsec; // ���݃��b�Z�[�W�̎c��b�B
2699 char nextbuff[1024];
2700 int nextmode; // ���݃��b�Z�[�W�̃��[�h�B
2701 int nextmsec; // ���݃��b�Z�[�W�̎c��b�B
2702 } MPanelMessageData;
2703 void MPanelMessageInit(void);
2704 void MPanelMessageAdd(char *message, int msec, int mode);
2705 void MPanelMessageClearAll(void);
2706 void MPanelMessageClear(void);
2707 void MPanelMessageNext(void);
2708 void MPanelMessageUpdate(void);
2709
2710 static HWND hPanelWnd;
2711 static char PanelWndClassName[] = "TiMidity Main Panel";
2712 static LRESULT CALLBACK PanelWndProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam);
2713 int MPanelMode = 0;
2714
InitPanelWnd(HWND hwnd)2715 static void InitPanelWnd(HWND hwnd)
2716 {
2717 WNDCLASS wndclass ;
2718 hPanelWnd = 0;
2719 wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS | CS_CLASSDC;
2720 wndclass.lpfnWndProc = PanelWndProc ;
2721 wndclass.cbClsExtra = 0 ;
2722 wndclass.cbWndExtra = 0 ;
2723 wndclass.hInstance = hInst ;
2724 wndclass.hIcon = NULL;
2725 wndclass.hCursor = LoadCursor(0,IDC_ARROW) ;
2726 wndclass.hbrBackground = (HBRUSH)(COLOR_SCROLLBAR + 1);
2727 wndclass.lpszMenuName = NULL;
2728 wndclass.lpszClassName = PanelWndClassName;
2729 RegisterClass(&wndclass);
2730 hPanelWnd =
2731 CreateWindowEx(0,PanelWndClassName,0,WS_CHILD,
2732 CW_USEDEFAULT,0,MPANEL_XMAX,MPANEL_YMAX,
2733 GetDlgItem(hwnd,IDC_RECT_PANEL),0,hInst,0);
2734 MPanelInit(hPanelWnd);
2735 MPanelReset();
2736 MPanelReadPanelInfo(1);
2737 MPanelUpdateAll();
2738 MPanelPaintAll();
2739 UpdateWindow(hPanelWnd);
2740 ShowWindow(hPanelWnd,SW_SHOW);
2741 }
2742
2743 static void MPanelPaintDo(void);
2744 static LRESULT CALLBACK
PanelWndProc(HWND hwnd,UINT uMess,WPARAM wParam,LPARAM lParam)2745 PanelWndProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam)
2746 {
2747 switch (uMess)
2748 {
2749 case WM_CREATE:
2750 break;
2751 case WM_PAINT:
2752 MPanelPaintDo();
2753 return 0;
2754 case WM_LBUTTONDBLCLK:
2755 // MPanelReset();
2756 MPanelReadPanelInfo(1);
2757 MPanelUpdateAll();
2758 MPanelPaintAll();
2759 break;
2760 case WM_DESTROY:
2761 if(MPanel.hFontTitle!=NULL)
2762 DeleteObject(MPanel.hFontTitle);
2763 if(MPanel.hFontFile!=NULL)
2764 DeleteObject(MPanel.hFontFile);
2765 if(MPanel.hFontTime!=NULL)
2766 DeleteObject(MPanel.hFontTime);
2767 if(MPanel.hFontVoices!=NULL)
2768 DeleteObject(MPanel.hFontVoices);
2769 if(MPanel.hFontMVolume!=NULL)
2770 DeleteObject(MPanel.hFontMVolume);
2771 if(MPanel.hFontRate!=NULL)
2772 DeleteObject(MPanel.hFontRate);
2773 if (MPanel.hFontMetronome != NULL)
2774 DeleteObject(MPanel.hFontMetronome);
2775 if (MPanel.hFontKeysig != NULL)
2776 DeleteObject(MPanel.hFontKeysig);
2777 if (MPanel.hFontTempo != NULL)
2778 DeleteObject(MPanel.hFontTempo);
2779 if(MPanel.hFontList!=NULL)
2780 DeleteObject(MPanel.hFontList);
2781 if(MPanel.hFontMisc!=NULL)
2782 DeleteObject(MPanel.hFontMisc);
2783 if(MPanel.hFontMessage!=NULL)
2784 DeleteObject(MPanel.hFontMessage);
2785 break;
2786 default:
2787 return DefWindowProc(hwnd,uMess,wParam,lParam) ;
2788 }
2789 return 0L;
2790 }
2791
2792 // Initialization of MPanel strucuter at once.
2793 volatile int MPanelOK = 0;
MPanelInit(HWND hwnd)2794 static void MPanelInit(HWND hwnd)
2795 {
2796 RECT rc;
2797 int tmp;
2798 GDI_LOCK(); // gdi_lock
2799 MPanel.hwnd = hwnd;
2800 MPanel.hParentWnd = GetParent(MPanel.hwnd);
2801 GetClientRect(MPanel.hParentWnd,&rc);
2802 MoveWindow(MPanel.hwnd,0,0,rc.right-rc.left,rc.bottom-rc.top,FALSE);
2803 MPanel.hdc = GetDC(MPanel.hwnd);
2804 MPanel.hbitmap =
2805 CreateCompatibleBitmap(MPanel.hdc,MPANEL_XMAX,MPANEL_YMAX);
2806 MPanel.hmdc =
2807 CreateCompatibleDC(MPanel.hdc);
2808 MPanel.hgdiobj_hmdcprev = SelectObject(MPanel.hmdc,MPanel.hbitmap);
2809 ReleaseDC(MPanel.hwnd,MPanel.hdc);
2810
2811 GetClientRect(MPanel.hwnd,&rc);
2812 // RECT reft,top,right,bottom
2813 SetRect(&(MPanel.rcMe),rc.left,rc.top,rc.right,rc.bottom);
2814 rc = MPanel.rcMe;
2815 SetRect(&(MPanel.rcTitle), rc.left+2, rc.top+2, rc.right-2, rc.top+2+14);
2816 SetRect(&(MPanel.rcFile), rc.left+2, rc.top+2+14+1, rc.right-2, rc.top+2+14+1+12);
2817 #if 0
2818 SetRect(&(MPanel.rcTime), rc.left+2, rc.top+2+14+1+12+1, rc.left+2+180, rc.top+2+14+1+12+1+25);
2819 SetRect(&(MPanel.rcVoices), rc.right-2-36-1-24-48, rc.top+2+14+1+12+1, rc.right-2-36-1-24, rc.top+2+14+1+12+1+12);
2820 SetRect(&(MPanel.rcMVolume),rc.right-2-36, rc.top+2+14+1+12+1, rc.right-2, rc.top+2+14+1+12+1+12);
2821 SetRect(&(MPanel.rcRate), rc.right-2-60-1-18-48, rc.top+2+14+1+12+1+12+1, rc.right-2-36-1, rc.top+2+14+1+12+1+12+1+12);
2822 SetRect(&(MPanel.rcList), rc.right-2-60, rc.top+2+14+1+12+1+12+1, rc.right-2, rc.top+2+14+1+12+1+12+1+12);
2823 SetRect(&(MPanel.rcMisc), rc.left+2, rc.top+2+14+1+12+1+25+1,rc.right-2,rc.top+2+14+1+12+1+25+1+12);
2824 SetRect(&(MPanel.rcMessage),rc.left,rc.top,rc.right,rc.bottom);
2825 #else
2826 SetRect(&(MPanel.rcTime),
2827 rc.left + 2,
2828 rc.top + 2 + 14 + 1 + 12 + 1,
2829 rc.left + 2 + 176,
2830 rc.top + 2 + 14 + 1 + 12 + 1 + 25);
2831 SetRect(&(MPanel.rcVoices),
2832 rc.left + 2 + 176 + 2,
2833 rc.top + 2 + 14 + 1 + 12 + 1,
2834 rc.left + 2 + 176 + 2 + 50,
2835 rc.top + 2 + 14 + 1 + 12 + 1 + 12);
2836 SetRect(&(MPanel.rcRate),
2837 rc.left + 2 + 176 + 2 + 50 + 2,
2838 rc.top + 2 + 14 + 1 + 12 + 1,
2839 rc.right - 2 - 38 - 2,
2840 rc.top + 2 + 14 + 1 + 12 + 1 + 12);
2841 SetRect(&(MPanel.rcMVolume),
2842 rc.right - 2 - 38,
2843 rc.top + 2 + 14 + 1 + 12 + 1,
2844 rc.right - 2,
2845 rc.top + 2 + 14 + 1 + 12 + 1 + 12);
2846 SetRect(&(MPanel.rcMetronome),
2847 rc.left + 2 + 176 - 40,
2848 rc.top + 2 + 14 + 1 + 12 + 1 + 12 + 1 + 12 + 1,
2849 rc.left + 2 + 176,
2850 rc.top + 2 + 14 + 1 + 12 + 1 + 12 + 1 + 12 + 1 + 12);
2851 SetRect(&(MPanel.rcKeysig),
2852 rc.left + 2 + 176 + 2,
2853 rc.top + 2 + 14 + 1 + 12 + 1 + 12 + 1,
2854 rc.right - 2 - 69 - 2,
2855 rc.top + 2 + 14 + 1 + 12 + 1 + 12 + 1 + 12);
2856 SetRect(&(MPanel.rcTempo),
2857 rc.right - 2 - 69,
2858 rc.top + 2 + 14 + 1 + 12 + 1 + 12 + 1,
2859 rc.right - 2,
2860 rc.top + 2 + 14 + 1 + 12 + 1 + 12 + 1 + 12);
2861 SetRect(&(MPanel.rcMisc),
2862 rc.left + 2 + 176 + 2,
2863 rc.top + 2 + 14 + 1 + 12 + 1 + 12 + 1 + 12 + 1,
2864 rc.right - 2 - 54 - 2,
2865 rc.top + 2 + 14 + 1 + 12 + 1 + 12 + 1 + 12 + 1 + 12);
2866 SetRect(&(MPanel.rcList),
2867 rc.right - 2 - 54,
2868 rc.top + 2 + 14 + 1 + 12 + 1 + 12 + 1 + 12 + 1,
2869 rc.right - 2,
2870 rc.top + 2 + 14 + 1 + 12 + 1 + 12 + 1 + 12 + 1 + 12);
2871 SetRect(&(MPanel.rcMessage),
2872 rc.left + 2,
2873 rc.top + 2 + 14 + 1 + 12 + 1 + 25 + 1,
2874 rc.left + 2 + 176 - 40 - 2,
2875 rc.top + 2 + 14 + 1 + 12 + 1 + 25 + 1 + 12);
2876 #endif
2877 MPanel.hFontTitle = NULL;
2878 MPanel.hFontFile = NULL;
2879 MPanel.hFontTime = NULL;
2880 MPanel.hFontVoices = NULL;
2881 MPanel.hFontMVolume = NULL;
2882 MPanel.hFontRate = NULL;
2883 MPanel.hFontMetronome = NULL;
2884 MPanel.hFontKeysig = NULL;
2885 MPanel.hFontTempo = NULL;
2886 MPanel.hFontList = NULL;
2887 // strcpy(MPanel.Font,"Times New Roman");
2888 strcpy(MPanel.Font,"Arial Bold");
2889 switch(PlayerLanguage){
2890 case LANGUAGE_ENGLISH:
2891 strcpy(MPanel.FontLang,"Times New Roman");
2892 strcpy(MPanel.FontLangFixed,"Times New Roman");
2893 break;
2894 default:
2895 case LANGUAGE_JAPANESE:
2896 strcpy(MPanel.FontLang,"�l�r �o����");
2897 strcpy(MPanel.FontLangFixed,"�l�r ����");
2898 break;
2899 }
2900 rc = MPanel.rcTitle;
2901 MPanel.hFontTitle =
2902 CreateFont(rc.bottom-rc.top+1,0,0,0,FW_DONTCARE,FALSE,FALSE,FALSE,
2903 DEFAULT_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,
2904 DEFAULT_PITCH | FF_DONTCARE,MPanel.FontLang);
2905 rc = MPanel.rcFile;
2906 MPanel.hFontFile =
2907 CreateFont(rc.bottom-rc.top+1,0,0,0,FW_DONTCARE,FALSE,FALSE,FALSE,
2908 DEFAULT_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,
2909 DEFAULT_PITCH | FF_DONTCARE,MPanel.FontLang);
2910 rc = MPanel.rcTime;
2911 MPanel.hFontTime =
2912 CreateFont(24,0,0,0,FW_DONTCARE,FALSE,FALSE,FALSE,
2913 DEFAULT_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,
2914 DEFAULT_PITCH | FF_DONTCARE,MPanel.Font);
2915 rc = MPanel.rcVoices;
2916 MPanel.hFontVoices =
2917 CreateFont(rc.bottom-rc.top+1,0,0,0,FW_DONTCARE,FALSE,FALSE,FALSE,
2918 DEFAULT_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,
2919 DEFAULT_PITCH | FF_DONTCARE,MPanel.Font);
2920 rc = MPanel.rcMVolume;
2921 MPanel.hFontMVolume =
2922 CreateFont(rc.bottom-rc.top+1,0,0,0,FW_DONTCARE,FALSE,FALSE,FALSE,
2923 DEFAULT_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,
2924 DEFAULT_PITCH | FF_DONTCARE,MPanel.Font);
2925 rc = MPanel.rcRate;
2926 MPanel.hFontRate =
2927 CreateFont(rc.bottom-rc.top+1,0,0,0,FW_DONTCARE,FALSE,FALSE,FALSE,
2928 DEFAULT_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,
2929 DEFAULT_PITCH | FF_DONTCARE,MPanel.Font);
2930 rc = MPanel.rcMetronome;
2931 MPanel.hFontMetronome =
2932 CreateFont(rc.bottom - rc.top + 1, 0, 0, 0, FW_DONTCARE,
2933 FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
2934 CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,
2935 DEFAULT_PITCH | FF_DONTCARE, MPanel.Font);
2936 rc = MPanel.rcKeysig;
2937 tmp = (rc.bottom - rc.top + 1) / 2;
2938 MPanel.hFontKeysig =
2939 CreateFont(tmp * 2, tmp, 0, 0, FW_DONTCARE,
2940 FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
2941 CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,
2942 FIXED_PITCH | FF_DONTCARE, MPanel.Font);
2943 rc = MPanel.rcTempo;
2944 tmp = (rc.bottom - rc.top + 1) / 2;
2945 MPanel.hFontTempo =
2946 CreateFont(tmp * 2, tmp, 0, 0, FW_DONTCARE,
2947 FALSE, FALSE, FALSE, DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
2948 CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY,
2949 FIXED_PITCH | FF_DONTCARE, MPanel.Font);
2950 rc = MPanel.rcList;
2951 MPanel.hFontList =
2952 CreateFont(rc.bottom-rc.top+1,0,0,0,FW_DONTCARE,FALSE,FALSE,FALSE,
2953 DEFAULT_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,
2954 DEFAULT_PITCH | FF_DONTCARE,MPanel.Font);
2955 rc = MPanel.rcMisc;
2956 tmp = (rc.bottom-rc.top+1)/2;
2957 MPanel.hFontMisc =
2958 CreateFont(tmp*2,tmp,0,0,FW_DONTCARE,FALSE,FALSE,FALSE,
2959 DEFAULT_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,
2960 FIXED_PITCH | FF_DONTCARE,MPanel.Font);
2961 rc = MPanel.rcMessage;
2962 tmp = (rc.bottom-rc.top+1)/2;
2963 MPanel.hFontMessage =
2964 CreateFont(tmp*2,tmp,0,0,FW_DONTCARE,FALSE,FALSE,FALSE,
2965 DEFAULT_CHARSET,OUT_DEFAULT_PRECIS,CLIP_DEFAULT_PRECIS,DEFAULT_QUALITY,
2966 FIXED_PITCH | FF_DONTCARE,MPanel.FontLangFixed);
2967 MPanelOK = 1;
2968 GDI_UNLOCK(); // gdi_lock
2969 MPanelMessageInit();
2970 }
2971
2972 // �p�l���\���̂����Z�b�g����B
MPanelReset(void)2973 void MPanelReset(void)
2974 {
2975 if(!MPanelOK)
2976 return;
2977 MPanel.Title[0] = '\0';
2978 MPanel.File[0] = '\0';
2979 strcpy(MPanel.Title,"No title.");
2980 strcpy(MPanel.File,"No file.");
2981 MPanel.CurTime_h = 0;
2982 MPanel.CurTime_m = 0;
2983 MPanel.CurTime_s = 0;
2984 MPanel.CurTime_ss = 0;
2985 MPanel.TotalTime_h = 0;
2986 MPanel.TotalTime_m = 0;
2987 MPanel.TotalTime_s = 0;
2988 MPanel.TotalTime_ss = 0;
2989 MPanel.CurVoices = 0;
2990 MPanel.MaxVoices = 0;
2991 MPanel.MVolume = 0;
2992 MPanel.Rate = 0;
2993 MPanel.Meas = 0;
2994 MPanel.Beat = 0;
2995 MPanel.Keysig[0] = '\0';
2996 MPanel.Key_offset = 0;
2997 MPanel.Tempo = 0;
2998 MPanel.Tempo_ratio = 0;
2999 MPanel.PlaylistNum = 0;
3000 MPanel.PlaylistMax = 0;
3001 MPanel.UpdateFlag = MP_UPDATE_ALL;
3002 // MPanel.FGColor = RGB(0x00,0x00,0x00);
3003 // MPanel.BGColor = RGB(0xff,0xff,0xff);
3004 MPanel.FGColor = RGB(0x00,0x00,0x00);
3005 // MPanel.BGColor = RGB(0xc0,0xc0,0xc0);
3006 MPanel.BGColor = RGB(0xc0,0xc5,0xc3);
3007 MPanel.BGBGColor = RGB(0x60,0x60,0x60);
3008 #if 0
3009 if(MPanel.hFontTitle!=NULL)
3010 DeleteObject(MPanel.hFontTitle);
3011 if(MPanel.hFontFile!=NULL)
3012 DeleteObject(MPanel.hFontFile);
3013 if(MPanel.hFontTime!=NULL)
3014 DeleteObject(MPanel.hFontTime);
3015 if(MPanel.hFontVoices!=NULL)
3016 DeleteObject(MPanel.hFontVoices);
3017 if(MPanel.hFontMVolume!=NULL)
3018 DeleteObject(MPanel.hFontMVolume);
3019 if(MPanel.hFontRate!=NULL)
3020 DeleteObject(MPanel.hFontRate);
3021 if (MPanel.hFontMetronome != NULL)
3022 DeleteObject(MPanel.hFontMetronome);
3023 if (MPanel.hFontKeysig != NULL)
3024 DeleteObject(MPanel.hFontKeysig);
3025 if (MPanel.hFontTempo != NULL)
3026 DeleteObject(MPanel.hFontTempo);
3027 if(MPanel.hFontList!=NULL)
3028 DeleteObject(MPanel.hFontList);
3029 #endif
3030 MPanel.play_system_mode = DEFAULT_SYSTEM_MODE;
3031 MPanel.current_file_info_file_type = IS_OTHER_FILE;
3032 MPanel.current_file_info_max_channel = -1;
3033 MPanelMessageClearAll();
3034 }
3035
3036 // �p�l���\���̂����ɍX�V����B
MPanelUpdate(void)3037 void MPanelUpdate(void)
3038 {
3039 if(!MPanelOK)
3040 return;
3041 MPanelMessageUpdate();
3042 if(MPanel.UpdateFlag==MP_UPDATE_NONE)
3043 return;
3044 if(MPanel.UpdateFlag & MP_UPDATE_BACKGROUND){
3045 // �r�b�g�}�b�v��\��t���邪���͓h��‚Ԃ��B
3046 HPEN hPen;
3047 HBRUSH hBrush;
3048 // COLORREF color = MPanel.FGColor;
3049 COLORREF color = MPanel.BGBGColor;
3050 RECT rc = MPanel.rcMe;
3051 HGDIOBJ hgdiobj_hpen, hgdiobj_hbrush;
3052 GDI_LOCK(); // gdi_lock
3053 hPen = CreatePen(PS_SOLID,1,color);
3054 hBrush = CreateSolidBrush(color);
3055 hgdiobj_hpen = SelectObject(MPanel.hmdc, hPen);
3056 hgdiobj_hbrush = SelectObject(MPanel.hmdc, hBrush);
3057 Rectangle(MPanel.hmdc,rc.left,rc.top,rc.right,rc.bottom);
3058 SelectObject(MPanel.hmdc, hgdiobj_hpen);
3059 DeleteObject(hPen);
3060 SelectObject(MPanel.hmdc, hgdiobj_hbrush);
3061 DeleteObject(hBrush);
3062 GDI_UNLOCK(); // gdi_lock
3063 InvalidateRect(MPanel.hwnd,&rc, FALSE);
3064 }
3065 if(MPanel.UpdateFlag & MP_UPDATE_TITLE){
3066 HGDIOBJ hgdiobj = SelectObject(MPanel.hmdc,MPanel.hFontTitle);
3067 GDI_LOCK(); // gdi_lock
3068 SetTextColor(MPanel.hmdc,MPanel.FGColor);
3069 SetBkColor(MPanel.hmdc,MPanel.BGColor);
3070 //#include "w32g2_c.h"
3071 SetTextAlign(MPanel.hmdc, TA_LEFT | TA_TOP | TA_NOUPDATECP);
3072 ExtTextOut(MPanel.hmdc,MPanel.rcTitle.left,MPanel.rcTitle.top,
3073 ETO_CLIPPED | ETO_OPAQUE,&(MPanel.rcTitle),
3074 MPanel.Title,strlen(MPanel.Title),NULL);
3075 if((HGDIOBJ)hgdiobj!=(HGDIOBJ)NULL && (HGDIOBJ)hgdiobj!=(HGDIOBJ)GDI_ERROR)
3076 SelectObject(MPanel.hmdc,hgdiobj);
3077 GDI_UNLOCK(); // gdi_lock
3078 InvalidateRect(hPanelWnd, &(MPanel.rcTitle), FALSE);
3079 }
3080 if(MPanel.UpdateFlag & MP_UPDATE_FILE){
3081 HGDIOBJ hgdiobj;
3082 GDI_LOCK(); // gdi_lock
3083 hgdiobj = SelectObject(MPanel.hmdc,MPanel.hFontFile);
3084 SetTextColor(MPanel.hmdc,MPanel.FGColor);
3085 SetBkColor(MPanel.hmdc,MPanel.BGColor);
3086 SetTextAlign(MPanel.hmdc, TA_LEFT | TA_TOP | TA_NOUPDATECP);
3087 ExtTextOut(MPanel.hmdc,MPanel.rcFile.left,MPanel.rcFile.top,
3088 ETO_CLIPPED | ETO_OPAQUE,&(MPanel.rcFile),
3089 MPanel.File,strlen(MPanel.File),NULL);
3090 if((HGDIOBJ)hgdiobj!=(HGDIOBJ)NULL && (HGDIOBJ)hgdiobj!=(HGDIOBJ)GDI_ERROR)
3091 SelectObject(MPanel.hmdc,hgdiobj);
3092 GDI_UNLOCK(); // gdi_lock
3093 InvalidateRect(hPanelWnd, &(MPanel.rcFile), FALSE);
3094 }
3095 if(MPanel.UpdateFlag & MP_UPDATE_TIME){
3096 char buffer[256];
3097 HGDIOBJ hgdiobj;
3098 GDI_LOCK(); // gdi_lock
3099 hgdiobj = SelectObject(MPanel.hmdc,MPanel.hFontTime);
3100 sprintf(buffer," %02d:%02d:%02d/%02d:%02d:%02d",
3101 MPanel.CurTime_h,MPanel.CurTime_m,MPanel.CurTime_s,
3102 MPanel.TotalTime_h,MPanel.TotalTime_m,MPanel.TotalTime_s);
3103 SetTextColor(MPanel.hmdc,MPanel.FGColor);
3104 SetBkColor(MPanel.hmdc,MPanel.BGColor);
3105 SetTextAlign(MPanel.hmdc, TA_LEFT | TA_TOP | TA_NOUPDATECP);
3106 ExtTextOut(MPanel.hmdc,MPanel.rcTime.left,MPanel.rcTime.top,
3107 ETO_CLIPPED | ETO_OPAQUE,&(MPanel.rcTime),
3108 buffer,strlen(buffer),NULL);
3109 if((HGDIOBJ)hgdiobj!=(HGDIOBJ)NULL && (HGDIOBJ)hgdiobj!=(HGDIOBJ)GDI_ERROR)
3110 SelectObject(MPanel.hmdc,hgdiobj);
3111 GDI_UNLOCK(); // gdi_lock
3112 InvalidateRect(hPanelWnd, &(MPanel.rcTime), FALSE);
3113 }
3114 if(MPanel.UpdateFlag & MP_UPDATE_VOICES){
3115 char buffer[256];
3116 HGDIOBJ hgdiobj;
3117 GDI_LOCK(); // gdi_lock
3118 hgdiobj = SelectObject(MPanel.hmdc,MPanel.hFontVoices);
3119 sprintf(buffer," %03d/%03d",MPanel.CurVoices,MPanel.MaxVoices);
3120 SetTextColor(MPanel.hmdc,MPanel.FGColor);
3121 SetBkColor(MPanel.hmdc,MPanel.BGColor);
3122 SetTextAlign(MPanel.hmdc, TA_LEFT | TA_TOP | TA_NOUPDATECP);
3123 ExtTextOut(MPanel.hmdc,MPanel.rcVoices.left,MPanel.rcVoices.top,
3124 ETO_CLIPPED | ETO_OPAQUE,&(MPanel.rcVoices),
3125 buffer,strlen(buffer),NULL);
3126 if((HGDIOBJ)hgdiobj!=(HGDIOBJ)NULL && (HGDIOBJ)hgdiobj!=(HGDIOBJ)GDI_ERROR)
3127 SelectObject(MPanel.hmdc,hgdiobj);
3128 GDI_UNLOCK(); // gdi_lock
3129 InvalidateRect(hPanelWnd, &(MPanel.rcVoices), FALSE);
3130 }
3131 if(MPanel.UpdateFlag & MP_UPDATE_MVOLUME){
3132 char buffer[256];
3133 HGDIOBJ hgdiobj;
3134 GDI_LOCK(); // gdi_lock
3135 hgdiobj = SelectObject(MPanel.hmdc,MPanel.hFontVoices);
3136 sprintf(buffer," %03d%%",MPanel.MVolume);
3137 SetTextColor(MPanel.hmdc,MPanel.FGColor);
3138 SetBkColor(MPanel.hmdc,MPanel.BGColor);
3139 SetTextAlign(MPanel.hmdc, TA_LEFT | TA_TOP | TA_NOUPDATECP);
3140 ExtTextOut(MPanel.hmdc,MPanel.rcMVolume.left,MPanel.rcMVolume.top,
3141 ETO_CLIPPED | ETO_OPAQUE,&(MPanel.rcMVolume),
3142 buffer,strlen(buffer),NULL);
3143 if((HGDIOBJ)hgdiobj!=(HGDIOBJ)NULL && (HGDIOBJ)hgdiobj!=(HGDIOBJ)GDI_ERROR)
3144 SelectObject(MPanel.hmdc,hgdiobj);
3145 GDI_UNLOCK(); // gdi_lock
3146 InvalidateRect(hPanelWnd, &(MPanel.rcMVolume), FALSE);
3147 }
3148 if(MPanel.UpdateFlag & MP_UPDATE_RATE){
3149 char buffer[256];
3150 HGDIOBJ hgdiobj;
3151 GDI_LOCK(); // gdi_lock
3152 hgdiobj = SelectObject(MPanel.hmdc,MPanel.hFontRate);
3153 sprintf(buffer," %05dHz",MPanel.Rate);
3154 SetTextColor(MPanel.hmdc,MPanel.FGColor);
3155 SetBkColor(MPanel.hmdc,MPanel.BGColor);
3156 SetTextAlign(MPanel.hmdc, TA_LEFT | TA_TOP | TA_NOUPDATECP);
3157 ExtTextOut(MPanel.hmdc,MPanel.rcRate.left,MPanel.rcRate.top,
3158 ETO_CLIPPED | ETO_OPAQUE,&(MPanel.rcRate),
3159 buffer,strlen(buffer),NULL);
3160 if((HGDIOBJ)hgdiobj!=(HGDIOBJ)NULL && (HGDIOBJ)hgdiobj!=(HGDIOBJ)GDI_ERROR)
3161 SelectObject(MPanel.hmdc,hgdiobj);
3162 GDI_UNLOCK(); // gdi_lock
3163 InvalidateRect(hPanelWnd, &(MPanel.rcRate), FALSE);
3164 }
3165 if (MPanel.UpdateFlag & MP_UPDATE_METRONOME) {
3166 char buffer[256];
3167 HGDIOBJ hgdiobj;
3168
3169 GDI_LOCK(); // gdi_lock
3170 hgdiobj = SelectObject(MPanel.hmdc, MPanel.hFontMetronome);
3171 sprintf(buffer, " %03d.%02d", MPanel.Meas, MPanel.Beat);
3172 SetTextColor(MPanel.hmdc, MPanel.FGColor);
3173 SetBkColor(MPanel.hmdc, MPanel.BGColor);
3174 SetTextAlign(MPanel.hmdc, TA_LEFT | TA_TOP | TA_NOUPDATECP);
3175 ExtTextOut(MPanel.hmdc,
3176 MPanel.rcMetronome.left, MPanel.rcMetronome.top,
3177 ETO_CLIPPED | ETO_OPAQUE, &(MPanel.rcMetronome),
3178 buffer, strlen(buffer), NULL);
3179 if ((HGDIOBJ) hgdiobj != (HGDIOBJ) NULL
3180 && (HGDIOBJ) hgdiobj != (HGDIOBJ) GDI_ERROR)
3181 SelectObject(MPanel.hmdc, hgdiobj);
3182 GDI_UNLOCK(); // gdi_lock
3183 InvalidateRect(hPanelWnd, &(MPanel.rcMetronome), FALSE);
3184 }
3185 if (MPanel.UpdateFlag & MP_UPDATE_KEYSIG) {
3186 char buffer[256];
3187 HGDIOBJ hgdiobj;
3188
3189 GDI_LOCK(); // gdi_lock
3190 hgdiobj = SelectObject(MPanel.hmdc, MPanel.hFontKeysig);
3191 if (MPanel.Keysig[0] == '\0')
3192 strcpy(MPanel.Keysig, "-- ---");
3193 sprintf(buffer, "%s (%+03d)", MPanel.Keysig, MPanel.Key_offset);
3194 SetTextColor(MPanel.hmdc, MPanel.FGColor);
3195 SetBkColor(MPanel.hmdc, MPanel.BGColor);
3196 SetTextAlign(MPanel.hmdc, TA_LEFT | TA_TOP | TA_NOUPDATECP);
3197 ExtTextOut(MPanel.hmdc,
3198 MPanel.rcKeysig.left + 2, MPanel.rcKeysig.top,
3199 ETO_CLIPPED | ETO_OPAQUE, &(MPanel.rcKeysig),
3200 buffer, strlen(buffer), NULL);
3201 if ((HGDIOBJ) hgdiobj != (HGDIOBJ) NULL
3202 && (HGDIOBJ) hgdiobj != (HGDIOBJ) GDI_ERROR)
3203 SelectObject(MPanel.hmdc, hgdiobj);
3204 GDI_UNLOCK(); // gdi_lock
3205 InvalidateRect(hPanelWnd, &(MPanel.rcKeysig), FALSE);
3206 }
3207 if (MPanel.UpdateFlag & MP_UPDATE_TEMPO) {
3208 char buffer[256];
3209 HGDIOBJ hgdiobj;
3210
3211 GDI_LOCK(); // gdi_lock
3212 hgdiobj = SelectObject(MPanel.hmdc, MPanel.hFontTempo);
3213 sprintf(buffer, "%3d (%03d %%)", MPanel.Tempo, MPanel.Tempo_ratio);
3214 SetTextColor(MPanel.hmdc, MPanel.FGColor);
3215 SetBkColor(MPanel.hmdc, MPanel.BGColor);
3216 SetTextAlign(MPanel.hmdc, TA_LEFT | TA_TOP | TA_NOUPDATECP);
3217 ExtTextOut(MPanel.hmdc,
3218 MPanel.rcTempo.left + 2, MPanel.rcTempo.top,
3219 ETO_CLIPPED | ETO_OPAQUE, &(MPanel.rcTempo),
3220 buffer, strlen(buffer), NULL);
3221 if ((HGDIOBJ) hgdiobj != (HGDIOBJ) NULL
3222 && (HGDIOBJ) hgdiobj != (HGDIOBJ) GDI_ERROR)
3223 SelectObject(MPanel.hmdc, hgdiobj);
3224 GDI_UNLOCK(); // gdi_lock
3225 InvalidateRect(hPanelWnd, &(MPanel.rcTempo), FALSE);
3226 }
3227 if(MPanel.UpdateFlag & MP_UPDATE_PLAYLIST){
3228 char buffer[256];
3229 HGDIOBJ hgdiobj;
3230 GDI_LOCK(); // gdi_lock
3231 hgdiobj = SelectObject(MPanel.hmdc,MPanel.hFontList);
3232 sprintf(buffer," %04d/%04d",MPanel.PlaylistNum,MPanel.PlaylistMax);
3233 SetTextColor(MPanel.hmdc,MPanel.FGColor);
3234 SetBkColor(MPanel.hmdc,MPanel.BGColor);
3235 SetTextAlign(MPanel.hmdc, TA_LEFT | TA_TOP | TA_NOUPDATECP);
3236 ExtTextOut(MPanel.hmdc,MPanel.rcList.left,MPanel.rcList.top,
3237 ETO_CLIPPED | ETO_OPAQUE,&(MPanel.rcList),
3238 buffer,strlen(buffer),NULL);
3239 if((HGDIOBJ)hgdiobj!=(HGDIOBJ)NULL && (HGDIOBJ)hgdiobj!=(HGDIOBJ)GDI_ERROR)
3240 SelectObject(MPanel.hmdc,hgdiobj);
3241 GDI_UNLOCK(); // gdi_lock
3242 InvalidateRect(hPanelWnd, &(MPanel.rcList), FALSE);
3243 }
3244 if(MPanel.UpdateFlag & MP_UPDATE_MISC){
3245 char buffer[256];
3246 HGDIOBJ hgdiobj;
3247 GDI_LOCK(); // gdi_lock
3248 hgdiobj = SelectObject(MPanel.hmdc,MPanel.hFontMisc);
3249 buffer[0] = '\0';
3250 switch(MPanel.play_system_mode){
3251 case GM_SYSTEM_MODE:
3252 strcat(buffer,"[GM]");
3253 break;
3254 case GS_SYSTEM_MODE:
3255 strcat(buffer,"[GS]");
3256 break;
3257 case XG_SYSTEM_MODE:
3258 strcat(buffer,"[XG]");
3259 break;
3260 default:
3261 case DEFAULT_SYSTEM_MODE:
3262 strcat(buffer,"[--]");
3263 break;
3264 }
3265 switch(MPanel.current_file_info_file_type){
3266 case IS_SMF_FILE:
3267 strcat(buffer,"[SMF]");
3268 break;
3269 case IS_MCP_FILE:
3270 strcat(buffer,"[MCP]");
3271 break;
3272 case IS_RCP_FILE:
3273 strcat(buffer,"[RCP]");
3274 break;
3275 case IS_R36_FILE:
3276 strcat(buffer,"[R36]");
3277 break;
3278 case IS_G18_FILE:
3279 strcat(buffer,"[G18]");
3280 break;
3281 case IS_G36_FILE:
3282 strcat(buffer,"[G36]");
3283 break;
3284 case IS_SNG_FILE:
3285 strcat(buffer,"[SNG]");
3286 break;
3287 case IS_MM2_FILE:
3288 strcat(buffer,"[MM2]");
3289 break;
3290 case IS_MML_FILE:
3291 strcat(buffer,"[MML]");
3292 break;
3293 case IS_FM_FILE:
3294 strcat(buffer,"[FM ]");
3295 break;
3296 case IS_FPD_FILE:
3297 strcat(buffer,"[FPD]");
3298 break;
3299 case IS_MOD_FILE:
3300 strcat(buffer,"[MOD]");
3301 break;
3302 case IS_669_FILE:
3303 strcat(buffer,"[669]");
3304 break;
3305 case IS_MTM_FILE:
3306 strcat(buffer,"[MTM]");
3307 break;
3308 case IS_STM_FILE:
3309 strcat(buffer,"[STM]");
3310 break;
3311 case IS_S3M_FILE:
3312 strcat(buffer,"[S3M]");
3313 break;
3314 case IS_ULT_FILE:
3315 strcat(buffer,"[ULT]");
3316 break;
3317 case IS_XM_FILE:
3318 strcat(buffer,"[XM ]");
3319 break;
3320 case IS_FAR_FILE:
3321 strcat(buffer,"[FAR]");
3322 break;
3323 case IS_WOW_FILE:
3324 strcat(buffer,"[WOW]");
3325 break;
3326 case IS_OKT_FILE:
3327 strcat(buffer,"[OKT]");
3328 break;
3329 case IS_DMF_FILE:
3330 strcat(buffer,"[DMF]");
3331 break;
3332 case IS_MED_FILE:
3333 strcat(buffer,"[MED]");
3334 break;
3335 case IS_IT_FILE:
3336 strcat(buffer,"[IT ]");
3337 break;
3338 case IS_PTM_FILE:
3339 strcat(buffer,"[PTM]");
3340 break;
3341 case IS_MFI_FILE:
3342 strcat(buffer,"[MFI]");
3343 break;
3344 default:
3345 case IS_OTHER_FILE:
3346 strcat(buffer,"[---]");
3347 break;
3348 }
3349 if(MPanel.current_file_info_max_channel>=0){
3350 char local[16];
3351 sprintf(local,"[%02dch]",MPanel.current_file_info_max_channel+1);
3352 strcat(buffer,local);
3353 }else
3354 strcat(buffer,"[--ch]");
3355 SetTextColor(MPanel.hmdc,MPanel.FGColor);
3356 SetBkColor(MPanel.hmdc,MPanel.BGColor);
3357 SetTextAlign(MPanel.hmdc, TA_LEFT | TA_TOP | TA_NOUPDATECP);
3358 ExtTextOut(MPanel.hmdc,MPanel.rcMisc.left,MPanel.rcMisc.top,
3359 ETO_CLIPPED | ETO_OPAQUE,&(MPanel.rcMisc),
3360 buffer,strlen(buffer),NULL);
3361 if((HGDIOBJ)hgdiobj!=(HGDIOBJ)NULL && (HGDIOBJ)hgdiobj!=(HGDIOBJ)GDI_ERROR)
3362 SelectObject(MPanel.hmdc,hgdiobj);
3363 GDI_UNLOCK(); // gdi_lock
3364 InvalidateRect(hPanelWnd, &(MPanel.rcMisc), FALSE);
3365 }
3366 if(MPanel.UpdateFlag & MP_UPDATE_MESSAGE){
3367 HGDIOBJ hgdiobj;
3368 GDI_LOCK(); // gdi_lock
3369 hgdiobj = SelectObject(MPanel.hmdc,MPanel.hFontMessage);
3370 SetTextColor(MPanel.hmdc,MPanel.FGColor);
3371 SetBkColor(MPanel.hmdc,MPanel.BGColor);
3372 SetTextAlign(MPanel.hmdc, TA_LEFT | TA_TOP | TA_NOUPDATECP);
3373 switch ( MPanelMessageData.curmode ) {
3374 case 0:
3375 ExtTextOut(MPanel.hmdc,MPanel.rcMessage.left,MPanel.rcMessage.top,
3376 ETO_CLIPPED | ETO_OPAQUE,&(MPanel.rcMessage),
3377 MPanelMessageData.buff,strlen(MPanelMessageData.buff),NULL);
3378 case 1:
3379 ExtTextOut(MPanel.hmdc,MPanel.rcMessage.left,MPanel.rcMessage.top,
3380 ETO_CLIPPED | ETO_OPAQUE,&(MPanel.rcMessage),
3381 MPanelMessageData.buff,strlen(MPanelMessageData.buff),NULL);
3382 // ExtTextOut(MPanel.hmdc,MPanel.rcMessage.left-(MPanel.rcMessage.bottom-MPanel.rcMessage.top)*2,
3383 // MPanel.rcMessage.top, ETO_CLIPPED | ETO_OPAQUE,&(MPanel.rcMessage),
3384 // MPanelMessageData.buff,strlen(MPanelMessageData.buff),NULL);
3385 case 2:
3386 ExtTextOut(MPanel.hmdc,MPanel.rcMessage.left,MPanel.rcMessage.top,
3387 ETO_CLIPPED | ETO_OPAQUE,&(MPanel.rcMessage),
3388 MPanelMessageData.buff,strlen(MPanelMessageData.buff),NULL);
3389 case -1:
3390 default:
3391 ExtTextOut(MPanel.hmdc,MPanel.rcMessage.left,MPanel.rcMessage.top,
3392 ETO_CLIPPED | ETO_OPAQUE,&(MPanel.rcMessage),
3393 MPanelMessageData.buff,strlen(MPanelMessageData.buff),NULL);
3394 }
3395 if((HGDIOBJ)hgdiobj!=(HGDIOBJ)NULL && (HGDIOBJ)hgdiobj!=(HGDIOBJ)GDI_ERROR)
3396 SelectObject(MPanel.hmdc,hgdiobj);
3397 GDI_UNLOCK(); // gdi_lock
3398 InvalidateRect(hPanelWnd, &(MPanel.rcMessage), FALSE);
3399 }
3400 if(MPanel.UpdateFlag==MP_UPDATE_ALL)
3401 InvalidateRect(hPanelWnd, NULL, FALSE);
3402 MPanel.UpdateFlag = MP_UPDATE_NONE;
3403 }
3404
MPanelPaintDo(void)3405 static void MPanelPaintDo(void)
3406 {
3407 RECT rc;
3408 if ( GetUpdateRect(MPanel.hwnd, &rc, FALSE) ) {
3409 PAINTSTRUCT ps;
3410 HDC hdc;
3411 GDI_LOCK(); // gdi_lock
3412 hdc = BeginPaint(MPanel.hwnd, &ps);
3413 BitBlt(hdc,rc.left,rc.top,rc.right,rc.bottom,MPanel.hmdc,rc.left,rc.top,SRCCOPY);
3414 EndPaint(MPanel.hwnd, &ps);
3415 GDI_UNLOCK(); // gdi_lock
3416 }
3417 }
3418
3419 // �`��
MPanelPaint(void)3420 void MPanelPaint(void)
3421 {
3422 UpdateWindow(hPanelWnd);
3423 }
3424
3425 // ���S�`��
MPanelPaintAll(void)3426 void MPanelPaintAll(void)
3427 {
3428 InvalidateRect(hPanelWnd, NULL, FALSE);
3429 MPanelPaint();
3430 }
3431
3432 // �p�l���\���̂����Ɋ��S�X�V������B
MPanelUpdateAll(void)3433 void MPanelUpdateAll(void)
3434 {
3435 if(!MPanelOK)
3436 return;
3437 MPanel.UpdateFlag = MP_UPDATE_ALL;
3438 MPanelUpdate();
3439 }
3440
3441 // PanelInfo �\���̂�ǂݍ���Ńp�l���\���̂֓K�p����B
3442 // flag �͋����X�V����B
MPanelReadPanelInfo(int flag)3443 void MPanelReadPanelInfo(int flag)
3444 {
3445 int cur_pl_num, playlist_num;
3446
3447 if(!MPanelOK)
3448 return;
3449 if(!PInfoOK)
3450 return;
3451
3452 if(!Panel->changed && !flag)
3453 return;
3454
3455 if(flag
3456 || MPanel.CurTime_s != Panel->cur_time_s
3457 // || MPanel.CurTime_ss != Panel->cur_time_ss
3458 || MPanel.CurTime_m != Panel->cur_time_m
3459 || MPanel.CurTime_h != Panel->cur_time_h
3460 || MPanel.TotalTime_s != Panel->total_time_s
3461 // || MPanel.TotalTime_ss != Panel->total_time_ss
3462 || MPanel.TotalTime_m != Panel->total_time_m
3463 || MPanel.TotalTime_h != Panel->total_time_h
3464 ){
3465 MPanel.CurTime_h = Panel->cur_time_h;
3466 MPanel.CurTime_m = Panel->cur_time_m;
3467 MPanel.CurTime_s = Panel->cur_time_s;
3468 MPanel.CurTime_ss = Panel->cur_time_ss;
3469 MPanel.TotalTime_h = Panel->total_time_h;
3470 MPanel.TotalTime_m = Panel->total_time_m;
3471 MPanel.TotalTime_s = Panel->total_time_s;
3472 // MPanel.TotalTime_ss = Panel->total_time_ss;
3473 RANGE(MPanel.CurTime_h,0,99);
3474 RANGE(MPanel.TotalTime_h,0,99);
3475 MPanel.UpdateFlag |= MP_UPDATE_TIME;
3476 }
3477 if(flag || MPanel.MaxVoices != Panel->voices){
3478 MPanel.MaxVoices = Panel->voices;
3479 MPanel.UpdateFlag |= MP_UPDATE_VOICES;
3480 }
3481 if(flag || MPanel.CurVoices != Panel->cur_voices){
3482 MPanel.CurVoices = Panel->cur_voices;
3483 MPanel.UpdateFlag |= MP_UPDATE_VOICES;
3484 }
3485 if(flag || MPanel.MVolume != amplification){
3486 MPanel.MVolume = amplification;
3487 MPanel.UpdateFlag |= MP_UPDATE_MVOLUME;
3488 }
3489 if(flag || MPanel.Rate != play_mode->rate){
3490 MPanel.Rate = play_mode->rate;
3491 MPanel.UpdateFlag |= MP_UPDATE_RATE;
3492 }
3493 if (flag || MPanel.Meas != Panel->meas) {
3494 MPanel.Meas = Panel->meas;
3495 MPanel.UpdateFlag |= MP_UPDATE_METRONOME;
3496 }
3497 if (flag || MPanel.Beat != Panel->beat) {
3498 MPanel.Beat = Panel->beat;
3499 MPanel.UpdateFlag |= MP_UPDATE_METRONOME;
3500 }
3501 if (flag || MPanel.Keysig != Panel->keysig) {
3502 strcpy(MPanel.Keysig, Panel->keysig);
3503 MPanel.UpdateFlag |= MP_UPDATE_KEYSIG;
3504 }
3505 if (flag || MPanel.Key_offset != Panel->key_offset) {
3506 MPanel.Key_offset = Panel->key_offset;
3507 MPanel.UpdateFlag |= MP_UPDATE_KEYSIG;
3508 }
3509 if (flag || MPanel.Tempo != Panel->tempo) {
3510 MPanel.Tempo = Panel->tempo;
3511 MPanel.UpdateFlag |= MP_UPDATE_TEMPO;
3512 }
3513 if (flag || MPanel.Tempo_ratio != Panel->tempo_ratio) {
3514 MPanel.Tempo_ratio = Panel->tempo_ratio;
3515 MPanel.UpdateFlag |= MP_UPDATE_TEMPO;
3516 }
3517
3518 w32g_get_playlist_index(&cur_pl_num, &playlist_num, NULL);
3519 if(playlist_num > 0)
3520 cur_pl_num++;
3521 if(flag || MPanel.PlaylistNum != cur_pl_num){
3522 MPanel.PlaylistNum = cur_pl_num;
3523 MPanel.UpdateFlag |= MP_UPDATE_PLAYLIST;
3524 }
3525 if(flag || MPanel.PlaylistMax != playlist_num){
3526 MPanel.PlaylistMax = playlist_num;
3527 MPanel.UpdateFlag |= MP_UPDATE_PLAYLIST;
3528 }
3529 if(flag || MPanel.play_system_mode != play_system_mode){
3530 MPanel.play_system_mode = play_system_mode;
3531 MPanel.UpdateFlag |= MP_UPDATE_MISC;
3532 }
3533 if(current_file_info!=NULL){
3534 if(flag || MPanel.current_file_info_file_type != current_file_info->file_type){
3535 MPanel.current_file_info_file_type = current_file_info->file_type;
3536 MPanel.UpdateFlag |= MP_UPDATE_MISC;
3537 }
3538 if(flag || MPanel.current_file_info_max_channel != current_file_info->max_channel){
3539 MPanel.current_file_info_max_channel = current_file_info->max_channel;
3540 MPanel.UpdateFlag |= MP_UPDATE_MISC;
3541 }
3542 }
3543 }
3544
MPanelStartLoad(char * filename)3545 void MPanelStartLoad(char *filename)
3546 {
3547 strncpy((char *)MPanel.File, filename, MP_FILE_MAX);
3548 MPanel.UpdateFlag |= MP_UPDATE_FILE;
3549 MPanelUpdate();
3550 }
3551
MPanelMessageInit(void)3552 void MPanelMessageInit(void)
3553 {
3554 int width = (MPanel.rcMessage.bottom - MPanel.rcMessage.top + 1) / 2;
3555 MPanelMessageData.len = (MPanel.rcMessage.right - MPanel.rcMessage.left) / width;
3556 MPanelMessageClearAll();
3557 }
3558
3559 // sec �b�� message �����B
3560 // mode 0: sec �b���� message ��\���B�f�t�H���g�B
3561 // mode 1: sec �b�̊Ԃ� message ���E���獶�ɗ����B
3562 // mode 2: sec �b�̊Ԃ� messege ��\���B�|�C���^��������E�Ɉڂ��B�|�C���^�����E�ɐF��ς���B
MPanelMessageAdd(char * message,int msec,int mode)3563 void MPanelMessageAdd(char *message, int msec, int mode)
3564 {
3565 if ( MPanelMessageData.nextmode >= 0 ) {
3566 MPanelMessageNext();
3567 strncpy(MPanelMessageData.nextbuff,message,sizeof(MPanelMessageData.nextbuff)-1);
3568 MPanelMessageData.nextmode = mode;
3569 MPanelMessageData.nextmsec = msec;
3570 } else if ( MPanelMessageData.curmode >= 0 ){
3571 strncpy(MPanelMessageData.nextbuff,message,sizeof(MPanelMessageData.nextbuff)-1);
3572 MPanelMessageData.nextmode = mode;
3573 MPanelMessageData.nextmsec = msec;
3574 } else {
3575 strncpy(MPanelMessageData.nextbuff,message,sizeof(MPanelMessageData.nextbuff)-1);
3576 MPanelMessageData.nextmode = mode;
3577 MPanelMessageData.nextmsec = msec;
3578 MPanelMessageNext();
3579 }
3580 }
MPanelMessageHaveMesssage(void)3581 int MPanelMessageHaveMesssage(void)
3582 {
3583 if ( MPanelMessageData.curmode >= 0 || MPanelMessageData.nextmode >= 0 )
3584 return 1;
3585 else
3586 return 0;
3587 }
MPanelMessageClearAll(void)3588 void MPanelMessageClearAll(void)
3589 {
3590 MPanelMessageData.buff[0] = '\0';
3591 MPanelMessageData.curmode = -1;
3592 MPanelMessageData.nextmode = -1;
3593 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3594 }
MPanelMessageClear(void)3595 void MPanelMessageClear(void)
3596 {
3597 MPanelMessageData.buff[0] = '\0';
3598 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3599 }
MPanelMessageNext(void)3600 void MPanelMessageNext(void)
3601 {
3602 MPanelMessageClear();
3603 if ( MPanelMessageData.nextmode >= 0 ) {
3604 strcpy(MPanelMessageData.curbuff,MPanelMessageData.nextbuff);
3605 MPanelMessageData.curbuffsize = strlen(MPanelMessageData.curbuff);
3606 MPanelMessageData.curmode = MPanelMessageData.nextmode;
3607 MPanelMessageData.curmsec = MPanelMessageData.nextmsec;
3608 MPanelMessageData.pointer = -1;
3609 MPanelMessageData.nextmode = -1;
3610 MPanelMessageData.prevtime = -1;
3611 } else {
3612 MPanelMessageData.curmode = -1;
3613 MPanelMessageData.prevtime = -1;
3614 }
3615 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3616 }
MPanelMessageUpdate(void)3617 void MPanelMessageUpdate(void)
3618 {
3619 // DWORD curtime = GetCurrentTime();
3620 DWORD curtime = 0;
3621 int pointer;
3622
3623 if ( MPanelMessageData.curmode >= 0 ) {
3624 curtime += Panel->cur_time_h;
3625 curtime *= 24;
3626 curtime += Panel->cur_time_m;
3627 curtime *= 60;
3628 curtime += Panel->cur_time_s;
3629 curtime *= 1000;
3630 curtime += Panel->cur_time_ss;
3631 }
3632 switch ( MPanelMessageData.curmode ) {
3633 case 0:
3634 if ( MPanelMessageData.prevtime == -1 ){
3635 strcpy( MPanelMessageData.buff, MPanelMessageData.curbuff );
3636 MPanelMessageData.prevtime = curtime;
3637 MPanelMessageData.msec = MPanelMessageData.curmsec;
3638 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3639 } else {
3640 MPanelMessageData.msec -= curtime - MPanelMessageData.prevtime;
3641 MPanelMessageData.prevtime = curtime;
3642 }
3643 if ( MPanelMessageData.msec <= 0 || curtime < MPanelMessageData.prevtime ) {
3644 MPanelMessageNext();
3645 MPanelMessageUpdate();
3646 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3647 break;
3648 }
3649 break;
3650 case 1:
3651 if ( MPanelMessageData.prevtime == -1 ){
3652 MPanelMessageData.prevtime = curtime;
3653 MPanelMessageData.msec = MPanelMessageData.curmsec;
3654 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3655 } else {
3656 MPanelMessageData.msec -= curtime - MPanelMessageData.prevtime;
3657 MPanelMessageData.prevtime = curtime;
3658 }
3659 if ( MPanelMessageData.msec <= 0 || curtime < MPanelMessageData.prevtime ) {
3660 MPanelMessageNext();
3661 MPanelMessageUpdate();
3662 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3663 return;
3664 }
3665 // pointer = MPanelMessageData.len * 4 / 5 + ( MPanelMessageData.curmsec - MPanelMessageData.msec ) / 1000 * 2;
3666 pointer = MPanelMessageData.len - 8 + ( MPanelMessageData.curmsec - MPanelMessageData.msec ) / 1000 * 2;
3667 pointer = (int)( pointer / 2 ) * 2;
3668 if ( MPanelMessageData.pointer != pointer ) {
3669 int p = MPanelMessageData.len - pointer;
3670 MPanelMessageData.buff[0] = '\0';
3671 MPanelMessageData.pointer = pointer;
3672 if ( p >= 0 ) {
3673 memset( MPanelMessageData.buff, 0x20, p );
3674 MPanelMessageData.buff[p] = '\0';
3675 strcat( MPanelMessageData.buff, MPanelMessageData.curbuff);
3676 } else if ( MPanelMessageData.curbuffsize + p > 0 ) {
3677 strcpy( MPanelMessageData.buff, MPanelMessageData.curbuff - p);
3678 } else {
3679 MPanelMessageData.buff[0] = '\0';
3680 }
3681 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3682 }
3683 break;
3684 case 2:
3685 if ( MPanelMessageData.prevtime == -1 ){
3686 strcpy( MPanelMessageData.buff, MPanelMessageData.curbuff );
3687 MPanelMessageData.prevtime = curtime;
3688 MPanelMessageData.msec = MPanelMessageData.curmsec;
3689 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3690 } else {
3691 MPanelMessageData.msec -= curtime - MPanelMessageData.prevtime;
3692 MPanelMessageData.prevtime = curtime;
3693 }
3694 if ( MPanelMessageData.msec <= 0 || curtime < MPanelMessageData.prevtime ) {
3695 MPanelMessageNext();
3696 MPanelMessageUpdate();
3697 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3698 break;
3699 }
3700 pointer = ( MPanelMessageData.len + MPanelMessageData.curbuffsize ) * ( MPanelMessageData.curmsec - MPanelMessageData.msec ) / MPanelMessageData.curmsec;
3701 if ( MPanelMessageData.pointer != pointer ) {
3702 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3703 }
3704 break;
3705 case 3:
3706 if ( MPanelMessageData.prevtime == -1 ){
3707 MPanelMessageData.prevtime = curtime;
3708 MPanelMessageData.msec = MPanelMessageData.curmsec;
3709 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3710 } else {
3711 MPanelMessageData.msec -= curtime - MPanelMessageData.prevtime;
3712 MPanelMessageData.prevtime = curtime;
3713 }
3714 if ( MPanelMessageData.msec <= 0 || curtime < MPanelMessageData.prevtime ) {
3715 MPanelMessageNext();
3716 MPanelMessageUpdate();
3717 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3718 return;
3719 }
3720 pointer = MPanelMessageData.len * 3 / 4 + ( MPanelMessageData.len / 4 + MPanelMessageData.curbuffsize ) * ( MPanelMessageData.curmsec - MPanelMessageData.msec ) / MPanelMessageData.curmsec;
3721 pointer = ((int)(pointer / 2)) * 2;
3722 if ( MPanelMessageData.pointer != pointer ) {
3723 int p = MPanelMessageData.len - pointer;
3724 MPanelMessageData.buff[0] = '\0';
3725 MPanelMessageData.pointer = pointer;
3726 if ( p >= 0 ) {
3727 memset( MPanelMessageData.buff, 0x20, p );
3728 MPanelMessageData.buff[p] = '\0';
3729 strcat( MPanelMessageData.buff, MPanelMessageData.curbuff);
3730 } else if ( MPanelMessageData.curbuffsize + p > 0 ) {
3731 strcpy( MPanelMessageData.buff, MPanelMessageData.curbuff - p);
3732 } else {
3733 MPanelMessageData.buff[0] = '\0';
3734 }
3735 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3736 }
3737 break;
3738 case 4:
3739 if ( MPanelMessageData.prevtime == -1 ){
3740 MPanelMessageData.prevtime = curtime;
3741 #define MPANELMESSAGE_MODE2_SLEEPMSEC 1000
3742 if ( MPanelMessageData.curmsec < MPANELMESSAGE_MODE2_SLEEPMSEC * 2 ) {
3743 MPanelMessageData.curmsec = MPANELMESSAGE_MODE2_SLEEPMSEC * 2;
3744 }
3745 MPanelMessageData.msec = MPanelMessageData.curmsec;
3746 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3747 } else {
3748 MPanelMessageData.msec -= curtime - MPanelMessageData.prevtime;
3749 MPanelMessageData.prevtime = curtime;
3750 }
3751 if ( MPanelMessageData.msec <= 0 || curtime < MPanelMessageData.prevtime ) {
3752 MPanelMessageNext();
3753 MPanelMessageUpdate();
3754 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3755 return;
3756 }
3757 if ( MPanelMessageData.curmsec - MPanelMessageData.msec <= MPANELMESSAGE_MODE2_SLEEPMSEC ) {
3758 pointer = 0;
3759 } else {
3760 pointer = MPanelMessageData.curbuffsize * ( MPanelMessageData.curmsec - MPanelMessageData.msec - MPANELMESSAGE_MODE2_SLEEPMSEC ) / ( MPanelMessageData.curmsec - MPANELMESSAGE_MODE2_SLEEPMSEC );
3761 }
3762 pointer = ((int)(pointer / 2)) * 2;
3763 if ( MPanelMessageData.pointer != pointer ) {
3764 MPanelMessageData.buff[0] = '\0';
3765 MPanelMessageData.pointer = pointer;
3766 if ( pointer < MPanelMessageData.curbuffsize ) {
3767 strcpy( MPanelMessageData.buff, MPanelMessageData.curbuff + pointer );
3768 } else {
3769 MPanelMessageData.buff[0] = '\0';
3770 }
3771 MPanel.UpdateFlag |= MP_UPDATE_MESSAGE;
3772 }
3773 break;
3774 case -1:
3775 default:
3776 // MPanelMessageData.buff[0] = '\0';
3777 break;
3778 }
3779 }
3780
3781
3782
3783
3784 // ----------------------------------------------------------------------------
3785 // Misc. Controls
3786
3787
3788
3789
3790
3791
3792
3793
3794
3795
3796
3797 // ----------------------------------------------------------------------------
3798
3799
3800
3801
3802
3803
3804
3805
3806
3807 // ****************************************************************************
3808 // Version Window
3809
VersionWnd(HWND hParentWnd)3810 static void VersionWnd(HWND hParentWnd)
3811 {
3812 char VersionText[2024];
3813 sprintf(VersionText,
3814 "TiMidity++ %s%s" NLS NLS
3815 "TiMidity-0.2i by Tuukka Toivonen <tt@cgs.fi>." NLS
3816 "TiMidity Win32 version by Davide Moretti <dave@rimini.com>." NLS
3817 "TiMidity Windows 95 port by Nicolas Witczak." NLS
3818 "TiMidity Win32 GUI by Daisuke Aoki <dai@y7.net>." NLS
3819 " Japanese menu, dialog, etc by Saito <timidity@flashmail.com>." NLS
3820 "TiMidity++ by Masanao Izumo <iz@onicos.co.jp>." NLS
3821 ,(strcmp(timidity_version, "current")) ? "version " : "", timidity_version);
3822 MessageBox(hParentWnd, VersionText, "Version", MB_OK);
3823 }
3824
TiMidityWnd(HWND hParentWnd)3825 static void TiMidityWnd(HWND hParentWnd)
3826 {
3827 char TiMidityText[2024];
3828 sprintf(TiMidityText,
3829 " TiMidity++ %s%s -- MIDI to WAVE converter and player" NLS
3830 " Copyright (C) 1999-2018 Masanao Izumo <iz@onicos.co.jp>" NLS
3831 " Copyright (C) 1995 Tuukka Toivonen <tt@cgs.fi>" NLS
3832 NLS
3833 " Win32 version by Davide Moretti <dmoretti@iper.net>" NLS
3834 " GUI by Daisuke Aoki <dai@y7.net>." NLS
3835 " Modified by Masanao Izumo <iz@onicos.co.jp>." NLS
3836 NLS
3837 " This program is free software; you can redistribute it and/or modify" NLS
3838 " it under the terms of the GNU General Public License as published by" NLS
3839 " the Free Software Foundation; either version 2 of the License, or" NLS
3840 " (at your option) any later version." NLS
3841 NLS
3842 " This program is distributed in the hope that it will be useful," NLS
3843 " but WITHOUT ANY WARRANTY; without even the implied warranty of"NLS
3844 " MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the" NLS
3845 " GNU General Public License for more details." NLS
3846 NLS
3847 " You should have received a copy of the GNU General Public License" NLS
3848 " along with this program; if not, write to the Free Software" NLS
3849 " Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA" NLS
3850 ,
3851 (strcmp(timidity_version, "current")) ? "version " : "", timidity_version
3852 );
3853 MessageBox(hParentWnd, TiMidityText, "TiMidity++", MB_OK);
3854 }
3855
SupplementWnd(HWND hParentWnd)3856 static void SupplementWnd(HWND hParentWnd)
3857 {
3858 char SupplementText[2024];
3859 sprintf(SupplementText,
3860 "GS is a registered trademark of Roland Corporation. " NLS
3861 "XG is a registered trademark of Yamaha Corporation. " NLS );
3862 MessageBox(hParentWnd, SupplementText, "Supplement", MB_OK);
3863 }
3864
3865
3866 // ****************************************************************************
3867
3868 #ifdef W32GUI_DEBUG
TiMidityHeapCheck(void)3869 void TiMidityHeapCheck(void)
3870 {
3871 HANDLE *ProcessHeaps = NULL;
3872 DWORD dwNumberOfHeaps;
3873 DWORD dw = 10;
3874 int i;
3875 PrintfDebugWnd("\n[Heaps Check Start]\n");
3876 if(GetProcessHeap()!=NULL)
3877 if(HeapValidate(GetProcessHeap(),0,NULL)==TRUE)
3878 PrintfDebugWnd("Process Heap is Valid\n");
3879 else
3880 PrintfDebugWnd("Process Heap is Invalid\n");
3881 ProcessHeaps = (HANDLE *)realloc(ProcessHeaps,sizeof(HANDLE)*dw);
3882 dwNumberOfHeaps = GetProcessHeaps(dw, ProcessHeaps);
3883 if(dw<dwNumberOfHeaps){
3884 dw = dwNumberOfHeaps;
3885 ProcessHeaps = (HANDLE *)realloc(ProcessHeaps,sizeof(HANDLE)*dw);
3886 dwNumberOfHeaps = GetProcessHeaps(dw, ProcessHeaps);
3887 }
3888 PrintfDebugWnd("NumberOfHeaps=%ld\n",(int)dwNumberOfHeaps);
3889 for(i=0;i<(int)dwNumberOfHeaps;i++){
3890 if(HeapValidate(ProcessHeaps[i],0,NULL)==TRUE)
3891 PrintfDebugWnd("Heap %d is Valid\n",i+1);
3892 else
3893 PrintfDebugWnd("Heap %d is Invalid\n",i+1);
3894 }
3895 PrintfDebugWnd("[Heaps Check End]\n\n");
3896 free(ProcessHeaps);
3897 }
3898 #endif
3899
TiMidityVariablesCheck(void)3900 void TiMidityVariablesCheck(void)
3901 {
3902 #if 0
3903 // player_status
3904 PrintfDebugWnd("[player_status]\n");
3905 PrintfDebugWnd("player_status=%ld\n",player_status);
3906 switch(player_status){
3907 case PLAYERSTATUS_NONE:
3908 PrintfDebugWnd("player_status=PLAYERSTATUS_NONE\n");
3909 break;
3910 case PLAYERSTATUS_STOP:
3911 PrintfDebugWnd("player_status=PLAYERSTATUS_STOP\n");
3912 break;
3913 case PLAYERSTATUS_PAUSE:
3914 PrintfDebugWnd("player_status=PLAYERSTATUS_PAUSE\n");
3915 break;
3916 case PLAYERSTATUS_PLAY:
3917 PrintfDebugWnd("player_status=PLAYERSTATUS_PLAY\n");
3918 break;
3919 case PLAYERSTATUS_PLAYSTART:
3920 PrintfDebugWnd("player_status=PLAYERSTATUS_PLAYSTART\n");
3921 break;
3922 case PLAYERSTATUS_DEMANDPLAY:
3923 PrintfDebugWnd("player_status=PLAYERSTATUS_DEMANDPLAY\n");
3924 break;
3925 case PLAYERSTATUS_PLAYEND:
3926 PrintfDebugWnd("player_status=PLAYERSTATUS_PLAYEND\n");
3927 break;
3928 case PLAYERSTATUS_PLAYERROREND:
3929 PrintfDebugWnd("player_status=PLAYERSTATUS_PLAYERROREND\n");
3930 break;
3931 case PLAYERSTATUS_QUIT:
3932 PrintfDebugWnd("player_status=PLAYERSTATUS_QUIT\n");
3933 break;
3934 case PLAYERSTATUS_ERROR:
3935 PrintfDebugWnd("player_status=PLAYERSTATUS_ERROR\n");
3936 break;
3937 case PLAYERSTATUS_FORCED_EXIT:
3938 PrintfDebugWnd("player_status=PLAYERSTATUS_FORCED_EXIT\n");
3939 break;
3940 default:
3941 break;
3942 }
3943 #endif
3944 }
3945
3946
3947
3948
3949 // ****************************************************************************
3950 // Debug Window
3951 #ifdef W32GUI_DEBUG
3952
3953 BOOL CALLBACK DebugWndProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam);
3954 void InitDebugEditWnd(HWND hParentWnd);
3955
InitDebugWnd(HWND hParentWnd)3956 void InitDebugWnd(HWND hParentWnd)
3957 {
3958 hDebugWnd = CreateDialog
3959 (hInst,MAKEINTRESOURCE(IDD_DIALOG_DEBUG),hParentWnd,DebugWndProc);
3960 ShowWindow(hDebugWnd,SW_HIDE);
3961 UpdateWindow(hDebugWnd);
3962 }
3963
3964 BOOL CALLBACK
DebugWndProc(HWND hwnd,UINT uMess,WPARAM wParam,LPARAM lParam)3965 DebugWndProc(HWND hwnd, UINT uMess, WPARAM wParam, LPARAM lParam)
3966 {
3967 switch (uMess){
3968 case WM_INITDIALOG:
3969 // InitDebugEditWnd(hwnd);
3970 hDebugEditWnd = GetDlgItem(hwnd,IDC_EDIT);
3971 if(DebugWndFlag)
3972 CheckDlgButton(hwnd, IDC_CHECKBOX_DEBUG_WND_VALID, 1);
3973 else
3974 CheckDlgButton(hwnd, IDC_CHECKBOX_DEBUG_WND_VALID, 0);
3975 TiMidityHeapCheck();
3976 return FALSE;
3977 case WM_DESTROY:
3978 PostQuitMessage(0);
3979 return 0;
3980 case WM_COMMAND:
3981 switch (LOWORD(wParam)) {
3982 case IDCLOSE:
3983 ShowWindow(hwnd, SW_HIDE);
3984 break;
3985 case IDCLEAR:
3986 ClearDebugWnd();
3987 break;
3988 case IDC_CHECKBOX_DEBUG_WND_VALID:
3989 if(IsDlgButtonChecked(hwnd,IDC_CHECKBOX_DEBUG_WND_VALID))
3990 DebugWndFlag = 1;
3991 else
3992 DebugWndFlag = 0;
3993 break;
3994 case IDC_BUTTON_EXITPROCESS:
3995 ExitProcess(0);
3996 return 0;
3997 case IDC_BUTTON_EXIT:
3998 return DestroyWindow(hwnd);
3999 case IDC_BUTTON_HEAP_CHECK:
4000 TiMidityHeapCheck();
4001 break;
4002 case IDC_BUTTON_VARIABLES_CHECK:
4003 TiMidityVariablesCheck();
4004 break;
4005 default:
4006 break;
4007 }
4008 switch (HIWORD(wParam)) {
4009 case EN_ERRSPACE:
4010 ClearConsoleWnd();
4011 // PutsConsoleWnd("### EN_ERRSPACE -> Clear! ###\n");
4012 break;
4013 default:
4014 break;
4015 }
4016 break;
4017 case WM_SIZE:
4018 // GetClientRect(hDebugWnd, &rc);
4019 // MoveWindow(hDebugEditWnd, rc.left, rc.top,rc.right, rc.bottom - 30,TRUE);
4020 return FALSE;
4021 case WM_CLOSE:
4022 ShowWindow(hDebugWnd, SW_HIDE);
4023 break;
4024 default:
4025 return FALSE;
4026 }
4027 return FALSE;
4028 }
4029
4030 #if 0
4031 void InitDebugEditWnd(HWND hParentWnd)
4032 {
4033 RECT rc;
4034 GetClientRect(hParentWnd, &rc);
4035 hDebugEditWnd = CreateWindowEx(
4036 WS_EX_CLIENTEDGE|WS_EX_TOOLWINDOW|WS_EX_DLGMODALFRAME,
4037 "EDIT","",
4038 WS_CHILD | WS_VISIBLE | WS_VSCROLL | ES_AUTOHSCROLL | WS_HSCROLL
4039 |ES_READONLY | ES_WANTRETURN | ES_MULTILINE | ES_AUTOVSCROLL ,
4040 // 0,0,rc.right, rc.bottom - 30,hParentWnd,NULL,hInst,NULL);
4041 0,0,100,100,hParentWnd,NULL,hInst,NULL);
4042 SendMessage(hDebugEditWnd, EM_SETLIMITTEXT, (WPARAM)1024*640, 0);
4043 // SendMessage(hDebugEditWnd, WM_PAINT, 0, 0);
4044 GetClientRect(hParentWnd, &rc);
4045 MoveWindow(hDebugEditWnd,rc.left,rc.top,rc.right,rc.bottom-30,TRUE);
4046 ClearDebugWnd();
4047 ShowWindow(hDebugEditWnd,SW_SHOW);
4048 UpdateWindow(hDebugEditWnd);
4049 }
4050 #endif
4051
PutsDebugWnd(char * str)4052 void PutsDebugWnd(char *str)
4053 {
4054 if(!IsWindow(hDebugEditWnd) || !DebugWndFlag)
4055 return;
4056 PutsEditCtlWnd(hDebugEditWnd,str);
4057 }
4058
PrintfDebugWnd(char * fmt,...)4059 void PrintfDebugWnd(char *fmt, ...)
4060 {
4061 va_list ap;
4062 if(!IsWindow(hDebugEditWnd) || !DebugWndFlag)
4063 return;
4064 va_start(ap, fmt);
4065 VprintfEditCtlWnd(hDebugEditWnd,fmt,ap);
4066 va_end(ap);
4067 }
4068
ClearDebugWnd(void)4069 void ClearDebugWnd(void)
4070 {
4071 if(!IsWindow(hDebugEditWnd))
4072 return;
4073 ClearEditCtlWnd(hDebugEditWnd);
4074 }
4075 #endif
4076
4077
4078
4079
4080
4081
4082
4083
4084
4085
4086
4087
4088
4089
4090
4091
4092
4093
4094
4095
4096
4097
4098 // ****************************************************************************
4099 // Main Thread
4100
4101 extern HWND hListSearchWnd;
4102 extern void HideListSearch(void);
4103
4104 #ifndef __BORLANDC__
4105 DWORD volatile dwMainThreadId = 0;
4106 #endif
4107
MainThread(void * arglist)4108 void WINAPI MainThread(void *arglist)
4109 {
4110 #ifdef __BORLANDC__
4111 DWORD volatile dwMainThreadId = 0;
4112 #endif
4113 MSG msg;
4114
4115 ThreadNumMax++;
4116
4117 dwMainThreadId = GetCurrentThreadId ();
4118 #ifdef W32GUI_DEBUG
4119 PrintfDebugWnd("(*/%d)MainThread : Start.\n",ThreadNumMax);
4120 #endif
4121 #ifdef USE_THREADTIMES
4122 ThreadTimesAddThread(hMainThread,"MainThread");
4123 #endif
4124 // Thread priority
4125 // SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_BELOW_NORMAL);
4126 SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_NORMAL);
4127 // SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_ABOVE_NORMAL);
4128
4129
4130 InitStartWnd(SW_HIDE);
4131
4132 w32g_wait_for_init = 0;
4133
4134 // message loop for the application
4135 while( GetMessage(&msg,NULL,0,0) ){
4136 // HandleFastSearch(msg);
4137 //PrintfDebugWnd("H%lu M%lu WP%lu LP%lu T%lu x%d y%d\n",
4138 // msg.hwnd, msg.message, msg.wParam, msg.lParam, msg.time, msg.pt.x, msg.pt.y);
4139 #if 1
4140 // ESC �ő���‚���B
4141 if ( msg.message == WM_KEYDOWN && (int)msg.wParam == VK_ESCAPE ) {
4142 if ( msg.hwnd == hConsoleWnd || IsChild ( hConsoleWnd, msg.hwnd ) ) {
4143 ToggleSubWindow(hConsoleWnd);
4144 } else if ( msg.hwnd == hDocWnd || IsChild ( hDocWnd, msg.hwnd ) ) {
4145 ToggleSubWindow(hDocWnd);
4146 } else if ( msg.hwnd == hWrdWnd || IsChild ( hWrdWnd, msg.hwnd ) ) {
4147 ToggleSubWindow(hWrdWnd);
4148 } else if ( msg.hwnd == hListWnd || IsChild ( hListWnd, msg.hwnd ) ) {
4149 ToggleSubWindow(hListWnd);
4150 } else if ( msg.hwnd == hListSearchWnd || IsChild ( hListSearchWnd, msg.hwnd ) ) {
4151 HideListSearch();
4152 } else if ( msg.hwnd == hTracerWnd || IsChild ( hTracerWnd, msg.hwnd ) ) {
4153 ToggleSubWindow(hTracerWnd);
4154 }
4155 }
4156 #endif
4157 TranslateMessage(&msg);
4158 DispatchMessage(&msg);
4159 }
4160
4161 #ifdef W32GUI_DEBUG
4162 Sleep(200);
4163 PrintfDebugWnd("w32gui_main: DebugWndExit\n");
4164 // MessageBox(NULL, "Exit!","Exit!",MB_OK);
4165 if(hDebugWnd!=NULL)
4166 for(;;){
4167 if(!DebugThreadExit){
4168 SendMessage(hDebugWnd,WM_COMMAND,(WPARAM)IDC_BUTTON_EXIT,0);
4169 Sleep(100);
4170 } else
4171 break;
4172 }
4173 #endif
4174 if(!w32g_restart_gui_flag)
4175 {
4176 OnExitReady();
4177 w32g_send_rc(RC_QUIT, 0);
4178 }
4179 crt_endthread();
4180 }
4181
4182
4183
4184
4185 // **************************************************************************
4186 // Misc Dialog
4187 #define DialogMaxFileName 16536
4188 static char DialogFileNameBuff[DialogMaxFileName];
DlgFileOpen(HWND hwnd,char * title,char * filter,char * dir)4189 static char *DlgFileOpen(HWND hwnd, char *title, char *filter, char *dir)
4190 {
4191 OPENFILENAME ofn;
4192 memset(DialogFileNameBuff, 0, sizeof(DialogFileNameBuff));
4193 memset(&ofn, 0, sizeof(OPENFILENAME));
4194 ofn.lStructSize = sizeof(OPENFILENAME);
4195 ofn.hwndOwner = hwnd;
4196 ofn.hInstance = hInst ;
4197 ofn.lpstrFilter = filter;
4198 ofn.lpstrCustomFilter = NULL;
4199 ofn.nMaxCustFilter = 0;
4200 ofn.nFilterIndex = 1 ;
4201 ofn.lpstrFile = DialogFileNameBuff;
4202 ofn.nMaxFile = sizeof(DialogFileNameBuff);
4203 ofn.lpstrFileTitle = 0;
4204 ofn.nMaxFileTitle = 0;
4205 ofn.lpstrInitialDir = dir;
4206 ofn.lpstrTitle = title;
4207 ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST
4208 | OFN_ALLOWMULTISELECT | OFN_EXPLORER | OFN_READONLY;
4209 ofn.lpstrDefExt = 0;
4210 ofn.lCustData = 0;
4211 ofn.lpfnHook = 0;
4212 ofn.lpTemplateName= 0;
4213
4214 if(GetOpenFileName(&ofn)==TRUE)
4215 return DialogFileNameBuff;
4216 else
4217 return NULL;
4218 }
4219
DlgMidiFileOpen(HWND hwnd)4220 static void DlgMidiFileOpen(HWND hwnd)
4221 {
4222 char *dir, *file;
4223 char *filter = "timidity file\0*.mid;*.smf;*.rcp;*.r36;*.g18;*.g36;*.rmi;*.lzh;*.zip;*.gz\0"
4224 "midi file\0*.mid;*.smf;*.rcp;*.r36;*.g18;*.g36;*.rmi\0"
4225 "archive file\0*.lzh;*.zip;*.gz\0"
4226 "playlist file\0*.pls;*.m3u;*.asx\0"
4227 "all files\0*.*\0"
4228 "\0\0";
4229
4230 if(w32g_lock_open_file)
4231 return;
4232
4233 if(MidiFileOpenDir[0])
4234 dir = MidiFileOpenDir;
4235 else
4236 dir = NULL;
4237
4238 if((file = DlgFileOpen(hwnd, NULL, filter, dir)) == NULL)
4239 return;
4240
4241 w32g_lock_open_file = 1;
4242 w32g_send_rc(RC_EXT_LOAD_FILE, (ptr_size_t)file);
4243 }
4244
4245 static volatile LPITEMIDLIST itemidlist_pre = NULL;
DlgDirOpenBrowseCallbackProc(HWND hwnd,UINT uMsg,LPARAM lParam,LPARAM lpData)4246 int CALLBACK DlgDirOpenBrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData)
4247 {
4248 switch(uMsg){
4249 case BFFM_INITIALIZED:
4250 if(itemidlist_pre)
4251 SendMessage(hwnd,BFFM_SETSELECTION,(WPARAM)0,(LPARAM)itemidlist_pre);
4252 break;
4253 default:
4254 break;
4255 }
4256 return 0;
4257 }
4258
DlgDirOpen(HWND hwnd)4259 static void DlgDirOpen(HWND hwnd)
4260 {
4261 static int initflag = 1;
4262 static char biBuffer[MAXPATH + 256];
4263 static char Buffer[MAXPATH + 256];
4264 BROWSEINFO bi;
4265 LPITEMIDLIST itemidlist;
4266
4267 if(w32g_lock_open_file)
4268 return;
4269
4270 if(initflag==1){
4271 biBuffer[0] = '\0';
4272 initflag = 0;
4273 }
4274 memset(&bi, 0, sizeof(bi));
4275 bi.hwndOwner = NULL;
4276 bi.pidlRoot = NULL;
4277 bi.pszDisplayName = biBuffer;
4278 if ( PlayerLanguage == LANGUAGE_JAPANESE )
4279 bi.lpszTitle = "MIDI �t�@�C���̂���f�B���N�g������I���Ȃ���܂��悤�B";
4280 else
4281 bi.lpszTitle = "Select a directory with MIDI files.";
4282 bi.ulFlags = 0;
4283 bi.lpfn = DlgDirOpenBrowseCallbackProc;
4284 bi.lParam = 0;
4285 bi.iImage = 0;
4286 itemidlist = SHBrowseForFolder(&bi);
4287 if(!itemidlist)
4288 return; /* Cancel */
4289 SHGetPathFromIDList(itemidlist, Buffer);
4290 strncpy(biBuffer, Buffer, sizeof(Buffer) - 1);
4291 if(itemidlist_pre)
4292 CoTaskMemFree(itemidlist_pre);
4293 itemidlist_pre = itemidlist;
4294 w32g_lock_open_file = 1;
4295 directory_form(Buffer);
4296 w32g_send_rc(RC_EXT_LOAD_FILE, (ptr_size_t)Buffer);
4297 }
4298
DlgPlaylistOpen(HWND hwnd)4299 static void DlgPlaylistOpen(HWND hwnd)
4300 {
4301 char *dir, *file;
4302 char *filter =
4303 "playlist file\0*.pls;*.m3u;*.asx\0"
4304 "all files\0*.*\0"
4305 "\0\0";
4306
4307 if(w32g_lock_open_file)
4308 return;
4309
4310 if(MidiFileOpenDir[0])
4311 dir = MidiFileOpenDir;
4312 else
4313 dir = NULL;
4314
4315 if((file = DlgFileOpen(hwnd, NULL, filter, dir)) == NULL)
4316 return;
4317
4318 w32g_lock_open_file = 1;
4319 w32g_send_rc(RC_EXT_LOAD_PLAYLIST, (ptr_size_t)file);
4320 }
4321
4322 #include <sys/stat.h> /* for stat() */
CheckOverWrite(HWND hwnd,char * filename)4323 static int CheckOverWrite(HWND hwnd, char *filename)
4324 {
4325 char buff[BUFSIZ];
4326 int exists;
4327
4328 #if 0
4329 FILE *fp;
4330 if((fp = fopen(filename, "r")) == NULL)
4331 exists = 0;
4332 else
4333 {
4334 fclose(fp);
4335 exists = 1;
4336 }
4337 #else
4338 struct stat st;
4339 exists = (stat(filename, &st) != -1);
4340 #endif
4341
4342 if(!exists)
4343 return 1;
4344 snprintf(buff, sizeof(buff), "%s exists. Overwrite it?", filename);
4345 return MessageBox(hwnd, buff, "Warning", MB_YESNO) == IDYES;
4346 }
4347
DlgPlaylistSave(HWND hwnd)4348 static void DlgPlaylistSave(HWND hwnd)
4349 {
4350 OPENFILENAME ofn;
4351 static char *dir;
4352 char *filter =
4353 "playlist file\0*.pls;*.m3u;*.asx\0"
4354 "all files\0*.*\0"
4355 "\0\0";
4356
4357 if(w32g_lock_open_file)
4358 return;
4359
4360 if(MidiFileOpenDir[0])
4361 dir = MidiFileOpenDir;
4362 else
4363 dir = NULL;
4364
4365 memset(DialogFileNameBuff, 0, sizeof(DialogFileNameBuff));
4366 memset(&ofn, 0, sizeof(OPENFILENAME));
4367 ofn.lStructSize = sizeof(OPENFILENAME);
4368 ofn.hwndOwner = hwnd;
4369 ofn.hInstance = hInst;
4370 ofn.lpstrFilter = filter;
4371 ofn.lpstrCustomFilter = NULL;
4372 ofn.nMaxCustFilter = 0;
4373 ofn.nFilterIndex = 1 ;
4374 ofn.lpstrFile = DialogFileNameBuff;
4375 ofn.nMaxFile = sizeof(DialogFileNameBuff);
4376 ofn.lpstrFileTitle = NULL;
4377 ofn.nMaxFileTitle = 0;
4378 ofn.lpstrInitialDir = dir;
4379 ofn.lpstrTitle = "Save Playlist File";
4380 ofn.Flags = OFN_PATHMUSTEXIST | OFN_EXPLORER | OFN_HIDEREADONLY;
4381 // ofn.lpstrDefExt = 0;
4382 ofn.lpstrDefExt = "pls";
4383 ofn.lCustData = 0;
4384 ofn.lpfnHook = 0;
4385 ofn.lpTemplateName= 0;
4386
4387 if(GetSaveFileName(&ofn) != TRUE)
4388 return;
4389 if(!CheckOverWrite(hwnd, DialogFileNameBuff))
4390 return;
4391 w32g_lock_open_file = 1;
4392 w32g_send_rc(RC_EXT_SAVE_PLAYLIST, (ptr_size_t)DialogFileNameBuff);
4393 }
4394
4395 // ****************************************************************************
4396 // Edit Ctl.
4397
VprintfEditCtlWnd(HWND hwnd,char * fmt,va_list argList)4398 void VprintfEditCtlWnd(HWND hwnd, char *fmt, va_list argList)
4399 {
4400 char buffer[BUFSIZ], out[BUFSIZ];
4401 char *in;
4402 int i;
4403
4404 if(!IsWindow(hwnd))
4405 return;
4406
4407 vsnprintf(buffer, sizeof(buffer), fmt, argList);
4408 in = buffer;
4409 i = 0;
4410 for(;;){
4411 if(*in == '\0' || i>sizeof(out)-3){
4412 out[i] = '\0';
4413 break;
4414 }
4415 if(*in=='\n'){
4416 out[i] = 13;
4417 out[i+1] = 10;
4418 in++;
4419 i += 2;
4420 continue;
4421 }
4422 out[i] = *in;
4423 in++;
4424 i++;
4425 }
4426 Edit_SetSel(hwnd,-1,-1);
4427 Edit_ReplaceSel(hwnd,out);
4428 }
4429
PrintfEditCtlWnd(HWND hwnd,char * fmt,...)4430 void PrintfEditCtlWnd(HWND hwnd, char *fmt, ...)
4431 {
4432 va_list ap;
4433 va_start(ap, fmt);
4434 VprintfEditCtlWnd(hwnd,fmt,ap);
4435 va_end(ap);
4436 }
4437
4438 #if 1
PutsEditCtlWnd(HWND hwnd,char * str)4439 void PutsEditCtlWnd(HWND hwnd, char *str)
4440 {
4441 char *in = str;
4442 int i;
4443 char out[BUFSIZ];
4444 i = 0;
4445 for(;;){
4446 if(*in == '\0' || i>sizeof(out)-3){
4447 out[i] = '\0';
4448 break;
4449 }
4450 if(*in=='\n'){
4451 out[i] = 13;
4452 out[i+1] = 10;
4453 in++;
4454 i += 2;
4455 continue;
4456 }
4457 out[i] = *in;
4458 in++;
4459 i++;
4460 }
4461 if(IsWindow(hwnd)){
4462 Edit_SetSel(hwnd,-1,-1);
4463 Edit_ReplaceSel(hwnd,out);
4464 }
4465 }
4466 #else
PutsEditCtlWnd(HWND hwnd,char * str)4467 void PutsEditCtlWnd(HWND hwnd, char *str)
4468 {
4469 if(!IsWindow(hwnd))
4470 return;
4471 PrintfEditCtlWnd(hwnd,"%s",str);
4472 }
4473 #endif
4474
ClearEditCtlWnd(HWND hwnd)4475 void ClearEditCtlWnd(HWND hwnd)
4476 {
4477 char pszVoid[]="";
4478 if(!IsWindow(hwnd))
4479 return;
4480 if(IsWindow(hwnd)){
4481 // Edit_SetSel(hwnd,0,-1);
4482 Edit_SetSel(hwnd,-1,-1);
4483 }
4484 Edit_SetText(hwnd,pszVoid);
4485 }
4486
4487
4488 // ****************************************************************************
4489 // Misc funciton.
4490
w32g_msg_box(char * message,char * title,int type)4491 int w32g_msg_box(char *message, char *title, int type)
4492 {
4493 return MessageBox(hMainWnd, message, title, type);
4494 }
4495
4496
4497 //#define RC_QUEUE_SIZE 8
4498 #define RC_QUEUE_SIZE 48
4499 static struct
4500 {
4501 int rc;
4502 ptr_size_t value;
4503 } rc_queue[RC_QUEUE_SIZE];
4504 static volatile int rc_queue_len, rc_queue_beg, rc_queue_end;
4505
4506 static HANDLE w32g_lock_sem = NULL;
4507 static HANDLE w32g_empty_sem = NULL;
4508
w32g_lock(void)4509 void w32g_lock(void)
4510 {
4511 if(w32g_lock_sem)
4512 WaitForSingleObject(w32g_lock_sem, INFINITE);
4513 }
4514
w32g_unlock(void)4515 void w32g_unlock(void)
4516 {
4517 if(w32g_lock_sem)
4518 ReleaseSemaphore(w32g_lock_sem, 1, NULL);
4519 }
4520
w32g_send_rc(int rc,ptr_size_t value)4521 void w32g_send_rc(int rc, ptr_size_t value)
4522 {
4523 w32g_lock();
4524
4525 if(rc_queue_len == RC_QUEUE_SIZE)
4526 {
4527 /* Over flow. Remove the oldest message */
4528 rc_queue_len--;
4529 rc_queue_beg = (rc_queue_beg + 1) % RC_QUEUE_SIZE;
4530 }
4531
4532 rc_queue_len++;
4533 rc_queue[rc_queue_end].rc = rc;
4534 rc_queue[rc_queue_end].value = value;
4535 rc_queue_end = (rc_queue_end + 1) % RC_QUEUE_SIZE;
4536 if(w32g_empty_sem)
4537 ReleaseSemaphore(w32g_empty_sem, 1, NULL);
4538 w32g_unlock();
4539 }
4540
w32g_get_rc(ptr_size_t * value,int wait_if_empty)4541 int w32g_get_rc(ptr_size_t *value, int wait_if_empty)
4542 {
4543 int rc;
4544
4545 while(rc_queue_len == 0)
4546 {
4547 if(!wait_if_empty)
4548 return RC_NONE;
4549 if(w32g_empty_sem)
4550 WaitForSingleObject(w32g_empty_sem, INFINITE);
4551 VOLATILE_TOUCH(rc_queue_len);
4552 }
4553
4554 w32g_lock();
4555 rc = rc_queue[rc_queue_beg].rc;
4556 *value = rc_queue[rc_queue_beg].value;
4557 rc_queue_len--;
4558 rc_queue_beg = (rc_queue_beg + 1) % RC_QUEUE_SIZE;
4559 w32g_unlock();
4560
4561 return rc;
4562 }
4563
w32g_open(void)4564 int w32g_open(void)
4565 {
4566 SaveSettingTiMidity(st_current);
4567 memcpy(st_temp, st_current, sizeof(SETTING_TIMIDITY));
4568
4569 w32g_lock_sem = CreateSemaphore(NULL, 1, 1, "TiMidity Mutex Lock");
4570 w32g_empty_sem = CreateSemaphore(NULL, 0, 8, "TiMidity Empty Lock");
4571
4572 hPlayerThread = GetCurrentThread();
4573 w32g_wait_for_init = 1;
4574 hMainThread = crt_beginthreadex(NULL, 0,
4575 (LPTHREAD_START_ROUTINE)MainThread,
4576 NULL, 0, &dwMainThreadID);
4577 while(w32g_wait_for_init)
4578 {
4579 Sleep(0);
4580 VOLATILE_TOUCH(w32g_wait_for_init);
4581 }
4582 return 0;
4583 }
4584
terminate_main_thread(void)4585 static void terminate_main_thread(void)
4586 {
4587 DWORD status;
4588
4589 switch(WaitForSingleObject(hMainThread, 0))
4590 {
4591 case WAIT_OBJECT_0:
4592 break;
4593 case WAIT_TIMEOUT:
4594 OnQuit();
4595 status = WaitForSingleObject(hMainThread, 5000);
4596 if(status == WAIT_TIMEOUT)
4597 TerminateThread(hMainThread, 0);
4598 break;
4599 default:
4600 TerminateThread(hMainThread, 0);
4601 break;
4602 }
4603 }
4604
w32g_close(void)4605 void w32g_close(void)
4606 {
4607 terminate_main_thread();
4608 if(w32g_lock_sem){
4609 CloseHandle(w32g_lock_sem);
4610 w32g_lock_sem = NULL;
4611 }
4612 if(w32g_empty_sem){
4613 CloseHandle(w32g_empty_sem);
4614 w32g_empty_sem = NULL;
4615 }
4616 }
4617
w32g_restart(void)4618 void w32g_restart(void)
4619 {
4620 w32g_restart_gui_flag = 1;
4621 terminate_main_thread();
4622 if(w32g_lock_sem){
4623 CloseHandle(w32g_lock_sem);
4624 w32g_lock_sem = NULL;
4625 }
4626 if(w32g_empty_sem){
4627 CloseHandle(w32g_empty_sem);
4628 w32g_empty_sem = NULL;
4629 }
4630
4631 /* Reset variable */
4632 hDebugEditWnd = 0;
4633
4634 /* Now ready to start */
4635 w32g_open();
4636 w32g_restart_gui_flag = 0;
4637 }
4638
w32g_ctle_play_start(int sec)4639 void w32g_ctle_play_start(int sec)
4640 {
4641 char *title;
4642
4643 if(sec >= 0)
4644 {
4645 SetScrollRange(hMainWndScrollbarProgressWnd, SB_CTL, 0, sec, TRUE);
4646 MainWndScrollbarProgressUpdate(0);
4647 }
4648 else
4649 MainWndScrollbarProgressUpdate(-1);
4650
4651 Panel->cur_time_h = MPanel.CurTime_h = 0;
4652 Panel->cur_time_m = MPanel.CurTime_m = 0;
4653 Panel->cur_time_s = MPanel.CurTime_s = 0;
4654 Panel->cur_time_ss = MPanel.CurTime_ss = 0;
4655
4656 MPanel.TotalTime_h = sec / 60 / 60;
4657 RANGE(MPanel.TotalTime_h, 0, 99);
4658 Panel->total_time_h = MPanel.TotalTime_h;
4659
4660 sec %= 60 * 60;
4661 Panel->total_time_m = MPanel.TotalTime_m = sec / 60;
4662 Panel->total_time_s = MPanel.TotalTime_s = sec % 60;
4663 Panel->total_time_ss = MPanel.TotalTime_ss = 0;
4664
4665 MPanel.UpdateFlag |= MP_UPDATE_TIME;
4666
4667 /* Now, ready to get the title of MIDI */
4668 if((title = get_midi_title(MPanel.File)) != NULL)
4669 {
4670 strncpy(MPanel.Title, title, MP_TITLE_MAX);
4671 MPanel.UpdateFlag |= MP_UPDATE_TITLE;
4672 }
4673 MPanelUpdate();
4674 }
4675
MainWndScrollbarProgressUpdate(int sec)4676 void MainWndScrollbarProgressUpdate(int sec)
4677 {
4678 static int lastsec = -1, enabled = 0;
4679
4680 if(sec == lastsec)
4681 return;
4682
4683 if(sec == -1)
4684 {
4685 EnableWindow(hMainWndScrollbarProgressWnd, FALSE);
4686 enabled = 0;
4687 progress_jump = -1;
4688 }
4689 else
4690 {
4691 if(!enabled)
4692 {
4693 EnableWindow(hMainWndScrollbarProgressWnd, TRUE);
4694 enabled = 1;
4695 }
4696 if(progress_jump == -1)
4697 SetScrollPos(hMainWndScrollbarProgressWnd, SB_CTL, sec, TRUE);
4698 }
4699 lastsec = sec;
4700 }
4701
w32g_show_console(void)4702 void w32g_show_console(void)
4703 {
4704 ShowWindow(hConsoleWnd, SW_SHOW);
4705 SendDlgItemMessage(hMainWnd, IDC_TOOLBARWINDOW_SUBWND,
4706 TB_CHECKBUTTON, IDM_CONSOLE, (LPARAM)MAKELONG(TRUE, 0));
4707 }
4708
4709 ///////////////////////////////////////////////////////////////////////
4710 // GDI �A�N�Z�X��P��X���b�h�Ɍ��肷�邽�߂̃��b�N�@�\
4711
4712 static HANDLE volatile hMutexGDI = NULL;
4713 // static int volatile lock_num = 0;
gdi_lock_ex(DWORD timeout)4714 int gdi_lock_ex ( DWORD timeout )
4715 {
4716 // lock_num++;
4717 // ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
4718 // "gdi_lock<%d %d>", GetCurrentThreadId(),lock_num );
4719 if(hMutexGDI==NULL){
4720 hMutexGDI = CreateMutex(NULL,FALSE,NULL);
4721 if(hMutexGDI==NULL)
4722 return -1;
4723 }
4724 if(WaitForSingleObject(hMutexGDI,timeout)==WAIT_FAILED){
4725 return -1;
4726 }
4727 return 0;
4728 }
gdi_lock(void)4729 int gdi_lock(void)
4730 {
4731 return gdi_lock_ex ( INFINITE );
4732 }
4733
gdi_unlock(void)4734 extern int gdi_unlock(void)
4735 {
4736 //lock_num--;
4737 //ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
4738 // "gdi_unlock<%d %d>", GetCurrentThreadId(),lock_num );
4739 if(hMutexGDI!=NULL){
4740 ReleaseMutex(hMutexGDI);
4741 }
4742 return 0;
4743 }
4744