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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
PlayerPlaylistBar.cpp
资源名称：bfyy.rar　[点击查看]
上传用户：tangyu_668
上传日期：2014-02-27
资源大小：678k
文件大小：34k
源码类别：

多媒体编程

开发平台：

Visual C++

PlayerPlaylistBar.cpp：源码内容
  1. /* 
  2.  * Copyright (C) 2003-2006 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, 0))
  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(CAtlList<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, CAtlList<CString>* subs)
  106. {
  107. CAtlList<CString> sl;
  108. sl.AddTail(fn);
  109. AddItem(sl, subs);
  110. }
  112. void CPlayerPlaylistBar::AddItem(CAtlList<CString>& fns, CAtlList<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. CAtlArray<CString> paths;
  179. paths.Add(_T("."));
  180. paths.Add(_T(".\subtitles"));
  181. paths.Add(_T("c:\subtitles"));
  183. CAtlArray<SubFile> 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, CAtlList<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, CAtlList<CString>* subs)
  248. {
  249. CAtlList<CString> sl;
  250. sl.AddTail(fn);
  251. ParsePlayList(sl, subs);
  252. }
  254. void CPlayerPlaylistBar::ParsePlayList(CAtlList<CString>& fns, CAtlList<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. CAtlList<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. CAtlList<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. CAtlMap<int, CPlaylistItem> pli;
  323. CAtlArray<int> idx;
  325. CWebTextFile f;
  326. if(!f.Open(fn) || !f.ReadString(str) || str != _T("MPCPLAYLIST"))
  327. return false;
  329. if(f.GetEncoding() == CTextFile::ASCII) 
  330. f.SetEncoding(CTextFile::ANSI);
  332. CPath base(fn);
  333. base.RemoveFileSpec();
  335. while(f.ReadString(str))
  336. {
  337. CAtlList<CString> sl;
  338. Explode(str, sl, ',', 3);
  339. if(sl.GetCount() != 3) continue;
  341. if(int i = _ttoi(sl.RemoveHead()))
  342. {
  343. CString key = sl.RemoveHead();
  344. CString value = sl.RemoveHead();
  346. if(key == _T("type")) {pli[i].m_type = (CPlaylistItem::type_t)_ttol(value); idx.Add(i);}
  347. else if(key == _T("label")) pli[i].m_label = value;
  348. else if(key == _T("filename")) {value = CombinePath(base, value); pli[i].m_fns.AddTail(value);}
  349. else if(key == _T("subtitle")) {value = CombinePath(base, value); pli[i].m_subs.AddTail(value);}
  350. else if(key == _T("video")) {while(pli[i].m_fns.GetCount() < 2) pli[i].m_fns.AddTail(_T("")); pli[i].m_fns.GetHead() = value;}
  351. else if(key == _T("audio")) {while(pli[i].m_fns.GetCount() < 2) pli[i].m_fns.AddTail(_T("")); pli[i].m_fns.GetTail() = value;}
  352. else if(key == _T("vinput")) pli[i].m_vinput = _ttol(value);
  353. else if(key == _T("vchannel")) pli[i].m_vchannel = _ttol(value);
  354. else if(key == _T("ainput")) pli[i].m_ainput = _ttol(value);
  355. else if(key == _T("country")) pli[i].m_country = _ttol(value);
  356. }
  357. }
  359. qsort(idx.GetData(), idx.GetCount(), sizeof(int), s_int_comp);
  360. for(int i = 0; i < idx.GetCount(); i++)
  361. m_pl.AddTail(pli[idx[i]]);
  363. return pli.GetCount() > 0;
  364. }
  366. bool CPlayerPlaylistBar::SaveMPCPlayList(CString fn, CTextFile::enc e, bool fRemovePath)
  367. {
  368. CTextFile f;
  369. if(!f.Save(fn, e))
  370. return false;
  372. f.WriteString(_T("MPCPLAYLISTn"));
  374. POSITION pos = m_pl.GetHeadPosition(), pos2;
  375. for(int i = 1; pos; i++)
  376. {
  377. CPlaylistItem& pli = m_pl.GetNext(pos);
  379. CString idx;
  380. idx.Format(_T("%d"), i);
  382. CString str;
  383. str.Format(_T("%d,type,%d"), i, pli.m_type);
  384. f.WriteString(str + _T("n"));
  386. if(!pli.m_label.IsEmpty()) 
  387. f.WriteString(idx + _T(",label,") + pli.m_label + _T("n"));
  389. if(pli.m_type == CPlaylistItem::file)
  390. {
  391. pos2 = pli.m_fns.GetHeadPosition();
  392. while(pos2)
  393. {
  394. CString fn = pli.m_fns.GetNext(pos2);
  395. if(fRemovePath) {CPath p(fn); p.StripPath(); fn = (LPCTSTR)p;}
  396. f.WriteString(idx + _T(",filename,") + fn + _T("n"));
  397. }
  399. pos2 = pli.m_subs.GetHeadPosition();
  400. while(pos2)
  401. {
  402. CString fn = pli.m_subs.GetNext(pos2);
  403. if(fRemovePath) {CPath p(fn); p.StripPath(); fn = (LPCTSTR)p;}
  404. f.WriteString(idx + _T(",subtitle,") + fn + _T("n"));
  405. }
  406. }
  407. else if(pli.m_type == CPlaylistItem::device && pli.m_fns.GetCount() == 2)
  408. {
  409. f.WriteString(idx + _T(",video,") + pli.m_fns.GetHead() + _T("n"));
  410. f.WriteString(idx + _T(",audio,") + pli.m_fns.GetTail() + _T("n"));
  411. str.Format(_T("%d,vinput,%d"), i, pli.m_vinput);
  412. f.WriteString(str + _T("n"));
  413. str.Format(_T("%d,vchannel,%d"), i, pli.m_vchannel);
  414. f.WriteString(str + _T("n"));
  415. str.Format(_T("%d,ainput,%d"), i, pli.m_ainput);
  416. f.WriteString(str + _T("n"));
  417. str.Format(_T("%d,country,%d"), i, pli.m_country);
  418. f.WriteString(str + _T("n"));
  419. }
  420. }
  422. return true;
  423. }
  425. void CPlayerPlaylistBar::Refresh()
  426. {
  427. SetupList();
  428. ResizeListColumn();
  429. }
  431. void CPlayerPlaylistBar::Empty()
  432. {
  433. m_pl.RemoveAll();
  434. m_list.DeleteAllItems();
  435. SavePlaylist();
  436. }
  438. void CPlayerPlaylistBar::Open(CAtlList<CString>& fns, bool fMulti, CAtlList<CString>* subs)
  439. {
  440. Empty();
  441. Append(fns, fMulti, subs);
  442. }
  444. void CPlayerPlaylistBar::Append(CAtlList<CString>& fns, bool fMulti, CAtlList<CString>* subs)
  445. {
  446. if(fMulti)
  447. {
  448. ASSERT(subs == NULL || subs->GetCount() == 0);
  449. POSITION pos = fns.GetHeadPosition();
  450. while(pos) ParsePlayList(fns.GetNext(pos), NULL);
  451. }
  452. else
  453. {
  454. ParsePlayList(fns, subs);
  455. }
  457. Refresh();
  458. SavePlaylist();
  459. }
  461. void CPlayerPlaylistBar::Open(CStringW vdn, CStringW adn, int vinput, int vchannel, int ainput)
  462. {
  463. Empty();
  464. Append(vdn, adn, vinput, vchannel, ainput);
  465. }
  467. void CPlayerPlaylistBar::Append(CStringW vdn, CStringW adn, int vinput, int vchannel, int ainput)
  468. {
  469. CPlaylistItem pli;
  470. pli.m_type = CPlaylistItem::device;
  471. pli.m_fns.AddTail(CString(vdn));
  472. pli.m_fns.AddTail(CString(adn));
  473. pli.m_vinput = vinput;
  474. pli.m_vchannel = vchannel;
  475. pli.m_ainput = ainput;
  476. CAtlList<CStringW> sl;
  477. CStringW vfn = GetFriendlyName(vdn);
  478. CStringW afn = GetFriendlyName(adn);
  479. if(!vfn.IsEmpty()) sl.AddTail(vfn);
  480. if(!afn.IsEmpty()) sl.AddTail(afn);
  481. CStringW label = Implode(sl, '|');
  482. label.Replace(L"|", L" - ");
  483. pli.m_label = CString(label);
  484. m_pl.AddTail(pli);
  486. Refresh();
  487. SavePlaylist();
  488. }
  490. void CPlayerPlaylistBar::SetupList()
  491. {
  492. m_list.DeleteAllItems();
  494. POSITION pos = m_pl.GetHeadPosition();
  495. for(int i = 0; pos; i++)
  496. {
  497. CPlaylistItem& pli = m_pl.GetAt(pos);
  498. m_list.SetItemData(m_list.InsertItem(i, pli.GetLabel()), (DWORD_PTR)pos);
  499. m_list.SetItemText(i, COL_TIME, pli.GetLabel(1));
  500. m_pl.GetNext(pos);
  501. }
  502. }
  504. void CPlayerPlaylistBar::UpdateList()
  505. {
  506. POSITION pos = m_pl.GetHeadPosition();
  507. for(int i = 0, j = m_list.GetItemCount(); pos && i < j; i++)
  508. {
  509. CPlaylistItem& pli = m_pl.GetAt(pos);
  510. m_list.SetItemData(i, (DWORD_PTR)pos);
  511. m_list.SetItemText(i, COL_NAME, pli.GetLabel(0));
  512. m_list.SetItemText(i, COL_TIME, pli.GetLabel(1));
  513. m_pl.GetNext(pos);
  514. }
  515. }
  517. void CPlayerPlaylistBar::EnsureVisible(POSITION pos)
  518. {
  519. int i = FindItem(m_pl.GetPos());
  520. if(i < 0) return;
  521. m_list.EnsureVisible(i, TRUE);
  522. m_list.Invalidate();
  523. }
  525. int CPlayerPlaylistBar::FindItem(POSITION pos)
  526. {
  527. for(int i = 0; i < m_list.GetItemCount(); i++)
  528. if((POSITION)m_list.GetItemData(i) == pos)
  529. return(i);
  530. return(-1);
  531. }
  533. POSITION CPlayerPlaylistBar::FindPos(int i)
  534. {
  535. if(i < 0) return(NULL);
  536. return((POSITION)m_list.GetItemData(i));
  537. }
  539. int CPlayerPlaylistBar::GetCount()
  540. {
  541. return(m_pl.GetCount()); // TODO: n - .fInvalid
  542. }
  544. int CPlayerPlaylistBar::GetSelIdx()
  545. {
  546. return(FindItem(m_pl.GetPos()));
  547. }
  549. void CPlayerPlaylistBar::SetSelIdx(int i)
  550. {
  551. m_pl.SetPos(FindPos(i));
  552. }
  554. bool CPlayerPlaylistBar::IsAtEnd()
  555. {
  556. return(m_pl.GetPos() && m_pl.GetPos() == m_pl.GetTailPosition());
  557. }
  559. bool CPlayerPlaylistBar::GetCur(CPlaylistItem& pli)
  560. {
  561. if(!m_pl.GetPos()) return(false);
  562. pli = m_pl.GetAt(m_pl.GetPos());
  563. return(true);
  564. }
  566. CString CPlayerPlaylistBar::GetCur()
  567. {
  568. CString fn;
  569. CPlaylistItem pli;
  570. if(GetCur(pli) && !pli.m_fns.IsEmpty()) fn = pli.m_fns.GetHead();
  571. return(fn);
  572. }
  574. void CPlayerPlaylistBar::SetNext()
  575. {
  576. POSITION pos = m_pl.GetPos(), org = pos;
  577. while(m_pl.GetNextWrap(pos).m_fInvalid && pos != org);
  578. UpdateList();
  579. m_pl.SetPos(pos);
  580. EnsureVisible(pos);
  581. }
  583. void CPlayerPlaylistBar::SetPrev()
  584. {
  585. POSITION pos = m_pl.GetPos(), org = pos;
  586. while(m_pl.GetPrevWrap(pos).m_fInvalid && pos != org);
  587. m_pl.SetPos(pos);
  588. EnsureVisible(pos);
  589. }
  591. void CPlayerPlaylistBar::SetFirst()
  592. {
  593. POSITION pos = m_pl.GetTailPosition(), org = pos;
  594. while(m_pl.GetNextWrap(pos).m_fInvalid && pos != org);
  595. UpdateList();
  596. m_pl.SetPos(pos);
  597. EnsureVisible(pos);
  598. }
  600. void CPlayerPlaylistBar::SetLast()
  601. {
  602. POSITION pos = m_pl.GetHeadPosition(), org = pos;
  603. while(m_pl.GetPrevWrap(pos).m_fInvalid && pos != org);
  604. m_pl.SetPos(pos);
  605. EnsureVisible(pos);
  606. }
  608. void CPlayerPlaylistBar::SetCurValid(bool fValid)
  609. {
  610. if(POSITION pos = m_pl.GetPos())
  611. {
  612. if(m_pl.GetAt(pos).m_fInvalid = !fValid)
  613. {
  614. int i = FindItem(pos);
  615. m_list.RedrawItems(i, i);
  616. }
  617. }
  618. }
  620. void CPlayerPlaylistBar::SetCurTime(REFERENCE_TIME rt)
  621. {
  622. if(POSITION pos = m_pl.GetPos())
  623. {
  624. CPlaylistItem& pli = m_pl.GetAt(pos);
  625. pli.m_duration = rt;
  626. m_list.SetItemText(FindItem(pos), COL_TIME, pli.GetLabel(1));
  627. }
  628. }
  630. OpenMediaData* CPlayerPlaylistBar::GetCurOMD(REFERENCE_TIME rtStart)
  631. {
  632. CPlaylistItem pli;
  633. if(!GetCur(pli)) return NULL;
  635. CString fn = CString(pli.m_fns.GetHead()).MakeLower();
  637. if(fn.Find(_T("video_ts.ifo")) >= 0
  638. || fn.Find(_T(".ratdvd")) >= 0)
  639. {
  640. if(OpenDVDData* p = new OpenDVDData())
  641. {
  642. p->path = pli.m_fns.GetHead(); 
  643. p->subs.AddTailList(&pli.m_subs);
  644. return p;
  645. }
  646. }
  648. if(pli.m_type == CPlaylistItem::device)
  649. {
  650. if(OpenDeviceData* p = new OpenDeviceData())
  651. {
  652. POSITION pos = pli.m_fns.GetHeadPosition();
  653. for(int i = 0; i < countof(p->DisplayName) && pos; i++)
  654. p->DisplayName[i] = pli.m_fns.GetNext(pos);
  655. p->vinput = pli.m_vinput;
  656. p->vchannel = pli.m_vchannel;
  657. p->ainput = pli.m_ainput;
  658. return p;
  659. }
  660. }
  661. else
  662. {
  663. if(OpenFileData* p = new OpenFileData())
  664. {
  665. p->fns.AddTailList(&pli.m_fns);
  666. p->subs.AddTailList(&pli.m_subs);
  667. p->rtStart = rtStart;
  668. return p;
  669. }
  670. }
  672. return NULL;
  673. }
  675. void CPlayerPlaylistBar::LoadPlaylist()
  676. {
  677. CString base;
  678. if(AfxGetMyApp()->GetAppDataPath(base))
  679. {
  680. CPath p;
  681. p.Combine(base, _T("default.mpcpl"));
  683. if(!AfxGetApp()->GetProfileInt(ResStr(IDS_R_SETTINGS), _T("RememberPlaylistItems"), TRUE))
  684. {
  685. DeleteFile(p);
  686. }
  687. else
  688. {
  689. ParseMPCPlayList(p);
  690. Refresh();
  691. }
  692. }
  693. }
  695. void CPlayerPlaylistBar::SavePlaylist()
  696. {
  697. CString base;
  698. if(AfxGetMyApp()->GetAppDataPath(base))
  699. {
  700. CPath p;
  701. p.Combine(base, _T("default.mpcpl"));
  703. if(!AfxGetApp()->GetProfileInt(ResStr(IDS_R_SETTINGS), _T("RememberPlaylistItems"), TRUE))
  704. {
  705. DeleteFile(p);
  706. }
  707. else
  708. {
  709. SaveMPCPlayList(p, CTextFile::UTF8, false);
  710. }
  711. }
  712. }
  714. BEGIN_MESSAGE_MAP(CPlayerPlaylistBar, CSizingControlBarG)
  715. ON_WM_SIZE()
  716. ON_NOTIFY(LVN_KEYDOWN, IDC_PLAYLIST, OnLvnKeyDown)
  717. ON_NOTIFY(NM_DBLCLK, IDC_PLAYLIST, OnNMDblclkList)
  718. // ON_NOTIFY(NM_CUSTOMDRAW, IDC_PLAYLIST, OnCustomdrawList)
  719. ON_WM_DRAWITEM()
  720. ON_COMMAND_EX(ID_FILE_CLOSEPLAYLIST, OnFileClosePlaylist)
  721. ON_COMMAND_EX(ID_PLAY_PLAY, OnPlayPlay)
  722. ON_WM_DROPFILES()
  723. ON_NOTIFY(LVN_BEGINDRAG, IDC_PLAYLIST, OnBeginDrag)
  724. ON_WM_MOUSEMOVE()
  725. ON_WM_LBUTTONUP()
  726. ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipNotify)
  727. ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipNotify)
  728. ON_WM_TIMER()
  729. ON_WM_CONTEXTMENU()
  730. ON_NOTIFY(LVN_ENDLABELEDIT, IDC_PLAYLIST, OnLvnEndlabeleditList)
  731. END_MESSAGE_MAP()
  734. // CPlayerPlaylistBar message handlers
  736. void CPlayerPlaylistBar::ResizeListColumn()
  737. {
  738. if(::IsWindow(m_list.m_hWnd))
  739. {
  740. CRect r;
  741. GetClientRect(r);
  742. r.DeflateRect(2, 2);
  743. m_list.SetRedraw(FALSE);
  744. m_list.MoveWindow(r);
  745. m_list.GetClientRect(r);
  746. m_list.SetColumnWidth(COL_NAME, r.Width()-m_nTimeColWidth); //LVSCW_AUTOSIZE_USEHEADER
  747. m_list.SetRedraw(TRUE);
  748. }
  749. }
  751. void CPlayerPlaylistBar::OnSize(UINT nType, int cx, int cy)
  752. {
  753. CSizingControlBarG::OnSize(nType, cx, cy);
  755. ResizeListColumn();
  756. }
  758. void CPlayerPlaylistBar::OnLvnKeyDown(NMHDR* pNMHDR, LRESULT* pResult) 
  759. {
  760. LPNMLVKEYDOWN pLVKeyDown = reinterpret_cast<LPNMLVKEYDOWN>(pNMHDR);
  762. *pResult = FALSE;
  764. CList<int> items;
  765. POSITION pos = m_list.GetFirstSelectedItemPosition();
  766. while(pos) items.AddHead(m_list.GetNextSelectedItem(pos));
  768. if(pLVKeyDown->wVKey == VK_DELETE && items.GetCount() > 0) 
  769. {
  770. pos = items.GetHeadPosition();
  771. while(pos) 
  772. {
  773. int i = items.GetNext(pos);
  774. if(m_pl.RemoveAt(FindPos(i))) ((CMainFrame*)AfxGetMainWnd())->CloseMedia();
  775. m_list.DeleteItem(i);
  776. }
  778. m_list.SetItemState(-1, 0, LVIS_SELECTED);
  779. m_list.SetItemState(
  780. max(min(items.GetTail(), m_list.GetItemCount()-1), 0), 
  781. LVIS_SELECTED, LVIS_SELECTED);
  783. ResizeListColumn();
  785. *pResult = TRUE;
  786. }
  787. else if(pLVKeyDown->wVKey == VK_SPACE && items.GetCount() == 1) 
  788. {
  789. m_pl.SetPos(FindPos(items.GetHead()));
  791. ((CMainFrame*)AfxGetMainWnd())->OpenCurPlaylistItem();
  793. *pResult = TRUE;
  794. }
  795. }
  797. void CPlayerPlaylistBar::OnNMDblclkList(NMHDR* pNMHDR, LRESULT* pResult)
  798. {
  799. LPNMLISTVIEW lpnmlv = (LPNMLISTVIEW)pNMHDR;
  801. if(lpnmlv->iItem >= 0 && lpnmlv->iSubItem >= 0)
  802. {
  803. m_pl.SetPos(FindPos(lpnmlv->iItem));
  804. m_list.Invalidate();
  805. ((CMainFrame*)AfxGetMainWnd())->OpenCurPlaylistItem();
  806. }
  808. *pResult = 0;
  809. }
  810. /*
  811. void CPlayerPlaylistBar::OnCustomdrawList(NMHDR* pNMHDR, LRESULT* pResult)
  812. {
  813. NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>(pNMHDR);
  815. *pResult = CDRF_DODEFAULT;
  817. if(CDDS_PREPAINT == pLVCD->nmcd.dwDrawStage)
  818. {
  819. *pResult = CDRF_NOTIFYPOSTPAINT|CDRF_NOTIFYITEMDRAW;
  820. }
  821. else if(CDDS_ITEMPREPAINT == pLVCD->nmcd.dwDrawStage)
  822. {
  823. pLVCD->nmcd.uItemState &= ~CDIS_SELECTED;
  824. pLVCD->nmcd.uItemState &= ~CDIS_FOCUS;
  826. pLVCD->clrText = (pLVCD->nmcd.dwItemSpec == m_playList.m_idx) ? 0x0000ff : CLR_DEFAULT;
  827. pLVCD->clrTextBk = m_list.GetItemState(pLVCD->nmcd.dwItemSpec, LVIS_SELECTED) ? 0xf1dacc : CLR_DEFAULT;
  829. *pResult = CDRF_NOTIFYPOSTPAINT;
  830. }
  831. else if(CDDS_ITEMPOSTPAINT == pLVCD->nmcd.dwDrawStage)
  832. {
  833.         int nItem = static_cast<int>(pLVCD->nmcd.dwItemSpec);
  835. if(m_list.GetItemState(pLVCD->nmcd.dwItemSpec, LVIS_SELECTED))
  836. {
  837. CRect r, r2;
  838. m_list.GetItemRect(nItem, &r, LVIR_BOUNDS);
  839. m_list.GetItemRect(nItem, &r2, LVIR_LABEL);
  840. r.left = r2.left;
  841. FrameRect(pLVCD->nmcd.hdc, &r, CBrush(0xc56a31));
  842. }
  844. *pResult = CDRF_SKIPDEFAULT;
  845. }
  846. else if(CDDS_POSTPAINT == pLVCD->nmcd.dwDrawStage)
  847. {
  848. }
  849. }
  850. */
  852. void CPlayerPlaylistBar::OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT lpDrawItemStruct)
  853. {
  854. if(nIDCtl != IDC_PLAYLIST) return;
  856. int nItem = lpDrawItemStruct->itemID;
  857. CRect rcItem = lpDrawItemStruct->rcItem;
  858. POSITION pos = FindPos(nItem);
  859. bool fSelected = pos == m_pl.GetPos();
  860. CPlaylistItem& pli = m_pl.GetAt(pos);
  862. CDC* pDC = CDC::FromHandle(lpDrawItemStruct->hDC);
  864. if(!!m_list.GetItemState(nItem, LVIS_SELECTED))
  865. {
  866. FillRect(pDC->m_hDC, rcItem, CBrush(0xf1dacc));
  867. FrameRect(pDC->m_hDC, rcItem, CBrush(0xc56a31));
  868. }
  869. else
  870. {
  871. FillRect(pDC->m_hDC, rcItem, CBrush(GetSysColor(COLOR_WINDOW)));
  872. }
  874. COLORREF textcolor = fSelected?0xff:0;
  875. if(pli.m_fInvalid) textcolor |= 0xA0A0A0;
  877. CString time = !pli.m_fInvalid ? m_list.GetItemText(nItem, COL_TIME) : _T("Invalid");
  878. CSize timesize(0, 0);
  879. CPoint timept(rcItem.right, 0);
  880. if(time.GetLength() > 0)
  881. {
  882. timesize = pDC->GetTextExtent(time);
  883. if((3+timesize.cx+3) < rcItem.Width()/2)
  884. {
  885. timept = CPoint(rcItem.right-(3+timesize.cx+3), (rcItem.top+rcItem.bottom-timesize.cy)/2);
  887. pDC->SetTextColor(textcolor);
  888. pDC->TextOut(timept.x, timept.y, time);
  889. }
  890. }
  892. CString fmt, file;
  893. fmt.Format(_T("%%0%dd. %%s"), (int)log10(0.1+m_pl.GetCount())+1);
  894. file.Format(fmt, nItem+1, m_list.GetItemText(nItem, COL_NAME));
  895. CSize filesize = pDC->GetTextExtent(file);
  896. while(3+filesize.cx+6 > timept.x && file.GetLength() > 3)
  897. {
  898. file = file.Left(file.GetLength()-4) + _T("...");
  899. filesize = pDC->GetTextExtent(file);
  900. }
  902. if(file.GetLength() > 3)
  903. {
  904. pDC->SetTextColor(textcolor);
  905. pDC->TextOut(rcItem.left+3, (rcItem.top+rcItem.bottom-filesize.cy)/2, file);
  906. }
  907. }
  909. BOOL CPlayerPlaylistBar::OnFileClosePlaylist(UINT nID)
  910. {
  911. Empty();
  912. return FALSE;
  913. }
  915. BOOL CPlayerPlaylistBar::OnPlayPlay(UINT nID)
  916. {
  917. m_list.Invalidate();
  918. return FALSE;
  919. }
  921. void CPlayerPlaylistBar::OnDropFiles(HDROP hDropInfo)
  922. {
  923. SetActiveWindow();
  925. CAtlList<CString> sl;
  927. UINT nFiles = ::DragQueryFile(hDropInfo, (UINT)-1, NULL, 0);
  928. for(UINT iFile = 0; iFile < nFiles; iFile++)
  929. {
  930. TCHAR szFileName[_MAX_PATH];
  931. ::DragQueryFile(hDropInfo, iFile, szFileName, _MAX_PATH);
  932. sl.AddTail(szFileName);
  933. }
  934. ::DragFinish(hDropInfo);
  936. Append(sl, true);
  937. }
  939. void CPlayerPlaylistBar::OnBeginDrag(NMHDR* pNMHDR, LRESULT* pResult)
  940. {
  941. ModifyStyle(WS_EX_ACCEPTFILES, 0);
  943. m_nDragIndex = ((LPNMLISTVIEW)pNMHDR)->iItem;
  945. CPoint p(0, 0);
  946. m_pDragImage = m_list.CreateDragImageEx(&p);
  948. CPoint p2 = ((LPNMLISTVIEW)pNMHDR)->ptAction;
  950. m_pDragImage->BeginDrag(0, p2 - p);
  951. m_pDragImage->DragEnter(GetDesktopWindow(), ((LPNMLISTVIEW)pNMHDR)->ptAction);
  953. m_bDragging = TRUE;
  954. m_nDropIndex = -1;
  956. SetCapture();
  957. }
  959. void CPlayerPlaylistBar::OnMouseMove(UINT nFlags, CPoint point)
  960. {
  961. if(m_bDragging)
  962. {
  963. m_ptDropPoint = point;
  964. ClientToScreen(&m_ptDropPoint);
  966. m_pDragImage->DragMove(m_ptDropPoint);
  967. m_pDragImage->DragShowNolock(FALSE);
  969. WindowFromPoint(m_ptDropPoint)->ScreenToClient(&m_ptDropPoint);
  971. m_pDragImage->DragShowNolock(TRUE);
  973. {
  974. int iOverItem = m_list.HitTest(m_ptDropPoint);
  975. int iTopItem = m_list.GetTopIndex();
  976. int iBottomItem = m_list.GetBottomIndex();
  978. if(iOverItem == iTopItem && iTopItem != 0) // top of list
  979. SetTimer(1, 100, NULL); 
  980. else
  981. KillTimer(1); 
  983. if(iOverItem >= iBottomItem && iBottomItem != (m_list.GetItemCount() - 1)) // bottom of list
  984. SetTimer(2, 100, NULL); 
  985. else 
  986. KillTimer(2); 
  987. }
  988. }
  990. __super::OnMouseMove(nFlags, point);
  991. }
  993. void CPlayerPlaylistBar::OnTimer(UINT nIDEvent)
  994. {
  995. int iTopItem = m_list.GetTopIndex();
  996. int iBottomItem = iTopItem + m_list.GetCountPerPage() - 1;
  998. if(m_bDragging)
  999. {
  1000. m_pDragImage->DragShowNolock(FALSE);
  1002. if(nIDEvent == 1)
  1003. {
  1004. m_list.EnsureVisible(iTopItem - 1, false);
  1005. m_list.UpdateWindow();
  1006. if(m_list.GetTopIndex() == 0) KillTimer(1); 
  1007. }
  1008. else if(nIDEvent == 2)
  1009. {
  1010. m_list.EnsureVisible(iBottomItem + 1, false);
  1011. m_list.UpdateWindow();
  1012. if(m_list.GetBottomIndex() == (m_list.GetItemCount() - 1)) KillTimer(2); 
  1013. } 
  1015. m_pDragImage->DragShowNolock(TRUE);
  1016. }
  1018. __super::OnTimer(nIDEvent);
  1019. }
  1021. void CPlayerPlaylistBar::OnLButtonUp(UINT nFlags, CPoint point)
  1022. {
  1023. if(m_bDragging)
  1024. {
  1025. ::ReleaseCapture();
  1027. m_bDragging = FALSE;
  1028. m_pDragImage->DragLeave(GetDesktopWindow());
  1029. m_pDragImage->EndDrag();
  1031. delete m_pDragImage;
  1032. m_pDragImage = NULL;
  1034. KillTimer(1);
  1035. KillTimer(2);
  1037. CPoint pt(point);
  1038. ClientToScreen(&pt);
  1040. if(WindowFromPoint(pt) == &m_list)
  1041. DropItemOnList();
  1042. }
  1044. ModifyStyle(0, WS_EX_ACCEPTFILES); 
  1046. __super::OnLButtonUp(nFlags, point);
  1047. }
  1049. void CPlayerPlaylistBar::DropItemOnList()
  1050. {
  1051. m_ptDropPoint.y += 10; //
  1052. m_nDropIndex = m_list.HitTest(CPoint(10, m_ptDropPoint.y));
  1054. TCHAR szLabel[MAX_PATH];
  1055. LV_ITEM lvi;
  1056. ZeroMemory(&lvi, sizeof(LV_ITEM));
  1057. lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE | LVIF_PARAM;
  1058. lvi.stateMask = LVIS_DROPHILITED | LVIS_FOCUSED | LVIS_SELECTED;
  1059. lvi.pszText = szLabel;
  1060. lvi.iItem = m_nDragIndex;
  1061. lvi.cchTextMax = MAX_PATH;
  1062. m_list.GetItem(&lvi);
  1064. if(m_nDropIndex < 0) m_nDropIndex = m_list.GetItemCount();
  1065. lvi.iItem = m_nDropIndex;
  1066. m_list.InsertItem(&lvi);
  1068. CHeaderCtrl* pHeader = (CHeaderCtrl*)m_list.GetDlgItem(0);
  1069. int nColumnCount = pHeader->GetItemCount();
  1070. lvi.mask = LVIF_TEXT;
  1071. lvi.iItem = m_nDropIndex;
  1072. //INDEX OF DRAGGED ITEM WILL CHANGE IF ITEM IS DROPPED ABOVE ITSELF
  1073. if(m_nDropIndex < m_nDragIndex) m_nDragIndex++;
  1074. for(int col=1; col < nColumnCount; col++)
  1075. {
  1076. _tcscpy(lvi.pszText, (LPCTSTR)(m_list.GetItemText(m_nDragIndex, col)));
  1077. lvi.iSubItem = col;
  1078. m_list.SetItem(&lvi);
  1079. }
  1081. m_list.DeleteItem(m_nDragIndex);
  1083. CList<CPlaylistItem> tmp;
  1084. UINT id = -1;
  1085. for(int i = 0; i < m_list.GetItemCount(); i++)
  1086. {
  1087. POSITION pos = (POSITION)m_list.GetItemData(i);
  1088. CPlaylistItem& pli = m_pl.GetAt(pos);
  1089. tmp.AddTail(pli);
  1090. if(pos == m_pl.GetPos()) id = pli.m_id;
  1091. }
  1092. m_pl.RemoveAll();
  1093. POSITION pos = tmp.GetHeadPosition();
  1094. for(int i = 0; pos; i++)
  1095. {
  1096. CPlaylistItem& pli = tmp.GetNext(pos);
  1097. m_pl.AddTail(pli);
  1098. if(pli.m_id == id) m_pl.SetPos(m_pl.GetTailPosition());
  1099. m_list.SetItemData(i, (DWORD_PTR)m_pl.GetTailPosition());
  1100. }
  1102. ResizeListColumn();
  1103. }
  1105. BOOL CPlayerPlaylistBar::OnToolTipNotify(UINT id, NMHDR* pNMHDR, LRESULT* pResult)
  1106. {
  1107. TOOLTIPTEXTA* pTTTA = (TOOLTIPTEXTA*)pNMHDR;
  1108. TOOLTIPTEXTW* pTTTW = (TOOLTIPTEXTW*)pNMHDR;
  1110. if((pNMHDR->code == TTN_NEEDTEXTA && (HWND)pTTTA->lParam != m_list.m_hWnd)
  1111. || (pNMHDR->code == TTN_NEEDTEXTW && (HWND)pTTTW->lParam != m_list.m_hWnd))
  1112. return FALSE;
  1114. int row = ((pNMHDR->idFrom-1) >> 10) & 0x3fffff;
  1115. int col = (pNMHDR->idFrom-1) & 0x3ff;
  1117. if(row < 0 || row >= m_pl.GetCount())
  1118. return FALSE;
  1120. CPlaylistItem& pli = m_pl.GetAt(FindPos(row));
  1122. CString strTipText;
  1124. if(col == COL_NAME)
  1125. {
  1126. POSITION pos = pli.m_fns.GetHeadPosition();
  1127. while(pos) strTipText += _T("n") + pli.m_fns.GetNext(pos);
  1128. strTipText.Trim();
  1130. if(pli.m_type == CPlaylistItem::device)
  1131. {
  1132. CString str;
  1133. str.Format(_T("Video Input %d"), pli.m_vinput);
  1134. if(pli.m_vinput >= 0) strTipText += _T("n") + str;
  1135. str.Format(_T("Video Channel %d"), pli.m_vchannel);
  1136. if(pli.m_vchannel >= 0) strTipText += _T("n") + str;
  1137. str.Format(_T("Audio Input %d"), pli.m_ainput);
  1138. if(pli.m_ainput >= 0) strTipText += _T("n") + str;
  1139. }
  1141. ::SendMessage(pNMHDR->hwndFrom, TTM_SETMAXTIPWIDTH, 0, (LPARAM)(INT)1000);
  1142. }
  1143. else if(col == COL_TIME)
  1144. {
  1145. return FALSE;
  1146. }
  1148. static CStringA m_strTipTextA;
  1149. static CStringW m_strTipTextW;
  1151. if(pNMHDR->code == TTN_NEEDTEXTA)
  1152. {
  1153. m_strTipTextA = strTipText;
  1154. pTTTA->lpszText = (LPSTR)(LPCSTR)m_strTipTextA;
  1155. }
  1156. else
  1157. {
  1158. m_strTipTextW = strTipText;
  1159. pTTTW->lpszText = (LPWSTR)(LPCWSTR)m_strTipTextW;
  1160. }
  1162. *pResult = 0;
  1164. return TRUE;    // message was handled
  1165. }
  1167. void CPlayerPlaylistBar::OnContextMenu(CWnd* /*pWnd*/, CPoint p)
  1168. {
  1169. LVHITTESTINFO lvhti;
  1170. lvhti.pt = p;
  1171. m_list.ScreenToClient(&lvhti.pt);
  1172. m_list.SubItemHitTest(&lvhti);
  1174. POSITION pos = FindPos(lvhti.iItem);
  1175. // bool fSelected = (pos == m_pl.GetPos());
  1176. bool fOnItem = !!(lvhti.flags&LVHT_ONITEM);
  1178. CMenu m;
  1179. m.CreatePopupMenu();
  1181. enum 
  1182. {
  1183. M_OPEN=1, M_ADD, M_REMOVE, M_CLIPBOARD, M_SAVEAS, 
  1184. M_SORTBYNAME, M_SORTBYPATH, M_RANDOMIZE, M_SORTBYID,
  1185. M_REMEMBERPLAYLIST, M_SHUFFLE
  1186. };
  1188. m.AppendMenu(MF_STRING|(!fOnItem?(MF_DISABLED|MF_GRAYED):MF_ENABLED), M_OPEN, ResStr(IDS_PLAYLIST_OPEN));
  1189. if(((CMainFrame*)AfxGetMainWnd())->m_iPlaybackMode == PM_CAPTURE) m.AppendMenu(MF_STRING|MF_ENABLED, M_ADD, ResStr(IDS_PLAYLIST_ADD));
  1190. m.AppendMenu(MF_STRING|(/*fSelected||*/!fOnItem?(MF_DISABLED|MF_GRAYED):MF_ENABLED), M_REMOVE, ResStr(IDS_PLAYLIST_REMOVE));
  1191. m.AppendMenu(MF_SEPARATOR);
  1192. m.AppendMenu(MF_STRING|(!fOnItem?(MF_DISABLED|MF_GRAYED):MF_ENABLED), M_CLIPBOARD, ResStr(IDS_PLAYLIST_COPYTOCLIPBOARD));
  1193. m.AppendMenu(MF_STRING|(!m_pl.GetCount()?(MF_DISABLED|MF_GRAYED):MF_ENABLED), M_SAVEAS, ResStr(IDS_PLAYLIST_SAVEAS));
  1194. m.AppendMenu(MF_SEPARATOR);
  1195. m.AppendMenu(MF_STRING|(!m_pl.GetCount()?(MF_DISABLED|MF_GRAYED):MF_ENABLED), M_SORTBYNAME, ResStr(IDS_PLAYLIST_SORTBYLABEL));
  1196. m.AppendMenu(MF_STRING|(!m_pl.GetCount()?(MF_DISABLED|MF_GRAYED):MF_ENABLED), M_SORTBYPATH, ResStr(IDS_PLAYLIST_SORTBYPATH));
  1197. m.AppendMenu(MF_STRING|(!m_pl.GetCount()?(MF_DISABLED|MF_GRAYED):MF_ENABLED), M_RANDOMIZE, ResStr(IDS_PLAYLIST_RANDOMIZE));
  1198. m.AppendMenu(MF_STRING|(!m_pl.GetCount()?(MF_DISABLED|MF_GRAYED):MF_ENABLED), M_SORTBYID, ResStr(IDS_PLAYLIST_RESTORE));
  1199. m.AppendMenu(MF_SEPARATOR);
  1200. m.AppendMenu(MF_STRING|MF_ENABLED|(AfxGetApp()->GetProfileInt(ResStr(IDS_R_SETTINGS), _T("ShufflePlaylistItems"), FALSE)?MF_CHECKED:0), M_SHUFFLE, ResStr(IDS_PLAYLIST_SHUFFLE));
  1201. m.AppendMenu(MF_STRING|MF_ENABLED|(AfxGetApp()->GetProfileInt(ResStr(IDS_R_SETTINGS), _T("RememberPlaylistItems"), TRUE)?MF_CHECKED:0), M_REMEMBERPLAYLIST, ResStr(IDS_PLAYLIST_REMEBERITEMS));
  1203. CMainFrame* pMainFrm = (CMainFrame*)AfxGetMainWnd();
  1205. int nID = (int)m.TrackPopupMenu(TPM_LEFTBUTTON|TPM_RETURNCMD, p.x, p.y, this);
  1206. switch(nID)
  1207. {
  1208. case M_OPEN:
  1209. m_pl.SetPos(pos);
  1210. m_list.Invalidate();
  1211. pMainFrm->OpenCurPlaylistItem();
  1212. break;
  1213. case M_ADD:
  1214. pMainFrm->AddCurDevToPlaylist();
  1215. m_pl.SetPos(m_pl.GetTailPosition());
  1216. break;
  1217. case M_REMOVE:
  1218. if(m_pl.RemoveAt(pos)) pMainFrm->CloseMedia();
  1219. m_list.DeleteItem(lvhti.iItem);
  1220. SavePlaylist();
  1221. break;
  1222. case M_SORTBYID:
  1223. m_pl.SortById();
  1224. SetupList();
  1225. SavePlaylist();
  1226. break;
  1227. case M_SORTBYNAME:
  1228. m_pl.SortByName();
  1229. SetupList();
  1230. SavePlaylist();
  1231. break;
  1232. case M_SORTBYPATH:
  1233. m_pl.SortByPath();
  1234. SetupList();
  1235. SavePlaylist();
  1236. break;
  1237. case M_RANDOMIZE:
  1238. m_pl.Randomize();
  1239. SetupList();
  1240. SavePlaylist();
  1241. break;
  1242. case M_CLIPBOARD:
  1243. if(OpenClipboard() && EmptyClipboard())
  1244. {
  1245. CString str;
  1247. CPlaylistItem& pli = m_pl.GetAt(pos);
  1248. POSITION pos = pli.m_fns.GetHeadPosition();
  1249. while(pos) str += _T("rn") + pli.m_fns.GetNext(pos);
  1250. str.Trim();
  1252. if(HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE, (str.GetLength()+1)*sizeof(TCHAR)))
  1253. {
  1254. if(TCHAR* s = (TCHAR*)GlobalLock(h))
  1255. {
  1256. _tcscpy(s, str);
  1257. GlobalUnlock(h);
  1258. #ifdef UNICODE
  1259. SetClipboardData(CF_UNICODETEXT, h);
  1260. #else
  1261. SetClipboardData(CF_TEXT, h);
  1262. #endif
  1263. }
  1264. }
  1265. CloseClipboard(); 
  1266. }
  1267. break;
  1268. case M_SAVEAS:
  1269. {
  1270. CSaveTextFileDialog fd(
  1271. CTextFile::ASCII, NULL, NULL,
  1272. _T("Media Player Classic playlist (*.mpcpl)|*.mpcpl|Playlist (*.pls)|*.pls|WinAmp playlist (*.m3u)|*.m3u|Windows Media Playlist (*.asx)|*.asx||"), 
  1273. this);
  1275. if(fd.DoModal() != IDOK)
  1276. break;
  1278. CTextFile::enc encoding = (CTextFile::enc)fd.GetEncoding();
  1279. if(encoding == CTextFile::ASCII) encoding = CTextFile::ANSI;
  1281. int idx = fd.m_pOFN->nFilterIndex;
  1283. CPath path(fd.GetPathName());
  1285. switch(idx)
  1286. {
  1287. case 1: path.AddExtension(_T(".mpcpl")); break;
  1288. case 2: path.AddExtension(_T(".pls")); break;
  1289. case 3: path.AddExtension(_T(".m3u")); break;
  1290. case 4: path.AddExtension(_T(".asx")); break;
  1291. default: break;
  1292. }
  1294. bool fRemovePath = true;
  1296. CPath p(path);
  1297. p.RemoveFileSpec();
  1298. CString base = (LPCTSTR)p;
  1300. pos = m_pl.GetHeadPosition();
  1301. while(pos && fRemovePath)
  1302. {
  1303. CPlaylistItem& pli = m_pl.GetNext(pos);
  1305. if(pli.m_type != CPlaylistItem::file) fRemovePath = false;
  1306. else
  1307. {
  1308. POSITION pos;
  1310. pos = pli.m_fns.GetHeadPosition();
  1311. while(pos && fRemovePath)
  1312. {
  1313. CString fn = pli.m_fns.GetNext(pos);
  1315. CPath p(fn);
  1316. p.RemoveFileSpec();
  1317. if(base != (LPCTSTR)p) fRemovePath = false;
  1318. }
  1320. pos = pli.m_subs.GetHeadPosition();
  1321. while(pos && fRemovePath)
  1322. {
  1323. CString fn = pli.m_subs.GetNext(pos);
  1325. CPath p(fn);
  1326. p.RemoveFileSpec();
  1327. if(base != (LPCTSTR)p) fRemovePath = false;
  1328. }
  1329. }
  1330. }
  1332. if(idx == 1)
  1333. {
  1334. SaveMPCPlayList(path, encoding, fRemovePath);
  1335. break;
  1336. }
  1338. CTextFile f;
  1339. if(!f.Save(path, encoding))
  1340. break;
  1342. if(idx == 4)
  1343. {
  1344. f.WriteString(_T("<ASX version = "3.0">n"));
  1345. }
  1347. pos = m_pl.GetHeadPosition();
  1348. for(int i = 0; pos; i++)
  1349. {
  1350. CPlaylistItem& pli = m_pl.GetNext(pos);
  1352. if(pli.m_type != CPlaylistItem::file) 
  1353. continue;
  1355. CString fn = pli.m_fns.GetHead();
  1357. /*
  1358. if(fRemovePath)
  1359. {
  1360. CPath p(path);
  1361. p.StripPath();
  1362. fn = (LPCTSTR)p;
  1363. }
  1364. */
  1366. CString str;
  1367. switch(idx)
  1368. {
  1369. case 2: str.Format(_T("File%d=%sn"), i+1, fn); break;
  1370. case 3: str.Format(_T("%sn"), fn); break;
  1371. case 4: str.Format(_T("<Entry><Ref href = "%s"/></Entry>n"), fn); break;
  1372. default: break;
  1373. }
  1374. f.WriteString(str);
  1375. }
  1377. if(idx == 4)
  1378. {
  1379. f.WriteString(_T("</ASX>n"));
  1380. }
  1381. }
  1382. break;
  1383. case M_REMEMBERPLAYLIST:
  1384. AfxGetApp()->WriteProfileInt(ResStr(IDS_R_SETTINGS), _T("RememberPlaylistItems"), 
  1385. !AfxGetApp()->GetProfileInt(ResStr(IDS_R_SETTINGS), _T("RememberPlaylistItems"), TRUE));
  1386. break;
  1387. case M_SHUFFLE:
  1388. AfxGetApp()->WriteProfileInt(ResStr(IDS_R_SETTINGS), _T("ShufflePlaylistItems"), 
  1389. !AfxGetApp()->GetProfileInt(ResStr(IDS_R_SETTINGS), _T("ShufflePlaylistItems"), FALSE));
  1390. break;
  1391. default:
  1392. break;
  1393. }
  1394. }
  1396. void CPlayerPlaylistBar::OnLvnEndlabeleditList(NMHDR* pNMHDR, LRESULT* pResult)
  1397. {
  1398. NMLVDISPINFO* pDispInfo = reinterpret_cast<NMLVDISPINFO*>(pNMHDR);
  1400. if(pDispInfo->item.iItem >= 0 && pDispInfo->item.pszText)
  1401. {
  1402. CPlaylistItem& pli = m_pl.GetAt((POSITION)m_list.GetItemData(pDispInfo->item.iItem));
  1403. pli.m_label = pDispInfo->item.pszText;
  1404. m_list.SetItemText(pDispInfo->item.iItem, 0, pDispInfo->item.pszText);
  1405. }
  1407. *pResult = 0;
  1408. }