开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
PlayerPlaylistBar.cpp
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：35k
源码类别：

多媒体编程

开发平台：

Visual C++

PlayerPlaylistBar.cpp：源码内容
  1. /* 
  2.  * Copyright (C) 2003-2005 Gabest
  3.  * http://www.gabest.org
  4.  *
  5.  *  This Program is free software; you can redistribute it and/or modify
  6.  *  it under the terms of the GNU General Public License as published by
  7.  *  the Free Software Foundation; either version 2, or (at your option)
  8.  *  any later version.
  9.  *   
  10.  *  This Program is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13.  *  GNU General Public License for more details.
  14.  *   
  15.  *  You should have received a copy of the GNU General Public License
  16.  *  along with GNU Make; see the file COPYING.  If not, write to
  17.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
  18.  *  http://www.gnu.org/copyleft/gpl.html
  19.  *
  20.  */
  22. #include "stdafx.h"
  23. #include <math.h>
  24. #include <afxinet.h>
  25. #include <atlrx.h>
  26. #include <atlutil.h>
  27. #include "mplayerc.h"
  28. #include "mainfrm.h"
  29. #include "....DSUtilDSUtil.h"
  30. #include "SaveTextFileDialog.h"
  31. #include ".playerplaylistbar.h"
  33. IMPLEMENT_DYNAMIC(CPlayerPlaylistBar, CSizingControlBarG)
  34. CPlayerPlaylistBar::CPlayerPlaylistBar()
  35. : m_list(0)
  36. , m_nTimeColWidth(0)
  37. {
  38. m_bDragging = FALSE;
  39. }
  41. CPlayerPlaylistBar::~CPlayerPlaylistBar()
  42. {
  43. }
  45. BOOL CPlayerPlaylistBar::Create(CWnd* pParentWnd)
  46. {
  47. if(!CSizingControlBarG::Create(_T("Playlist"), pParentWnd, 50))
  48. return FALSE;
  50. m_list.CreateEx(
  51. WS_EX_DLGMODALFRAME|WS_EX_CLIENTEDGE, 
  52. WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_TABSTOP
  53. |LVS_OWNERDRAWFIXED
  54. |LVS_NOCOLUMNHEADER
  55. |LVS_EDITLABELS
  56. |LVS_REPORT|LVS_SINGLESEL|LVS_AUTOARRANGE|LVS_NOSORTHEADER, // TODO: remove LVS_SINGLESEL and implement multiple item repositioning (dragging is ready)
  57. CRect(0,0,100,100), this, IDC_PLAYLIST);
  59. m_list.SetExtendedStyle(m_list.GetExtendedStyle()|LVS_EX_FULLROWSELECT|LVS_EX_DOUBLEBUFFER);
  61. m_list.InsertColumn(COL_NAME, _T("Name"), LVCFMT_LEFT, 380);
  63. CDC* pDC = m_list.GetDC();
  64. CFont* old = pDC->SelectObject(GetFont());
  65. m_nTimeColWidth = pDC->GetTextExtent(_T("000:00:00")).cx + 5;
  66. pDC->SelectObject(old);
  67. m_list.ReleaseDC(pDC);
  68. m_list.InsertColumn(COL_TIME, _T("Time"), LVCFMT_RIGHT, m_nTimeColWidth);
  70.     m_fakeImageList.Create(1, 16, ILC_COLOR4, 10, 10);
  71. m_list.SetImageList(&m_fakeImageList, LVSIL_SMALL);
  73. return TRUE;
  74. }
  76. BOOL CPlayerPlaylistBar::PreCreateWindow(CREATESTRUCT& cs)
  77. {
  78. if(!CSizingControlBarG::PreCreateWindow(cs))
  79. return FALSE;
  81. cs.dwExStyle |= WS_EX_ACCEPTFILES;
  83. return TRUE;
  84. }
  86. BOOL CPlayerPlaylistBar::PreTranslateMessage(MSG* pMsg)
  87. {
  88. if(IsWindow(pMsg->hwnd) && IsVisible() && pMsg->message >= WM_KEYFIRST && pMsg->message <= WM_KEYLAST)
  89. {
  90. if(IsDialogMessage(pMsg))
  91. return TRUE;
  92. }
  94. return CSizingControlBarG::PreTranslateMessage(pMsg);
  95. }
  97. bool FindFileInList(CList<CString>& sl, CString fn)
  98. {
  99. bool fFound = false;
  100. POSITION pos = sl.GetHeadPosition();
  101. while(pos && !fFound) {if(!sl.GetNext(pos).CompareNoCase(fn)) fFound = true;}
  102. return(fFound);
  103. }
  105. void CPlayerPlaylistBar::AddItem(CString fn, CList<CString>* subs)
  106. {
  107. CList<CString> sl;
  108. sl.AddTail(fn);
  109. AddItem(sl, subs);
  110. }
  112. void CPlayerPlaylistBar::AddItem(CList<CString>& fns, CList<CString>* subs)
  113. {
  114. CPlaylistItem pli;
  116. POSITION pos = fns.GetHeadPosition();
  117. while(pos)
  118. {
  119. CString fn = fns.GetNext(pos);
  120. if(!fn.Trim().IsEmpty()) pli.m_fns.AddTail(fn);
  121. }
  123. if(subs)
  124. {
  125. POSITION pos = subs->GetHeadPosition();
  126. while(pos)
  127. {
  128. CString fn = subs->GetNext(pos);
  129. if(!fn.Trim().IsEmpty()) pli.m_subs.AddTail(fn);
  130. }
  131. }
  133. if(pli.m_fns.IsEmpty()) return;
  135. CString fn = pli.m_fns.GetHead();
  137. if(AfxGetAppSettings().fAutoloadAudio && fn.Find(_T("://")) < 0)
  138. {
  139. int i = fn.ReverseFind('.');
  140. if(i > 0)
  141. {
  142. CMediaFormats& mf = AfxGetAppSettings().Formats;
  144. CString ext = fn.Mid(i+1).MakeLower();
  146. if(!mf.FindExt(ext, true))
  147. {
  148. CString path = fn;
  149. path.Replace('/', '\');
  150. path = path.Left(path.ReverseFind('\')+1);
  152. WIN32_FIND_DATA fd = {0};
  153. HANDLE hFind = FindFirstFile(fn.Left(i) + _T("*.*"), &fd);
  154. if(hFind != INVALID_HANDLE_VALUE)
  155. {
  156. do
  157. {
  158. if(fd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) continue;
  160. CString fullpath = path + fd.cFileName;
  161. CString ext2 = fullpath.Mid(fullpath.ReverseFind('.')+1).MakeLower();
  162. if(!FindFileInList(pli.m_fns, fullpath) && ext != ext2 
  163. && mf.FindExt(ext2, true) && mf.IsUsingEngine(fullpath, DirectShow))
  164. {
  165. pli.m_fns.AddTail(fullpath);
  166. }
  167. }
  168. while(FindNextFile(hFind, &fd));
  170. FindClose(hFind);
  171. }
  172. }
  173. }
  174. }
  176. if(AfxGetAppSettings().fAutoloadSubtitles)
  177. {
  178. CStringArray paths;
  179. paths.Add(_T("."));
  180. paths.Add(_T(".\subtitles"));
  181. paths.Add(_T("c:\subtitles"));
  183. SubFiles ret;
  184. GetSubFileNames(fn, paths, ret);
  186. for(int i = 0; i < ret.GetCount(); i++)
  187. {
  188. if(!FindFileInList(pli.m_subs, ret[i].fn))
  189. pli.m_subs.AddTail(ret[i].fn);
  190. }
  191. }
  193. m_pl.AddTail(pli);
  194. }
  196. static bool SearchFiles(CString mask, CList<CString>& sl)
  197. {
  198. if(mask.Find(_T("://")) >= 0)
  199. return(false);
  201. mask.Trim();
  202. sl.RemoveAll();
  204. CMediaFormats& mf = AfxGetAppSettings().Formats;
  206. bool fFilterKnownExts;
  207. WIN32_FILE_ATTRIBUTE_DATA fad;
  208. mask = (fFilterKnownExts = (GetFileAttributesEx(mask, GetFileExInfoStandard, &fad) 
  209. && (fad.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)))
  210. ? CString(mask).TrimRight(_T("\/")) + _T("\*.*")
  211. : mask;
  213. {
  214. CString dir = mask.Left(max(mask.ReverseFind('\'), mask.ReverseFind('/'))+1);
  216. WIN32_FIND_DATA fd;
  217. HANDLE h = FindFirstFile(mask, &fd);
  218. if(h != INVALID_HANDLE_VALUE)
  219. {
  220. do
  221. {
  222. if(fd.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY) continue;
  224. CString fn = fd.cFileName;
  225. CString ext = fn.Mid(fn.ReverseFind('.')+1).MakeLower();
  226. CString path = dir + fd.cFileName;
  228. if(!fFilterKnownExts || mf.FindExt(ext))
  229. sl.AddTail(path);
  230. }
  231. while(FindNextFile(h, &fd));
  233. FindClose(h);
  235. if(sl.GetCount() == 0 && mask.Find(_T(":\")) == 1)
  236. {
  237. GetCDROMType(mask[0], sl);
  238. }
  239. }
  240. }
  242. return(sl.GetCount() > 1
  243. || sl.GetCount() == 1 && sl.GetHead().CompareNoCase(mask)
  244. || sl.GetCount() == 0 && mask.FindOneOf(_T("?*")) >= 0);
  245. }
  247. void CPlayerPlaylistBar::ParsePlayList(CString fn, CList<CString>* subs)
  248. {
  249. CList<CString> sl;
  250. sl.AddTail(fn);
  251. ParsePlayList(sl, subs);
  252. }
  254. void CPlayerPlaylistBar::ParsePlayList(CList<CString>& fns, CList<CString>* subs)
  255. {
  256. if(fns.IsEmpty()) return;
  258. // resolve .lnk files
  260. CComPtr<IShellLink> pSL;
  261. pSL.CoCreateInstance(CLSID_ShellLink);
  262. CComQIPtr<IPersistFile> pPF = pSL;
  264. POSITION pos = fns.GetHeadPosition();
  265. while(pSL && pPF && pos)
  266. {
  267. CString& fn = fns.GetNext(pos);
  268. TCHAR buff[MAX_PATH];
  269. if(CPath(fn).GetExtension().MakeLower() != _T(".lnk")
  270. || FAILED(pPF->Load(CStringW(fn), STGM_READ))
  271. || FAILED(pSL->Resolve(NULL, SLR_ANY_MATCH|SLR_NO_UI))
  272. || FAILED(pSL->GetPath(buff, countof(buff), NULL, 0)))
  273. continue;
  275. fn = buff;
  276. }
  278. //
  280. CList<CString> sl;
  281. if(SearchFiles(fns.GetHead(), sl))
  282. {
  283. if(sl.GetCount() > 1) subs = NULL;
  284. POSITION pos = sl.GetHeadPosition();
  285. while(pos) ParsePlayList(sl.GetNext(pos), subs);
  286. return;
  287. }
  289. CList<CString> redir;
  290. CStringA ct = GetContentType(fns.GetHead(), &redir);
  291. if(!redir.IsEmpty())
  292. {
  293. POSITION pos = redir.GetHeadPosition();
  294. while(pos) ParsePlayList(sl.GetNext(pos), subs);
  295. return;
  296. }
  298. if(ct == "application/x-mpc-playlist")
  299. {
  300. ParseMPCPlayList(fns.GetHead());
  301. return;
  302. }
  304. AddItem(fns, subs);
  305. }
  307. static int s_int_comp(const void* i1, const void* i2)
  308. {
  309. return (int)i1 - (int)i2;
  310. }
  312. static CString CombinePath(CPath p, CString fn)
  313. {
  314. if(fn.Find(':') >= 0 || fn.Find(_T("\")) == 0) return fn;
  315. p.Append(CPath(fn));
  316. return (LPCTSTR)p;
  317. }
  319. bool CPlayerPlaylistBar::ParseMPCPlayList(CString fn)
  320. {
  321. CString str;
  322. CMap<int, int, CPlaylistItem, CPlaylistItem&> pli;
  323. CArray<int> idx;
  325. CWebTextFile f;
  326. if(!f.Open(fn) || !f.ReadString(str) || str != _T("MPCPLAYLIST"))
  327. return false;
  329. CPath base(fn);
  330. base.RemoveFileSpec();
  332. while(f.ReadString(str))
  333. {
  334. CList<CString> sl;
  335. Explode(str, sl, ',', 3);
  336. if(sl.GetCount() != 3) continue;
  338. if(int i = _ttoi(sl.RemoveHead()))
  339. {
  340. CString key = sl.RemoveHead();
  341. CString value = sl.RemoveHead();
  343. if(key == _T("type")) {pli[i].m_type = (CPlaylistItem::type_t)_ttol(value); idx.Add(i);}
  344. else if(key == _T("label")) pli[i].m_label = value;
  345. else if(key == _T("filename")) {value = CombinePath(base, value); pli[i].m_fns.AddTail(value);}
  346. else if(key == _T("subtitle")) {value = CombinePath(base, value); pli[i].m_subs.AddTail(value);}
  347. else if(key == _T("video")) {while(pli[i].m_fns.GetCount() < 2) pli[i].m_fns.AddTail(_T("")); pli[i].m_fns.GetHead() = value;}
  348. else if(key == _T("audio")) {while(pli[i].m_fns.GetCount() < 2) pli[i].m_fns.AddTail(_T("")); pli[i].m_fns.GetTail() = value;}
  349. else if(key == _T("vinput")) pli[i].m_vinput = _ttol(value);
  350. else if(key == _T("vchannel")) pli[i].m_vchannel = _ttol(value);
  351. else if(key == _T("ainput")) pli[i].m_ainput = _ttol(value);
  352. else if(key == _T("country")) pli[i].m_country = _ttol(value);
  353. }
  354. }
  356. qsort(idx.GetData(), idx.GetCount(), sizeof(int), s_int_comp);
  357. for(int i = 0; i < idx.GetCount(); i++)
  358. m_pl.AddTail(pli[idx[i]]);
  360. return pli.GetCount() > 0;
  361. }
  363. bool CPlayerPlaylistBar::SaveMPCPlayList(CString fn, CTextFile::enc e, bool fRemovePath)
  364. {
  365. CTextFile f;
  366. if(!f.Save(fn, e))
  367. return false;
  369. f.WriteString(_T("MPCPLAYLISTn"));
  371. POSITION pos = m_pl.GetHeadPosition(), pos2;
  372. for(int i = 1; pos; i++)
  373. {
  374. CPlaylistItem& pli = m_pl.GetNext(pos);
  376. CString idx;
  377. idx.Format(_T("%d"), i);
  379. CString str;
  380. str.Format(_T("%d,type,%d"), i, pli.m_type);
  381. f.WriteString(str + _T("n"));
  383. if(!pli.m_label.IsEmpty()) 
  384. f.WriteString(idx + _T(",label,") + pli.m_label + _T("n"));
  386. if(pli.m_type == CPlaylistItem::file)
  387. {
  388. pos2 = pli.m_fns.GetHeadPosition();
  389. while(pos2)
  390. {
  391. CString fn = pli.m_fns.GetNext(pos2);
  392. if(fRemovePath) {CPath p(fn); p.StripPath(); fn = (LPCTSTR)p;}
  393. f.WriteString(idx + _T(",filename,") + fn + _T("n"));
  394. }
  396. pos2 = pli.m_subs.GetHeadPosition();
  397. while(pos2)
  398. {
  399. CString fn = pli.m_subs.GetNext(pos2);
  400. if(fRemovePath) {CPath p(fn); p.StripPath(); fn = (LPCTSTR)p;}
  401. f.WriteString(idx + _T(",subtitle,") + fn + _T("n"));
  402. }
  403. }
  404. else if(pli.m_type == CPlaylistItem::device && pli.m_fns.GetCount() == 2)
  405. {
  406. f.WriteString(idx + _T(",video,") + pli.m_fns.GetHead() + _T("n"));
  407. f.WriteString(idx + _T(",audio,") + pli.m_fns.GetTail() + _T("n"));
  408. str.Format(_T("%d,vinput,%d"), i, pli.m_vinput);
  409. f.WriteString(str + _T("n"));
  410. str.Format(_T("%d,vchannel,%d"), i, pli.m_vchannel);
  411. f.WriteString(str + _T("n"));
  412. str.Format(_T("%d,ainput,%d"), i, pli.m_ainput);
  413. f.WriteString(str + _T("n"));
  414. str.Format(_T("%d,country,%d"), i, pli.m_country);
  415. f.WriteString(str + _T("n"));
  416. }
  417. }
  419. return true;
  420. }
  422. void CPlayerPlaylistBar::Refresh()
  423. {
  424. SetupList();
  425. ResizeListColumn();
  426. }
  428. void CPlayerPlaylistBar::Empty()
  429. {
  430. m_pl.RemoveAll();
  431. m_list.DeleteAllItems();
  432. SavePlaylist();
  433. }
  435. void CPlayerPlaylistBar::Open(CList<CString>& fns, bool fMulti, CList<CString>* subs)
  436. {
  437. Empty();
  438. Append(fns, fMulti, subs);
  439. }
  441. void CPlayerPlaylistBar::Append(CList<CString>& fns, bool fMulti, CList<CString>* subs)
  442. {
  443. if(fMulti)
  444. {
  445. ASSERT(subs == NULL || subs->GetCount() == 0);
  446. POSITION pos = fns.GetHeadPosition();
  447. while(pos) ParsePlayList(fns.GetNext(pos), NULL);
  448. }
  449. else
  450. {
  451. ParsePlayList(fns, subs);
  452. }
  454. Refresh();
  455. SavePlaylist();
  456. }
  458. void CPlayerPlaylistBar::Open(CStringW vdn, CStringW adn, int vinput, int vchannel, int ainput)
  459. {
  460. Empty();
  461. Append(vdn, adn, vinput, vchannel, ainput);
  462. }
  464. void CPlayerPlaylistBar::Append(CStringW vdn, CStringW adn, int vinput, int vchannel, int ainput)
  465. {
  466. CPlaylistItem pli;
  467. pli.m_type = CPlaylistItem::device;
  468. pli.m_fns.AddTail(CString(vdn));
  469. pli.m_fns.AddTail(CString(adn));
  470. pli.m_vinput = vinput;
  471. pli.m_vchannel = vchannel;
  472. pli.m_ainput = ainput;
  473. CList<CStringW> sl;
  474. CStringW vfn = GetFriendlyName(vdn);
  475. CStringW afn = GetFriendlyName(adn);
  476. if(!vfn.IsEmpty()) sl.AddTail(vfn);
  477. if(!afn.IsEmpty()) sl.AddTail(afn);
  478. CStringW label = Implode(sl, '|');
  479. label.Replace(L"|", L" - ");
  480. pli.m_label = CString(label);
  481. m_pl.AddTail(pli);
  483. Refresh();
  484. SavePlaylist();
  485. }
  487. void CPlayerPlaylistBar::SetupList()
  488. {
  489. m_list.DeleteAllItems();
  491. POSITION pos = m_pl.GetHeadPosition();
  492. for(int i = 0; pos; i++)
  493. {
  494. CPlaylistItem& pli = m_pl.GetAt(pos);
  495. m_list.SetItemData(m_list.InsertItem(i, pli.GetLabel()), (DWORD_PTR)pos);
  496. m_list.SetItemText(i, COL_TIME, pli.GetLabel(1));
  497. m_pl.GetNext(pos);
  498. }
  499. }
  501. void CPlayerPlaylistBar::UpdateList()
  502. {
  503. POSITION pos = m_pl.GetHeadPosition();
  504. for(int i = 0, j = m_list.GetItemCount(); pos && i < j; i++)
  505. {
  506. CPlaylistItem& pli = m_pl.GetAt(pos);
  507. m_list.SetItemData(i, (DWORD_PTR)pos);
  508. m_list.SetItemText(i, COL_NAME, pli.GetLabel(0));
  509. m_list.SetItemText(i, COL_TIME, pli.GetLabel(1));
  510. m_pl.GetNext(pos);
  511. }
  512. }
  514. void CPlayerPlaylistBar::EnsureVisible(POSITION pos)
  515. {
  516. int i = FindItem(m_pl.GetPos());
  517. if(i < 0) return;
  518. m_list.EnsureVisible(i, TRUE);
  519. m_list.Invalidate();
  520. }
  522. int CPlayerPlaylistBar::FindItem(POSITION pos)
  523. {
  524. for(int i = 0; i < m_list.GetItemCount(); i++)
  525. if((POSITION)m_list.GetItemData(i) == pos)
  526. return(i);
  527. return(-1);
  528. }
  530. POSITION CPlayerPlaylistBar::FindPos(int i)
  531. {
  532. if(i < 0) return(NULL);
  533. return((POSITION)m_list.GetItemData(i));
  534. }
  536. int CPlayerPlaylistBar::GetCount()
  537. {
  538. return(m_pl.GetCount()); // TODO: n - .fInvalid
  539. }
  541. int CPlayerPlaylistBar::GetSelIdx()
  542. {
  543. return(FindItem(m_pl.GetPos()));
  544. }
  546. void CPlayerPlaylistBar::SetSelIdx(int i)
  547. {
  548. m_pl.SetPos(FindPos(i));
  549. }
  551. bool CPlayerPlaylistBar::IsAtEnd()
  552. {
  553. return(m_pl.GetPos() && m_pl.GetPos() == m_pl.GetTailPosition());
  554. }
  556. bool CPlayerPlaylistBar::GetCur(CPlaylistItem& pli)
  557. {
  558. if(!m_pl.GetPos()) return(false);
  559. pli = m_pl.GetAt(m_pl.GetPos());
  560. return(true);
  561. }
  563. CString CPlayerPlaylistBar::GetCur()
  564. {
  565. CString fn;
  566. CPlaylistItem pli;
  567. if(GetCur(pli) && !pli.m_fns.IsEmpty()) fn = pli.m_fns.GetHead();
  568. return(fn);
  569. }
  571. void CPlayerPlaylistBar::SetNext()
  572. {
  573. POSITION pos = m_pl.GetPos(), org = pos;
  574. while(m_pl.GetNextWrap(pos).m_fInvalid && pos != org);
  575. UpdateList();
  576. m_pl.SetPos(pos);
  577. EnsureVisible(pos);
  578. }
  580. void CPlayerPlaylistBar::SetPrev()
  581. {
  582. POSITION pos = m_pl.GetPos(), org = pos;
  583. while(m_pl.GetPrevWrap(pos).m_fInvalid && pos != org);
  584. m_pl.SetPos(pos);
  585. EnsureVisible(pos);
  586. }
  588. void CPlayerPlaylistBar::SetFirst()
  589. {
  590. POSITION pos = m_pl.GetTailPosition(), org = pos;
  591. while(m_pl.GetNextWrap(pos).m_fInvalid && pos != org);
  592. UpdateList();
  593. m_pl.SetPos(pos);
  594. EnsureVisible(pos);
  595. }
  597. void CPlayerPlaylistBar::SetLast()
  598. {
  599. POSITION pos = m_pl.GetHeadPosition(), org = pos;
  600. while(m_pl.GetPrevWrap(pos).m_fInvalid && pos != org);
  601. m_pl.SetPos(pos);
  602. EnsureVisible(pos);
  603. }
  605. void CPlayerPlaylistBar::SetCurValid(bool fValid)
  606. {
  607. if(POSITION pos = m_pl.GetPos())
  608. {
  609. if(m_pl.GetAt(pos).m_fInvalid = !fValid)
  610. {
  611. int i = FindItem(pos);
  612. m_list.RedrawItems(i, i);
  613. }
  614. }
  615. }
  617. void CPlayerPlaylistBar::SetCurTime(REFERENCE_TIME rt)
  618. {
  619. if(POSITION pos = m_pl.GetPos())
  620. {
  621. CPlaylistItem& pli = m_pl.GetAt(pos);
  622. pli.m_duration = rt;
  623. m_list.SetItemText(FindItem(pos), COL_TIME, pli.GetLabel(1));
  624. }
  625. }
  627. OpenMediaData* CPlayerPlaylistBar::GetCurOMD(REFERENCE_TIME rtStart)
  628. {
  629. CPlaylistItem pli;
  630. if(!GetCur(pli)) return NULL;
  632. CString fn = CString(pli.m_fns.GetHead()).MakeLower();
  634. if(fn.Find(_T("video_ts.ifo")) >= 0
  635. || fn.Find(_T(".ratdvd")) >= 0)
  636. {
  637. if(OpenDVDData* p = new OpenDVDData())
  638. {
  639. p->path = pli.m_fns.GetHead(); 
  640. p->subs.AddTail(&pli.m_subs);
  641. return p;
  642. }
  643. }
  645. if(pli.m_type == CPlaylistItem::device)
  646. {
  647. if(OpenDeviceData* p = new OpenDeviceData())
  648. {
  649. POSITION pos = pli.m_fns.GetHeadPosition();
  650. for(int i = 0; i < countof(p->DisplayName) && pos; i++)
  651. p->DisplayName[i] = pli.m_fns.GetNext(pos);
  652. p->vinput = pli.m_vinput;
  653. p->vchannel = pli.m_vchannel;
  654. p->ainput = pli.m_ainput;
  655. return p;
  656. }
  657. }
  658. else
  659. {
  660. if(OpenFileData* p = new OpenFileData())
  661. {
  662. p->fns.AddTail((CList<CString>*)&pli.m_fns);
  663. p->subs.AddTail((CList<CString>*)&pli.m_subs);
  664. p->rtStart = rtStart;
  665. return p;
  666. }
  667. }
  669. return NULL;
  670. }
  672. void CPlayerPlaylistBar::LoadPlaylist()
  673. {
  674. CString base;
  675. if(AfxGetMyApp()->GetAppDataPath(base))
  676. {
  677. CPath p;
  678. p.Combine(base, _T("default.mpcpl"));
  680. if(!AfxGetApp()->GetProfileInt(ResStr(IDS_R_SETTINGS), _T("RememberPlaylistItems"), TRUE))
  681. {
  682. DeleteFile(p);
  683. }
  684. else
  685. {
  686. ParseMPCPlayList(p);
  687. Refresh();
  688. }
  689. }
  690. }
  692. void CPlayerPlaylistBar::SavePlaylist()
  693. {
  694. CString base;
  695. if(AfxGetMyApp()->GetAppDataPath(base))
  696. {
  697. CPath p;
  698. p.Combine(base, _T("default.mpcpl"));
  700. if(!AfxGetApp()->GetProfileInt(ResStr(IDS_R_SETTINGS), _T("RememberPlaylistItems"), TRUE))
  701. {
  702. DeleteFile(p);
  703. }
  704. else
  705. {
  706. SaveMPCPlayList(p, CTextFile::UTF8, false);
  707. }
  708. }
  709. }
  711. BEGIN_MESSAGE_MAP(CPlayerPlaylistBar, CSizingControlBarG)
  712. ON_WM_SIZE()
  713. ON_NOTIFY(LVN_KEYDOWN, IDC_PLAYLIST, OnLvnKeyDown)
  714. ON_NOTIFY(NM_DBLCLK, IDC_PLAYLIST, OnNMDblclkList)
  715. // ON_NOTIFY(NM_CUSTOMDRAW, IDC_PLAYLIST, OnCustomdrawList)
  716. ON_WM_DRAWITEM()
  717. ON_COMMAND_EX(ID_FILE_CLOSEPLAYLIST, OnFileClosePlaylist)
  718. ON_COMMAND_EX(ID_PLAY_PLAY, OnPlayPlay)
  719. ON_WM_DROPFILES()
  720. ON_NOTIFY(LVN_BEGINDRAG, IDC_PLAYLIST, OnBeginDrag)
  721. ON_WM_MOUSEMOVE()
  722. ON_WM_LBUTTONUP()
  723. ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipNotify)
  724. ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipNotify)
  725. ON_WM_TIMER()
  726. ON_WM_CONTEXTMENU()
  727. ON_NOTIFY(LVN_ENDLABELEDIT, IDC_PLAYLIST, OnLvnEndlabeleditList)
  728. END_MESSAGE_MAP()
  731. // CPlayerPlaylistBar message handlers
  733. void CPlayerPlaylistBar::ResizeListColumn()
  734. {
  735. if(::IsWindow(m_list.m_hWnd))
  736. {
  737. CRect r;
  738. GetClientRect(r);
  739. r.DeflateRect(2, 2);
  740. m_list.SetRedraw(FALSE);
  741. m_list.MoveWindow(r);
  742. m_list.GetClientRect(r);
  743. m_list.SetColumnWidth(COL_NAME, r.Width()-m_nTimeColWidth); //LVSCW_AUTOSIZE_USEHEADER
  744. m_list.SetRedraw(TRUE);
  745. }
  746. }
  748. void CPlayerPlaylistBar::OnSize(UINT nType, int cx, int cy)
  749. {
  750. CSizingControlBarG::OnSize(nType, cx, cy);
  752. ResizeListColumn();
  753. }
  755. void CPlayerPlaylistBar::OnLvnKeyDown(NMHDR* pNMHDR, LRESULT* pResult) 
  756. {
  757. LPNMLVKEYDOWN pLVKeyDown = reinterpret_cast<LPNMLVKEYDOWN>(pNMHDR);
  759. *pResult = FALSE;
  761. CList<int> items;
  762. POSITION pos = m_list.GetFirstSelectedItemPosition();
  763. while(pos) items.AddHead(m_list.GetNextSelectedItem(pos));
  765. if(pLVKeyDown->wVKey == VK_DELETE && items.GetCount() > 0) 
  766. {
  767. pos = items.GetHeadPosition();
  768. while(pos) 
  769. {
  770. int i = items.GetNext(pos);
  771. if(m_pl.RemoveAt(FindPos(i))) ((CMainFrame*)AfxGetMainWnd())->CloseMedia();
  772. m_list.DeleteItem(i);
  773. }
  775. m_list.SetItemState(-1, 0, LVIS_SELECTED);
  776. m_list.SetItemState(
  777. max(min(items.GetTail(), m_list.GetItemCount()-1), 0), 
  778. LVIS_SELECTED, LVIS_SELECTED);
  780. ResizeListColumn();
  782. *pResult = TRUE;
  783. }
  784. else if(pLVKeyDown->wVKey == VK_SPACE && items.GetCount() == 1) 
  785. {
  786. m_pl.SetPos(FindPos(items.GetHead()));
  788. ((CMainFrame*)AfxGetMainWnd())->OpenCurPlaylistItem();
  790. *pResult = TRUE;
  791. }
  792. }
  794. void CPlayerPlaylistBar::OnNMDblclkList(NMHDR* pNMHDR, LRESULT* pResult)
  795. {
  796. LPNMLISTVIEW lpnmlv = (LPNMLISTVIEW)pNMHDR;
  798. if(lpnmlv->iItem >= 0 && lpnmlv->iSubItem >= 0)
  799. {
  800. m_pl.SetPos(FindPos(lpnmlv->iItem));
  801. m_list.Invalidate();
  802. ((CMainFrame*)AfxGetMainWnd())->OpenCurPlaylistItem();
  803. }
  805. *pResult = 0;
  806. }
  807. /*
  808. void CPlayerPlaylistBar::OnCustomdrawList(NMHDR* pNMHDR, LRESULT* pResult)
  809. {
  810. NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>(pNMHDR);
  812. *pResult = CDRF_DODEFAULT;
  814. if(CDDS_PREPAINT == pLVCD->nmcd.dwDrawStage)
  815. {
  816. *pResult = CDRF_NOTIFYPOSTPAINT|CDRF_NOTIFYITEMDRAW;
  817. }
  818. else if(CDDS_ITEMPREPAINT == pLVCD->nmcd.dwDrawStage)
  819. {
  820. pLVCD->nmcd.uItemState &= ~CDIS_SELECTED;
  821. pLVCD->nmcd.uItemState &= ~CDIS_FOCUS;
  823. pLVCD->clrText = (pLVCD->nmcd.dwItemSpec == m_playList.m_idx) ? 0x0000ff : CLR_DEFAULT;
  824. pLVCD->clrTextBk = m_list.GetItemState(pLVCD->nmcd.dwItemSpec, LVIS_SELECTED) ? 0xf1dacc : CLR_DEFAULT;
  826. *pResult = CDRF_NOTIFYPOSTPAINT;
  827. }
  828. else if(CDDS_ITEMPOSTPAINT == pLVCD->nmcd.dwDrawStage)
  829. {
  830.         int nItem = static_cast<int>(pLVCD->nmcd.dwItemSpec);
  832. if(m_list.GetItemState(pLVCD->nmcd.dwItemSpec, LVIS_SELECTED))
  833. {
  834. CRect r, r2;
  835. m_list.GetItemRect(nItem, &r, LVIR_BOUNDS);
  836. m_list.GetItemRect(nItem, &r2, LVIR_LABEL);
  837. r.left = r2.left;
  838. FrameRect(pLVCD->nmcd.hdc, &r, CBrush(0xc56a31));
  839. }
  841. *pResult = CDRF_SKIPDEFAULT;
  842. }
  843. else if(CDDS_POSTPAINT == pLVCD->nmcd.dwDrawStage)
  844. {
  845. }
  846. }
  847. */
  849. void CPlayerPlaylistBar::OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct)
  850. {
  851. if(nIDCtl != IDC_PLAYLIST) return;
  853. int nItem = lpDrawItemStruct->itemID;
  854. CRect rcItem = lpDrawItemStruct->rcItem;
  855. POSITION pos = FindPos(nItem);
  856. bool fSelected = pos == m_pl.GetPos();
  857. CPlaylistItem& pli = m_pl.GetAt(pos);
  859. CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
  861. if(!!m_list.GetItemState(nItem, LVIS_SELECTED))
  862. {
  863. FillRect(pDC->m_hDC, rcItem, CBrush(0xf1dacc));
  864. FrameRect(pDC->m_hDC, rcItem, CBrush(0xc56a31));
  865. }
  866. else
  867. {
  868. FillRect(pDC->m_hDC, rcItem, CBrush(GetSysColor(COLOR_WINDOW)));
  869. }
  871. COLORREF textcolor = fSelected?0xff:0;
  872. if(pli.m_fInvalid) textcolor |= 0xA0A0A0;
  874. CString time = !pli.m_fInvalid ? m_list.GetItemText(nItem, COL_TIME) : _T("Invalid");
  875. CSize timesize(0, 0);
  876. CPoint timept(rcItem.right, 0);
  877. if(time.GetLength() > 0)
  878. {
  879. timesize = pDC->GetTextExtent(time);
  880. if((3+timesize.cx+3) < rcItem.Width()/2)
  881. {
  882. timept = CPoint(rcItem.right-(3+timesize.cx+3), (rcItem.top+rcItem.bottom-timesize.cy)/2);
  884. pDC->SetTextColor(textcolor);
  885. pDC->TextOut(timept.x, timept.y, time);
  886. }
  887. }
  889. CString fmt, file;
  890. fmt.Format(_T("%%0%dd. %%s"), (int)log10(0.1+m_pl.GetCount())+1);
  891. file.Format(fmt, nItem+1, m_list.GetItemText(nItem, COL_NAME));
  892. CSize filesize = pDC->GetTextExtent(file);
  893. while(3+filesize.cx+6 > timept.x && file.GetLength() > 3)
  894. {
  895. file = file.Left(file.GetLength()-4) + _T("...");
  896. filesize = pDC->GetTextExtent(file);
  897. }
  899. if(file.GetLength() > 3)
  900. {
  901. pDC->SetTextColor(textcolor);
  902. pDC->TextOut(rcItem.left+3, (rcItem.top+rcItem.bottom-filesize.cy)/2, file);
  903. }
  904. }
  906. BOOL CPlayerPlaylistBar::OnFileClosePlaylist(UINT nID)
  907. {
  908. Empty();
  909. return FALSE;
  910. }
  912. BOOL CPlayerPlaylistBar::OnPlayPlay(UINT nID)
  913. {
  914. m_list.Invalidate();
  915. return FALSE;
  916. }
  918. void CPlayerPlaylistBar::OnDropFiles(HDROP hDropInfo)
  919. {
  920. SetActiveWindow();
  922. CList<CString> sl;
  924. UINT nFiles = ::DragQueryFile(hDropInfo, (UINT)-1, NULL, 0);
  925. for(UINT iFile = 0; iFile < nFiles; iFile++)
  926. {
  927. TCHAR szFileName[_MAX_PATH];
  928. ::DragQueryFile(hDropInfo, iFile, szFileName, _MAX_PATH);
  929. sl.AddTail(szFileName);
  930. }
  931. ::DragFinish(hDropInfo);
  933. Append(sl, true);
  934. }
  936. void CPlayerPlaylistBar::OnBeginDrag(NMHDR* pNMHDR, LRESULT* pResult)
  937. {
  938. ModifyStyle(WS_EX_ACCEPTFILES, 0);
  940. m_nDragIndex = ((LPNMLISTVIEW)pNMHDR)->iItem;
  942. CPoint p(0, 0);
  943. m_pDragImage = m_list.CreateDragImageEx(&p);
  945. CPoint p2 = ((LPNMLISTVIEW)pNMHDR)->ptAction;
  947. m_pDragImage->BeginDrag(0, p2 - p);
  948. m_pDragImage->DragEnter(GetDesktopWindow(), ((LPNMLISTVIEW)pNMHDR)->ptAction);
  950. m_bDragging = TRUE;
  951. m_nDropIndex = -1;
  953. SetCapture();
  954. }
  956. void CPlayerPlaylistBar::OnMouseMove(UINT nFlags, CPoint point)
  957. {
  958. if(m_bDragging)
  959. {
  960. m_ptDropPoint = point;
  961. ClientToScreen(&m_ptDropPoint);
  963. m_pDragImage->DragMove(m_ptDropPoint);
  964. m_pDragImage->DragShowNolock(FALSE);
  966. WindowFromPoint(m_ptDropPoint)->ScreenToClient(&m_ptDropPoint);
  968. m_pDragImage->DragShowNolock(TRUE);
  970. {
  971. int iOverItem = m_list.HitTest(m_ptDropPoint);
  972. int iTopItem = m_list.GetTopIndex();
  973. int iBottomItem = m_list.GetBottomIndex();
  975. if(iOverItem == iTopItem && iTopItem != 0) // top of list
  976. SetTimer(1, 100, NULL); 
  977. else
  978. KillTimer(1); 
  980. if(iOverItem >= iBottomItem && iBottomItem != (m_list.GetItemCount() - 1)) // bottom of list
  981. SetTimer(2, 100, NULL); 
  982. else 
  983. KillTimer(2); 
  984. }
  985. }
  987. __super::OnMouseMove(nFlags, point);
  988. }
  990. void CPlayerPlaylistBar::OnTimer(UINT nIDEvent)
  991. {
  992. int iTopItem = m_list.GetTopIndex();
  993. int iBottomItem = iTopItem + m_list.GetCountPerPage() - 1;
  995. if(m_bDragging)
  996. {
  997. m_pDragImage->DragShowNolock(FALSE);
  999. if(nIDEvent == 1)
  1000. {
  1001. m_list.EnsureVisible(iTopItem - 1, false);
  1002. m_list.UpdateWindow();
  1003. if(m_list.GetTopIndex() == 0) KillTimer(1); 
  1004. }
  1005. else if(nIDEvent == 2)
  1006. {
  1007. m_list.EnsureVisible(iBottomItem + 1, false);
  1008. m_list.UpdateWindow();
  1009. if(m_list.GetBottomIndex() == (m_list.GetItemCount() - 1)) KillTimer(2); 
  1010. } 
  1012. m_pDragImage->DragShowNolock(TRUE);
  1013. }
  1015. __super::OnTimer(nIDEvent);
  1016. }
  1018. void CPlayerPlaylistBar::OnLButtonUp(UINT nFlags, CPoint point)
  1019. {
  1020. if(m_bDragging)
  1021. {
  1022. ::ReleaseCapture();
  1024. m_bDragging = FALSE;
  1025. m_pDragImage->DragLeave(GetDesktopWindow());
  1026. m_pDragImage->EndDrag();
  1028. delete m_pDragImage;
  1029. m_pDragImage = NULL;
  1031. KillTimer(1);
  1032. KillTimer(2);
  1034. CPoint pt(point);
  1035. ClientToScreen(&pt);
  1037. if(WindowFromPoint(pt) == &m_list)
  1038. DropItemOnList();
  1039. }
  1041. ModifyStyle(0, WS_EX_ACCEPTFILES); 
  1043. __super::OnLButtonUp(nFlags, point);
  1044. }
  1046. void CPlayerPlaylistBar::DropItemOnList()
  1047. {
  1048. m_ptDropPoint.y += 10; //
  1049. m_nDropIndex = m_list.HitTest(CPoint(10, m_ptDropPoint.y));
  1051. TCHAR szLabel[MAX_PATH];
  1052. LV_ITEM lvi;
  1053. ZeroMemory(&lvi, sizeof(LV_ITEM));
  1054. lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE | LVIF_PARAM;
  1055. lvi.stateMask = LVIS_DROPHILITED | LVIS_FOCUSED | LVIS_SELECTED;
  1056. lvi.pszText = szLabel;
  1057. lvi.iItem = m_nDragIndex;
  1058. lvi.cchTextMax = MAX_PATH;
  1059. m_list.GetItem(&lvi);
  1061. if(m_nDropIndex < 0) m_nDropIndex = m_list.GetItemCount();
  1062. lvi.iItem = m_nDropIndex;
  1063. m_list.InsertItem(&lvi);
  1065. CHeaderCtrl* pHeader = (CHeaderCtrl*)m_list.GetDlgItem(0);
  1066. int nColumnCount = pHeader->GetItemCount();
  1067. lvi.mask = LVIF_TEXT;
  1068. lvi.iItem = m_nDropIndex;
  1069. //INDEX OF DRAGGED ITEM WILL CHANGE IF ITEM IS DROPPED ABOVE ITSELF
  1070. if(m_nDropIndex < m_nDragIndex) m_nDragIndex++;
  1071. for(int col=1; col < nColumnCount; col++)
  1072. {
  1073. _tcscpy(lvi.pszText, (LPCTSTR)(m_list.GetItemText(m_nDragIndex, col)));
  1074. lvi.iSubItem = col;
  1075. m_list.SetItem(&lvi);
  1076. }
  1078. m_list.DeleteItem(m_nDragIndex);
  1080. CList<CPlaylistItem> tmp;
  1081. UINT id = -1;
  1082. for(int i = 0; i < m_list.GetItemCount(); i++)
  1083. {
  1084. POSITION pos = (POSITION)m_list.GetItemData(i);
  1085. CPlaylistItem& pli = m_pl.GetAt(pos);
  1086. tmp.AddTail(pli);
  1087. if(pos == m_pl.GetPos()) id = pli.m_id;
  1088. }
  1089. m_pl.RemoveAll();
  1090. POSITION pos = tmp.GetHeadPosition();
  1091. for(int i = 0; pos; i++)
  1092. {
  1093. CPlaylistItem& pli = tmp.GetNext(pos);
  1094. m_pl.AddTail(pli);
  1095. if(pli.m_id == id) m_pl.SetPos(m_pl.GetTailPosition());
  1096. m_list.SetItemData(i, (DWORD_PTR)m_pl.GetTailPosition());
  1097. }
  1099. ResizeListColumn();
  1100. }
  1102. BOOL CPlayerPlaylistBar::OnToolTipNotify(UINT id, NMHDR* pNMHDR, LRESULT* pResult)
  1103. {
  1104. TOOLTIPTEXTA* pTTTA = (TOOLTIPTEXTA*)pNMHDR;
  1105. TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
  1107. if((pNMHDR->code == TTN_NEEDTEXTA && (HWND)pTTTA->lParam != m_list.m_hWnd)
  1108. || (pNMHDR->code == TTN_NEEDTEXTW && (HWND)pTTTW->lParam != m_list.m_hWnd))
  1109. return FALSE;
  1111. int row = ((pNMHDR->idFrom-1) >> 10) & 0x3fffff;
  1112. int col = (pNMHDR->idFrom-1) & 0x3ff;
  1114. if(row < 0 || row >= m_pl.GetCount())
  1115. return FALSE;
  1117. CPlaylistItem& pli = m_pl.GetAt(FindPos(row));
  1119. CString strTipText;
  1121. if(col == COL_NAME)
  1122. {
  1123. POSITION pos = pli.m_fns.GetHeadPosition();
  1124. while(pos) strTipText += _T("n") + pli.m_fns.GetNext(pos);
  1125. strTipText.Trim();
  1127. if(pli.m_type == CPlaylistItem::device)
  1128. {
  1129. CString str;
  1130. str.Format(_T("Video Input %d"), pli.m_vinput);
  1131. if(pli.m_vinput >= 0) strTipText += _T("n") + str;
  1132. str.Format(_T("Video Channel %d"), pli.m_vchannel);
  1133. if(pli.m_vchannel >= 0) strTipText += _T("n") + str;
  1134. str.Format(_T("Audio Input %d"), pli.m_ainput);
  1135. if(pli.m_ainput >= 0) strTipText += _T("n") + str;
  1136. }
  1138. ::SendMessage(pNMHDR->hwndFrom, TTM_SETMAXTIPWIDTH, 0, (LPARAM)(INT)1000);
  1139. }
  1140. else if(col == COL_TIME)
  1141. {
  1142. return FALSE;
  1143. }
  1145. static CStringA m_strTipTextA;
  1146. static CStringW m_strTipTextW;
  1148. if(pNMHDR->code == TTN_NEEDTEXTA)
  1149. {
  1150. m_strTipTextA = strTipText;
  1151. pTTTA->lpszText = (LPSTR)(LPCSTR)m_strTipTextA;
  1152. }
  1153. else
  1154. {
  1155. m_strTipTextW = strTipText;
  1156. pTTTW->lpszText = (LPWSTR)(LPCWSTR)m_strTipTextW;
  1157. }
  1159. *pResult = 0;
  1161. return TRUE;    // message was handled
  1162. }
  1164. void CPlayerPlaylistBar::OnContextMenu(CWnd* /*pWnd*/, CPoint p)
  1165. {
  1166. LVHITTESTINFO lvhti;
  1167. lvhti.pt = p;
  1168. m_list.ScreenToClient(&lvhti.pt);
  1169. m_list.SubItemHitTest(&lvhti);
  1171. POSITION pos = FindPos(lvhti.iItem);
  1172. // bool fSelected = (pos == m_pl.GetPos());
  1173. bool fOnItem = !!(lvhti.flags&LVHT_ONITEM);
  1175. CMenu m;
  1176. m.CreatePopupMenu();
  1178. enum 
  1179. {
  1180. M_OPEN=1, M_ADD, M_REMOVE, M_CLIPBOARD, M_SAVEAS, 
  1181. M_SORTBYNAME, M_SORTBYPATH, M_RANDOMIZE, M_SORTBYID,
  1182. M_REMEMBERPLAYLIST, M_SHUFFLE
  1183. };
  1185. m.AppendMenu(MF_STRING|(!fOnItem?(MF_DISABLED|MF_GRAYED):MF_ENABLED), M_OPEN, ResStr(IDS_PLAYLIST_OPEN));
  1186. if(((CMainFrame*)AfxGetMainWnd())->m_iPlaybackMode == PM_CAPTURE) m.AppendMenu(MF_STRING|MF_ENABLED, M_ADD, ResStr(IDS_PLAYLIST_ADD));
  1187. m.AppendMenu(MF_STRING|(/*fSelected||*/!fOnItem?(MF_DISABLED|MF_GRAYED):MF_ENABLED), M_REMOVE, ResStr(IDS_PLAYLIST_REMOVE));
  1188. m.AppendMenu(MF_SEPARATOR);
  1189. m.AppendMenu(MF_STRING|(!fOnItem?(MF_DISABLED|MF_GRAYED):MF_ENABLED), M_CLIPBOARD, ResStr(IDS_PLAYLIST_COPYTOCLIPBOARD));
  1190. m.AppendMenu(MF_STRING|(!m_pl.GetCount()?(MF_DISABLED|MF_GRAYED):MF_ENABLED), M_SAVEAS, ResStr(IDS_PLAYLIST_SAVEAS));
  1191. m.AppendMenu(MF_SEPARATOR);
  1192. m.AppendMenu(MF_STRING|(!m_pl.GetCount()?(MF_DISABLED|MF_GRAYED):MF_ENABLED), M_SORTBYNAME, ResStr(IDS_PLAYLIST_SORTBYLABEL));
  1193. m.AppendMenu(MF_STRING|(!m_pl.GetCount()?(MF_DISABLED|MF_GRAYED):MF_ENABLED), M_SORTBYPATH, ResStr(IDS_PLAYLIST_SORTBYPATH));
  1194. m.AppendMenu(MF_STRING|(!m_pl.GetCount()?(MF_DISABLED|MF_GRAYED):MF_ENABLED), M_RANDOMIZE, ResStr(IDS_PLAYLIST_RANDOMIZE));
  1195. m.AppendMenu(MF_STRING|(!m_pl.GetCount()?(MF_DISABLED|MF_GRAYED):MF_ENABLED), M_SORTBYID, ResStr(IDS_PLAYLIST_RESTORE));
  1196. m.AppendMenu(MF_SEPARATOR);
  1197. m.AppendMenu(MF_STRING|MF_ENABLED|(AfxGetApp()->GetProfileInt(ResStr(IDS_R_SETTINGS), _T("ShufflePlaylistItems"), FALSE)?MF_CHECKED:0), M_SHUFFLE, _T("Shuffle"));
  1198. m.AppendMenu(MF_STRING|MF_ENABLED|(AfxGetApp()->GetProfileInt(ResStr(IDS_R_SETTINGS), _T("RememberPlaylistItems"), TRUE)?MF_CHECKED:0), M_REMEMBERPLAYLIST, _T("Remember items"));
  1200. CMainFrame* pMainFrm = (CMainFrame*)AfxGetMainWnd();
  1202. int nID = (int)m.TrackPopupMenu(TPM_LEFTBUTTON|TPM_RETURNCMD, p.x, p.y, this);
  1203. switch(nID)
  1204. {
  1205. case M_OPEN:
  1206. m_pl.SetPos(pos);
  1207. m_list.Invalidate();
  1208. pMainFrm->OpenCurPlaylistItem();
  1209. break;
  1210. case M_ADD:
  1211. pMainFrm->AddCurDevToPlaylist();
  1212. m_pl.SetPos(m_pl.GetTailPosition());
  1213. break;
  1214. case M_REMOVE:
  1215. if(m_pl.RemoveAt(pos)) pMainFrm->CloseMedia();
  1216. m_list.DeleteItem(lvhti.iItem);
  1217. SavePlaylist();
  1218. break;
  1219. case M_SORTBYID:
  1220. m_pl.SortById();
  1221. SetupList();
  1222. SavePlaylist();
  1223. break;
  1224. case M_SORTBYNAME:
  1225. m_pl.SortByName();
  1226. SetupList();
  1227. SavePlaylist();
  1228. break;
  1229. case M_SORTBYPATH:
  1230. m_pl.SortByPath();
  1231. SetupList();
  1232. SavePlaylist();
  1233. break;
  1234. case M_RANDOMIZE:
  1235. m_pl.Randomize();
  1236. SetupList();
  1237. SavePlaylist();
  1238. break;
  1239. case M_CLIPBOARD:
  1240. if(OpenClipboard() && EmptyClipboard())
  1241. {
  1242. CString str;
  1244. CPlaylistItem& pli = m_pl.GetAt(pos);
  1245. POSITION pos = pli.m_fns.GetHeadPosition();
  1246. while(pos) str += _T("rn") + pli.m_fns.GetNext(pos);
  1247. str.Trim();
  1249. if(HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE, (str.GetLength()+1)*sizeof(TCHAR)))
  1250. {
  1251. if(TCHAR* s = (TCHAR*)GlobalLock(h))
  1252. {
  1253. _tcscpy(s, str);
  1254. GlobalUnlock(h);
  1255. #ifdef UNICODE
  1256. SetClipboardData(CF_UNICODETEXT, h);
  1257. #else
  1258. SetClipboardData(CF_TEXT, h);
  1259. #endif
  1260. }
  1261. }
  1262. CloseClipboard(); 
  1263. }
  1264. break;
  1265. case M_SAVEAS:
  1266. {
  1267. CSaveTextFileDialog fd(
  1268. CTextFile::ASCII, NULL, NULL,
  1269. _T("Media Player Classic playlist (*.mpcpl)|*.mpcpl|Playlist (*.pls)|*.pls|WinAmp playlist (*.m3u)|*.m3u|Windows Media Playlist (*.asx)|*.asx||"), 
  1270. this);
  1272. if(fd.DoModal() != IDOK)
  1273. break;
  1275. int idx = fd.m_pOFN->nFilterIndex;
  1277. CPath path(fd.GetPathName());
  1279. switch(idx)
  1280. {
  1281. case 1: path.AddExtension(_T(".mpcpl")); break;
  1282. case 2: path.AddExtension(_T(".pls")); break;
  1283. case 3: path.AddExtension(_T(".m3u")); break;
  1284. case 4: path.AddExtension(_T(".asx")); break;
  1285. default: break;
  1286. }
  1288. bool fRemovePath = true;
  1290. CPath p(path);
  1291. p.RemoveFileSpec();
  1292. CString base = (LPCTSTR)p;
  1294. pos = m_pl.GetHeadPosition();
  1295. while(pos && fRemovePath)
  1296. {
  1297. CPlaylistItem& pli = m_pl.GetNext(pos);
  1299. if(pli.m_type != CPlaylistItem::file) fRemovePath = false;
  1300. else
  1301. {
  1302. POSITION pos;
  1304. pos = pli.m_fns.GetHeadPosition();
  1305. while(pos && fRemovePath)
  1306. {
  1307. CString fn = pli.m_fns.GetNext(pos);
  1309. CPath p(fn);
  1310. p.RemoveFileSpec();
  1311. if(base != (LPCTSTR)p) fRemovePath = false;
  1312. }
  1314. pos = pli.m_subs.GetHeadPosition();
  1315. while(pos && fRemovePath)
  1316. {
  1317. CString fn = pli.m_subs.GetNext(pos);
  1319. CPath p(fn);
  1320. p.RemoveFileSpec();
  1321. if(base != (LPCTSTR)p) fRemovePath = false;
  1322. }
  1323. }
  1324. }
  1326. if(idx == 1)
  1327. {
  1328. SaveMPCPlayList(path, fd.GetEncoding(), fRemovePath);
  1329. break;
  1330. }
  1332. CTextFile f;
  1333. if(!f.Save(path, fd.GetEncoding()))
  1334. break;
  1336. if(idx == 4)
  1337. {
  1338. f.WriteString(_T("<ASX version = "3.0">n"));
  1339. }
  1341. pos = m_pl.GetHeadPosition();
  1342. for(int i = 0; pos; i++)
  1343. {
  1344. CPlaylistItem& pli = m_pl.GetNext(pos);
  1346. if(pli.m_type != CPlaylistItem::file) 
  1347. continue;
  1349. CString fn = pli.m_fns.GetHead();
  1351. /*
  1352. if(fRemovePath)
  1353. {
  1354. CPath p(path);
  1355. p.StripPath();
  1356. fn = (LPCTSTR)p;
  1357. }
  1358. */
  1360. CString str;
  1361. switch(idx)
  1362. {
  1363. case 2: str.Format(_T("File%d=%sn"), i+1, fn); break;
  1364. case 3: str.Format(_T("%sn"), fn); break;
  1365. case 4: str.Format(_T("<Entry><Ref href = "%s"/></Entry>n"), fn); break;
  1366. default: break;
  1367. }
  1368. f.WriteString(str);
  1369. }
  1371. if(idx == 4)
  1372. {
  1373. f.WriteString(_T("</ASX>n"));
  1374. }
  1375. }
  1376. break;
  1377. case M_REMEMBERPLAYLIST:
  1378. AfxGetApp()->WriteProfileInt(ResStr(IDS_R_SETTINGS), _T("RememberPlaylistItems"), 
  1379. !AfxGetApp()->GetProfileInt(ResStr(IDS_R_SETTINGS), _T("RememberPlaylistItems"), TRUE));
  1380. break;
  1381. case M_SHUFFLE:
  1382. AfxGetApp()->WriteProfileInt(ResStr(IDS_R_SETTINGS), _T("ShufflePlaylistItems"), 
  1383. !AfxGetApp()->GetProfileInt(ResStr(IDS_R_SETTINGS), _T("ShufflePlaylistItems"), FALSE));
  1384. break;
  1385. default:
  1386. break;
  1387. }
  1388. }
  1390. void CPlayerPlaylistBar::OnLvnEndlabeleditList(NMHDR* pNMHDR, LRESULT* pResult)
  1391. {
  1392. NMLVDISPINFO* pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);
  1394. if(pDispInfo->item.iItem >= 0 && pDispInfo->item.pszText)
  1395. {
  1396. CPlaylistItem& pli = m_pl.GetAt((POSITION)m_list.GetItemData(pDispInfo->item.iItem));
  1397. pli.m_label = pDispInfo->item.pszText;
  1398. m_list.SetItemText(pDispInfo->item.iItem, 0, pDispInfo->item.pszText);
  1399. }
  1401. *pResult = 0;
  1402. }