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

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

多媒体编程

开发平台：

Visual C++

PlayerSubresyncBar.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. // PlayerSubresyncBar.cpp : implementation file
  23. //
  25. #include "stdafx.h"
  26. #include "mplayerc.h"
  27. #include "mainfrm.h"
  28. #include "PlayerSubresyncBar.h"
  30. // CPlayerSubresyncBar
  32. IMPLEMENT_DYNAMIC(CPlayerSubresyncBar, CSizingControlBarG)
  33. CPlayerSubresyncBar::CPlayerSubresyncBar()
  34. {
  35. m_rt = 0;
  36. m_fUnlink = false;
  37. m_lastSegment = -1;
  38. }
  40. CPlayerSubresyncBar::~CPlayerSubresyncBar()
  41. {
  42. }
  44. BOOL CPlayerSubresyncBar::Create(CWnd* pParentWnd, CCritSec* pSubLock)
  45. {
  46. if(!CSizingControlBarG::Create(_T("Subresync"), pParentWnd, 50))
  47. return FALSE;
  49. m_pSubLock = pSubLock;
  51. m_list.CreateEx(
  52. WS_EX_DLGMODALFRAME|WS_EX_CLIENTEDGE, 
  53. WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_TABSTOP|LVS_REPORT/*|LVS_SHOWSELALWAYS*/|LVS_AUTOARRANGE|LVS_NOSORTHEADER, 
  54. CRect(0,0,100,100), this, IDC_SUBRESYNCLIST);
  56. m_list.SetExtendedStyle(m_list.GetExtendedStyle()|LVS_EX_FULLROWSELECT|LVS_EX_DOUBLEBUFFER);
  58. return TRUE;
  59. }
  61. BOOL CPlayerSubresyncBar::PreCreateWindow(CREATESTRUCT& cs)
  62. {
  63. if(!CSizingControlBarG::PreCreateWindow(cs))
  64. return FALSE;
  66. return TRUE;
  67. }
  69. BOOL CPlayerSubresyncBar::PreTranslateMessage(MSG* pMsg)
  70. {
  71. if(IsWindow(pMsg->hwnd) && IsVisible() && pMsg->message >= WM_KEYFIRST && pMsg->message <= WM_KEYLAST)
  72. {
  73. if(IsDialogMessage(pMsg))
  74. return TRUE;
  75. }
  77. return CSizingControlBarG::PreTranslateMessage(pMsg);
  78. }
  80. void CPlayerSubresyncBar::SetTime(__int64 rt)
  81. {
  82. m_rt = rt;
  84. int curSegment;
  86. if(!m_sts.SearchSubs((int)(rt/10000), 25, &curSegment))
  87. {
  88. curSegment = -1;
  89. }
  91. if(m_lastSegment != curSegment) m_list.Invalidate();
  92. m_lastSegment = curSegment;
  93. }
  95. void CPlayerSubresyncBar::SetSubtitle(ISubStream* pSubStream, double fps)
  96. {
  97. m_pSubStream = pSubStream;
  99. m_mode = NONE;
  100. m_lastSegment = -1;
  101. m_sts.Empty();
  103. ResetSubtitle();
  105. if(!m_pSubStream) return;
  107. CLSID clsid;
  108. m_pSubStream->GetClassID(&clsid);
  110. if(clsid == __uuidof(CVobSubFile))
  111. {
  112. CVobSubFile* pVSF = (CVobSubFile*)(ISubStream*)m_pSubStream;
  114. m_mode = VOBSUB;
  116. CArray<CVobSubFile::SubPos>& sp = pVSF->m_langs[pVSF->m_iLang].subpos;
  118. for(int i = 0, j = sp.GetSize(); i < j; i++)
  119. {
  120. CString str;
  121. str.Format(_T("%d,%d,%d,%d"), sp[i].vobid, sp[i].cellid, sp[i].fForced, i);
  122. m_sts.Add(TToW(str), false, (int)sp[i].start, (int)sp[i].stop);
  123. }
  125. m_sts.CreateDefaultStyle(DEFAULT_CHARSET);
  127. pVSF->m_fOnlyShowForcedSubs = false;
  129. for(int i = 0, j = m_list.GetHeaderCtrl()->GetItemCount(); i < j; i++) m_list.DeleteColumn(0);
  130. m_list.InsertColumn(COL_START, _T("Time"), LVCFMT_LEFT, 80);
  131. m_list.InsertColumn(COL_END, _T("End"), LVCFMT_LEFT, 80);
  132. m_list.InsertColumn(COL_PREVSTART, _T("Preview"), LVCFMT_LEFT, 80);
  133. m_list.InsertColumn(COL_PREVEND, _T("End"), LVCFMT_LEFT, 80);
  134. m_list.InsertColumn(COL_VOBID, _T("Vob ID"), LVCFMT_CENTER, 60);
  135. m_list.InsertColumn(COL_CELLID, _T("Cell ID"), LVCFMT_CENTER, 60);
  136. m_list.InsertColumn(COL_FORCED, _T("Forced"), LVCFMT_CENTER, 60);
  137. }
  138. else if(clsid == __uuidof(CRenderedTextSubtitle))
  139. {
  140. CRenderedTextSubtitle* pRTS = (CRenderedTextSubtitle*)(ISubStream*)m_pSubStream;
  142. m_mode = TEXTSUB;
  144. m_sts.Copy(*pRTS);
  145. m_sts.ConvertToTimeBased(fps);
  146. m_sts.Sort(true); /*!!m_fUnlink*/
  148. #ifndef UNICODE
  149. if(!m_sts.IsEntryUnicode(0))
  150. {
  151. CFont* f = m_list.GetFont();
  152. LOGFONT lf;
  153. f->GetLogFont(&lf);
  154. lf.lfCharSet = m_sts.GetCharSet(0);
  155. m_font.DeleteObject();
  156. m_font.CreateFontIndirect(&lf);
  157. m_list.SetFont(&m_font);
  158. }
  159. #endif
  160. for(int i = 0, j = m_list.GetHeaderCtrl()->GetItemCount(); i < j; i++) m_list.DeleteColumn(0);
  161. m_list.InsertColumn(COL_START, _T("Time"), LVCFMT_LEFT, 90);
  162. m_list.InsertColumn(COL_END, _T("End"), LVCFMT_LEFT, 4);
  163. m_list.InsertColumn(COL_PREVSTART, _T("Preview"), LVCFMT_LEFT, 80);
  164. m_list.InsertColumn(COL_PREVEND, _T("End"), LVCFMT_LEFT, 4);
  165. m_list.InsertColumn(COL_TEXT, _T("Text"), LVCFMT_LEFT, 275);
  166. m_list.InsertColumn(COL_STYLE, _T("Style"), LVCFMT_LEFT, 80);
  167. m_list.InsertColumn(COL_FONT, _T("Font"), LVCFMT_LEFT, 60);
  168. m_list.InsertColumn(COL_CHARSET, _T("CharSet"), LVCFMT_CENTER, 20);
  169. m_list.InsertColumn(COL_UNICODE, _T("Unicode"), LVCFMT_CENTER, 40);
  170. m_list.InsertColumn(COL_LAYER, _T("Layer"), LVCFMT_CENTER, 50);
  171. m_list.InsertColumn(COL_ACTOR, _T("Actor"), LVCFMT_LEFT, 80);
  172. m_list.InsertColumn(COL_EFFECT, _T("Effect"), LVCFMT_LEFT, 80);
  173. }
  175. m_subtimes.SetSize(m_sts.GetSize());
  177. for(int i = 0, j = m_sts.GetSize(); i < j; i++)
  178. {
  179. m_subtimes[i].orgstart = m_sts[i].start;
  180. m_subtimes[i].orgend = m_sts[i].end;
  181. }
  183. ResetSubtitle();
  184. }
  186. void CPlayerSubresyncBar::ResetSubtitle()
  187. {
  188. m_list.DeleteAllItems();
  190. if(m_mode == VOBSUB || m_mode == TEXTSUB) 
  191. {
  192. TCHAR buff[32];
  194. int prevstart = INT_MIN;
  196. for(int i = 0, j = m_sts.GetSize(); i < j; i++)
  197. {
  198. m_subtimes[i].newstart = m_subtimes[i].orgstart;
  199. m_subtimes[i].newend = m_subtimes[i].orgend;
  201. FormatTime(i, buff, 0, false);
  202. m_list.InsertItem(i, buff, COL_START);
  203. FormatTime(i, buff, 0, true);
  204. m_list.SetItemText(i, COL_END, buff);
  206. if(prevstart > m_subtimes[i].orgstart) m_list.SetItemData(i, TSEP);
  207. prevstart = m_subtimes[i].orgstart;
  209. SetCheck(i, false, false);
  210. }
  212. UpdatePreview();
  214. m_list.SetColumnWidth(COL_START, LVSCW_AUTOSIZE);
  215. m_list.SetColumnWidth(COL_PREVSTART, LVSCW_AUTOSIZE);
  216. }
  218. UpdateStrings();
  219. }
  221. void CPlayerSubresyncBar::SaveSubtitle()
  222. {
  223. CMainFrame* pFrame = ((CMainFrame*)AfxGetMainWnd());
  224. if(!pFrame) return;
  226. CLSID clsid;
  227. m_pSubStream->GetClassID(&clsid);
  229. if(clsid == __uuidof(CVobSubFile) && m_mode == VOBSUB)
  230. {
  231. CVobSubFile* pVSF = (CVobSubFile*)(ISubStream*)m_pSubStream;
  233. CAutoLock cAutoLock(m_pSubLock);
  235. CArray<CVobSubFile::SubPos>& sp = pVSF->m_langs[pVSF->m_iLang].subpos;
  237. for(int i = 0, j = sp.GetSize(); i < j; i++) 
  238. {
  239. sp[i].fValid = false;
  240. }
  242. for(int i = 0, j = m_sts.GetSize(); i < j; i++) 
  243. {
  244. int vobid, cellid, forced, spnum, c;
  245. if(_stscanf(m_sts.GetStr(i), _T("%d%c%d%c%d%c%d"), &vobid, &c, &cellid, &c, &forced, &c, &spnum) != 7) continue;
  246.             sp[spnum].start = m_sts[i].start;
  247. sp[spnum].stop = m_sts[i].end;
  248. sp[spnum].fValid = true;
  249. }
  250. }
  251. else if(clsid == __uuidof(CRenderedTextSubtitle) && m_mode == TEXTSUB)
  252. {
  253. CRenderedTextSubtitle* pRTS = (CRenderedTextSubtitle*)(ISubStream*)m_pSubStream;
  255. CAutoLock cAutoLock(m_pSubLock);
  257. pRTS->Copy(m_sts);
  258. }
  259. else 
  260. {
  261. return;
  262. }
  264. pFrame->InvalidateSubtitle();
  265. }
  267. void CPlayerSubresyncBar::UpdatePreview()
  268. {
  269. if(m_mode == VOBSUB || m_mode == TEXTSUB) 
  270. {
  271. if(0/*m_fUnlink*/)
  272. {
  273. for(int i = 0, j = m_sts.GetSize(); i < j; i++)
  274. {
  275. bool fStartMod, fEndMod, fStartAdj, fEndAdj;
  276. GetCheck(i, fStartMod, fEndMod, fStartAdj, fEndAdj);
  277. m_sts[i].start = (fStartMod||fStartAdj) ? m_subtimes[i].newstart : m_subtimes[i].orgstart;
  278. m_sts[i].end = (fEndMod||fEndAdj) ? m_subtimes[i].newend : m_subtimes[i].orgend;
  279. }
  280. }
  281. else
  282. {
  283. CArray <int, int> schk;
  285. for(int i = 0, j = m_sts.GetSize(); i < j;)
  286. {
  287. schk.RemoveAll();
  289. int start = i, end;
  291. for(end = i; end < j; end++)
  292. {
  293. int data = (int)m_list.GetItemData(end);
  294. if((data&TSEP) && end > i) break;
  295. if(data&(TSMOD|TSADJ))
  296. schk.Add(end);
  297. }
  299. if(schk.GetSize() == 0)
  300. {
  301. for(; start < end; start++) 
  302. {
  303. m_sts[start].start = m_subtimes[start].orgstart;
  304. m_sts[start].end = m_subtimes[start].orgend;
  305. }
  306. }
  307. else if(schk.GetSize() == 1)
  308. {
  309. int k = schk[0];
  310. int dt = m_subtimes[k].newstart - m_subtimes[k].orgstart;
  311. for(; start < end; start++) 
  312. {
  313. m_sts[start].start = m_subtimes[start].orgstart + dt;
  314. m_sts[start].end = (m_list.GetItemData(start)&TEMOD)
  315. ? m_subtimes[start].newend
  316. : (m_subtimes[start].orgend + dt);
  317. }
  318. }
  319. else if(schk.GetSize() >= 2)
  320. {
  321. int i0, i1, ti0, ds;
  322. double m = 0;
  324. for(int k = 0, l = schk.GetSize()-1; k < l; k++)
  325. {
  326. i0 = schk[k];
  327. i1 = schk[k+1];
  329. ti0 = m_subtimes[i0].orgstart;
  330. ds = m_subtimes[i1].orgstart - ti0;
  332. if(ds == 0)
  333. {
  334. for(; start < i1; start++)
  335. {
  336. m_sts[start].start = ti0;
  337. m_sts[start].end = (m_list.GetItemData(start)&TEMOD)
  338. ? m_subtimes[start].newend
  339. : (ti0 + m_subtimes[start].orgend - m_subtimes[start].orgstart);
  340. }
  341. }
  342. else
  343. {
  344. m = double(m_subtimes[i1].newstart - m_subtimes[i0].newstart) / ds;
  346. for(; start < i1; start++) 
  347. {
  348. m_sts[start].start = int((m_subtimes[start].orgstart - ti0)*m + m_subtimes[i0].newstart);
  349. m_sts[start].end = (m_list.GetItemData(start)&TEMOD)
  350. ? m_subtimes[start].newend
  351. : m_mode == VOBSUB
  352. ? (m_sts[start].start + m_subtimes[start].orgend - m_subtimes[start].orgstart)
  353. : (m_sts[start].start + int((m_subtimes[start].orgend - m_subtimes[start].orgstart)*m));
  354. }
  355. }
  356. }
  358. if(ds == 0)
  359. {
  360. for(; start < end; start++) 
  361. {
  362. m_sts[start].start = ti0;
  363. m_sts[start].end = (m_list.GetItemData(start)&TEMOD)
  364. ? m_subtimes[start].newend
  365. : (ti0 + (m_subtimes[start].orgend - m_subtimes[start].orgstart));
  366. }
  367. }
  368. else
  369. {
  370. for(; start < end; start++)
  371. {
  372. m_sts[start].start = int((m_subtimes[start].orgstart - ti0)*m + m_subtimes[i0].newstart);
  373. m_sts[start].end = (m_list.GetItemData(start)&TEMOD)
  374. ? m_subtimes[start].newend
  375. : m_mode == VOBSUB
  376. ? (m_sts[start].start + m_subtimes[start].orgend - m_subtimes[start].orgstart)
  377. : (m_sts[start].start + int((m_subtimes[start].orgend - m_subtimes[start].orgstart)*m));
  378. }
  379. }
  380. }
  382. i = end;
  383. }
  384. }
  386. m_sts.CreateSegments();
  388. for(int i = 0, j = m_sts.GetSize(); i < j; i++)
  389. {
  390. TCHAR buff[32];
  391. FormatTime(i, buff, 2, false);
  392. m_list.SetItemText(i, COL_PREVSTART, buff);
  393. FormatTime(i, buff, 2, true);
  394. m_list.SetItemText(i, COL_PREVEND, buff);
  395. }
  397. if(IsWindowVisible())
  398. {
  399. SaveSubtitle();
  400. }
  401. }
  402. }
  404. void CPlayerSubresyncBar::UpdateStrings()
  405. {
  406. CString str;
  408. if(m_mode == TEXTSUB)
  409. {
  410. for(int i = 0, j = m_sts.GetSize(); i < j; i++)
  411. {
  412. STSStyle stss;
  413. m_sts.GetStyle(i, stss);
  415. m_list.SetItemText(i, COL_TEXT, m_sts.GetStr(i, true));
  416. m_list.SetItemText(i, COL_STYLE, m_sts[i].style);
  417. m_list.SetItemText(i, COL_FONT, stss.fontName);
  418. str.Format(_T("%d"), stss.charSet);
  419. m_list.SetItemText(i, COL_CHARSET, str);
  420. m_list.SetItemText(i, COL_UNICODE, m_sts.IsEntryUnicode(i) ? _T("yes") : _T("no"));
  421. str.Format(_T("%d"), m_sts[i].layer);
  422. m_list.SetItemText(i, COL_LAYER, str);
  423. m_list.SetItemText(i, COL_ACTOR, m_sts[i].actor);
  424. m_list.SetItemText(i, COL_EFFECT, m_sts[i].effect);
  425. }
  426. }
  427. else if(m_mode == VOBSUB)
  428. {
  429. for(int i = 0, j = m_sts.GetSize(); i < j; i++)
  430. {
  431. int vobid, cellid, forced, c;
  432. if(_stscanf(m_sts.GetStr(i), _T("%d%c%d%c%d"), &vobid, &c, &cellid, &c, &forced) != 5) continue;
  433. if(vobid < 0) str = _T("-");
  434. else str.Format(_T("%d"), vobid);
  435. m_list.SetItemText(i, COL_VOBID, str);
  436. if(cellid < 0) str = _T("-");
  437. else str.Format(_T("%d"), cellid);
  438. m_list.SetItemText(i, COL_CELLID, str);
  439. str = forced?_T("Yes"):_T("");
  440. m_list.SetItemText(i, COL_FORCED, str);
  441. }
  442. }
  443. }
  445. void CPlayerSubresyncBar::GetCheck(int iItem, bool& fStartMod, bool& fEndMod, bool& fStartAdj, bool& fEndAdj)
  446. {
  447. if(0 <= iItem && iItem < m_sts.GetSize())
  448. {
  449.         int nCheck = (int)m_list.GetItemData(iItem);
  450. fStartMod = !!(nCheck&TSMOD);
  451. fEndMod = !!(nCheck&TEMOD);
  452. fStartAdj = !!(nCheck&TSADJ);
  453. fEndAdj = !!(nCheck&TEADJ);
  454. }
  455. }
  457. void CPlayerSubresyncBar::SetCheck(int iItem, bool fStart, bool fEnd)
  458. {
  459. if(0 <= iItem && iItem < m_sts.GetSize())
  460. {
  461. SubTime& st = m_subtimes[iItem];
  463.         int nCheck = (int)m_list.GetItemData(iItem) & TSEP;
  465. if(fStart) nCheck |= TSMOD;
  466. else if(abs(st.orgstart-st.newstart)) nCheck |= TSADJ;
  467. if(fEnd) nCheck |= TEMOD;
  468. else if(abs(st.orgend-st.newend)) nCheck |= TEADJ;
  470. m_list.SetItemData(iItem, (DWORD)nCheck);
  472. TCHAR buff[32];
  473. FormatTime(iItem, buff, fStart, false);
  474. m_list.SetItemText(iItem, COL_START, buff);
  475. FormatTime(iItem, buff, fEnd, true);
  476. m_list.SetItemText(iItem, COL_END, buff);
  477. }
  478. }
  480. bool CPlayerSubresyncBar::ModStart(int iItem, int t, bool fReset)
  481. {
  482. bool fRet = false;
  484. bool fStartMod, fEndMod, fStartAdj, fEndAdj;
  485. GetCheck(iItem, fStartMod, fEndMod, fStartAdj, fEndAdj);
  487. SubTime& st = m_subtimes[iItem];
  489. // if(fStartMod || fStartAdj || st.orgstart != t || fReset)
  490. {
  491. fRet = (st.newstart != t);
  493. st.newstart = t;
  494. if(!fEndMod) st.newend = st.newstart + (st.orgend - st.orgstart);
  495. else if(fReset) st.newstart = st.newend - (st.orgend - st.orgstart);
  497. SetCheck(iItem, !fReset, fEndMod);
  498. }
  500. return(fRet);
  501. }
  503. bool CPlayerSubresyncBar::ModEnd(int iItem, int t, bool fReset)
  504. {
  505. bool fRet = false;
  507. bool fStartMod, fEndMod, fStartAdj, fEndAdj;
  508. GetCheck(iItem, fStartMod, fEndMod, fStartAdj, fEndAdj);
  510. SubTime& st = m_subtimes[iItem];
  512. // if(fEndMod || fEndAdj || st.orgend != t || fReset)
  513. {
  514. fRet = (st.newend != t);
  516. st.newend = t;
  517. if(!fStartMod) st.newstart = st.newend - (st.orgend - st.orgstart);
  518. else if(fReset) st.newend = st.newstart + (st.orgend - st.orgstart);
  520. SetCheck(iItem, fStartMod, !fReset);
  521. }
  523. return(fRet);
  524. }
  526. void CPlayerSubresyncBar::FormatTime(int iItem, TCHAR* buff, int time, bool fEnd)
  527. {
  528. int t = !fEnd 
  529. ?(time == 2 ? m_sts[iItem].start
  530. : time == 1 ? m_subtimes[iItem].newstart 
  531. : m_subtimes[iItem].orgstart)
  532. : (time == 2 ? m_sts[iItem].end
  533. : time == 1 ? m_subtimes[iItem].newend
  534. : m_subtimes[iItem].orgend);
  536. _stprintf(buff, t >= 0 
  537. ? _T("%02d:%02d:%02d.%03d") 
  538. : _T("-%02d:%02d:%02d.%03d"), 
  539. abs(t)/60/60/1000, 
  540. (abs(t)/60/1000)%60, 
  541. (abs(t)/1000)%60, 
  542. abs(t)%1000);
  543. }
  546. BEGIN_MESSAGE_MAP(CPlayerSubresyncBar, CSizingControlBarG)
  547. ON_WM_SIZE()
  548. ON_NOTIFY(LVN_BEGINLABELEDIT, IDC_SUBRESYNCLIST, OnBeginlabeleditList)
  549. ON_NOTIFY(LVN_DOLABELEDIT, IDC_SUBRESYNCLIST, OnDolabeleditList)
  550. ON_NOTIFY(LVN_ENDLABELEDIT, IDC_SUBRESYNCLIST, OnEndlabeleditList)
  551. ON_NOTIFY(NM_RCLICK, IDC_SUBRESYNCLIST, OnRclickList)
  552. ON_NOTIFY(NM_DBLCLK, IDC_SUBRESYNCLIST, OnNMDblclkList)
  553. ON_NOTIFY(LVN_KEYDOWN, IDC_SUBRESYNCLIST, OnLvnKeydownList)
  554. ON_NOTIFY(NM_CUSTOMDRAW, IDC_SUBRESYNCLIST, OnCustomdrawList)
  555. END_MESSAGE_MAP()
  558. // CPlayerSubresyncBar message handlers
  560. void CPlayerSubresyncBar::OnSize(UINT nType, int cx, int cy)
  561. {
  562. CSizingControlBarG::OnSize(nType, cx, cy);
  564. if(::IsWindow(m_list.m_hWnd))
  565. {
  566. CRect r;
  567. GetClientRect(r);
  568. r.DeflateRect(2, 2);
  569. m_list.MoveWindow(r);
  570. }
  571. }
  573. static bool ParseTime(CString str, int& ret, bool fWarn = true)
  574. {
  575. int sign = 1, h, m, s, ms;
  576. TCHAR c;
  578. str.Trim();
  579. if(str.GetLength() > 0 && str[0] == '-') sign = -1;
  581. int n = _stscanf(str, _T("%d%c%d%c%d%c%d"), &h, &c, &m, &c, &s, &c, &ms);
  583. h = abs(h);
  585. if(n == 7
  586. && 0 <= h && h < 24 
  587. && 0 <= m && m < 60 
  588. && 0 <= s && s < 60 
  589. && 0 <= ms && ms < 1000)
  590. {
  591. ret = sign*(h*60*60*1000+m*60*1000+s*1000+ms);
  592. return(true);
  593. }
  595. if(fWarn) AfxMessageBox(_T("The correct time format is [-]hh:mm:ss.msn(e.g. 01:23:45.678)"));
  596. return(false);
  597. }
  599. void CPlayerSubresyncBar::OnBeginlabeleditList(NMHDR* pNMHDR, LRESULT* pResult) 
  600. {
  601. LV_DISPINFO* pDispInfo = (LV_DISPINFO*)pNMHDR;
  602. LV_ITEM* pItem = &pDispInfo->item;
  604. *pResult = FALSE;
  606. if(pItem->iItem >= 0)
  607. {
  608. if((pItem->iSubItem == COL_START || pItem->iSubItem == COL_END || pItem->iSubItem == COL_TEXT
  609. || pItem->iSubItem == COL_STYLE || pItem->iSubItem == COL_LAYER
  610. || pItem->iSubItem == COL_ACTOR || pItem->iSubItem == COL_EFFECT) 
  611. && m_mode == TEXTSUB)
  612. {
  613. *pResult = TRUE;
  614. }
  615. else if((pItem->iSubItem == COL_START) 
  616. && m_mode == VOBSUB)
  617. {
  618. *pResult = TRUE;
  619. }
  620. }
  621. }
  623. void CPlayerSubresyncBar::OnDolabeleditList(NMHDR* pNMHDR, LRESULT* pResult) 
  624. {
  625. LV_DISPINFO* pDispInfo = (LV_DISPINFO*)pNMHDR;
  626. LV_ITEM* pItem = &pDispInfo->item;
  628. *pResult = FALSE;
  630. if(pItem->iItem >= 0)
  631. {
  632. if((pItem->iSubItem == COL_START || pItem->iSubItem == COL_END || pItem->iSubItem == COL_TEXT
  633. || pItem->iSubItem == COL_STYLE || pItem->iSubItem == COL_LAYER
  634. || pItem->iSubItem == COL_ACTOR || pItem->iSubItem == COL_EFFECT)
  635. && m_mode == TEXTSUB)
  636. {
  637. m_list.ShowInPlaceEdit(pItem->iItem, pItem->iSubItem);
  638. *pResult = TRUE;
  639. }
  640. else if((pItem->iSubItem == COL_START)
  641. && m_mode == VOBSUB)
  642. {
  643. m_list.ShowInPlaceEdit(pItem->iItem, pItem->iSubItem);
  644. *pResult = TRUE;
  645. }
  646. }
  647. }
  649. void CPlayerSubresyncBar::OnEndlabeleditList(NMHDR* pNMHDR, LRESULT* pResult) 
  650. {
  651. LV_DISPINFO* pDispInfo = (LV_DISPINFO*)pNMHDR;
  652. LV_ITEM* pItem = &pDispInfo->item;
  654. *pResult = FALSE;
  656. if(!m_list.m_fInPlaceDirty)
  657. return;
  659. bool fNeedsUpdate = false;
  661. if(pItem->iItem >= 0 && pItem->pszText && (m_mode == VOBSUB || m_mode == TEXTSUB))
  662. {
  663. if(pItem->iSubItem == COL_START)
  664. {
  665. int t;
  666. if(ParseTime(pItem->pszText, t))
  667. {
  668. fNeedsUpdate = ModStart(pItem->iItem, t);
  670. *pResult = TRUE;
  671. }
  672. }
  673. else if(pItem->iSubItem == COL_END && m_mode == TEXTSUB)
  674. {
  675. int t;
  676. if(ParseTime(pItem->pszText, t))
  677. {
  678. fNeedsUpdate = ModEnd(pItem->iItem, t);
  680. *pResult = TRUE;
  681. }
  682. }
  683. else if(pItem->iSubItem == COL_TEXT && m_mode == TEXTSUB)
  684. {
  685. CString str = m_sts.GetStr(pItem->iItem, true);
  687. if(str != pItem->pszText) 
  688. {
  689. fNeedsUpdate = true;
  690. m_sts.SetStr(pItem->iItem, CString(pItem->pszText), true);
  691. m_list.SetItemText(pItem->iItem, pItem->iSubItem, m_sts.GetStr(pItem->iItem, true));
  692. }
  693. }
  694. else if(pItem->iSubItem == COL_STYLE && m_mode == TEXTSUB)
  695. {
  696. CString str(pItem->pszText);
  697. str.Trim();
  699. if(!str.IsEmpty() && m_sts[pItem->iItem].style != str) 
  700. {
  701. fNeedsUpdate = true;
  703. void* val;
  704. if(!m_sts.m_styles.Lookup(str, val))
  705. m_sts.AddStyle(str, new STSStyle());
  707. m_sts[pItem->iItem].style = str;
  709. m_list.SetItemText(pItem->iItem, pItem->iSubItem, pItem->pszText);
  710. }
  711. }
  712. else if(pItem->iSubItem == COL_LAYER && m_mode == TEXTSUB)
  713. {
  714. int l;
  715. if(_stscanf(pItem->pszText, _T("%d"), &l) == 1)
  716. {
  717. fNeedsUpdate = true;
  718. m_sts[pItem->iItem].layer = l;
  719. CString str;
  720. str.Format(_T("%d"), l);
  721. m_list.SetItemText(pItem->iItem, pItem->iSubItem, str);
  722. }
  723. }
  724. else if(pItem->iSubItem == COL_ACTOR && m_mode == TEXTSUB)
  725. {
  726. CString str(pItem->pszText);
  727. str.Trim();
  728. if(!str.IsEmpty())
  729. {
  730. fNeedsUpdate = true;
  731. m_sts[pItem->iItem].actor = str;
  732. m_list.SetItemText(pItem->iItem, pItem->iSubItem, str);
  733. }
  734. }
  735. else if(pItem->iSubItem == COL_EFFECT && m_mode == TEXTSUB)
  736. {
  737. CString str(pItem->pszText);
  738. str.Trim();
  739. if(!str.IsEmpty())
  740. {
  741. fNeedsUpdate = true;
  742. m_sts[pItem->iItem].effect = str;
  743. m_list.SetItemText(pItem->iItem, pItem->iSubItem, str);
  744. }
  745. }
  746. }
  748. if(fNeedsUpdate)
  749. {
  750. UpdatePreview();
  751. }
  752. }
  754. static int uintcomp(const void* i1, const void* i2)
  755. {
  756. return(*((UINT*)i2) - *((UINT*)i1));
  757. }
  759. void CPlayerSubresyncBar::OnRclickList(NMHDR* pNMHDR, LRESULT* pResult) 
  760. {
  761. LPNMLISTVIEW lpnmlv = (LPNMLISTVIEW)pNMHDR;
  763. if(lpnmlv->iItem >= 0 && lpnmlv->iSubItem >= 0)
  764. {
  765. enum 
  766. {
  767. TOGSEP=1, 
  768. DUPITEM, DELITEM, 
  769. RESETS, SETOS, SETCS, RESETE, SETOE, SETCE,
  770. STYLEFIRST, STYLELAST=STYLEFIRST+1000, STYLEEDIT,
  771. UNICODEYES, UNICODENO,
  772. LAYERDEC, LAYERINC,
  773. ACTORFIRST, ACTORLAST=ACTORFIRST+1000,
  774. EFFECTFIRST, EFFECTLAST=EFFECTFIRST+1000
  775. };
  777. CStringArray styles;
  778. CStringArray actors;
  779. CStringArray effects;
  781. CMenu m;
  782. m.CreatePopupMenu();
  784. if(m_mode == VOBSUB || m_mode == TEXTSUB)
  785. {
  786. m.AppendMenu(MF_STRING|MF_ENABLED, TOGSEP, ResStr(IDS_SUBRESYNC_SEPARATOR));
  787. m.AppendMenu(MF_SEPARATOR);
  788. if(m_mode == TEXTSUB) m.AppendMenu(MF_STRING|MF_ENABLED, DUPITEM, ResStr(IDS_SUBRESYNC_DUPLICATE));
  789. m.AppendMenu(MF_STRING|MF_ENABLED, DELITEM, ResStr(IDS_SUBRESYNC_DELETE));
  790. }
  792. if(lpnmlv->iSubItem == COL_START && (m_mode == VOBSUB || m_mode == TEXTSUB))
  793. {
  794. m.AppendMenu(MF_SEPARATOR);
  795. m.AppendMenu(MF_STRING|MF_ENABLED, RESETS, ResStr(IDS_SUBRESYNC_RESET));
  796. m.AppendMenu(MF_STRING|MF_ENABLED, SETOS, ResStr(IDS_SUBRESYNC_ORIGINAL));
  797. m.AppendMenu(MF_STRING|MF_ENABLED, SETCS, ResStr(IDS_SUBRESYNC_CURRENT));
  798. }
  799. else if(lpnmlv->iSubItem == COL_END && m_mode == TEXTSUB)
  800. {
  801. m.AppendMenu(MF_SEPARATOR);
  802. m.AppendMenu(MF_STRING|MF_ENABLED, RESETE, ResStr(IDS_SUBRESYNC_RESET));
  803. m.AppendMenu(MF_STRING|MF_ENABLED, SETOE, ResStr(IDS_SUBRESYNC_ORIGINAL));
  804. m.AppendMenu(MF_STRING|MF_ENABLED, SETCE, ResStr(IDS_SUBRESYNC_CURRENT));
  805. }
  806. else if(lpnmlv->iSubItem == COL_STYLE && m_mode == TEXTSUB)
  807. {
  808. m.AppendMenu(MF_SEPARATOR);
  810. int id = STYLEFIRST;
  812. POSITION pos = m_sts.m_styles.GetStartPosition();
  813. while(pos && id <= STYLELAST)
  814. {
  815. CString key;
  816. void* val;
  817. m_sts.m_styles.GetNextAssoc(pos, key, val);
  819. styles.Add(key);
  821. m.AppendMenu(MF_STRING|MF_ENABLED, id++, key);
  822. }
  824. if(id > STYLEFIRST && m_list.GetSelectedCount() == 1)
  825. {
  826. m.AppendMenu(MF_SEPARATOR);
  827. m.AppendMenu(MF_STRING|MF_ENABLED, STYLEEDIT, ResStr(IDS_SUBRESYNC_EDIT));
  828. }
  829. }
  830. else if(lpnmlv->iSubItem == COL_UNICODE && m_mode == TEXTSUB)
  831. {
  832. m.AppendMenu(MF_SEPARATOR);
  833. m.AppendMenu(MF_STRING|MF_ENABLED, UNICODEYES, ResStr(IDS_SUBRESYNC_YES));
  834. m.AppendMenu(MF_STRING|MF_ENABLED, UNICODENO, ResStr(IDS_SUBRESYNC_NO));
  835. }
  836.   else if(lpnmlv->iSubItem == COL_LAYER && m_mode == TEXTSUB)
  837. {
  838. m.AppendMenu(MF_SEPARATOR);
  839. m.AppendMenu(MF_STRING|MF_ENABLED, LAYERDEC, ResStr(IDS_SUBRESYNC_DECREASE));
  840. m.AppendMenu(MF_STRING|MF_ENABLED, LAYERINC, ResStr(IDS_SUBRESYNC_INCREASE));
  841. }
  842. else if(lpnmlv->iSubItem == COL_ACTOR && m_mode == TEXTSUB)
  843. {
  844. CMapStringToPtr actormap;
  846. for(int i = 0, j = m_sts.GetSize(); i < j; i++)
  847. actormap[m_sts[i].actor] = NULL;
  849. actormap.RemoveKey(_T(""));
  851. if(actormap.GetCount() > 0)
  852. {
  853. m.AppendMenu(MF_SEPARATOR);
  855. int id = ACTORFIRST;
  857. POSITION pos = actormap.GetStartPosition();
  858. while(pos && id <= ACTORLAST)
  859. {
  860. CString key;
  861. void* val;
  862. actormap.GetNextAssoc(pos, key, val);
  864. actors.Add(key);
  866. m.AppendMenu(MF_STRING|MF_ENABLED, id++, key);
  867. }
  868. }
  869. }
  870. else if(lpnmlv->iSubItem == COL_EFFECT && m_mode == TEXTSUB)
  871. {
  872. CMapStringToPtr effectmap;
  874. for(int i = 0, j = m_sts.GetSize(); i < j; i++)
  875. effectmap[m_sts[i].effect] = NULL;
  877. effectmap.RemoveKey(_T(""));
  879. if(effectmap.GetCount() > 0)
  880. {
  881. m.AppendMenu(MF_SEPARATOR);
  883. int id = EFFECTFIRST;
  885. POSITION pos = effectmap.GetStartPosition();
  886. while(pos && id <= EFFECTLAST)
  887. {
  888. CString key;
  889. void* val;
  890. effectmap.GetNextAssoc(pos, key, val);
  892. effects.Add(key);
  894. m.AppendMenu(MF_STRING|MF_ENABLED, id++, key);
  895. }
  896. }
  897. }
  899. CPoint p = lpnmlv->ptAction;
  900. ::MapWindowPoints(pNMHDR->hwndFrom, HWND_DESKTOP, &p, 1);
  902. UINT id = m.TrackPopupMenu(TPM_LEFTBUTTON|TPM_RETURNCMD, p.x, p.y, this);
  904. bool fNeedsUpdate = false;
  906. POSITION pos = m_list.GetFirstSelectedItemPosition();
  907. while(pos)
  908. {
  909. int iItem = m_list.GetNextSelectedItem(pos);
  911. SubTime& st = m_subtimes[iItem];
  913. switch(id)
  914. {
  915. case TOGSEP: 
  916. m_list.SetItemData(iItem, m_list.GetItemData(iItem)^TSEP); 
  917. m_list.Invalidate(); 
  918. fNeedsUpdate = true; 
  919. break;
  920. case DUPITEM:
  921. {
  922. CUIntArray items;
  923. pos = m_list.GetFirstSelectedItemPosition();
  924. while(pos) items.Add(m_list.GetNextSelectedItem(pos));
  926. qsort(items.GetData(), items.GetSize(), sizeof(UINT), uintcomp);
  928. for(int i = 0; i < items.GetSize(); i++)
  929. {
  930. iItem = items[i];
  932. STSEntry stse = m_sts[iItem];
  933. m_sts.InsertAt(iItem+1, stse);
  935. SubTime st = m_subtimes[iItem];
  936. m_subtimes.InsertAt(iItem+1, st);
  938. CHeaderCtrl* pHeader = (CHeaderCtrl*)m_list.GetDlgItem(0);
  939. int nColumnCount = pHeader->GetItemCount();
  941. CStringArray sa;
  942. sa.SetSize(nColumnCount);
  943. for(int col = 0; col < nColumnCount; col++)
  944. sa[col] = m_list.GetItemText(iItem, col);
  946. DWORD data = m_list.GetItemData(iItem);
  947. m_list.InsertItem(iItem+1, sa[0]);
  948. m_list.SetItemData(iItem+1, data);
  949. for(int col = 1; col < nColumnCount; col++)
  950. m_list.SetItemText(iItem+1, col, sa[col]);
  951. }
  952. }
  954. fNeedsUpdate = true; 
  955. break;
  956. case DELITEM:
  957. {
  958. CUIntArray items;
  959. pos = m_list.GetFirstSelectedItemPosition();
  960. while(pos) items.Add(m_list.GetNextSelectedItem(pos));
  962. qsort(items.GetData(), items.GetSize(), sizeof(UINT), uintcomp);
  964. for(int i = 0; i < items.GetSize(); i++)
  965. {
  966. iItem = items[i];
  967. m_sts.RemoveAt(iItem);
  968. m_subtimes.RemoveAt(iItem);
  969. m_list.DeleteItem(iItem);
  970. }
  972. iItem = items[items.GetSize()-1];
  973. if(iItem >= m_list.GetItemCount()) iItem = m_list.GetItemCount()-1;
  975. m_list.SetSelectionMark(iItem);
  976. }
  977. fNeedsUpdate = true; 
  978. break;
  979. case RESETS: /*if(*/ModStart(iItem, st.orgstart, true);/*)*/ fNeedsUpdate = true; break;
  980. case SETOS: /*if(*/ModStart(iItem, st.orgstart);/*)*/ fNeedsUpdate = true; break;
  981. case SETCS: /*if(*/ModStart(iItem, (int)(m_rt/10000));/*)*/ fNeedsUpdate = true; break;
  982. case RESETE: /*if(*/ModEnd(iItem, st.orgend, true);/*)*/ fNeedsUpdate = true; break;
  983. case SETOE: /*if(*/ModEnd(iItem, st.orgend);/*)*/ fNeedsUpdate = true; break;
  984. case SETCE: /*if(*/ModEnd(iItem, (int)(m_rt/10000));/*)*/ fNeedsUpdate = true; break;
  985. default: 
  986. if(STYLEFIRST <= id && id <= STYLELAST)
  987. {
  988. CString s = styles[id - STYLEFIRST];
  989. if(m_sts[iItem].style != s) fNeedsUpdate = true;
  990. m_sts[iItem].style = s;
  991. m_list.SetItemText(iItem, lpnmlv->iSubItem, s);
  992. }
  993. else if(id == STYLEEDIT)
  994. {
  995. CAutoPtrArray<CPPageSubStyle> pages;
  996. CArray<STSStyle*> styles;
  998. STSStyle* stss = m_sts.GetStyle(iItem);
  999. int iSelPage = 0;
  1001. POSITION pos = m_sts.m_styles.GetStartPosition();
  1002. for(int i = 0; pos; i++)
  1003. {
  1004. CString key;
  1005. void* val;
  1006. m_sts.m_styles.GetNextAssoc(pos, key, val);
  1008. CAutoPtr<CPPageSubStyle> page(new CPPageSubStyle());
  1009. page->InitStyle(key, *(STSStyle*)val);
  1010. pages.Add(page);
  1011. styles.Add((STSStyle*)val);
  1013. if(stss == (STSStyle*)val) 
  1014. iSelPage = i;
  1015. }
  1017. CPropertySheet dlg(_T("Styles..."), this, iSelPage);
  1018. for(int i = 0; i < (int)pages.GetCount(); i++) dlg.AddPage(pages[i]);
  1020. if(dlg.DoModal() == IDOK)
  1021. {
  1022. for(int j = 0; j < (int)pages.GetCount(); j++)
  1023. {
  1024. stss = styles[j];
  1025. pages[j]->GetStyle(*stss);
  1027. for(int i = 0; i < m_sts.GetSize(); i++)
  1028. {
  1029. if(m_sts.GetStyle(i) == stss)
  1030. {
  1031. CString str;
  1032. m_list.SetItemText(i, COL_TEXT, m_sts.GetStr(i, true));
  1033. m_list.SetItemText(i, COL_FONT, stss->fontName);
  1034. str.Format(_T("%d"), stss->charSet);
  1035. m_list.SetItemText(i, COL_CHARSET, str);
  1036. str.Format(_T("%d"), m_sts[i].layer);
  1037. }
  1038. }
  1039. }
  1041. fNeedsUpdate = true;
  1042. }
  1043. }
  1044. else if(id == UNICODEYES || id == UNICODENO)
  1045. {
  1046. m_sts.ConvertUnicode(iItem, id == UNICODEYES);
  1047. m_list.SetItemText(iItem, COL_TEXT, m_sts.GetStr(iItem, true));
  1048. m_list.SetItemText(iItem, COL_UNICODE, m_sts.IsEntryUnicode(iItem) ? _T("yes") : _T("no"));
  1049. fNeedsUpdate = true;
  1050. }
  1051. else if(id == LAYERDEC || id == LAYERINC)
  1052. {
  1053. int d = (id == LAYERDEC) ? -1 : (id == LAYERINC) ? +1 : 0;
  1054. if(d != 0) fNeedsUpdate = true;
  1055. m_sts[iItem].layer += d;
  1056. CString s;
  1057. s.Format(_T("%d"), m_sts[iItem].layer);
  1058. m_list.SetItemText(iItem, lpnmlv->iSubItem, s);
  1059. }
  1060. else if(ACTORFIRST <= id && id <= ACTORLAST)
  1061. {
  1062. CString s = actors[id - ACTORFIRST];
  1063. if(m_sts[iItem].actor != s) fNeedsUpdate = true;
  1064. m_sts[iItem].actor = s;
  1065. m_list.SetItemText(iItem, lpnmlv->iSubItem, s);
  1066. }
  1067. else if(EFFECTFIRST <= id && id <= EFFECTLAST)
  1068. {
  1069. CString s = effects[id - EFFECTFIRST];
  1070. if(m_sts[iItem].effect != s) fNeedsUpdate = true;
  1071. m_sts[iItem].effect = s;
  1072. m_list.SetItemText(iItem, lpnmlv->iSubItem, s);
  1073. }
  1074. break;
  1075. }
  1076. }
  1078. if(fNeedsUpdate) 
  1079. {
  1080. UpdatePreview();
  1081. }
  1082. }
  1084. *pResult = 0;
  1085. }
  1087. void CPlayerSubresyncBar::OnNMDblclkList(NMHDR* pNMHDR, LRESULT* pResult)
  1088. {
  1089. LPNMLISTVIEW lpnmlv = (LPNMLISTVIEW)pNMHDR;
  1091. if(lpnmlv->iItem >= 0 && lpnmlv->iSubItem >= 0 && (m_mode == VOBSUB || m_mode == TEXTSUB))
  1092. {
  1093. if(CMainFrame* pFrame = (CMainFrame*)AfxGetMainWnd())
  1094. {
  1095. int t = 0;
  1096. if(!ParseTime(m_list.GetItemText(lpnmlv->iItem, lpnmlv->iSubItem), t, false))
  1097. t = m_sts[lpnmlv->iItem].start;
  1099. REFERENCE_TIME rt = 
  1100. lpnmlv->iSubItem == COL_START ? ((REFERENCE_TIME)t*10000) : 
  1101. lpnmlv->iSubItem == COL_END ? ((REFERENCE_TIME)t*10000) : 
  1102. lpnmlv->iSubItem == COL_PREVSTART ? ((REFERENCE_TIME)t*10000) : 
  1103. lpnmlv->iSubItem == COL_PREVEND ? ((REFERENCE_TIME)t*10000) : 
  1104. ((REFERENCE_TIME)t*10000);
  1106. pFrame->SeekTo(rt);
  1107. }
  1108. }
  1110. *pResult = 0;
  1111. }
  1113. void CPlayerSubresyncBar::OnLvnKeydownList(NMHDR* pNMHDR, LRESULT* pResult)
  1114. {
  1115. LPNMLVKEYDOWN pLVKeyDown = reinterpret_cast<LPNMLVKEYDOWN>(pNMHDR);
  1117. *pResult = 0;
  1118. }
  1120. static CUIntArray m_itemGroups;
  1121. static int m_totalGroups;
  1123. void CPlayerSubresyncBar::OnCustomdrawList(NMHDR* pNMHDR, LRESULT* pResult)
  1124. {
  1125. NMLVCUSTOMDRAW* pLVCD = reinterpret_cast<NMLVCUSTOMDRAW*>(pNMHDR);
  1127. *pResult = CDRF_DODEFAULT;
  1129. if(CDDS_PREPAINT == pLVCD->nmcd.dwDrawStage)
  1130. {
  1131. m_itemGroups.SetSize(m_list.GetItemCount());
  1132. m_totalGroups = 0;
  1133. for(int i = 0, j = m_list.GetItemCount(); i < j; i++)
  1134. {
  1135. if(m_list.GetItemData(i)&TSEP) m_totalGroups++;
  1136. m_itemGroups[i] = m_totalGroups;
  1137. }
  1139. *pResult = CDRF_NOTIFYPOSTPAINT|CDRF_NOTIFYITEMDRAW;
  1140. }
  1141. else if(CDDS_ITEMPREPAINT == pLVCD->nmcd.dwDrawStage)
  1142. {
  1143. pLVCD->nmcd.uItemState &= ~CDIS_FOCUS;
  1145. *pResult = CDRF_NOTIFYPOSTPAINT|CDRF_NOTIFYSUBITEMDRAW;
  1146. }
  1147. else if((CDDS_ITEMPREPAINT|CDDS_SUBITEM) == pLVCD->nmcd.dwDrawStage)
  1148. {
  1149. COLORREF clrText;
  1150. COLORREF clrTextBk;
  1152. if((pLVCD->iSubItem == COL_START || pLVCD->iSubItem == COL_END || pLVCD->iSubItem == COL_TEXT || pLVCD->iSubItem == COL_STYLE
  1153. || pLVCD->iSubItem == COL_LAYER || pLVCD->iSubItem == COL_ACTOR || pLVCD->iSubItem == COL_EFFECT)
  1154. && m_mode == TEXTSUB)
  1155. {
  1156. clrText = 0;
  1157. }
  1158. else if((pLVCD->iSubItem == COL_START)
  1159. && m_mode == VOBSUB)
  1160. {
  1161. clrText = 0;
  1162. }
  1163. else
  1164. {
  1165. clrText = 0x606060;
  1166. }
  1168. clrTextBk = 0xffffff;
  1169. // if(m_totalGroups > 0)
  1170. clrTextBk -= ((m_itemGroups[pLVCD->nmcd.dwItemSpec]&1) ? 0x100010 : 0x200020);
  1172. if(m_sts[pLVCD->nmcd.dwItemSpec].start <= m_rt/10000 && m_rt/10000 < m_sts[pLVCD->nmcd.dwItemSpec].end)
  1173. {
  1174. clrText |= 0xFF;
  1175. }
  1177. int nCheck = (int)m_list.GetItemData(pLVCD->nmcd.dwItemSpec);
  1179. if((nCheck&1) && (pLVCD->iSubItem == COL_START || pLVCD->iSubItem == COL_PREVSTART))
  1180. {
  1181. clrTextBk = 0xffddbb;
  1182. }
  1183. else if((nCheck&4) && (/*pLVCD->iSubItem == COL_START ||*/ pLVCD->iSubItem == COL_PREVSTART))
  1184. {
  1185. clrTextBk = 0xffeedd;
  1186. }
  1188. if((nCheck&2) && (pLVCD->iSubItem == COL_END || pLVCD->iSubItem == COL_PREVEND))
  1189. {
  1190. clrTextBk = 0xffddbb;
  1191. }
  1192. else if((nCheck&8) && (/*pLVCD->iSubItem == COL_END ||*/ pLVCD->iSubItem == COL_PREVEND))
  1193. {
  1194. clrTextBk = 0xffeedd;
  1195. }
  1197. pLVCD->clrText = clrText;
  1198. pLVCD->clrTextBk = clrTextBk;
  1200. *pResult = CDRF_NOTIFYPOSTPAINT;
  1201. }
  1202. else if((CDDS_ITEMPOSTPAINT|CDDS_SUBITEM) == pLVCD->nmcd.dwDrawStage)
  1203. {
  1204. // *pResult = CDRF_DODEFAULT;
  1205. }
  1206. else if(CDDS_ITEMPOSTPAINT == pLVCD->nmcd.dwDrawStage)
  1207. {
  1208.         int nItem = static_cast<int>(pLVCD->nmcd.dwItemSpec);
  1210. LVITEM rItem;
  1211.         ZeroMemory(&rItem, sizeof(LVITEM));
  1212.         rItem.mask  = LVIF_IMAGE | LVIF_STATE;
  1213.         rItem.iItem = nItem;
  1214.         rItem.stateMask = LVIS_SELECTED;
  1215.         m_list.GetItem(&rItem);
  1217. {
  1218.             CDC* pDC = CDC::FromHandle(pLVCD->nmcd.hdc);
  1220. CRect rcItem;
  1221.             m_list.GetItemRect(nItem, &rcItem, LVIR_BOUNDS);
  1223. {
  1224. bool fSeparator = nItem < m_list.GetItemCount()-1 && (m_list.GetItemData(nItem+1)&TSEP);
  1225. CPen p(PS_INSIDEFRAME, 1, fSeparator ? 0x404040 : 0xe0e0e0);
  1226. CPen* old = pDC->SelectObject(&p);
  1227. pDC->MoveTo(CPoint(rcItem.left, rcItem.bottom-1));
  1228. pDC->LineTo(CPoint(rcItem.right, rcItem.bottom-1));
  1229. pDC->SelectObject(old);
  1230. }
  1232. {
  1233. CPen p(PS_INSIDEFRAME, 1, 0xe0e0e0);
  1234. CPen* old = pDC->SelectObject(&p);
  1236. CHeaderCtrl* pHeader = (CHeaderCtrl*)m_list.GetDlgItem(0);
  1237. int nColumnCount = pHeader->GetItemCount();
  1239. // Get the column offset
  1240. int offset = rcItem.left;
  1241. for(int i = 0; i < nColumnCount; i++)
  1242. {
  1243. offset += m_list.GetColumnWidth(i);
  1244. pDC->MoveTo(CPoint(offset, rcItem.top));
  1245. pDC->LineTo(CPoint(offset, rcItem.bottom));
  1246. }
  1248. pDC->SelectObject(old);
  1249. }
  1251.             *pResult = CDRF_SKIPDEFAULT;
  1252.         }
  1253. }
  1254. else if(CDDS_POSTPAINT == pLVCD->nmcd.dwDrawStage)
  1255. {
  1256. }
  1257. }