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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
RealTime.cpp
资源名称：realtime.rar　[点击查看]
上传用户：mgf822
上传日期：2013-10-03
资源大小：133k
文件大小：15k
源码类别：

对话框与窗口

开发平台：

Visual C++

RealTime.cpp：源码内容
  1. #include "stdafx.h"
  2. //#include <windows.h>
  3. //#include <stdio.h>
  4. #include "RealTime.h"
  6. CALine::CALine()
  7. { 
  8. m_nColor = RGB(0, 0, 0);
  9. m_nLineStyle = PS_SOLID;
  10. m_nLineWidth = 0;
  11. m_pValues = NULL;
  12. m_sName = "";
  13. m_sDescription = "";
  14. m_sUnit = "";
  15. m_dMin = 0;
  16. m_dMax = 0;
  17. m_dScaleLow = 0;
  18. m_dScaleHigh = 0;
  19. m_nSize = 0; 
  20. }
  22. bool CALine::Reset(DWORD size)
  23. {
  24. assert(size > 0);
  25. if (m_pValues) free(m_pValues);
  26. m_pValues  = (CValue*)calloc((size_t)(size + 1), sizeof(CValue));
  27. if(!m_pValues) 
  28. return false;
  30. m_nSize = size;
  31. return true;
  32. }
  34. void CALine::AddValue(double& value, DWORD begin, DWORD end)
  35. {
  36. if (m_pValues == NULL) return;
  37. if (end == m_nSize)
  38. {
  39. m_pValues[begin].bFlag = 1;
  40. m_pValues[begin].YValue = value;
  41. }
  42. else
  43. {
  44. m_pValues[end].bFlag = 1;
  45. m_pValues[end].YValue = value;
  46. }
  47. }
  49. CRealTime::CRealTime()
  50. {
  51. m_bSetingFailed = true;
  52. m_nMaxPages = 1;
  53. m_nTimeStart = 0;
  54. m_nBegin = 0;
  55. m_nEnd = 0;
  56. m_nTimes = 0;
  57. m_nCounter = 1;
  58. m_nTick = 0;
  59. m_sHigh = 17;
  60. m_nPage = 0;
  61. m_nMaxTime = 0;
  62. m_nCursorTime = 0;
  63. m_pValueTime = NULL;
  64. m_pLineArray = NULL;
  65. m_pCurLine = NULL;
  66. m_wdTickLine = 2;
  67. m_crTickLine = RGB(255, 0, 0);
  69. m_SpeedLevel[0] = 10000;// 10 seconds (0.1 cycle per second)
  70. m_SpeedLevel[1] = 5000; // 5 seconds (0.2 cycle per second)
  71. m_SpeedLevel[2] = 2500; // 2.5 seconds (0.4 cycle per second)
  72. m_SpeedLevel[3] = 2000; // 2 seconds (0.5 cycle per second)
  73. m_SpeedLevel[4] = 1000; // 1 seconds (1 cycle per second)
  74. m_SpeedLevel[5] = 500; // 0.5 seconds (2 cycle per second)
  75. m_SpeedLevel[6] = 250; // 0.4 seconds (4 cycle per second)
  76. m_SpeedLevel[7] = 200; // 0.2 seconds (5 cycle per second)
  77. m_SpeedLevel[8] = 125; // 0.125 seconds(8 cycle per second)
  78. m_SpeedLevel[9] = 100;  // 0.1 second (10 cycle per second)
  79. m_nSysJS=60000;
  80. }
  82. CRealTime::~CRealTime()
  83. {
  84. if (m_pLineArray)
  85. free(m_pLineArray);
  87. if (m_pValueTime)
  88. free(m_pValueTime);
  90. int n = m_LineArray.GetSize();
  91. for(int i = n-1; i >= 0; i --)
  92. m_LineArray.RemoveAt(i);
  93. }
  95. RECT CRealTime::TickBarSize()
  96. {
  97. m_SRect    = m_PlotRect;
  98. m_SRect.top    = m_SRect.top - m_sHigh;
  99. m_SRect.bottom = m_SRect.top  + m_sHigh - 1;
  100. m_SRect.left   = m_SRect.left - 7;
  101. m_SRect.right  = m_SRect.right + 7;
  103. return m_SRect;
  104. }
  106. bool CRealTime::SetRange(double xmin, double ymin, double xmax, double ymax)
  107. {
  108. if (ymax <= ymin)
  109. return false; 
  111. m_Scale.xmin = xmin;
  112.     m_Scale.ymin = ymin;
  113.     m_Scale.xmax = xmax;
  114.     m_Scale.ymax = ymax;
  115. return true; 
  116. }
  118. bool CRealTime::InitialSetting(double CycsPerSec, DWORD StartTime, DWORD TimeSpan,
  119.    DWORD MaxSeconds, int XTick, bool IsForward)
  120. {
  121. if (!IsForward && 1000 * TimeSpan > StartTime)
  122. {
  123. int ret = MessageBox(NULL, "<1000 * TimeSpan - StartTime> must be positive valuenin initial backward drawing."
  124.  " Changed to foreward drawing?", 
  125.  "From InitialSetting() ...", MB_YESNO);
  126. if (ret == IDYES)
  127. IsForward = true;
  128. else
  129. return false;
  130. }
  132. assert(StartTime >= 0);
  133. assert(TimeSpan >= 30);
  134. assert(TimeSpan >= (DWORD)XTick);
  135. assert(MaxSeconds >= TimeSpan);
  136. MaxSeconds = TimeSpan * (MaxSeconds / TimeSpan);
  137. assert(CycsPerSec >= 0.09999 && CycsPerSec <= 10.00001f);
  139. if (MaxSeconds == TimeSpan ) MaxSeconds ++;
  140. m_nDataPerLine = (DWORD)(0.5 + MaxSeconds * CycsPerSec + 1);
  142. m_pValueTime = (DWORD*)calloc(m_nDataPerLine, sizeof(DWORD));
  143. if (!m_pValueTime) return false;
  145. m_nMaxPages = MaxSeconds / TimeSpan;
  146. m_nTimeSpan = TimeSpan;
  147. m_nXTicks = XTick;
  148. m_nCyclesPerSec = CycsPerSec;
  149. m_nCounter = (int)CycsPerSec;
  150. m_bIsForwardDrawing = IsForward;
  151. m_nSTicks = (int)(0.5 + TimeSpan * CycsPerSec);
  153. if (IsForward)
  154. {
  155. m_Scale.xmin = StartTime;
  156. m_Scale.xmax = StartTime + 1000. * TimeSpan;
  157. }
  158. else
  159. {
  160. m_Scale.xmin = StartTime - 1000. * TimeSpan;
  161. m_Scale.xmax = StartTime;
  162. }
  164. assert(m_Scale.xmin >= 0);
  165. assert(m_Scale.xmax >= 0);
  166. assert(m_Scale.xmax - m_Scale.xmin > 0);
  167. m_TimeToDraw = (DWORD)(0.5 + (m_Scale.xmax - m_Scale.xmin) / 1000 * m_nCyclesPerSec + 1);
  169. m_pLineArray = (POINT*)calloc(m_TimeToDraw, sizeof(POINT));
  170. if (!m_pLineArray)
  171. {
  172. free(m_pValueTime);
  173. return false;
  174. }
  176. m_nMin = (DWORD)m_Scale.xmin;
  177. m_nMax = (DWORD)m_Scale.xmax;
  178. SetTimeRange(m_nMin, m_nMax);
  179. m_bAutoScrollX = true;
  181. EnableLegend(false);
  182. m_bLegendShadow = false;
  184. return true;
  185. }
  187. void CRealTime::SetTimeRange(DWORD FromTime, DWORD ToTime)
  188. {
  189. assert(ToTime - FromTime > 0);
  190. m_Scale.xmin = FromTime;
  191. m_Scale.xmax = ToTime;
  192. m_Scale.dx   = (m_Scale.xmax - m_Scale.xmin) / PX;
  193. }
  195. void CRealTime::Reset()
  196. {
  197. if (m_bAutoScrollX)
  198. SetTimeRange(m_nMin, m_nMax);
  199. else
  200. {
  201. if (m_nEnd == m_nDataPerLine)
  202. m_nFrom = m_nBegin + m_nPage * (m_TimeToDraw - 1);
  203. else
  204. m_nFrom = m_nBegin + m_nPage * (m_TimeToDraw - 1); // -1 ;
  205. m_nFrom %= m_nDataPerLine;
  206. m_nTo    = m_nFrom + m_TimeToDraw - 1;
  207. m_nTo   %= m_nDataPerLine;
  208. SetTimeRange(m_pValueTime[m_nFrom], m_pValueTime[m_nTo]);
  209. }
  210. }
  212. bool CRealTime::AddALine(COLORREF color, double low, double high, 
  213.  const char* name, const char* desc, const char* unit, 
  214.  double min, double max, int style, int width)
  215. {
  216. m_LineArray.Add(m_line);
  217. int n = m_LineArray.GetSize() - 1;
  219. // support only three styles : PS_SOLID, PS_DASH, PS_DOT
  220. if (style < PS_SOLID) style = PS_SOLID;
  221. if (style > PS_DOT) style = PS_DOT;
  223. m_LineArray[n].m_nColor = color;
  224. m_LineArray[n].m_dScaleLow = low;
  225. m_LineArray[n].m_dScaleHigh = high;
  226. m_LineArray[n].m_sName = name;
  227. m_LineArray[n].m_sDescription = desc;
  228. m_LineArray[n].m_sUnit = unit;
  229. m_LineArray[n].m_dMin = min;
  230. m_LineArray[n].m_dMax = max;
  231. m_LineArray[n].m_nLineStyle = style;
  232. m_LineArray[n].m_nLineWidth = width;
  234. if (!m_LineArray[n].Reset(m_nDataPerLine))
  235. {
  236. m_LineArray.RemoveAt(n);
  237. return false;
  238. }
  240. return true;
  241. }
  243. bool CRealTime::InsertALine(int index, COLORREF color, double low, double high, 
  244.  const char* name, const char* desc, const char* unit, 
  245.  double min, double max, int style, int width)
  246. {
  247. int n = m_LineArray.GetSize();
  248. if (index < 0 || index > n)
  249. return false;
  251. m_LineArray.InsertAt(index, m_line);
  253. if (style < PS_SOLID) style = PS_SOLID;
  254. if (style > PS_DOT) style = PS_DOT;
  256. m_LineArray[index].m_nColor = color;
  257. m_LineArray[index].m_dScaleLow = low;
  258. m_LineArray[index].m_dScaleHigh = high;
  259. m_LineArray[index].m_sName = name;
  260. m_LineArray[index].m_sDescription = desc;
  261. m_LineArray[index].m_sUnit = unit;
  262. m_LineArray[index].m_dMin = min;
  263. m_LineArray[index].m_dMax = max;
  264. m_LineArray[index].m_nLineStyle = style;
  265. m_LineArray[index].m_nLineWidth = width;
  267. if (!m_LineArray[index].Reset(m_nDataPerLine))
  268. {
  269. m_LineArray.RemoveAt(index);
  270. return false;
  271. }
  273. return true;
  274. }
  276. bool CRealTime::RemoveALine(int Index)
  277. {
  278. int n = m_LineArray.GetSize();
  279. if (n <= 0 || n <= Index)
  280. return false;
  282. m_LineArray.RemoveAt(Index);
  283. return true;
  284. }
  286. void CRealTime::DrawXAxisTimeTicks(int x, int y, DWORD& ticks)
  287. {
  288. sprintf(m_sTempStr, "%d:%d:%d", ticks/3600, (ticks/60)%60, ticks%60);
  289. PrintString(x, y, 0, m_sTempStr);
  290. }
  292. void CRealTime::XAxis()
  293. {
  294. int j=0,k=6;
  295. m_nStep = (m_TimeToDraw > m_nEnd) ? m_nEnd : m_TimeToDraw;
  296. for(int i = 0; i < m_nStep; i ++) 
  297. {
  298. DWORD sec = (DWORD)(m_Scale.xmin + i * 1000 / m_nCyclesPerSec + 0.5);
  299. xb = xe = (int)(GL + (sec - m_Scale.xmin) / m_Scale.dx);
  300. if ((sec % 1000) == 0 && ((sec / 1000) % (m_nTimeSpan / m_nXTicks)) == 0)
  301. {
  302. j++;
  303. if (i == 0)
  304. SetStringAlign(LEFT, TOP);
  305. else if (i >= m_nStep - (int)m_nCyclesPerSec - 1 && m_TimeToDraw <= m_nEnd)
  306. {
  307. SetStringAlign(RIGHT, TOP);
  308. if(j==7) {
  309. m_nSysJS=m_nSysTime;
  310. k=7;
  311. }
  312. }
  313. else
  314. SetStringAlign(CENTER, TOP);
  316. ye = GB + m_bM / 7;
  317. DWORD ticks = (m_nSysJS-m_nSysJG*5*(k-j)+15) / 1000;
  318. DrawXAxisTimeTicks(xb, GB + m_bM / 5, ticks);
  319. }
  320. else 
  321. ye = GB + m_bM / 14;
  323. yb=GB;
  324. if (!(sec % 1000) && i > 0 && i < m_nStep - 1)
  325. DrawLine(xb, yb, xe, ye);
  326. }
  328. PrintTime();
  329. }
  331. void CRealTime::Grid()
  332. {
  333. HPEN hPen = ::CreatePen(PS_DOT, 0, m_nGridColor);
  334. HPEN hOldPen = (HPEN)::SelectObject(m_hDC, hPen);
  336. m_nStep = (m_TimeToDraw > m_nEnd) ? m_nEnd : m_TimeToDraw;
  337. for(int i = 0; i < m_nStep; i ++) 
  338. {
  339. DWORD sec = (DWORD)(m_Scale.xmin + i * 1000 / m_nCyclesPerSec + 0.5);
  340. xb = xe = (int)(GL + (sec - m_Scale.xmin) / m_Scale.dx);
  341. if (xb == GL)
  342. xb = xe = GL + 1;
  343. if ((sec % 1000) == 0 && ((sec / 1000) % (m_nTimeSpan / m_nXTicks)) == 0)
  344. DrawLine(xb, GT + 1, xe, GB - 1);
  345. }
  347. for(i = 1; i < YGridTicks; i ++) 
  348. {
  349. yb = ye = GT + (int)(1.0 * i * (GB-GT) / YGridTicks);
  350. DrawLine(GL + 1, yb, GR - 1, ye);
  351. }
  353. ::SelectObject(m_hDC, hOldPen);
  354. ::DeleteObject(hPen);
  355. }
  357. void CRealTime::DrawRealTimeLines()
  358. {
  359. int n = m_LineArray.GetSize();
  360. if (m_bLegendShadow)
  361. DrawShadow(n);
  363. for(int i = 0; i < n; i ++)
  364. {
  365. m_pCurLine = &m_LineArray[i];
  366. DrawCurrentLine();
  367. if (m_bEnableLegend)
  368. {
  369. m_CurPen = ::CreatePen(m_pCurLine->m_nLineStyle, m_pCurLine->m_nLineWidth, m_pCurLine->m_nColor);
  370. m_OldPen = (HPEN)::SelectObject(m_hDC, m_CurPen);
  371. CGraphics::Legend(m_pCurLine->m_nColor, i + 1, m_pCurLine->m_sName.GetChar());
  372. ::SelectObject(m_hDC, m_OldPen);
  373. ::DeleteObject(m_CurPen);
  374. }
  375. }
  377. DrawTickLine();
  378. }
  380. void CRealTime::DrawCurrentLine()
  381. {
  382. if (m_nEnd < 2)
  383. return;
  385. m_CurPen = ::CreatePen(m_pCurLine->m_nLineStyle, m_pCurLine->m_nLineWidth, m_pCurLine->m_nColor);
  386. m_OldPen = (HPEN)::SelectObject(m_hDC, m_CurPen);
  388. m_nP = 0;
  389. DWORD nB, nE;
  391. if (m_bAutoScrollX)
  392. {
  393. nB = m_nBegin;
  394. nE = m_nEnd;
  396. // forward drawing: something like "*******------" 
  397. // or "------******------", or "------******"
  398. if (nB == 0 && nE <= m_TimeToDraw)
  399. {
  400. m_nTimeStart = nB;
  401. ForwardDraw(nB, nE);
  402. }
  403. else if (nB == 0 && nE > m_TimeToDraw)
  404. {
  405. nB = nE - m_TimeToDraw;
  406. m_nTimeStart = nB;
  407. ForwardDraw(nB, nE);
  408. }
  409. else if (nB >= m_TimeToDraw)
  410. {
  411. m_nTimeStart = nB - m_TimeToDraw;
  412. ForwardDraw(nB - m_TimeToDraw, nB);
  413. }
  414. // backward drawing: something like "******--------******"
  415. else
  416. {
  417. m_nTimeStart = nE - m_TimeToDraw + nB;
  418. BackwardDraw(nB, nE);
  419. }
  420. }
  421. else
  422. {
  423. nB = m_nFrom;
  424. nE = m_nTo + 1;
  425. if (nB <= m_nDataPerLine - m_TimeToDraw)
  426. {
  427. ForwardDraw(nB, nE);
  428. }
  429. else
  430. {
  431. ForwardDraw(nB, m_nDataPerLine);
  432. ForwardDraw(0, nE);
  433. }
  434. }
  436. if(m_nP > 1)
  437. ::Polyline(m_hDC, m_pLineArray, m_nP);
  439. ::SelectObject(m_hDC, m_OldPen);
  440. ::DeleteObject(m_CurPen);
  441. }
  443. int CRealTime::ForwardDraw(int nB, int nE)
  444. {
  445. for(int i = nB; i < nE; i ++)
  446. {
  447. if (m_pCurLine->m_pValues[i].bFlag)
  448. {
  449. m_Pt.x = (int)(GL + ((m_pValueTime[i] - m_Scale.xmin) / m_Scale.dx));
  450. m_Pt.y = (int)(GB - ((m_pCurLine->m_pValues[i].YValue - m_Scale.ymin) / m_Scale.dy));
  451. if(m_Pt.x >= GL && m_Pt.x <= GR)
  452. {
  453. assert(m_nP<m_nDataPerLine);
  454. m_pLineArray[m_nP].x = m_Pt.x;
  455. m_pLineArray[m_nP].y = m_Pt.y;
  456. m_nP++;
  457. }
  458. else // something wrong
  459. assert(false);
  460. }
  461. }
  463. return m_nP;
  464. }
  466. int CRealTime::BackwardDraw(int nB, int nE)
  467. {
  468. //-----------------------------******
  469. ForwardDraw(nE - m_TimeToDraw + nB, nE);
  470. nE = nB;
  471. nB = 0;
  472. //******-----------------------------
  473. ForwardDraw(nB, nE);
  475. return m_nP;
  476. }
  478. void CRealTime::UpdateTimeRange(DWORD& vtime)
  479. {
  480. if ((int)m_nCyclesPerSec == 0)
  481. m_nTimes += (int)(0.5 + 1 / m_nCyclesPerSec);
  482. else
  483. {
  484. if (m_nCounter == (int)m_nCyclesPerSec)
  485. {
  486. m_nTimes ++;
  487. m_nCounter = 1;
  488. }
  489. else
  490. m_nCounter ++;
  491. }
  493. if (m_nEnd == m_nDataPerLine)
  494. {
  495. if (m_nBegin == m_nDataPerLine) m_nBegin = 0;
  496. m_pValueTime[m_nBegin++] = vtime;
  497. }
  498. else
  499. m_pValueTime[m_nEnd++] = vtime;
  501. if (vtime > (DWORD)m_Scale.xmax)
  502. {
  503. DWORD span  = (DWORD)(m_Scale.xmax - m_Scale.xmin);
  504. m_nMin = vtime - span; 
  505. m_nMax = vtime;
  506. }
  508. if(m_bAutoScrollX)
  509. SetTimeRange(m_nMin, m_nMax);
  510. else
  511. {
  512. m_nFrom ++; 
  513. m_nTo ++;
  515. if (m_nFrom == m_nDataPerLine)
  516. m_nFrom = 0;
  517. if (m_nTo == m_nDataPerLine)
  518. m_nTo = 0;
  520. SetTimeRange(m_pValueTime[m_nFrom], m_pValueTime[m_nTo]);
  521. }
  522. }
  524. DWORD CRealTime::GetCursorTime()
  525. {
  526. DWORD time;
  527. if (m_bAutoScrollX)
  528. {
  529. if (m_nEnd < (int)m_TimeToDraw) 
  530. {
  531. time = m_pValueTime[m_nTick];
  532. }
  533. else if (m_nEnd < m_nDataPerLine)
  534. {
  535. time = m_pValueTime[m_nEnd - m_TimeToDraw + m_nTick];
  536. }
  537. else
  538. {
  539. int tv = m_nDataPerLine - m_nSTicks + m_nBegin + m_nTick - 1;
  540. tv %= m_nDataPerLine;
  541. time = m_pValueTime[tv];
  542. }
  543. }
  544. else
  545. {
  546. int tv = m_nFrom % m_nDataPerLine;
  547. tv += m_nTick;
  548. tv %= m_nDataPerLine;
  549. time = m_pValueTime[tv];
  550. }
  552. return time;
  553. }
  555. int CRealTime::GetCursorTimeAndIndex(DWORD& time)
  556. {
  557. int Index;
  558. if (m_bAutoScrollX)
  559. {
  561. if (m_nEnd < (int)m_TimeToDraw) 
  562. {
  563. Index = m_nTick;
  564. time  = m_pValueTime[Index];
  565. }
  566. else if (m_nEnd < m_nDataPerLine)
  567. {
  568. Index = m_nEnd - m_TimeToDraw + m_nTick;
  569. time = m_pValueTime[Index];
  570. }
  571. else
  572. {
  573. int tv = m_nDataPerLine - m_nSTicks + m_nBegin + m_nTick - 1;
  574. tv %= m_nDataPerLine;
  575. Index = tv;
  576. time = m_pValueTime[Index];
  577. }
  578. }
  579. else
  580. {
  581. int tv = m_nFrom % m_nDataPerLine;
  582. tv += m_nTick;
  583. tv %= m_nDataPerLine;
  584. Index = tv;
  585. time = m_pValueTime[Index];
  586. }
  588. return Index;
  589. }
  591. void CRealTime::Redraw(HWND hWnd)
  592. {
  593. RECT rt;
  594. rt.left   = GL;
  595. rt.top    = GT - 1;
  596. rt.right  = GR;
  597. rt.bottom = m_Rect.bottom - 1;
  598. ::InvalidateRect(hWnd, &rt, FALSE);
  599. }
  601. void CRealTime::DrawTickLine()
  602. {
  603. POINT pt;
  604. if (m_nEnd < (int)m_TimeToDraw)
  605. {
  606. if (m_nTick == 0) return;
  607. else if (!m_bIsForwardDrawing)
  608. pt.x = GR - 1;
  609. else
  610. pt.x = GL + PX * (m_nTick - 1) / (m_TimeToDraw - 1);
  611. }
  612. else
  613. pt.x = GL + PX * m_nTick / (m_TimeToDraw - 1);
  615. if (pt.x == GL)
  616. pt.x ++;
  617. if (pt.x == GR)
  618. pt.x --;
  620. pt.y = GT + 1;
  622. m_CurPen = ::CreatePen(PS_SOLID, m_wdTickLine, RGB(0, 0, 0));
  623. m_OldPen = (HPEN)::SelectObject(m_hDC, m_CurPen);
  624. ::MoveToEx(m_hDC, pt.x + 1, pt.y, NULL);
  625. pt.y = GB - 1;
  626. ::LineTo(m_hDC, pt.x + 1, pt.y);
  627. ::SelectObject(m_hDC, m_OldPen);
  628. ::DeleteObject(m_CurPen);
  630. m_CurPen = ::CreatePen(PS_SOLID, m_wdTickLine, m_crTickLine);
  631. m_OldPen = (HPEN)::SelectObject(m_hDC, m_CurPen);
  632. ::MoveToEx(m_hDC, pt.x, pt.y, NULL);
  633. pt.y = GT + 1;
  634. ::LineTo(m_hDC, pt.x, pt.y);
  635. ::SelectObject(m_hDC, m_OldPen);
  636. ::DeleteObject(m_CurPen);
  638. }
  640. void CRealTime::SetPrintTime(DWORD time, int flag)
  641. {
  642. if (flag == MaxTime)
  643. m_nMaxTime = time / 1000;
  644. else
  645. m_nCursorTime = time / 1000;
  646. }
  648. void CRealTime::PrintTime()
  649. {
  650. int n = 5;
  651. if (m_bPrinting) n *= m_nPrintScale;
  652. n = m_Rect.bottom - n - 1;
  653. SetStringAlign(LEFT, BOTTOM);
  654. ShowTime(GL, n, "Cursor time", m_nCursorTime);
  655. SetStringAlign(RIGHT, BOTTOM);
  656. ShowTime(GR, n, "Total lapse time", m_nMaxTime);
  657. }
  659. void CRealTime::ShowTime(int x, int y, const char* Tag, DWORD& cTime)
  660. {
  661. if (m_nCyclesPerSec > 0.9999 && m_nCyclesPerSec < 1.0001)
  662. sprintf(m_sTempStr, "%s (%d:%d:%d)", Tag, 
  663. cTime / 3600, (cTime / 60) % 60, cTime % 60);
  664. else
  665. sprintf(m_sTempStr, "%s (%d:%d:%d / %d:%d:%d)", Tag,
  666.     ((DWORD)(m_nCyclesPerSec * cTime)) / 3600, 
  667. (((DWORD)(m_nCyclesPerSec * cTime)) / 60) % 60, 
  668. ((DWORD)(m_nCyclesPerSec * cTime)) % 60, 
  669. cTime / 3600, (cTime / 60) % 60, cTime % 60);
  670. PrintString(x, y, 0, m_sTempStr);
  671. }