rtoss - Blame information for rev 26

Subversion Repositories:
Rev:
Rev Author Line No. Line
14 roytam 1 #include "GSPlayer2.h"
2 #include "PpcMainWnd.h"
3 #include "PpcOptions.h"
4 #include "PpcSkin.h"
5 #include "PpcDisplay.h"
6  
7 extern const TCHAR s_szSupportedExt[][5];
8  
9 static const UINT s_uHoldKeys[][2] = {
10         {VK_RETURN, 0}, {VK_LEFT, 0},
11         {VK_UP, 0}, {VK_RIGHT, 0}, {VK_DOWN, 0},
12         {VK_BTN1, MOD_WIN}, {VK_BTN2, MOD_WIN},
13         {VK_BTN3, MOD_WIN}, {VK_BTN4, MOD_WIN},
14         {VK_BTN5, MOD_WIN}, {VK_BTN6, MOD_WIN},
15 };
16  
17 CPpcMainWnd::CPpcMainWnd()
18 {
19         m_fMenuLoop = FALSE;
20         m_fActive = FALSE;
21         m_fHotKey = FALSE;
22         m_dwLastOperation = 0;
23         m_fDisplay = GetDisplayStatus();
24  
25         m_hwndCB = NULL;
26         m_hwndLV = NULL;
27         m_fListDrag = FALSE;
28         m_fHold = FALSE;
29         m_fNoListRedraw = FALSE;
30  
31         InitSize();
32 }
33  
34 CPpcMainWnd::~CPpcMainWnd()
35 {
36 }
37  
38 COptions* CPpcMainWnd::GetOptionsClass()
39 {
40         return new CPpcOptions();
41 }
42  
43 CSkin* CPpcMainWnd::GetSkinClass()
44 {
45         return new CPpcSkin();
46 }
47  
48 HACCEL CPpcMainWnd::GetAccelHandle()
49 {
50         if (!m_hAccel) {
51                 ACCEL accel[] = {
52                         {FVIRTKEY | FCONTROL, 'Z', IDM_PLAY_PLAYPAUSE},         // Play/Pause
53                         {FVIRTKEY | FCONTROL, 'X', IDM_PLAY_STOP},                              // Stop
54                         {FVIRTKEY | FCONTROL, 'C', IDM_PLAY_PREV},                              // Prev
55                         {FVIRTKEY | FCONTROL, 'V', IDM_PLAY_REW},                               // Rew
56                         {FVIRTKEY | FCONTROL, 'B', IDM_PLAY_FF},                                // FF
57                         {FVIRTKEY | FCONTROL, 'N', IDM_PLAY_NEXT},                              // Next
58                         {FVIRTKEY | FCONTROL, 'R', IDM_PLAY_REPEAT},                    // Repeat
59                         {FVIRTKEY | FCONTROL, 'H', IDM_PLAY_SHUFFLE},                   // Shuffle
60                         {FVIRTKEY | FCONTROL, 'O', IDM_FILE_OPEN},                              // Open
61                         {FVIRTKEY | FCONTROL, 'U', IDM_FILE_OPEN_LOCATION},     // Open Location
62                         {FVIRTKEY | FCONTROL, 'A', IDM_FILE_ADD},                               // Add
63                         {FVIRTKEY | FCONTROL, 'F', IDM_FILE_FIND},                              // Find
64                         {FVIRTKEY | FCONTROL, 'L', IDM_FILE_LIST},                              // List
65                         {FVIRTKEY | FCONTROL, 'S', IDM_FILE_SAVE_LIST},         // Save List
66                         {FVIRTKEY | FCONTROL, 'E', IDM_TOOL_EFFECT},                    // Effect
67                         {FVIRTKEY | FCONTROL, 'Y', IDM_TOOL_VOLUP},                     // Volume Up
68                         {FVIRTKEY | FCONTROL, 'T', IDM_TOOL_VOLDOWN},           // Volume Down
69                         {FVIRTKEY | FCONTROL, 'Q', IDM_APP_EXIT},       // Exit
70                 };
71                 m_hAccel = CreateAcceleratorTable(accel, sizeof(accel) / sizeof(ACCEL));
72         }
73         return m_hAccel;
74 }
75  
76 BOOL CPpcMainWnd::CanTransAccel(MSG* pMsg)
77 {
78         return pMsg->hwnd == m_hWnd || pMsg->hwnd == m_hwndLV;
79 }
80  
81 void CPpcMainWnd::RegisterClass()
82 {
83         WNDCLASS        wc;
84         memset(&wc, 0, sizeof(WNDCLASS));
85     wc.style = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
86     wc.lpfnWndProc = (WNDPROC)PpcMainWndProc;
87     wc.hInstance = GetInst();
88     wc.hbrBackground = (HBRUSH)GetStockObject(GRAY_BRUSH);
89     wc.lpszClassName = MAINWND_CLASS_NAME;
90         ::RegisterClass(&wc);
91 }
92  
93 LRESULT CALLBACK CPpcMainWnd::PpcMainWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
94 {
95         static CPpcMainWnd* pMainWnd = NULL;
96  
97         if (pMainWnd &&
98                 uMsg != WM_TIMER && uMsg != WM_PAINT && uMsg != WM_GETTEXT &&
99                 uMsg != WM_ERASEBKGND && uMsg < MAP_MSG_BASE) {
100                 pMainWnd->m_dwLastOperation = GetTickCount();
101         }
102  
103         switch (uMsg) {
104         case WM_CREATE:
105                 CREATESTRUCT* pcs;
106                 pcs = (CREATESTRUCT*)lParam;
107                 pMainWnd = (CPpcMainWnd*)pcs->lpCreateParams;
108                 return CMainWnd::MainWndProc(hwnd, uMsg, wParam, lParam);
109         case WM_INITMENUPOPUP:
110                 pMainWnd->OnInitMenuPopup((HMENU)wParam, LOWORD(lParam), HIWORD(lParam));
111                 return CMainWnd::MainWndProc(hwnd, uMsg, wParam, lParam);
112         case WM_NOTIFY:
113                 {
114                         NMHDR* pnmh = (NMHDR*)lParam;
115                         switch (pnmh->code) {
116                         case NM_RETURN:
117                                 pMainWnd->OnListViewReturn(pnmh);
118                                 return 0;
119                         case LVN_KEYDOWN:
120                                 pMainWnd->OnListViewKeyDown(pnmh);
121                                 return 0;
122                         case NM_DBLCLK:
123                                 pMainWnd->OnListViewDblClk(pnmh);
124                                 return 0;
125                         case LVN_BEGINDRAG:
126                                 pMainWnd->OnListViewBeginDrag(pnmh);
127                                 return 0;
128                         case GN_CONTEXTMENU:
129                                 pMainWnd->OnListViewConextMenu(pnmh);
130                                 return 0;
131                         default:
132                                 return CMainWnd::MainWndProc(hwnd, uMsg, wParam, lParam);
133                         }
134                 }
135         case WM_SETTINGCHANGE:
136                 SHHandleWMSettingChange(hwnd, wParam, lParam, &pMainWnd->m_sai);
137                 return CMainWnd::MainWndProc(hwnd, uMsg, wParam, lParam);
138         case WM_ENTERMENULOOP:
139                 pMainWnd->m_fMenuLoop = TRUE;
140                 return 0;
141         case WM_EXITMENULOOP:
142                 pMainWnd->m_fMenuLoop = FALSE;
143                 return 0;
144         }
145         return CMainWnd::MainWndProc(hwnd, uMsg, wParam, lParam);
146 }
147  
148 BOOL CPpcMainWnd::Create(LPTSTR pszCmdLine, HWND hwndParent, DWORD dwStyle)
149 {
150         CWaitCursor wc;
151  
152         // クラスの登録
153         RegisterClass();
154  
155         // ウインドウ作成
156         CreateWindow(MAINWND_CLASS_NAME, MAINWND_TITLE, WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT,
157                 PPC_MAINWND_WIDTH, PPC_MAINWND_HEIGHT, NULL, NULL, GetInst(), this);
158  
159  
160         if (!m_hWnd)
161                 return FALSE;
162  
163         ShowWindow(m_hWnd, SW_SHOW);
164         UpdateWindow(m_hWnd);
165  
166         if (_tcslen(pszCmdLine)) {
167                 SendCmdLine(m_hWnd, pszCmdLine);
168         }
169         else {
170                 // デフォルトリストの読み込み
171                 if (((CPpcOptions*)m_pOptions)->m_fSaveDefList) {
172                         m_nCurrent = 0; // 開かないようにする
173  
174                         // 読み込み
175                         m_fNoListRedraw = TRUE;
176                         SendMessage(m_hwndLV, WM_SETREDRAW, 0, 0);
177                         TCHAR szPath[MAX_PATH];
178                         GetDefPlayListPath(szPath);
179                         LoadPlayList(szPath);
180                         SendMessage(m_hwndLV, WM_SETREDRAW, 1, 0);
181                         m_fNoListRedraw = FALSE;
182                         InvalidateRect(m_hwndLV, 0, FALSE);
183                         UpdateWindow(m_hwndLV);
184  
185                         m_nCurrent = OPEN_NONE;
186  
187                         // レジュ[ム情報を反映する
188                         if (((CPpcOptions*)m_pOptions)->m_fResume &&
189                                 ((CPpcOptions*)m_pOptions)->m_nResumeTrack != -1 &&
190                                 ((CPpcOptions*)m_pOptions)->m_nResumeTrack < m_pListFile->GetCount()) {
191                                 Open(((CPpcOptions*)m_pOptions)->m_nResumeTrack);
192                                 if (m_nCurrent == OPEN_NONE)
193                                         OpenFirstFile();
194                                 else {
195                                         MAP_Seek(m_hMap, ((CPpcOptions*)m_pOptions)->m_nResumeTime);
196                                         ((CPpcOptions*)m_pOptions)->m_nResumeTime = 0;
197                                 }
198                         }
199                         else
200                                 OpenFirstFile();
201                         if (((CPpcOptions*)m_pOptions)->m_fPlayOnStart)
202                                 Play();
203                 }
204         }
205  
206         return TRUE;
207 }
208  
209 BOOL CPpcMainWnd::InitImages()
210 {
211         InitSize();
212         BOOL fRet = CMainWnd::InitImages();
213         if (fRet) {
214                 ShowWindow(m_hwndLV, ((CPpcSkin*)m_pSkin)->IsPlaylistVisible() ? SW_SHOW : SW_HIDE);
215                 ListView_SetBkColor(m_hwndLV, ((CPpcSkin*)m_pSkin)->GetColor2(COLOR2_PLAYLISTBACK));
216                 ListView_SetTextBkColor(m_hwndLV, ((CPpcSkin*)m_pSkin)->GetColor2(COLOR2_PLAYLISTBACK));
217                 ListView_SetTextColor(m_hwndLV, ((CPpcSkin*)m_pSkin)->GetColor2(COLOR2_PLAYLISTTEXT));
218  
219                 m_hFntTitle = (HFONT)SendMessage(m_hWnd, WM_GETFONT, 0, 0);
220  
221                 InvalidateRect(m_hwndLV, NULL, TRUE);
222                 UpdateWindow(m_hwndLV);
223  
224                 // ボリュ[ムスライダ[が有効か無効か
225                 if (m_pSkin->GetImageList(IMAGELIST_VOLSLIDER) && m_pSkin->GetImageList(IMAGELIST_VOLTRACK)) {
226                         m_nVolumeSliderLeft = VOLSLIDER_LEFT;
227                         m_nVolumeSliderTop = PPC_VOLSLIDER_TOP;
228                         m_nVolumeSliderWidth = VOLSLIDER_WIDTH;
229                         m_nVolumeSliderHeight = VOLSLIDER_HEIGHT;
230                 }
231                 else {
232                         m_nVolumeSliderLeft = 0;
233                         m_nVolumeSliderTop = 0;
234                         m_nVolumeSliderWidth = 0;
235                         m_nVolumeSliderHeight = 0;
236                 }
237  
238                 m_nBtnMax = PPC_BTN_MAX;
239         }
240  
241         return fRet;
242 }
243  
244 void CPpcMainWnd::InitSize()
245 {
246         m_nWidth = PPC_MAINWND_WIDTH;
247         m_nHeight = PPC_MAINWND_HEIGHT;
248         m_nClientWidth = PPC_MAINWND_WIDTH;
249         m_nClientHeight = PPC_MAINWND_HEIGHT;
250         m_nDispWidth = PPC_DISP_WIDTH;
251         m_nDispHeight = PPC_DISP_HEIGHT;
252         m_nBtnTop = PPC_BTN_TOP;
253         m_nBtnMax = PPC_BTN_MAX;
254         m_nStatusTop = PPC_STATUS_TOP;
255         m_nStatusHeight = PPC_STATUS_HEIGHT;
256         m_nTitleTop = PPC_TITLE_TOP;
257         m_nTitleWidth = PPC_TITLE_WIDTH;
258         m_nTitleHeight = PPC_TITLE_HEIGHT;
259         m_nSeekTop = PPC_SEEK_TOP;
260         m_nSeekWidth = PPC_SEEK_WIDTH;
261         m_nStreamTitleTop = PPC_STREAM_TITLE_TOP;
262         m_nStreamTitleWidth = PPC_STREAM_TITLE_WIDTH;
263         m_nStreamTitleHeight = PPC_STREAM_TITLE_HEIGHT;
264         m_nVolumeSliderLeft = VOLSLIDER_LEFT;
265         m_nVolumeSliderTop = PPC_VOLSLIDER_TOP;
266         m_nVolumeSliderWidth = VOLSLIDER_WIDTH;
267         m_nVolumeSliderHeight = VOLSLIDER_HEIGHT;
268         m_nVolumeTrackWidth = VOLTRACK_WIDTH;
269 }
270  
271 void CPpcMainWnd::OnCreate(HWND hwnd)
272 {
273         m_hWnd = hwnd;
274         CreateMenuBar();
275         CreateListView();
276  
277         CMainWnd::OnCreate(hwnd);
278  
279         RegisterHotKeys();
280         SetTimer(m_hWnd, ID_TIMER_DISPCHECK, TIMER_DISPCHECK_INTERVAL, NULL);
281         SetTimer(m_hWnd, ID_TIMER_DISPSTATE, TIMER_DISPSTATE_INTERVAL, NULL);
282  
283         memset(&m_sai, 0, sizeof(m_sai));
284         m_sai.cbSize = sizeof(m_sai);
285  
286         SetFocus(m_hwndLV);
287         ShowWindow(m_hwndLV, SW_HIDE);
288 }
289  
290 void CPpcMainWnd::OnClose()
291 {
292         KillTimer(m_hWnd, ID_TIMER_DISPCHECK);
293         UnregisterHotKeys();
294         CMainWnd::OnClose();
295 }
296  
297 LRESULT CPpcMainWnd::OnCommand(WPARAM wParam, LPARAM lParam)
298 {
299         switch (LOWORD(wParam)) {
300         case IDM_TOOL_TOGGLEDISPLAY:
301                 ToggleDisplay();
302                 OnTimer(ID_TIMER_DISPSTATE);
303                 return 0;
26 roytam 304         case IDM_FILE_INFO:
305                 OnFileInfo();
306                 return 0;
14 roytam 307         case IDM_FILE_UP:
308                 OnFileUp();
309                 return 0;
310         case IDM_FILE_DOWN:
311                 OnFileDown();
312                 return 0;
313         case IDM_FILE_DELETE:
314                 OnFileDelete();
315                 return 0;
316         case IDM_FILE_DELETEALL:
317                 OnFileDeleteAll();
318                 return 0;
319         case IDM_PLAY_SELECTED:
320                 OnPlaySelected();
321                 return 0;
322         case IDM_FILE_SORT_BYNAME:
323         case IDM_FILE_SORT_BYPATH:
324                 OnFileSort(LOWORD(wParam));
325                 return 0;
326         case IDOK:
327                 PostMessage(m_hWnd, WM_CLOSE, 0, 0);
328                 return 0;
329         case IDM_TOOL_HOLD:
330                 OnToolHold();
331                 return 0;
332         case IDM_TOOL_HOLDDISP:
333                 OnToolHoldDisp();
334                 return 0;
335         case IDM_PLAY_PLAYSTOP:
336                 OnPlayPlayStop();
337                 return 0;
338         case IDM_ENQUEUE:
339                 OnEnqueue();
340                 return 0;
341         case IDM_DEQUEUE:
342                 OnDequeue();
343                 return 0;
344         case IDM_CLEARQUEUE:
345                 OnClearQueue();
346                 return 0;
347         }
348         return CMainWnd::OnCommand(wParam, lParam);
349 }
350  
351 void CPpcMainWnd::OnActivate(int nActive, BOOL fMinimized, HWND hwndPrevious)
352 {
353         m_fActive = nActive == WA_INACTIVE ? FALSE : TRUE;
354  
355         if (!m_pOptions)
356                 return;
357  
358         if (((CPpcOptions*)m_pOptions)->m_fReleaseKeyMap && !m_fHold) {
359                 if (nActive == WA_INACTIVE)
360                         UnregisterHotKeys();
361                 else
362                         RegisterHotKeys();
363         }
364  
365         SHHandleWMActivate(m_hWnd, MAKELONG(nActive, fMinimized), (LONG)hwndPrevious, &m_sai, FALSE);
366 }
367  
368 void CPpcMainWnd::OnHotKey(int nId, UINT fuModifiers, UINT uVirtKey)
369 {
370         // 未処理のWM_HOTKEYを削除する
371         MSG msg;
372         while (PeekMessage(&msg, m_hWnd, WM_HOTKEY, WM_HOTKEY, PM_REMOVE));
373  
374         CPpcOptions* pOptions = (CPpcOptions*)m_pOptions;
375         if (!pOptions) return;
376  
377         // 登録情報を参照する
378         for (int i = 0; i < pOptions->m_listKeyMap.GetCount(); i++) {
379                 ACCEL* p = (ACCEL*)pOptions->m_listKeyMap.GetAt(i);
380                 if (p->key == uVirtKey) {
381                         // モ[ダルダイアログが表示されている場合は
382                         // ダイアログをだすもの、メニュ[を出すものを処理しない
383                         if (m_fMenuLoop || m_hMenu || (GetWindowLong(m_hWnd, GWL_STYLE) & WS_DISABLED)) {
384                                 switch (p->cmd) {
385                                 case IDM_PLAY_PLAYPAUSE:
386                                 case IDM_PLAY_STOP:
387                                 case IDM_PLAY_PREV:
388                                 case IDM_PLAY_REW:
389                                 case IDM_PLAY_FF:
390                                 case IDM_PLAY_NEXT:
391                                 case IDM_PLAY_REPEAT:
392                                 case IDM_TOOL_VOLUP:
393                                 case IDM_TOOL_VOLDOWN:
394                                 case IDM_TOOL_TOGGLEDISPLAY:
395                                 case IDM_TOOL_HOLD:
396                                 case IDM_TOOL_HOLDDISP:
397                                 case IDM_PLAY_PLAYSTOP:
398                                 case IDM_ENQUEUE:
399                                 case IDM_DEQUEUE:
400                                         break;
401                                 default: return;
402                                 }
403                         }
404  
405                         if (m_fHold) {
406                                 BOOL fHold = FALSE;
407                                 ACCEL* p = (ACCEL*)pOptions->m_listKeyMap.GetAt(i);
408                                 for (int j = 0; j < sizeof(s_uHoldKeys) / sizeof(UINT) / 2; j++) {
409                                         if (s_uHoldKeys[j][0] == p->key) {
410                                                 fHold = TRUE;
411                                                 break;
412                                         }
413                                 }
414  
415                                 if (p->cmd == IDM_TOOL_TOGGLEDISPLAY ||
416                                         p->cmd == IDM_TOOL_HOLD ||
417                                         p->cmd == IDM_TOOL_HOLDDISP || !fHold)
418                                         PostMessage(m_hWnd, WM_COMMAND, p->cmd, 0);
419                                 else {
420                                         KillTimer(m_hWnd, ID_TIMER_HOLD);
421                                         m_fDrawHold = TRUE;
422                                         SetTimer(m_hWnd, ID_TIMER_HOLD, TIMER_HOLD_INTERVAL, NULL);
423                                         UpdateTitle();
424                                 }
425                         }
426                         else PostMessage(m_hWnd, WM_COMMAND, p->cmd, 0);
427  
428                         // バックライト制御以外で
429                         // 自動バックライトON制御が有効のとき
430                         if (pOptions->m_fDispAutoOn &&
431                                 (p->cmd != IDM_TOOL_TOGGLEDISPLAY && p->cmd != IDM_TOOL_HOLDDISP)) {
432                                 TurnOnDisplay();
433                                 m_fDisplay = TRUE;
434  
435                                 InvalidateRect(m_hWnd, NULL, TRUE);
436                                 UpdateWindow(m_hWnd);
437                         }
438                         return;
439                 }
440         }
441  
442         if (m_fHold) {
443                 KillTimer(m_hWnd, ID_TIMER_HOLD);
444                 m_fDrawHold = TRUE;
445                 SetTimer(m_hWnd, ID_TIMER_HOLD, TIMER_HOLD_INTERVAL, NULL);
446                 UpdateTitle();
447         }
448 }
449  
450 void CPpcMainWnd::OnTimer(UINT uID)
451 {
452         CMainWnd::OnTimer(uID);
453         if (uID == ID_TIMER_DISPCHECK) {
454                 // 自動画面OFFのチェック
455                 if (!m_pOptions)
456                         return;
457  
458                 // フラグのチェック
459                 if (!((CPpcOptions*)m_pOptions)->m_nDispAutoOff) {
460                         m_dwLastOperation = GetTickCount();
461                         return;
462                 }
463  
464                 // フォ[カスがない場合
465                 if (!m_fActive) {
466                         m_dwLastOperation = GetTickCount();
467                         return;
468                 }
469  
470                 // バッテリ状態チェック
471                 if (((CPpcOptions*)m_pOptions)->m_fDispEnableBattery) {
472                         SYSTEM_POWER_STATUS_EX spse;
473                         GetSystemPowerStatusEx(&spse, FALSE);
474                         if (spse.ACLineStatus == 1) {
475                                 m_dwLastOperation = GetTickCount();
476                                 return;
477                         }
478                 }
479  
480                 // 既にオフの場合
481                 if (!GetDisplayStatus()) {
482                         m_dwLastOperation = GetTickCount();
483                         return;
484                 }
485  
486                 // 再生中のチェック
487                 if (MAP_GetStatus(m_hMap) != MAP_STATUS_PLAY) {
488                         m_dwLastOperation = GetTickCount();
489                         return;
490                 }
491  
492                 // カウントUp & オフ
493                 if (((int)(GetTickCount() - m_dwLastOperation) / 1000) >= ((CPpcOptions*)m_pOptions)->m_nDispAutoOff) {
494                         TurnOffDisplay();
495                         m_fDisplay = FALSE;
496                         m_dwLastOperation = GetTickCount();
497                 }
498         }
499         else if (uID == ID_TIMER_DISPSTATE) {
500                 // ステ[タス更新のために呼んでおく
501                 BOOL fRet = GetDisplayStatus();
502  
503                 if (fRet && m_fDisplay != fRet) {
504                         InvalidateRect(m_hWnd, NULL, TRUE);
505                         UpdateWindow(m_hWnd);
506                 }
507                 m_fDisplay = fRet;
508         }
509         else if (uID == ID_TIMER_HOLD) {
510                 KillTimer(m_hWnd, ID_TIMER_HOLD);
511                 m_fDrawHold = FALSE;
512                 UpdateTitle();
513         }
514 }
515  
516 void CPpcMainWnd::OnSize(UINT nType, int cx, int cy)
517 {
518         DeleteImages();
519         InitImages();
520  
521         RECT rc;
522         MoveWindow(m_hwndLV, PPC_PLAYLIST_LEFT, PPC_PLAYLIST_TOP, PPC_PLAYLIST_WIDTH, PPC_PLAYLIST_HEIGHT, TRUE);
523         GetWindowRect(m_hwndLV, &rc);
524         SendMessage(m_hwndLV, LVM_SETCOLUMNWIDTH, 0,
525                 MAKELPARAM(RECT_WIDTH(&rc) - GetSystemMetrics(SM_CXVSCROLL) - GetSystemMetrics(SM_CXBORDER) * 2, 0));
526  
527         InvalidateRect(m_hWnd, NULL, TRUE);
528         UpdateWindow(m_hWnd);
529 }
530  
531 void CPpcMainWnd::OnLButtonDown(int x, int y)
532 {
533         CMainWnd::OnLButtonDown(x, y);
534 }
535  
536 void CPpcMainWnd::OnMouseMove(int fKey, int x, int y)
537 {
538         if (m_fListDrag) {
539                 RECT rcItem;
540                 if (!ListView_GetItemRect(m_hwndLV, 0, &rcItem, LVIR_BOUNDS))
541                         return;
542  
543                 POINT pt = {x, y};
544                 ClientToScreen(m_hWnd, &pt);
545                 ScreenToClient(m_hwndLV, &pt);
546  
547                 RECT rcLV;
548                 GetClientRect(m_hwndLV, &rcLV);
549                 if (pt.y < RECT_HEIGHT(&rcItem)) {
550                         ListView_Scroll(m_hwndLV, 0, -RECT_HEIGHT(&rcItem));
551                         OnFileUp();
552                         m_nListDragItem = max(m_nListDragItem - 1, 0);
553                 }
554                 else if (pt.y > rcLV.bottom - RECT_HEIGHT(&rcItem)) {
555                         ListView_Scroll(m_hwndLV, 0, RECT_HEIGHT(&rcItem));
556                         OnFileDown();
557                         m_nListDragItem = min(m_nListDragItem + 1, ListView_GetItemCount(m_hwndLV) - 1);
558                 }
559                 else {
560                         LVHITTESTINFO lvhti;
561                         lvhti.pt.x = pt.x;
562                         lvhti.pt.y = pt.y;
563                         int nItem = ListView_HitTest(m_hwndLV, &lvhti);
564                         if (nItem == -1)
565                                 return;
566  
567                         if (nItem - m_nListDragItem > 0) {
568                                 for (int i = 0; i < nItem - m_nListDragItem; i++)
569                                         OnFileDown();
570                                 m_nListDragItem = nItem;
571                         }
572                         else if (nItem - m_nListDragItem < 0) {
573                                 for (int i = 0; i < m_nListDragItem - nItem; i++)
574                                         OnFileUp();
575                                 m_nListDragItem = nItem;
576                         }
577                 }
578         }
579         else
580                 CMainWnd::OnMouseMove(fKey, x, y);
581 }
582  
583 void CPpcMainWnd::OnLButtonUp(int x, int y)
584 {
585         if (m_fListDrag) {
586                 ReleaseCapture();
587                 m_fListDrag = FALSE;
588         }
589         else
590                 CMainWnd::OnLButtonUp(x, y);
591 }
592  
593 void CPpcMainWnd::OnInitMenuPopup(HMENU hMenu, UINT uPos, BOOL fSystemMenu)
594 {
595         if (uPos == IDM_PLAY) {
596                 switch (((CPpcOptions*)m_pOptions)->m_fRepeat) {
597                 case COptions::RepeatAll:
598                         CheckMenuItem(hMenu, IDM_PLAY_REPEAT_NONE, MF_BYCOMMAND | MF_UNCHECKED);
599                         CheckMenuItem(hMenu, IDM_PLAY_REPEAT_ALL, MF_BYCOMMAND | MF_CHECKED);
600                         CheckMenuItem(hMenu, IDM_PLAY_REPEAT_ONE, MF_BYCOMMAND | MF_UNCHECKED);
601                         break;
602                 case COptions::RepeatOne:
603                         CheckMenuItem(hMenu, IDM_PLAY_REPEAT_NONE, MF_BYCOMMAND | MF_UNCHECKED);
604                         CheckMenuItem(hMenu, IDM_PLAY_REPEAT_ALL, MF_BYCOMMAND | MF_UNCHECKED);
605                         CheckMenuItem(hMenu, IDM_PLAY_REPEAT_ONE, MF_BYCOMMAND | MF_CHECKED);
606                         break;
607                 default:
608                         CheckMenuItem(hMenu, IDM_PLAY_REPEAT_NONE, MF_BYCOMMAND | MF_CHECKED);
609                         CheckMenuItem(hMenu, IDM_PLAY_REPEAT_ALL, MF_BYCOMMAND | MF_UNCHECKED);
610                         CheckMenuItem(hMenu, IDM_PLAY_REPEAT_ONE, MF_BYCOMMAND | MF_UNCHECKED);
611                         break;
612                 }
613                 CheckMenuItem(hMenu, IDM_PLAY_SHUFFLE,
614                         ((CPpcOptions*)m_pOptions)->m_fShuffle ? MF_BYCOMMAND | MF_CHECKED : MF_BYCOMMAND | MF_UNCHECKED);
615                 CheckMenuItem(hMenu, IDM_PLAY_STOPAFTERCURR,
616                         m_fStopAfterCurr ? MF_BYCOMMAND | MF_CHECKED : MF_BYCOMMAND | MF_UNCHECKED);
617         }
618 }
619  
620 void CPpcMainWnd::OnFileList()
621 {
622         SetForegroundWindow(m_hWnd);
623         CMainWnd::OnFileList();
624 }
625  
626 void CPpcMainWnd::OnFileSort(UINT uID)
627 {
628         int nSort = SORTFILE_BYNAME;
629         switch (uID) {
630                 case IDM_FILE_SORT_BYNAME:
631                         nSort = SORTFILE_BYNAME; break;
632                 case IDM_FILE_SORT_BYPATH:
633                         nSort = SORTFILE_BYPATH; break;
634         }
635         SortFile(nSort);
636 }
637  
638 void CPpcMainWnd::OnToolEffect()
639 {
640         SetForegroundWindow(m_hWnd);
641         CMainWnd::OnToolEffect();
642 }
643  
644 void CPpcMainWnd::OnToolOption()
645 {
646         if (m_fHold)
647                 return;
648  
649         SetForegroundWindow(m_hWnd);
650         UnregisterHotKeys();
651         CMainWnd::OnToolOption();
652         RegisterHotKeys();
653 }
654  
655 void CPpcMainWnd::OnShowMenu(POINT* ppt)
656 {
657         //SetForegroundWindow(m_hWnd);
658         //CMainWnd::OnShowMenu(ppt);
659 }
660  
661 void CPpcMainWnd::OnToolHold()
662 {
663         UnregisterHotKeys();
664         m_fHold = !m_fHold;
665         EnableWindow(m_hWnd, !m_fHold);
666         RegisterHotKeys();
667  
668         if (!m_fActive)
669                 SetForegroundWindow(m_hWnd);
670  
671         KillTimer(m_hWnd, ID_TIMER_HOLD);
672         m_fDrawHold = TRUE;
673         SetTimer(m_hWnd, ID_TIMER_HOLD, TIMER_HOLD_INTERVAL, NULL);
674         UpdateTitle();
675 }
676  
677 void CPpcMainWnd::OnToolHoldDisp()
678 {
679         UnregisterHotKeys();
680         m_fHold = !m_fHold;
681         EnableWindow(m_hWnd, !m_fHold);
682         RegisterHotKeys();
683  
684         if (!m_fActive)
685                 SetForegroundWindow(m_hWnd);
686  
687         KillTimer(m_hWnd, ID_TIMER_HOLD);
688         m_fDrawHold = TRUE;
689         SetTimer(m_hWnd, ID_TIMER_HOLD, TIMER_HOLD_INTERVAL, NULL);
690         UpdateTitle();
691  
692         if (m_fHold) {
693                 TurnOffDisplay();
694                 m_fDisplay = FALSE;
695         }
696         else {
697                 TurnOnDisplay();
698                 m_fDisplay = TRUE;
699                 InvalidateRect(m_hWnd, NULL, TRUE);
700                 UpdateWindow(m_hWnd);
701         }
702 }
703  
704 void CPpcMainWnd::RegisterHotKeys()
705 {
706         if (m_fHotKey)
707                 return;
708  
709         int i, j;
710         if (m_fHold) {
711                 for (i = 0; i < sizeof(s_uHoldKeys) / sizeof(UINT) / 2; i++)
712                         RegisterHotKey(m_hWnd, s_uHoldKeys[i][0], s_uHoldKeys[i][1], s_uHoldKeys[i][0]);
713  
714                 CPpcOptions* pOptions = (CPpcOptions*)m_pOptions;
715                 for (i = 0; i < pOptions->m_listKeyMap.GetCount(); i++) {
716                         BOOL fHold = FALSE;
717                         ACCEL* p = (ACCEL*)pOptions->m_listKeyMap.GetAt(i);
718                         for (j = 0; j < sizeof(s_uHoldKeys) / sizeof(UINT) / 2; j++) {
719                                 if (s_uHoldKeys[j][0] == p->key) {
720                                         fHold = TRUE;
721                                         break;
722                                 }
723                         }
724  
725                         if (!fHold) {
726                                 UINT fsModifiers = 0;
727                                 if (p->fVirt & FALT)
728                                         fsModifiers |= MOD_ALT;
729                                 if (p->fVirt & FCONTROL)
730                                         fsModifiers |= MOD_CONTROL;
731                                 if (p->fVirt & FSHIFT)
732                                         fsModifiers |= MOD_SHIFT;
733                                 if (p->fVirt & FWIN)
734                                         fsModifiers |= MOD_WIN;
735                                 RegisterHotKey(m_hWnd, p->key, fsModifiers, p->key);
736                         }
737                 }
738         }
739         else {
740                 CPpcOptions* pOptions = (CPpcOptions*)m_pOptions;
741                 for (i = 0; i < pOptions->m_listKeyMap.GetCount(); i++) {
742                         ACCEL* p = (ACCEL*)pOptions->m_listKeyMap.GetAt(i);
743  
744                         UINT fsModifiers = 0;
745                         if (p->fVirt & FALT)
746                                 fsModifiers |= MOD_ALT;
747                         if (p->fVirt & FCONTROL)
748                                 fsModifiers |= MOD_CONTROL;
749                         if (p->fVirt & FSHIFT)
750                                 fsModifiers |= MOD_SHIFT;
751                         if (p->fVirt & FWIN)
752                                 fsModifiers |= MOD_WIN;
753                         RegisterHotKey(m_hWnd, p->key, fsModifiers, p->key);
754                 }
755         }
756         m_fHotKey = TRUE;
757 }
758  
759 void CPpcMainWnd::UnregisterHotKeys()
760 {
761         if (!m_fHotKey)
762                 return;
763  
764         int i, j;
765         if (m_fHold) {
766                 for (i = 0; i < sizeof(s_uHoldKeys) / sizeof(UINT) / 2; i++)
767                         UnregisterHotKey(m_hWnd, s_uHoldKeys[i][0]);
768  
769                 CPpcOptions* pOptions = (CPpcOptions*)m_pOptions;
770                 for (i = 0; i < pOptions->m_listKeyMap.GetCount(); i++) {
771                         BOOL fHold = FALSE;
772                         ACCEL* p = (ACCEL*)pOptions->m_listKeyMap.GetAt(i);
773                         for (j = 0; j < sizeof(s_uHoldKeys) / sizeof(UINT) / 2; j++) {
774                                 if (s_uHoldKeys[j][0] == p->key) {
775                                         fHold = TRUE;
776                                         break;
777                                 }
778                         }
779  
780                         if (!fHold) UnregisterHotKey(m_hWnd, p->key);
781                 }
782         }
783         else {
784                 CPpcOptions* pOptions = (CPpcOptions*)m_pOptions;
785                 for (i = 0; i < pOptions->m_listKeyMap.GetCount(); i++) {
786                         ACCEL* p = (ACCEL*)pOptions->m_listKeyMap.GetAt(i);
787                         UnregisterHotKey(m_hWnd, p->key);
788                 }
789         }
790         m_fHotKey = FALSE;
791 }
792  
793 void CPpcMainWnd::CreateMenuBar()
794 {
795         SHMENUBARINFO mbi = {0};
796         mbi.cbSize = sizeof(SHMENUBARINFO);
797         mbi.hwndParent = m_hWnd;
798         mbi.nToolBarId = IDR_MAIN;
799         mbi.hInstRes = GetInst();
800         mbi.nBmpId = IDR_MAIN;
801         mbi.cBmpImages = 5;
802         //mbi.dwFlags = SHCMBF_HIDESIPBUTTON;
803  
804         if (!SHCreateMenuBar(&mbi))
805                 return;
806  
807         m_hwndCB = mbi.hwndMB;
808  
809         TBBUTTON tbbMain[] = {
810                 {1, IDM_FILE_ADD, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0},
811                 {2, IDM_FILE_UP, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 1},
812                 {3, IDM_FILE_DOWN, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 2},
813                 {4, IDM_FILE_DELETE, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 3},
814                 //{5, IDM_FILE_SAVE_LIST, TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 4}
815         };
816         CommandBar_AddButtons(m_hwndCB, sizeof(tbbMain) / sizeof(TBBUTTON), tbbMain);
817  
818 #ifdef LANG_JPN
819         TBBUTTONINFO tbi = {sizeof(TBBUTTONINFO), TBIF_TEXT | TBIF_IMAGE, 0, 0, TBSTYLE_BUTTON, 0, 0, 0, 0, 0};
820         SendMessage(m_hwndCB, TB_SETBUTTONINFO, IDM_TOOL, (LPARAM)&tbi);
821 #endif
822 }
823  
824 void CPpcMainWnd::CreateListView()
825 {
826         DWORD dwStyle = WS_VISIBLE | WS_CHILD | LVS_REPORT | LVS_NOCOLUMNHEADER;
827         m_hwndLV = CreateWindow(WC_LISTVIEW, NULL, dwStyle,
828                 PPC_PLAYLIST_LEFT, PPC_PLAYLIST_TOP, PPC_PLAYLIST_WIDTH, PPC_PLAYLIST_HEIGHT, m_hWnd, 0, GetInst(), NULL);
829  
830         ListView_SetExtendedListViewStyle(m_hwndLV,
831                         ListView_GetExtendedListViewStyle(m_hwndLV) | LVS_EX_FULLROWSELECT);
832  
833         LVCOLUMN lvc;
834         lvc.mask = LVCF_FMT | LVCF_SUBITEM | LVCF_TEXT | LVCF_WIDTH;
835         lvc.fmt = LVCFMT_LEFT;
836         lvc.cx = 0;
837         lvc.pszText = _T("Name");
838         lvc.iSubItem = 0;
839         ListView_InsertColumn(m_hwndLV, 0, &lvc);
840  
841         RECT rc;
842         GetWindowRect(m_hwndLV, &rc);
843         SendMessage(m_hwndLV, LVM_SETCOLUMNWIDTH, 0,
844                 MAKELPARAM(RECT_WIDTH(&rc) - GetSystemMetrics(SM_CXVSCROLL) - GetSystemMetrics(SM_CXBORDER) * 2 - 1, 0));
845 }
846  
847 // リスト
848 BOOL CPpcMainWnd::AddFile(LPTSTR pszFile, LPTSTR pszTitle, long nDur)
849 {
850         if (!m_hMap) return FALSE;
851  
852         // 存在チェック
853         if (IsExisting(pszFile))
854                 return FALSE;
855  
856         // 有効性チェック
857         if (!((CPpcOptions*)m_pOptions)->m_fFastLoad && !IsValidStream(pszFile))
858                 return FALSE;
859  
860         // リストに追加
861         FILEINFO* pInfo = new FILEINFO;
862  
863         if (nDur)
864                 pInfo->info.nDuration = nDur;
865  
866         if (pszTitle)
867                 _tcscpy(pInfo->szDisplayName, pszTitle);
868         else
869                 MAP_GetId3TagFile(m_hMap, pszFile, &pInfo->tag);
870         _tcscpy(pInfo->szPath, pszFile);
871         m_pListFile->Add((DWORD)pInfo);
872  
873         // リストビュ[に追加
874         TCHAR szTitle[MAX_PATH];
875         GetTitle(m_pListFile->GetCount() - 1, szTitle);
876         LVITEM lvi = {0};
877         lvi.mask = LVIF_TEXT;
878         lvi.iItem = ListView_GetItemCount(m_hwndLV);
879         lvi.pszText = szTitle;
880         ListView_InsertItem(m_hwndLV, &lvi);
881  
882         // 開いていない場合は開く
883         OpenFirstFile();
884  
885         return TRUE;
886 }
887  
888 void CPpcMainWnd::AddDir(LPTSTR pszDir)
889 {
890         CMainWnd::AddDir(pszDir);
891 }
892  
893 BOOL CPpcMainWnd::InsertFile(LPTSTR pszFile, int nIndex)
894 {
895         if (!m_hMap) return FALSE;
896  
897         // 有効性チェック
898         if (!IsValidStream(pszFile))
899                 return FALSE;
900  
901         // リストに挿入
902         FILEINFO* pInfo = new FILEINFO;
903         MAP_GetId3TagFile(m_hMap, pszFile, &pInfo->tag);
904         _tcscpy(pInfo->szPath, pszFile);
905         m_pListFile->Insert((DWORD)pInfo, nIndex);
906  
907         // リストビュ[に追加
908         TCHAR szTitle[MAX_PATH];
909         GetTitle(m_pListFile->GetCount() - 1, szTitle);
910         LVITEM lvi = {0};
911         lvi.mask = LVIF_TEXT;
912         lvi.iItem = nIndex;
913         lvi.pszText = szTitle;
914         ListView_InsertItem(m_hwndLV, &lvi);
915  
916         // 開いていない場合は開く
917         OpenFirstFile();
918  
919         return TRUE;
920 }
921  
922 void ExchangeItem(HWND hwndLV, int nItem1, int nItem2)
923 {
924         UINT uItem1, uItem2;
925         TCHAR szTitle1[MAX_PATH];
926         TCHAR szTitle2[MAX_PATH];
927         ListView_GetItemText(hwndLV, nItem1, 0, szTitle1, MAX_PATH);
928         ListView_GetItemText(hwndLV, nItem2, 0, szTitle2, MAX_PATH);
929         uItem1 = ListView_GetItemState(hwndLV, nItem1, LVIS_FOCUSED | LVIS_SELECTED);
930         uItem2 = ListView_GetItemState(hwndLV, nItem2, LVIS_FOCUSED | LVIS_SELECTED);
931  
932         ListView_SetItemText(hwndLV, nItem1, 0, szTitle2);
933         ListView_SetItemText(hwndLV, nItem2, 0, szTitle1);
934         ListView_SetItemState(hwndLV, nItem1, uItem2, LVIS_FOCUSED | LVIS_SELECTED);
935         ListView_SetItemState(hwndLV, nItem2, uItem1, LVIS_FOCUSED | LVIS_SELECTED);
936 }
937  
938 BOOL CPpcMainWnd::UpFile(int nIndex)
939 {
940         if (nIndex <= 0)
941                 return FALSE;
942  
943         FILEINFO* p1 = (FILEINFO*)m_pListFile->GetAt(nIndex);
944         FILEINFO* p2 = (FILEINFO*)m_pListFile->GetAt(nIndex - 1);
945         if (!p1 || !p2)
946                 return FALSE;
947  
948         m_pListFile->SetAt(nIndex - 1, (DWORD)p1);
949         m_pListFile->SetAt(nIndex, (DWORD)p2);
950  
951         ExchangeItem(m_hwndLV, nIndex - 1, nIndex);
952  
953         if (m_nCurrent == nIndex)
954                 m_nCurrent--;
955         else if (m_nCurrent == nIndex - 1)
956                 m_nCurrent++;
957  
958         UpdateTrack();
959         return TRUE;
960 }
961  
962 BOOL CPpcMainWnd::DownFile(int nIndex)
963 {
964         if (nIndex >= m_pListFile->GetCount() - 1)
965                 return FALSE;
966  
967         FILEINFO* p1 = (FILEINFO*)m_pListFile->GetAt(nIndex);
968         FILEINFO* p2 = (FILEINFO*)m_pListFile->GetAt(nIndex + 1);
969         if (!p1 || !p2)
970                 return FALSE;
971  
972         m_pListFile->SetAt(nIndex + 1, (DWORD)p1);
973         m_pListFile->SetAt(nIndex, (DWORD)p2);
974  
975         ExchangeItem(m_hwndLV, nIndex + 1, nIndex);
976  
977         if (m_nCurrent == nIndex)
978                 m_nCurrent++;
979         else if (m_nCurrent == nIndex + 1)
980                 m_nCurrent--;
981  
982         UpdateTrack();
983         return TRUE;
984 }
985 BOOL CPpcMainWnd::DeleteFile(int nIndex)
986 {
987         if (!m_pListFile->RemoveAt(nIndex))
988                 return FALSE;
989  
990         ListView_DeleteItem(m_hwndLV, nIndex);
991  
992         if (!m_pListFile->GetCount()) {
993                 Close();
994                 m_nCurrent = OPEN_NONE;
995                 InvalidateRect(m_hWnd, NULL, TRUE);
996                 UpdateWindow(m_hWnd);
997         }
998         else if (m_nCurrent == nIndex) {
999                 Stop();
1000  
1001                 UpdateTime();
1002                 UpdateStatus();
1003                 m_nCurrent = OPEN_NONE;
1004  
1005                 Open(m_pListFile->GetCount() - 1 < nIndex ? 0 : nIndex);
1006         }
1007         else if (m_nCurrent > nIndex) {
1008                 m_nCurrent--;
1009                 UpdateTrack();
1010         }
1011         return TRUE;
1012 }
1013  
1014 void CPpcMainWnd::DeleteAllFile()
1015 {
1016         Stop();
1017         Close();
1018  
1019         m_nCurrent = OPEN_NONE;
1020         for (int i = 0; i < m_pListFile->GetCount(); i++) {
1021                 FILEINFO* pInfo = (FILEINFO*)m_pListFile->GetAt(i);
1022                 delete pInfo;
1023         }
1024         m_pListFile->RemoveAll();
1025         ListView_DeleteAllItems(m_hwndLV);
1026  
1027         InvalidateRect(m_hWnd, NULL, TRUE);
1028         UpdateWindow(m_hWnd);
1029 }
1030  
1031 void CPpcMainWnd::SortFile(int nSort)
1032 {
1033 #define CURRENT_MASK    0x8000
1034         int i, nFocus = -1;
1035         FILEINFO* p;
1036         TCHAR szTitle[MAX_PATH];
1037  
1038         for (i = 0; i < m_pListFile->GetCount(); i++) {
1039                 p = (FILEINFO*)m_pListFile->GetAt(i);
1040                 p->dwUser = (i == m_nCurrent) ? CURRENT_MASK : 0;
1041                 p->dwUser |= ListView_GetItemState(m_hwndLV, i, LVIS_FOCUSED | LVIS_SELECTED);
1042         }
1043  
1044         m_pListFile->Sort(SortCompareProc, nSort);
1045         for (i = 0; i < m_pListFile->GetCount(); i++) {
1046                 p = (FILEINFO*)m_pListFile->GetAt(i);
1047                 if (p->dwUser & CURRENT_MASK)
1048                         m_nCurrent = i;
1049                 GetTitle(i, szTitle);
1050                 ListView_SetItemText(m_hwndLV, i, 0, szTitle);
1051                 ListView_SetItemState(m_hwndLV, i, p->dwUser, LVIS_FOCUSED | LVIS_SELECTED);
1052                 if (p->dwUser &LVIS_FOCUSED)
1053                         nFocus = i;
1054         }
1055         if (nFocus != -1)
1056                 ListView_EnsureVisible(m_hwndLV, nFocus, FALSE);
1057  
1058         UpdateTrack();
1059 }
1060  
1061 void CPpcMainWnd::OnFileUp()
1062 {
1063         if (!ListView_GetSelectedCount(m_hwndLV))
1064                 return;
1065  
1066         int nCount = ListView_GetItemCount(m_hwndLV);
1067         if (ListView_GetItemState(m_hwndLV, 0, LVIS_SELECTED))
1068                 return;
1069  
1070         for (int i = 1; i < nCount; i++) {
1071                 if (ListView_GetItemState(m_hwndLV, i, LVIS_SELECTED))
1072                         UpFile(i);
1073         }
1074 }
1075  
1076 void CPpcMainWnd::OnFileDown()
1077 {
1078         if (!ListView_GetSelectedCount(m_hwndLV))
1079                 return;
1080  
1081         int nCount = ListView_GetItemCount(m_hwndLV);
1082         if (ListView_GetItemState(m_hwndLV, nCount - 1, LVIS_SELECTED))
1083                 return;
1084  
1085         for (int i = nCount - 2; i >= 0; i--) {
1086                 if (ListView_GetItemState(m_hwndLV, i, LVIS_SELECTED))
1087                         DownFile(i);
1088         }
1089 }
1090  
26 roytam 1091 void CPpcMainWnd::OnFileInfo()
1092 {
1093         TCHAR szMsg[MAX_PATH*10];
1094  
1095         if (!ListView_GetSelectedCount(m_hwndLV))
1096                 return;
1097  
1098         int nCount = ListView_GetItemCount(m_hwndLV);
1099         for (int i = 0; i < nCount; i++) {
1100                 if (ListView_GetItemState(m_hwndLV, i, LVIS_SELECTED)) {
1101                         FILEINFO* pInfo = (FILEINFO*)m_pListFile->GetAt(i);
1102                         wsprintf(szMsg,_T("File: %s\nTrack name: %s\nArtist: %s\nAlbum: %s\nComment: %s\nGenre: %s\nYear: %d\nTrack Number: %d"),pInfo->szPath,pInfo->tag.szTrack,pInfo->tag.szArtist,pInfo->tag.szAlbum,pInfo->tag.szComment,pInfo->tag.szGenre,pInfo->tag.nYear,pInfo->tag.nTrackNum);
1103                         MessageBox(m_hWnd, szMsg, _T("File Info"), MB_ICONINFORMATION);
1104                 }
1105         }
1106  
1107 }
1108  
14 roytam 1109 void CPpcMainWnd::OnFileDelete()
1110 {
1111         int i;
1112  
1113         if (!ListView_GetSelectedCount(m_hwndLV))
1114                 return;
1115  
1116         int nCount = ListView_GetItemCount(m_hwndLV);
1117         for (i = nCount - 1; i >= 0; i--) {
1118                 if (ListView_GetItemState(m_hwndLV, i, LVIS_SELECTED))
1119                         DeleteFile(i);
1120         }
1121  
1122         nCount = ListView_GetItemCount(m_hwndLV);
1123         for (i = 0; i < nCount; i++) {
1124                 if (ListView_GetItemState(m_hwndLV, i, LVIS_FOCUSED)) {
1125                         ListView_SetItemState(m_hwndLV, i, LVIS_SELECTED, LVIS_SELECTED);
1126                         break;
1127                 }
1128         }
1129 }
1130  
1131 void CPpcMainWnd::OnFileDeleteAll()
1132 {
1133         m_fNoListRedraw = TRUE;
1134         SendMessage(m_hwndLV, WM_SETREDRAW, 0, 0);
1135         int nCount = ListView_GetItemCount(m_hwndLV);
1136         for (int i = nCount - 1; i >= 0; i--)
1137                 DeleteFile(i);
1138         SendMessage(m_hwndLV, WM_SETREDRAW, 1, 0);
1139         m_fNoListRedraw = FALSE;
1140 }
1141  
1142 void CPpcMainWnd::OnPlaySelected()
1143 {
1144         OnListViewDblClk(NULL);
1145 }
1146  
1147 void CPpcMainWnd::OnListViewReturn(NMHDR* pnmh)
1148 {
1149         // バックライト制御以外で
1150         // 自動バックライトON制御が有効のとき
1151         if (((CPpcOptions*)m_pOptions)->m_fDispAutoOn) {
1152                 TurnOnDisplay();
1153                 m_fDisplay = TRUE;
1154  
1155                 InvalidateRect(m_hWnd, NULL, TRUE);
1156                 UpdateWindow(m_hWnd);
1157         }
1158  
1159         if (!ListView_GetSelectedCount(m_hwndLV))
1160                 return;
1161  
1162         int nCount = ListView_GetItemCount(m_hwndLV);
1163         for (int i = 0; i < nCount; i++) {
1164                 if (ListView_GetItemState(m_hwndLV, i, LVIS_FOCUSED)) {
1165                         Play(i);
1166                         break;
1167                 }
1168         }
1169 }
1170  
1171 void CPpcMainWnd::OnListViewKeyDown(NMHDR* pnmh)
1172 {
1173         // バックライト制御以外で
1174         // 自動バックライトON制御が有効のとき
1175         if (((CPpcOptions*)m_pOptions)->m_fDispAutoOn)  {
1176                 TurnOnDisplay();
1177                 m_fDisplay = TRUE;
1178  
1179                 InvalidateRect(m_hWnd, NULL, TRUE);
1180                 UpdateWindow(m_hWnd);
1181         }
1182  
1183         if (((LPNMLVKEYDOWN)pnmh)->wVKey == 'Q' && (GetAsyncKeyState(VK_CONTROL) & 0x8000))
1184                 PostMessage(m_hWnd, WM_CLOSE, 0, 0);
1185 }
1186  
1187 void CPpcMainWnd::OnListViewDblClk(NMHDR* pnmh)
1188 {
1189         if (!ListView_GetSelectedCount(m_hwndLV))
1190                 return;
1191  
1192         int nCount = ListView_GetItemCount(m_hwndLV);
1193         for (int i = 0; i < nCount; i++) {
1194                 if (ListView_GetItemState(m_hwndLV, i, LVIS_FOCUSED)) {
1195                         Play(i);
1196                         break;
1197                 }
1198         }
1199 }
1200  
1201 void CPpcMainWnd::OnListViewBeginDrag(NMHDR* pnmh)
1202 {
1203         NMLISTVIEW* pnmlv = (NMLISTVIEW*)pnmh;
1204  
1205         SetCapture(m_hWnd);
1206         m_fListDrag = TRUE;
1207         m_nListDragItem = pnmlv->iItem;
1208 }
1209  
1210 void CPpcMainWnd::OnListViewConextMenu(NMHDR* pnmh)
1211 {
1212         NMRGINFO* pnmri = (NMRGINFO*)pnmh;
1213  
1214         int nCount = ListView_GetSelectedCount(m_hwndLV);
1215         if (nCount) {
1216                 HMENU hMenu, hSub;
1217                 hMenu = LoadMenu(GetInst(), (LPCTSTR)IDR_POPUP);
1218                 if (nCount == 1)
1219                         hSub = GetSubMenu(hMenu, IDM_SUBMENU_SEL0);
1220                 else
1221                         hSub = GetSubMenu(hMenu, IDM_SUBMENU_SEL1);
1222                 TrackPopupMenu(hSub, TPM_LEFTALIGN | TPM_TOPALIGN,
1223                                                 pnmri->ptAction.x, pnmri->ptAction.y, 0, m_hWnd, NULL);
1224                 DestroyMenu(hMenu);
1225         }
1226 }
1227  
1228 void CPpcMainWnd::OnMsgStatus(MAP_STATUS status, BOOL fError)
1229 {
1230         CMainWnd::OnMsgStatus(status, fError);
1231  
1232         if (status == MAP_STATUS_PLAY) {
1233                 TCHAR szText[MAX_PATH];
1234                 TCHAR szTitle[MAX_PATH];
1235  
1236                 int nCount = ListView_GetItemCount(m_hwndLV);
1237                 for (int i = 0; i < nCount; i++) {
1238                         ListView_GetItemText(m_hwndLV, i, 0, szText, MAX_PATH);
1239                         GetTitle(i, szTitle);
1240  
1241                         if (_tcscmp(szTitle, szText) != 0)
1242                                 ListView_SetItemText(m_hwndLV, i, 0, szTitle);
1243                 }
1244         }
1245 }
1246  
1247 void CPpcMainWnd::DrawTitle(HDC hDC)
1248 {
1249         if (m_fDrawHold) {
1250                 RECT rc = {TITLE_LEFT, m_nTitleTop,
1251                         TITLE_LEFT + m_nTitleWidth, m_nTitleTop + m_nTitleHeight};
1252  
1253                 CTempStr str(m_fHold ? IDS_MSG_HOLD_ON : IDS_MSG_HOLD_OFF);
1254                 COLORREF crBk = SetTextColor(hDC, m_pSkin->GetColor(COLOR_TITLE));
1255                 int nOld = SetBkMode(hDC, TRANSPARENT);
1256                 HFONT hBk = (HFONT)SelectObject(hDC, m_hFntTitle);
1257                 DrawText(hDC, str, -1, &rc, DT_LEFT | DT_BOTTOM | DT_SINGLELINE | DT_NOPREFIX);
1258                 SetTextColor(hDC, crBk);
1259                 SetBkMode(hDC, nOld);
1260                 SelectObject(hDC, hBk);
1261         }
1262         else CMainWnd::DrawTitle(hDC);
1263 }
1264  
1265 void CPpcMainWnd::OnPlayPlayStop()
1266 {
1267         if (MAP_GetStatus(m_hMap) == MAP_STATUS_STOP)
1268                 OnPlayPlayPause();
1269         else
1270                 OnPlayStop();
1271 }
1272  
1273 void CPpcMainWnd::OnEnqueue()
1274 {
1275         TCHAR szTitle[MAX_PATH];
1276  
1277         if (!ListView_GetSelectedCount(m_hwndLV))
1278                 return;
1279  
1280         int nCount = ListView_GetItemCount(m_hwndLV);
1281         for (int i = 0; i < nCount; i++) {
1282                 if (ListView_GetItemState(m_hwndLV, i, LVIS_SELECTED)) {
1283                         Enqueue(i);
1284                         GetTitle(i, szTitle);
1285                         ListView_SetItemText(m_hwndLV, i, 0, szTitle);
1286                 }
1287         }
1288 }
1289  
1290 void CPpcMainWnd::OnDequeue()
1291 {
1292  
1293         if (!ListView_GetSelectedCount(m_hwndLV))
1294                 return;
1295  
1296         int nCount = ListView_GetItemCount(m_hwndLV);
1297         for (int i = 0; i < nCount; i++) {
1298                 if (ListView_GetItemState(m_hwndLV, i, LVIS_SELECTED)) {
1299                         Dequeue(i);
1300                 }
1301         }
1302         // Hack - Refresh Playlist
1303         OnMsgStatus(MAP_STATUS_PLAY, FALSE);
1304 }
1305  
1306 void CPpcMainWnd::OnClearQueue()
1307 {
1308         ClearQueue();
1309         // Hack - Refresh Playlist
1310         OnMsgStatus(MAP_STATUS_PLAY, FALSE);
1311 }
1312  
1313 BOOL CPpcMainWnd::Open(int nIndex)
1314 {
1315         m_fDrawHold = FALSE;
1316         KillTimer(m_hWnd, ID_TIMER_HOLD);
1317  
1318         return CMainWnd::Open(nIndex);
1319 }
1320  
1321 void CPpcMainWnd::OnCopyData(COPYDATASTRUCT* pcds)
1322 {
1323         m_fNoListRedraw = TRUE;
1324         SendMessage(m_hwndLV, WM_SETREDRAW, 0, 0);
1325         CMainWnd::OnCopyData(pcds);
1326         SendMessage(m_hwndLV, WM_SETREDRAW, 1, 0);
1327         m_fNoListRedraw = FALSE;
1328  
1329         InvalidateRect(m_hwndLV, NULL, FALSE);
1330         UpdateWindow(m_hwndLV);
1331 }
1332  
1333 void CPpcMainWnd::OnFileFind()
1334 {
1335         m_fNoListRedraw = TRUE;
1336         SendMessage(m_hwndLV, WM_SETREDRAW, 0, 0);
1337         CMainWnd::OnFileFind();
1338         SendMessage(m_hwndLV, WM_SETREDRAW, 1, 0);
1339         m_fNoListRedraw = FALSE;
1340  
1341         InvalidateRect(m_hwndLV, NULL, FALSE);
1342         UpdateWindow(m_hwndLV);
1343 }
1344  
1345 #define FILE_BUFF_LEN 2048
1346 BOOL CPpcMainWnd::OpenMediaFile(BOOL fAdd, HWND hwndParent)
1347 {
1348         if (m_fShowOpenDlg)
1349                 return FALSE;
1350  
1351         BOOL fRet;
1352         m_fShowOpenDlg = TRUE;
1353         CTempStr strTitle(fAdd ? IDS_TITLE_ADD_FILE : IDS_TITLE_OPEN_FILE);
1354         TCHAR szFile[FILE_BUFF_LEN] = {0};
1355  
1356         OPENFILENAME ofn;
1357         memset(&(ofn), 0, sizeof(ofn));
1358         ofn.lStructSize = sizeof(ofn);
1359         ofn.hwndOwner   = hwndParent ? hwndParent : m_hWnd;
1360         ofn.lpstrFile   = szFile;
1361         ofn.nMaxFile    = FILE_BUFF_LEN;       
1362         ofn.lpstrTitle  = strTitle;
1363  
1364         BOOL (*gsGetOpenFileName)(OPENFILENAME*) = NULL;
1365         HINSTANCE hInst = LoadLibrary(_T("gsgetfile.dll"));
1366         if (hInst) {
1367                 (FARPROC&)gsGetOpenFileName = GetProcAddress(hInst, _T("gsGetOpenFileName"));
1368         }
1369  
1370         if (gsGetOpenFileName) {
1371                 if (!m_pszOpenFilter) MakeOpenFilter(&m_pszOpenFilter, TRUE);
1372                 ofn.lpstrFilter = m_pszOpenFilter;
1373                 ofn.Flags       = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_ALLOWMULTISELECT | OFN_HIDEREADONLY;
1374                 ofn.lpstrInitialDir = ((CPpcOptions*)m_pOptions)->m_szLastDir;
1375                 fRet = gsGetOpenFileName(&ofn);
1376         }
1377         else {
1378                 if (!m_pszOpenFilter) MakeOpenFilter(&m_pszOpenFilter, TRUE);
1379                 ofn.lpstrFilter = m_pszOpenFilter;
1380                 ofn.Flags       = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
1381                 ofn.lpstrInitialDir = ((CPpcOptions*)m_pOptions)->m_szLastDir;
1382                 fRet = GetOpenFileName(&ofn);
1383         }
1384  
1385         if (hInst) FreeLibrary(hInst);
1386  
1387         m_fShowOpenDlg = FALSE;
1388         if (!fRet)
1389                 return FALSE;
1390  
1391         m_fNoListRedraw = TRUE;
1392         SendMessage(m_hwndLV, WM_SETREDRAW, 0, 0);
1393  
1394         // 既存のリストを削除
1395         if (!fAdd) DeleteAllFile();
1396  
1397         // 追加
1398         DWORD dw = GetFileAttributes(szFile);
1399         if (dw != 0xFFFFFFFF) {
1400                 if (!(dw & FILE_ATTRIBUTE_DIRECTORY)) {
1401                         // single
1402                         if (IsPlayList(szFile))
1403                                 LoadPlayList(szFile);
1404                         else
1405                                 AddFile(szFile);
1406                         LPTSTR psz = _tcsrchr(szFile, _T('\\'));
1407                         if (psz) *psz = _T('\0');
1408                                 _tcscpy(((CPpcOptions*)m_pOptions)->m_szLastDir, szFile);
1409                 }
1410                 else {
1411                         // multi
1412                         TCHAR szPath[MAX_PATH];
1413  
1414                         LPTSTR p = szFile;
1415                         _tcscpy(((CPpcOptions*)m_pOptions)->m_szLastDir, szFile);
1416                         while (TRUE) {
1417                                 p += _tcslen(p);
1418                                 if (*p != NULL || *(p + 1) == NULL)
1419                                         break;
1420  
1421                                 wsprintf(szPath, _T("%s\\%s"), ((CPpcOptions*)m_pOptions)->m_szLastDir, ++p);
1422                                 if (IsPlayList(szPath))
1423                                         LoadPlayList(szPath);
1424                                 else
1425                                         AddFile(szPath);
1426                         }
1427                 }
1428         }
1429  
1430         SendMessage(m_hwndLV, WM_SETREDRAW, 1, 0);
1431         m_fNoListRedraw = FALSE;
1432  
1433         InvalidateRect(m_hwndLV, NULL, FALSE);
1434         UpdateWindow(m_hwndLV);
1435         return TRUE;
1436 }
1437  
1438 void CPpcMainWnd::OpenFirstFile()
1439 {
1440         CMainWnd::OpenFirstFile();
1441         if (m_fNoListRedraw)
1442                 SendMessage(m_hwndLV, WM_SETREDRAW, 0, 0);
1443 }