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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > 绘图程序 > 查看源码
clPlot.cpp
资源名称：r-time.zip　[点击查看]
上传用户：apnc006
上传日期：2013-01-26
资源大小：178k
文件大小：26k
源码类别：

绘图程序

开发平台：

Visual C++

clPlot.cpp：源码内容
  1. //*******************************************************************************************************/
  2. //* FileName: clPlot.cpp
  3. //*
  4. //* Contents: Implementation of clPlot, axis, legend, serie and timeaxis
  5. //*
  6. //* NOTE 1: Only a minimum of parameter validation is implemented to save time since this plot is 
  7. //* time critical.
  8. //*
  9. //* NOTE 2: All functionality is not fully implemented.
  10. //*
  11. //* Author: Jan Vidar Berger
  12. //*******************************************************************************************************/
  13. //* 12.feb.98 Jan Vidar Berger Implemented flicker free drawing. Thanks to John Kim for providing 
  14. //* the MemDC and to Keith Rule, the author of CMemDC.
  15. //*******************************************************************************************************/
  17. #include "stdafx.h"
  18. #include "clPlot.h"
  19. #include "MemDC.h"
  21. #include "malloc.h"
  22. #ifdef _DEBUG
  23. #define new DEBUG_NEW
  24. #undef THIS_FILE
  25. static char THIS_FILE[] = __FILE__;
  26. #endif
  28. long clPlot::m_lMaxDataPrSerie; // max allowed data pr. serie.
  29. long clPlot::m_lMaxDataTotal; // max allowed data total.
  31. //*******************************************************************************************************/
  32. //* time axis threshold. contains grid and label intervals to be used within specified
  33. //* seconds pr. pixels thresholds. The array is terminated by a 'bIAmInUse'=FALSE.
  34. //*******************************************************************************************************/
  35. struct{
  36. BOOL bIAmInUse; // indicate valid entry, last=FALSE
  37. long lgridinterval; // grid line interval in seconds
  38. long llabelinterval; // time label interval in seconds
  39. long lmodethreshold; // mode threshold in seconds pr. pixel
  40. }gridsetting[]={
  41. TRUE, 1, 4, 0, // 0: pr. second
  43. FALSE, 1, 1,0, // last entry in table
  44. };
  46. //*******************************************************************************************************/
  47. //* Function: serie::serie
  48. //*******************************************************************************************************/
  49. serie::serie()
  50. {
  51. m_bIAmInUse = FALSE;
  52. m_color = RGB(0,0,0);
  53. m_iLineStyle = PS_SOLID;
  54. m_bRightAxisAlign = FALSE;
  55. m_lNoValues = 0;
  56. m_lbegin = 0;
  57. m_lend = 0;
  58. m_pvalues = NULL;
  60. }
  62. //*******************************************************************************************************/
  63. //* Function: serie::~serie
  64. //*******************************************************************************************************/
  65. serie::~serie()
  66. {
  67. if(m_pvalues !=NULL)
  68. free(m_pvalues);
  69. }
  71. //*******************************************************************************************************/
  72. //* Function: serie::AddPoint
  73. //*
  74. //* Description: AddPoint add new data to the end of a data serie. It will simply append the data,
  75. //* update the list index and get out. 
  76. //*
  77. //* This function will also call realloc or malloc to re-size or create the plot array as
  78. //* needed.
  79. //*
  80. //* The nice thing about circular lists is that they are multi thread enabled as is. You
  81. //* must however implement a syncronization mechanism if more than one thread is supposed
  82. //* to enter data into the plot.
  83. //*
  84. //* Parameters: valuetime Time (x value).
  85. //* y y value
  86. //*
  87. //* Return Value: -none-
  88. //*
  89. //* Author: Jan Vidar Berger
  90. //*******************************************************************************************************/
  91. void serie::AddPoint(CTime &valuetime , double &y)
  92. {
  93. if(m_lNoValues > 0)
  94. m_pvalues = (value*)realloc(m_pvalues, (m_lNoValues+1)*sizeof(value));
  95. else
  96. m_pvalues = (value*)malloc((m_lNoValues+1)*sizeof(value));
  98. m_pvalues[m_lend].ValueTime = valuetime;
  99. m_pvalues[m_lend].dValue = y;
  100. m_lNoValues++;
  101. m_lend++;
  102. if(m_lend >= clPlot::m_lMaxDataPrSerie)
  103. m_lend=0;
  104. if(m_lbegin == m_lend){
  105. m_lbegin++;
  106. if(m_lbegin >= clPlot::m_lMaxDataPrSerie)
  107. m_lbegin=0;
  108. }
  109. }
  111. //*******************************************************************************************************/
  112. //* Function: serie::Reset
  113. //*
  114. //* Description: Reset the serie. Remove data and reset indexes and pointers.
  115. //*
  116. //* Parameters: -none-
  117. //*
  118. //* Return Value: -none-
  119. //*
  120. //* Author: Jan Vidar Berger
  121. //*******************************************************************************************************/
  122. void serie::Reset()
  123. {
  124. m_lNoValues=0;
  126. if(m_pvalues !=NULL)
  127. free(m_pvalues);
  129. m_pvalues = NULL;
  131. m_lbegin = 0;
  132. m_lend = 0;
  133. }
  135. //*******************************************************************************************************/
  136. //*******************************************************************************************************/
  137. clPlot::clPlot()
  138. {
  139. m_ctlBkColor = RGB(255,255,255);
  140. m_plotBkColor = RGB(255,255,255);
  141. m_legendBkColor = RGB(255,255,255);
  142. m_gridColor = RGB(127,127,127);
  143. m_bctlBorder = TRUE;
  144. m_bplotBorder = TRUE;
  145. m_blegendBorder = TRUE;
  146. m_bPrimaryLegend = FALSE;
  147. m_bSecondaryLegend = FALSE;
  148. m_bAxisLY = TRUE;
  149. m_bAxisRY = TRUE;
  150. m_bAxisBX = TRUE;
  151. m_bAutoScrollX = FALSE;
  152. m_bSimMode = FALSE;
  154. m_lMaxDataPrSerie = 10000;
  155. m_lMaxDataTotal = 100000;
  156. m_dNoData = 0.0;
  158. m_dzoom = 1.0;
  160. lArraySize = 1000; // only points with differebt x,y will be put into the array
  162. pLineArray = new CPoint[lArraySize];
  163. SetBXRange(CTime::GetCurrentTime()-CTimeSpan(60),CTime::GetCurrentTime());
  165. m_logFont.lfHeight = -13;
  166. m_logFont.lfWidth = 0;
  167. m_logFont.lfEscapement = 0;
  168. m_logFont.lfOrientation = 0;
  169. m_logFont.lfWeight = 400;
  170. m_logFont.lfItalic = FALSE;
  171. m_logFont.lfUnderline = FALSE;
  172. m_logFont.lfStrikeOut = FALSE;
  173. m_logFont.lfCharSet = ANSI_CHARSET;
  174. m_logFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
  175. m_logFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
  176. m_logFont.lfQuality = PROOF_QUALITY;
  177. m_logFont.lfPitchAndFamily = DEFAULT_PITCH;
  178. strcpy(m_logFont.lfFaceName,"Ariel");
  180. m_zoomFont.lfHeight = -13;
  181. m_zoomFont.lfWidth = 0;
  182. m_zoomFont.lfEscapement = 0;
  183. m_zoomFont.lfOrientation = 0;
  184. m_zoomFont.lfWeight = 400;
  185. m_zoomFont.lfItalic = FALSE;
  186. m_zoomFont.lfUnderline = FALSE;
  187. m_zoomFont.lfStrikeOut = FALSE;
  188. m_zoomFont.lfCharSet = ANSI_CHARSET;
  189. m_zoomFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
  190. m_zoomFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
  191. m_zoomFont.lfQuality = PROOF_QUALITY;
  192. m_zoomFont.lfPitchAndFamily = DEFAULT_PITCH;
  193. strcpy(m_zoomFont.lfFaceName,"Ariel");
  195. m_font.CreateFontIndirect(&m_zoomFont);
  196. }
  198. //*******************************************************************************************************/
  199. //*******************************************************************************************************/
  200. clPlot::~clPlot()
  201. {
  202. delete [] pLineArray;
  203. }
  206. //*******************************************************************************************************/
  207. //*******************************************************************************************************/
  208. BEGIN_MESSAGE_MAP(clPlot, CWnd)
  209. //{{AFX_MSG_MAP(clPlot)
  210. ON_WM_PAINT()
  211. //}}AFX_MSG_MAP
  212. END_MESSAGE_MAP()
  214. //*******************************************************************************************************/
  215. //*******************************************************************************************************/
  216. BOOL clPlot::Create(DWORD dwstyle, CRect &rect, CWnd *pParent, UINT id)
  217. {
  218. DWORD style = dwstyle & (~WS_BORDER);
  219. if(dwstyle & WS_BORDER)
  220. m_bctlBorder=TRUE;
  221. else
  222. m_bctlBorder=FALSE;
  224. if(!CWnd::Create(NULL, "", style, rect, pParent, id, NULL))
  225. return FALSE;
  228. m_ctlRect = rect;
  229. pParent->ClientToScreen(m_ctlRect);
  230. ScreenToClient(m_ctlRect);
  232. ComputeRects(TRUE);
  233. return TRUE;
  234. }
  236. //*******************************************************************************************************/
  237. //* Function        : clPlot::ComputeRects
  238. //*
  239. //* Description     : Compute rects used for internal possitioning of different objects. This function is 
  240. //*   called when the plot is created or sized.
  241. //*
  242. //* Return type     : void 
  243. //*
  244. //* Parameter(s)    : bInitialization indicate wherever parameters that can be changed abu the user
  245. //* also should be computed.
  246. //*
  247. //* Author          : Jan Vidar Berger
  248. //*******************************************************************************************************/
  249. void clPlot::ComputeRects(BOOL bInitialization)
  250. {
  251. // adjust the client rect for borders
  253. //GetClientRect(m_ctlRect);
  254. CClientDC dc(this);
  255. int w = 0;
  256. int n=0;
  257. CSize z=dc.GetTextExtent(CString("A"));
  258. // m_TextHeight = z.cy;
  260. m_dzoom = ((double)m_ctlRect.Height()/(double)z.cy) / 25.0;
  262. m_zoomFont.lfWidth = (int)(m_logFont.lfWidth * m_dzoom);
  263. m_zoomFont.lfHeight = (int)(m_logFont.lfHeight * m_dzoom);
  264. m_font.Detach();
  265. m_font.CreateFontIndirect(&m_zoomFont);
  266. CFont *oFont = dc.SelectObject(&m_font);
  267. // SetFont(&m_font);
  268. z=dc.GetTextExtent(CString("A"));
  269. m_TextHeight = z.cy;
  270. if(m_bctlBorder){
  271. m_clientRect.left = m_ctlRect.left+2;
  272. m_clientRect.right = m_ctlRect.right-2;
  273. m_clientRect.top = m_ctlRect.top+2;
  274. m_clientRect.bottom = m_ctlRect.bottom-2;
  275. }else{
  276. m_clientRect = m_ctlRect;
  277. }
  279. if(bInitialization)
  280. {
  281. m_iMtop = m_iMbottom = m_clientRect.Height()/10;
  282. m_iMleft = m_iMright = m_clientRect.Width()/10;
  283. }
  285. // compute plot rect.
  286. m_plotRect.left = m_clientRect.left + m_iMleft;
  287. m_plotRect.right = m_clientRect.right - m_iMright;
  288. m_plotRect.top = m_clientRect.top + m_iMtop;
  289. m_plotRect.bottom = m_clientRect.bottom - m_iMbottom;
  291. // compute default legend possition
  293. if(bInitialization)
  294. {
  295. m_legendRect.left = m_plotRect.left + (m_iMleft/5);
  296. m_legendRect.right = m_plotRect.left + (m_plotRect.Width()/5);
  297. m_legendRect.top = m_plotRect.top - (m_iMtop/2);
  298. m_legendRect.bottom = m_plotRect.top + (m_iMtop);
  299. int w = 0;
  300. int n=0;
  301. for(int x = 0; x< MAXLEGENDS;x++){
  302. if(m_primarylegends[x].m_bIAmInUse){
  303. n++;
  304. z=dc.GetTextExtent(CString(m_primarylegends[x].m_szTitle));
  305. if(z.cx > w )
  306. w=z.cx;
  307. // m_TextHeight = z.cy;
  308. }
  309. }
  311. m_legendRect.right = m_legendRect.left + 40 + w;
  312. m_legendRect.bottom = m_legendRect.top + 10 + (m_TextHeight*n);
  313. }
  315. // compute left axis area
  316. m_axisLYRect.left = m_clientRect.left + (m_iMleft/5);
  317. m_axisLYRect.right = m_plotRect.left;
  318. m_axisLYRect.top = m_plotRect.top;
  319. m_axisLYRect.bottom = m_plotRect.bottom;
  321. // compute right axis area
  322. m_axisRYRect.left =  m_plotRect.left;
  323. m_axisRYRect.right = m_clientRect.right - (m_iMright/5);
  324. m_axisRYRect.top = m_plotRect.top;
  325. m_axisRYRect.bottom = m_plotRect.bottom;
  327. // compute bottom axis area
  328. m_axisBXRect.left = m_plotRect.left;
  329. m_axisBXRect.right = m_plotRect.right;
  330. m_axisBXRect.top = m_plotRect.bottom;
  331. m_axisBXRect.bottom = m_clientRect.bottom - (m_iMbottom/5);
  333. // if(bInitialization)
  334. // {
  335. m_timeaxis.m_dSecondsPrPixel = ((double)(m_timeaxis.m_maxtime.GetTime() - m_timeaxis.m_mintime.GetTime())) / (double)m_plotRect.Width();
  336. m_leftaxis.m_dValuePrPixel   = ((double)(m_leftaxis.maxrange- m_leftaxis.minrange) / (double)m_plotRect.Height());
  337. m_rightaxis.m_dValuePrPixel   = ((double)(m_rightaxis.maxrange- m_rightaxis.minrange) / (double)m_plotRect.Height());
  338. // }
  339. dc.SelectObject(oFont);
  340. }
  342. //*******************************************************************************************************/
  343. //* Function: clPlot::OnPaint
  344. //*
  345. //* Description: This function will create a memory image, call Draw to draw the plot on it, and when
  346. //* copy the image into memory.
  347. //*
  348. //* This is fast and provides flicker free plot update.
  349. //*
  350. //* Author: Jan Vidar Berger
  351. //*******************************************************************************************************/
  352. void clPlot::OnPaint() 
  353. {
  354.         CPaintDC dc(this); // device context for painting
  355.         CMemDC  pdc(&dc);  // non flickering painting
  357.         Draw(&pdc);
  359. // Do not call CWnd::OnPaint() for painting messages
  360. }
  362. BOOL clPlot::OnEraseBkgnd(CDC* pDC) 
  363. {
  364. return FALSE;
  365. }
  367. //*******************************************************************************************************/
  368. //*******************************************************************************************************/
  369. void clPlot::Draw(CDC * dc)
  370. {
  371. CFont *oFont = dc->SelectObject(&m_font);
  372. DrawBasic(dc);
  373. DrawGrid(dc);
  374. DrawPlot(dc);
  375. DrawLegend(dc);
  376. dc->SelectObject(oFont);
  377. }
  379. //*******************************************************************************************************/
  380. //*******************************************************************************************************/
  381. void clPlot::DrawBasic(CDC * dc)
  382. {
  383. CBrush brushctlBkColor(m_ctlBkColor);
  384. dc->FillRect(m_ctlRect,&brushctlBkColor);
  385. if(m_bctlBorder)
  386. {
  387. dc->DrawEdge(m_ctlRect,BDR_SUNKENINNER|BDR_SUNKENOUTER, BF_RECT); 
  388. }
  389. dc->Rectangle(m_plotRect);
  390. DrawLegendShadow(dc);
  391. }
  393. //*******************************************************************************************************/
  394. //*******************************************************************************************************/
  395. void clPlot::DrawPlot(CDC * dc)
  396. {
  397. for(int s=0;s<MAXSERIES;s++)
  398. {
  399. if(m_series[s].m_bIAmInUse)
  400. {
  401. DrawSerie(dc, s);
  402. }
  403. }
  404. }
  406. //*******************************************************************************************************/
  407. //*******************************************************************************************************/
  408. void clPlot::DrawSerie(CDC *dc,int s)
  409. {
  410. BOOL bMore=TRUE;
  411. BOOL bDraw;
  412. CPoint p;
  413. int ly;
  414. // lets get some serie parameters now and save the time of indexing during the loop
  415. long y = m_series[s].m_lbegin;
  416. long m = m_series[s].m_lend;
  417. long a = m_series[s].m_lNoValues;
  418. BOOL bRightAxis = m_series[s].m_bRightAxisAlign;
  419. CPen pen(m_series[s].m_iLineStyle, 1, m_series[s].m_color);
  420. CPen *old = dc->SelectObject(&pen);
  421. while(bMore){
  422. bDraw=FALSE;
  423. bMore=FALSE;
  424. ly=0;
  425. while(y != m && !bDraw){
  426. if(m_series[s].m_pvalues[y].dValue == m_dNoData)
  427. {
  428. bDraw = TRUE;
  429. bMore = TRUE;
  430. }else{
  431. // Scaling. We do scaling inline to save some time
  432. time_t valuetime = m_series[s].m_pvalues[y].ValueTime.GetTime();
  433. p.x = (int)(m_plotRect.left + ((valuetime-m_timeaxis.m_mintime.GetTime())/m_timeaxis.m_dSecondsPrPixel));
  435. if(bRightAxis){
  436. p.y = (int)(m_plotRect.bottom - ((m_series[s].m_pvalues[y].dValue-m_rightaxis.minrange)/m_rightaxis.m_dValuePrPixel));
  437. }else{
  438. p.y = (int)(m_plotRect.bottom - ((m_series[s].m_pvalues[y].dValue-m_leftaxis.minrange)/m_leftaxis.m_dValuePrPixel));
  439. }
  441. if((ly == 0 || p.x != pLineArray[ly].x || p.y != pLineArray[ly].y)
  442. && (p.x >= m_plotRect.left && p.x <= m_plotRect.right))
  443. {
  444. pLineArray[ly].x = p.x;
  445. pLineArray[ly].y = p.y;
  446. ly++;
  447. }
  448. }
  449. y++;
  450. if(y > a) // wrap list index ?
  451. y=0;
  452. }
  453. if(ly > 0){
  454. dc->Polyline(pLineArray, ly);
  455. }
  456. }
  457. dc->SelectObject(old);
  458. }
  460. //*******************************************************************************************************/
  461. //*
  462. //*******************************************************************************************************/
  463. void clPlot::DrawGrid(CDC * dc)
  464. {
  465. DrawXAxisGrid(dc);
  466. DrawYAxisGrid(dc);
  467. }
  469. //*******************************************************************************************************/
  470. //*******************************************************************************************************/
  471. void clPlot::DrawYAxisGrid(CDC * dc)
  472. {
  473. double yGrid = m_leftaxis.minrange;
  474. double delta = 25.0 + (long)(((m_leftaxis.m_dValuePrPixel)))*25;
  475. if((long)delta%50 != 0 && delta > 20.0)
  476. delta +=25;
  477. double d10 = delta / 5.0;
  478. // todo: delta switch
  479. long diff = ((long)yGrid)%((long)delta);
  480. yGrid = yGrid - diff;
  481. CPen *old, pen(PS_SOLID, 1, m_gridColor);
  482. CPen stick(PS_SOLID,0,RGB(0,0,0));
  483. CPen mline(PS_SOLID,0,RGB(192,192,192));
  485. for( long sy = (long)((long)(m_leftaxis.minrange) - diff); sy < m_leftaxis.maxrange; sy+=(long)d10)
  486. {
  487. int off=3;
  488. if((long)sy%(long)delta == 0){
  489. off=5;
  490. }
  491. if(sy > m_leftaxis.minrange){
  492. int y = (int)(m_plotRect.bottom - ((sy-m_leftaxis.minrange)/m_leftaxis.m_dValuePrPixel));
  493. old = dc->SelectObject(&stick); 
  494. dc->MoveTo(CPoint(m_plotRect.left,y));
  495. dc->LineTo(CPoint(m_plotRect.left-off,y));
  496. dc->MoveTo(CPoint(m_plotRect.right,y));
  497. dc->LineTo(CPoint(m_plotRect.right+off,y));
  498. dc->SelectObject(old);
  500. old = dc->SelectObject(&mline);
  501. dc->MoveTo(CPoint(m_plotRect.left+1,y));
  502. dc->LineTo(CPoint(m_plotRect.right-1,y));
  503. dc->SelectObject(old);
  504. }
  505. }
  507. old = dc->SelectObject(&pen);
  508. while(yGrid <= m_leftaxis.maxrange)
  509. {
  510. double yy = m_plotRect.bottom - ((yGrid-m_leftaxis.minrange)/m_leftaxis.m_dValuePrPixel);
  511. int y = (int)yy;
  512. if(yGrid > m_leftaxis.minrange && yGrid<m_leftaxis.maxrange){
  513. dc->MoveTo(CPoint(m_plotRect.left+1,y));
  514. dc->LineTo(CPoint(m_plotRect.right-1,y));
  515. }
  517. char b[100];
  518. sprintf(b, "%.0f", yGrid);
  519. dc->DrawText(b, CRect(m_clientRect.left, y-m_TextHeight/2,m_plotRect.left-5,y+m_TextHeight/2), DT_RIGHT|DT_BOTTOM);
  521. double yr = (m_plotRect.bottom - yy) * m_rightaxis.m_dValuePrPixel + m_rightaxis.minrange;
  522. sprintf(b, "%.0f", yr);
  523. dc->DrawText(b, CRect(m_plotRect.right+5, y-m_TextHeight/2,m_clientRect.right,y+m_TextHeight/2), DT_LEFT|DT_BOTTOM);
  525. yGrid += delta;
  526. }
  527. dc->SelectObject(old);
  528. }
  530. //*******************************************************************************************************/
  531. //*******************************************************************************************************/
  532. void clPlot::DrawXAxisGrid(CDC * dc)
  533. {
  534. long yGrid = m_timeaxis.m_mintime.GetTime();
  535. long delta = (long)(10.0 + (long)(((m_timeaxis.m_dSecondsPrPixel)))*10);
  536. long d10 = (long)(delta / 10.0);
  537. // todo: delta switch
  538. long diff = ((long)yGrid)%((long)delta);
  539. yGrid = yGrid - diff;
  540. CPen *old, pen(PS_SOLID, 1, m_gridColor);
  541. CPen stick(PS_SOLID,0,RGB(0,0,0));
  542. CPen mline(PS_SOLID,0,RGB(192,192,192));
  544. for( long sx = m_timeaxis.m_mintime.GetTime() - diff; sx < m_timeaxis.m_maxtime.GetTime(); sx+=d10)
  545. {
  546. int off=3;
  547. if((long)sx%(long)delta == 0){
  548. off=5;
  549. }
  550. if(sx > m_timeaxis.m_mintime.GetTime()){
  551. int x = (int)(m_plotRect.left + ((sx-m_timeaxis.m_mintime.GetTime())/m_timeaxis.m_dSecondsPrPixel));
  552. // int x = m_plotRect.right - ((sx-m_timeaxis.m_mintime.GetTime())/m_timeaxis.m_lSecondsPrPixel);
  553. old = dc->SelectObject(&stick); 
  554. dc->MoveTo(CPoint(x,m_plotRect.bottom));
  555. dc->LineTo(CPoint(x+off,m_plotRect.bottom));
  556. dc->SelectObject(old);
  558. old = dc->SelectObject(&mline);
  559. dc->MoveTo(CPoint(x,m_plotRect.bottom-1));
  560. dc->LineTo(CPoint(x,m_plotRect.top+1));
  561. dc->SelectObject(old);
  562. }
  563. }
  565. old = dc->SelectObject(&pen);
  566. while(yGrid <= m_timeaxis.m_maxtime.GetTime())
  567. {
  568. int x = (int)(m_plotRect.left + ((yGrid-m_timeaxis.m_mintime.GetTime())/m_timeaxis.m_dSecondsPrPixel));
  570. if(yGrid > m_timeaxis.m_mintime.GetTime() && yGrid<m_timeaxis.m_maxtime.GetTime()){
  571. dc->MoveTo(CPoint(x,m_plotRect.bottom-1));
  572. dc->LineTo(CPoint(x,m_plotRect.top+1));
  573. }
  575. // char b[100];
  576. // sprintf(b, "%.0f", yGrid);
  577. // dc->DrawText(b, CRect(m_clientRect.left, y-m_TextHeight/2,m_plotRect.left-5,y+m_TextHeight/2), DT_RIGHT|DT_BOTTOM);
  579. yGrid += delta;
  580. }
  581. dc->SelectObject(old);
  582. }
  584. //*******************************************************************************************************/
  585. //*******************************************************************************************************/
  586. void clPlot::DrawLegendShadow(CDC * dc)
  587. {
  588. if(m_blegendBorder){
  589. CPen pen(PS_SOLID, 1, RGB(127,127,127));
  590. CPen *oPen = dc->SelectObject(&pen);
  591. CBrush *oBrush , brush(RGB(127,127,127));
  592. oBrush = dc->SelectObject(&brush);
  593. dc->Rectangle(CRect(m_legendRect.left+5,m_legendRect.top+5,m_legendRect.right+5, m_legendRect.bottom+5));
  594. dc->SelectObject(oBrush);
  595. dc->SelectObject(oPen);
  596. }
  597. }
  599. //*******************************************************************************************************/
  600. //*******************************************************************************************************/
  601. void clPlot::DrawLegend(CDC * dc)
  602. {
  603. if(m_blegendBorder){
  604. CPen pen(PS_SOLID, 1, RGB(0,0,0));
  605. CPen *oPen = dc->SelectObject(&pen);
  606. CBrush *oBrush , brush(m_legendBkColor);
  607. oBrush = dc->SelectObject(&brush);
  608. dc->Rectangle(m_legendRect);
  609. dc->SelectObject(oBrush);
  610. dc->SelectObject(oPen);
  611. }
  612. int y = m_legendRect.top + 5;
  613. int dx = m_legendRect.left + (2*m_TextHeight);
  614. int mh = m_TextHeight/2;
  615. for(int x = 0; x< MAXLEGENDS;x++){
  616. if(m_primarylegends[x].m_bIAmInUse){
  617. CRect lRect( dx + 5, y, m_legendRect.right - 5, y + m_TextHeight);
  618. CPen pen(m_primarylegends[x].m_istyle, 1, m_primarylegends[x].m_color);
  619. CPen *oPen = dc->SelectObject(&pen);
  620. dc->MoveTo(CPoint(m_legendRect.left+5, y + mh));
  621. dc->LineTo(CPoint(dx, y+mh));
  622. dc->SelectObject(oPen);
  624. dc->DrawText(m_primarylegends[x].m_szTitle, lRect, DT_LEFT);
  625. y+=m_TextHeight+1;
  626. }
  627. }
  628. }
  630. //*******************************************************************************************************/
  631. //* Function: clPlot::AddPoint
  632. //*******************************************************************************************************/
  633. BOOL clPlot::AddPoint(int serie, CTime &valuetime, double &value)
  634. {
  635. if(m_series[serie].m_lNoValues < m_lMaxDataPrSerie){
  636. m_series[serie].AddPoint(valuetime, value);
  637. if(m_bAutoScrollX && valuetime > m_timeaxis.m_maxtime){
  638. time_t span = m_timeaxis.m_maxtime.GetTime() - m_timeaxis.m_mintime.GetTime();
  639. time_t mintime = valuetime.GetTime() - span;
  641. SetBXRange(CTime(mintime), valuetime);
  642. }
  643. return TRUE;
  644. }
  645. return FALSE;
  646. }
  648. //*******************************************************************************************************/
  649. //*******************************************************************************************************/
  650. void clPlot::SetBXRange(CTime &fromtime, CTime &totime, BOOL bMove)
  651. {
  652. m_timeaxis.m_mintime = fromtime;
  653. m_timeaxis.m_maxtime = totime;
  654. if(!bMove){
  655. m_timeaxis.m_dSecondsPrPixel = ((double)(m_timeaxis.m_maxtime.GetTime() - m_timeaxis.m_mintime.GetTime()+1)) / (double)m_plotRect.Width();
  656. }
  657. }
  659. //*******************************************************************************************************/
  660. //*******************************************************************************************************/
  661. void clPlot::SetLYRange(double &minrange, double &maxrange)
  662. {
  663. }
  665. //*******************************************************************************************************/
  666. //*******************************************************************************************************/
  667. void clPlot::SetRYRange(double &minrange, double &maxrange)
  668. {
  669. }
  671. //*******************************************************************************************************/
  672. //*******************************************************************************************************/
  673. void clPlot::SetBXTitle(const char *title)
  674. {
  675. }
  677. //*******************************************************************************************************/
  678. //*******************************************************************************************************/
  679. void clPlot::SetLYTitle(const char *title)
  680. {
  681. }
  683. //*******************************************************************************************************/
  684. //*******************************************************************************************************/
  685. void clPlot::SetRYTitle(const char *title)
  686. {
  687. }
  689. //*******************************************************************************************************/
  690. //*******************************************************************************************************/
  691. void clPlot::Reset()
  692. {
  693. }
  695. //*******************************************************************************************************/
  696. //*******************************************************************************************************/
  697. void clPlot::SetSerie(int s, int style, COLORREF color, double minrange, double maxrange, const char *szTitle, BOOL Rightalign)
  698. {
  699. m_series[s].m_bIAmInUse = TRUE;
  700. m_series[s].m_color = color;
  701. m_series[s].m_iLineStyle = style;
  702. m_series[s].m_bRightAxisAlign = Rightalign;
  703. }
  705. //*******************************************************************************************************/
  706. //*******************************************************************************************************/
  707. void clPlot::MoveWindow(CRect & Rect)
  708. {
  709. m_ctlRect = Rect;
  710. GetParent()->ClientToScreen(m_ctlRect);
  711. ScreenToClient(m_ctlRect);
  712. ComputeRects(TRUE);
  713. CWnd::MoveWindow(Rect);
  714. }
  716. //*******************************************************************************************************/
  717. //*******************************************************************************************************/
  718. void clPlot::SetLegend(int l, int style, COLORREF color, const char *text)
  719. {
  720. m_primarylegends[l].m_bIAmInUse = TRUE;
  721. m_primarylegends[l].m_color = color;
  722. m_primarylegends[l].m_istyle = style;
  723. m_primarylegends[l].m_szTitle = text;
  724. CClientDC dc(this);
  725. CFont *oFont = dc.SelectObject(&m_font);
  726. int w = 0;
  727. int n=0;
  728. for(int x = 0; x< MAXLEGENDS;x++){
  729. if(m_primarylegends[x].m_bIAmInUse){
  730. n++;
  731. CSize z=dc.GetTextExtent(CString(m_primarylegends[x].m_szTitle));
  732. if(z.cx > w )
  733. w=z.cx;
  734. // m_TextHeight = z.cy;
  735. }
  736. }
  738. m_legendRect.right = m_legendRect.left + 10+(2*m_TextHeight) + w;
  739. m_legendRect.bottom = m_legendRect.top + 10 + (m_TextHeight*n);
  740. dc.SelectObject(oFont);
  741. }