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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
Graph.cpp
资源名称：OSDemo　[点击查看]
上传用户：tianjwyx
上传日期：2007-01-13
资源大小：813k
文件大小：288k
源码类别：

操作系统开发

开发平台：

Visual C++

Graph.cpp：源码内容
  1. //Graph.cpp - Version 3.0 (Brian Convery, May, 2001)
  3. #include "stdafx.h"
  4. #include "afxtempl.h"
  5. #include "GraphSeries.h"
  6. #include "GraphLegend.h"
  7. #include "math.h"
  8. #include "Graph.h"
  9. #include "GraphDataColor.h"
  10. #include "GraphPieLabel.h" //for pie labels
  12. #ifdef _DEBUG
  13. #define new DEBUG_NEW
  14. #undef THIS_FILE
  15. static char THIS_FILE[] = __FILE__;
  16. #endif
  18. /////////////////////////////////////////////////////////////////////////////
  19. // CGraph
  21. CGraph::CGraph()
  22. {
  23. graphSeries = new CObList();
  24. seriesSize = 0;
  25. minTick = 0;
  26. maxTick = 100;
  27. numTicks = 10;
  28. tickSpace = 10;
  30. graphHasLegend = FALSE;
  31. legendWidth = 0;
  32. legendMaxText= 0;
  33. graphAlignment = VERTICAL_ALIGN;  
  35. graphType = 0;
  37. xAxisAlign = 0;  //horizontal
  38. xAxisLabelLength = 0;
  40. xTickFontSize = 12;
  41. yTickFontSize = 12;
  42. legendFontSize = 12;
  44. depth = 0;
  45. depthRatio = 0.05;
  47. line3DXBase = 0;
  48. line3DYBase = 0;
  50. SetGridLines(FALSE);
  52. graphQuadType = 1;
  53. quadSetManually = FALSE;
  54. }
  56. CGraph::CGraph(int type)
  57. {
  58. graphSeries = new CObList();
  59. colorList = new CObList();
  60. seriesSize = 0;
  61. minTick = 0;
  62. maxTick = 100;
  63. numTicks = 10;
  64. tickSpace = 10;
  66. graphHasLegend = FALSE;
  67. legendWidth = 0;
  68. legendMaxText= 0;
  69. graphAlignment = VERTICAL_ALIGN;  
  71. graphType = type;
  73. xAxisAlign = 0;  //in degrees == horizontal
  74. xAxisLabelLength = 0;
  76. xTickFontSize = 12;
  77. yTickFontSize = 12;
  78. legendFontSize = 12;
  80. depth = 0;
  81. depthRatio = 0.05;
  83. line3DXBase = 0;
  84. line3DYBase = 0;
  86. SetGridLines(FALSE);
  88. graphQuadType = 1;
  89. if(type != BAR_GRAPH)
  90. quadSetManually = TRUE;
  91. else
  92. quadSetManually = FALSE;
  93. }
  95. CGraph::~CGraph()
  96. {
  97. POSITION pos;
  98. CGraphSeries* pSeries;
  100. for( pos = graphSeries->GetHeadPosition(); pos != NULL; )
  101. {
  102. pSeries = (CGraphSeries*) graphSeries->GetNext( pos );
  103. graphSeries->RemoveAt(pos);
  104. delete pSeries;
  105. }
  107. graphSeries->RemoveAll();
  108. delete graphSeries;
  110. CGraphDataColor* dataColor;
  111. for( pos = colorList->GetHeadPosition(); pos != NULL; )
  112. {
  113. dataColor = (CGraphDataColor*) colorList->GetNext( pos );
  114. colorList->RemoveAt(pos);
  115. delete dataColor;
  116. }
  118. colorList->RemoveAll();
  119. delete colorList;
  121. }
  124. BEGIN_MESSAGE_MAP(CGraph, CStatic)
  125. //{{AFX_MSG_MAP(CGraph)
  126. // NOTE - the ClassWizard will add and remove mapping macros here.
  127. //}}AFX_MSG_MAP
  128. END_MESSAGE_MAP()
  130. /////////////////////////////////////////////////////////////////////////////
  131. // CGraph message handlers
  133. void CGraph::SetGraphType(int gType)
  134. {
  135. graphType = gType;
  136. }
  138. void CGraph::SetXAxisAlignment(int alignValue)
  139. {
  140. xAxisAlign = alignValue;
  141. }
  143. int CGraph::GetXAxisAlignment()
  144. {
  145. return xAxisAlign;
  146. }
  148. void CGraph::SetColor(int dataGroup, COLORREF groupColor)
  149. {
  150. CGraphDataColor *dataColor = new CGraphDataColor(dataGroup, groupColor);
  151. colorList->AddTail(dataColor);
  152. }
  154. COLORREF CGraph::GetColor(int dataGroup)
  155. {
  156. POSITION pos;
  157. if((colorList->GetCount() <= dataGroup) || (colorList->GetCount() == 0))
  158. return BLACK;
  160. CGraphDataColor* dataColor;
  161. pos = colorList->GetHeadPosition();
  162. for(int i = 0; i < dataGroup; i++)
  163. colorList->GetNext(pos);
  165. dataColor = (CGraphDataColor*) colorList->GetAt( pos );
  166. return dataColor->GetColor();
  167. }
  169. void CGraph::DrawGraph(CDC* pDC)
  170. {
  171. CString tickLabel;
  172. CWnd* graphWnd = pDC->GetWindow();
  173. CRect graphRect;
  174. graphWnd->GetClientRect(&graphRect);
  175. TEXTMETRIC tm;
  177. //reset graph to be clear background
  178. COLORREF backColor;
  179. pDC->SetBkMode(TRANSPARENT);
  180. backColor = RGB(214,223,247);  //replace with desired background color
  181. CBrush backBrush (backColor);
  182. CBrush* pOldBackBrush;
  183. pOldBackBrush = pDC->SelectObject(&backBrush);
  184. //pDC->Rectangle(0, 0, graphRect.Width(), graphRect.Height());
  185. pDC->SelectObject(pOldBackBrush);
  187. maxHeight = graphRect.Height() - 20;  //for frame window and status bar
  188. maxWidth = graphRect.Width() - 5;  //for frame window
  190. //draw graph title
  191. CFont titleFont;
  192. int tFontSize = 20;
  193. while((graphTitle.GetLength() * (tFontSize / 2)) > maxWidth)
  194. {
  195. tFontSize -= 2;
  196. }
  197. titleFont.CreateFont(tFontSize, 0, 0, 0, 500, FALSE, FALSE, 0,
  198. DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  199. DEFAULT_QUALITY, DEFAULT_PITCH ,"楷体_GB2312");
  200. CFont* pOldFont = (CFont*) pDC->SelectObject(&titleFont);
  202. pDC->GetTextMetrics(&tm);
  204. int charWidth = tm.tmAveCharWidth;
  205. //next line is centered....trust me !!
  206. pDC->TextOut((graphRect.Width() / 2) - ((graphTitle.GetLength() / 2) * charWidth),
  207. 10, graphTitle);
  208. pDC->SelectObject(pOldFont);
  210. if((graphType == PIE_GRAPH) || (graphType == PIE_GRAPH_3D))
  211. {
  213. //since pie does not have axis lines, set to full size minus 5 on each side
  214. //these are needed for legend to plot itself
  215. xAxisWidth = maxWidth - 10;
  216. yAxisHeight = maxHeight - 50;  //10 buffer, 20 for title, and 20 for series label
  217. xApexPoint = 5;
  218. yApexPoint = maxHeight - 5;
  219. }
  220. else
  221. {
  222. //compute label size for axis alignment
  223. CFont sideFont, axisFont;
  224. int tFontSize = 16;
  225. if(maxWidth > maxHeight)
  226. {
  227. while((axisYLabel.GetLength() * (tFontSize / 2)) > maxHeight)
  228. {
  229. tFontSize -= 2;
  230. }
  231. }
  232. else
  233. {
  234. while((axisXLabel.GetLength() * (tFontSize / 2)) > maxWidth)
  235. {
  236. tFontSize -= 2;
  237. }
  238. }
  239. axisFont.CreateFont(tFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  240. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  241. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  242. sideFont.CreateFont(tFontSize, 0, 900, 0, 700, FALSE, FALSE, 0,
  243. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  244. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  246. CFont* pOldFont = (CFont*) pDC->SelectObject(&sideFont);
  247. pDC->GetTextMetrics(&tm);
  248. int charWidth = tm.tmAveCharWidth;
  249. int labelHeight = tm.tmHeight + 10;
  250. if(graphAlignment)
  251. {
  252. if(axisYLabel.GetLength() == 0)
  253. labelHeight = 0;
  254. }
  255. else
  256. {
  257. if(axisXLabel.GetLength() == 0)
  258. labelHeight = 0;
  259. }
  260. pDC->SelectObject(pOldFont);
  262. tickLabel.Format("%d", maxTick);
  264. //determine axis specifications 
  265. if(graphAlignment)
  266. {
  267. if(graphType == SCATTER_GRAPH)
  268. {
  269. xApexPoint = 5 + (xAxisLabelLength * charWidth) + labelHeight; //labelHeight added for y-axis label height
  270. yApexPoint = (maxHeight - 15) - tm.tmHeight;
  271. yAxisHeight = yApexPoint - 40;
  272. xAxisWidth = (maxWidth - 5) - xApexPoint;
  273. }
  274. else
  275. {
  276. xApexPoint = 5 + (tickLabel.GetLength() * (yTickFontSize / 2)) + 45; 
  277. if(!xAxisAlign)  //horizontal
  278. yApexPoint = (maxHeight - 5) - 45; //apex points are the cross section of axis lines
  279. else
  280. yApexPoint = (maxHeight - 5) - (xAxisLabelLength * (xTickFontSize / 2)) - 10;
  281. yAxisHeight = yApexPoint - 40;
  282. xAxisWidth = (maxWidth - 5) - xApexPoint;
  283. }
  284. }
  285. else
  286. {
  287. xApexPoint = 5 + (xAxisLabelLength * charWidth) + labelHeight; //labelHeight added for y-axis label height
  288. yApexPoint = (maxHeight - 15) - tm.tmHeight;
  289. yAxisHeight = yApexPoint - 40;
  290. xAxisWidth = (maxWidth - 5) - xApexPoint;
  291. }
  292. }
  294. //draw legend
  295. if(graphHasLegend)
  296. {
  297. int legendLeft = DrawLegend(pDC);
  298. xAxisWidth = legendLeft - 10 - xApexPoint;
  299. }
  301. if((!quadSetManually) && (graphType == BAR_GRAPH))
  302. {
  303. //computer number of quadrants needed based on data
  304. POSITION pos;
  305. pos = graphSeries->GetHeadPosition();
  306. CGraphSeries* tmpSeries;
  307. int minXValue = 0;
  308. int minYValue = 0;
  309. for(int x = 1; x <= graphSeries->GetCount(); x++)
  310. {
  311. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  312. for(int s = 0; s < seriesSize; s++)
  313. {
  314. //to allow scalability (height may be less than tickRange)
  315. int curXValue = tmpSeries->GetXDataValue();
  316. int curYValue = tmpSeries->GetYDataValue();
  317. if(curXValue < minXValue)
  318. minXValue = curXValue;
  319. if(curYValue < minYValue)
  320. minYValue = curYValue;
  321. }
  322. }
  323. graphQuadType = 1;
  324. if((minXValue < 0) && (minYValue < 0))
  325. graphQuadType = 4;
  326. if((minXValue < 0) && (minYValue >= 0))
  327. graphQuadType = 2;
  328. if((minXValue >= 0) && (minYValue < 0))
  329. graphQuadType = 3;
  330. }
  332. if(graphType == BAR_GRAPH)
  333. {
  334. switch(graphQuadType)
  335. {
  336. case 2 :
  337. xApexPoint += xAxisWidth / 2;
  338. break;
  339. case 3 :
  340. yApexPoint -= yAxisHeight / 2;
  341. break;
  342. case 4 :
  343. xApexPoint += xAxisWidth / 2;
  344. yApexPoint -= yAxisHeight / 2;
  345. break;
  346. }
  347. }
  349. if((graphType != 2) && (graphType != 32))  //pie & 3d pie
  350. {
  351. inRedraw = FALSE;
  352. //draw axis lines
  353. DrawAxis(pDC);
  354. }
  356. //draw series data and labels
  357. DrawSeries(pDC);
  359. //lines below are commented for doing redraw.  If you
  360. //want the axis lines on top of the other graph elements
  361. //uncomment this functionality...I may add it back later
  362. //but there were some bugs doing it this way.
  364. //redraw axis lines in case graph elements overwrote the axis lines
  365. // if((graphType != 2) && (graphType != 32) && (graphQuadType > 1))  //pie & 3d pie
  366. // {
  367. // inRedraw = TRUE;
  368. //draw axis lines
  369. // DrawAxis(pDC);
  370. // }
  371. }
  373. void CGraph::DrawAxis(CDC* pDC)
  374. {
  375. TEXTMETRIC tm;
  376. pDC->SetTextColor(BLACK);
  377. CFont sideFont, axisFont, dummyFont;
  378. int charWidth, labelHeight;
  379. double tickScale;
  380. int tickXLocation, tickYLocation;
  381. int seriesSpace;
  382. CFont* pOldFont;
  383. int x, y;
  385. COLORREF axisLineColor;
  386. axisLineColor = BLACK;
  387. CPen axisPen (PS_SOLID, 2, axisLineColor);
  388. dummyFont.CreateFont(12, 0, 0, 0, 700, FALSE, FALSE, 0,
  389. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  390. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  391. pOldFont = (CFont*)pDC->SelectObject(&dummyFont);
  392. switch(graphType)
  393. {
  394. case BAR_GRAPH :
  395. case LINE_GRAPH :
  396. case SCATTER_GRAPH :
  397. case BOX_WHISKER_GRAPH :
  398. // case RADAR_GRAPH :
  399. case STACKED_BAR_GRAPH :
  400. case XY_LINE_GRAPH :
  401. CPen* pOldAxisPen;
  402. pOldAxisPen = pDC->SelectObject(&axisPen);
  403. switch(graphQuadType)
  404. {
  405. case 1 :
  406. //draw y axis
  407. pDC->MoveTo(xApexPoint, yApexPoint);  
  408. pDC->LineTo(xApexPoint, yApexPoint - yAxisHeight);
  410. //draw x axis
  411. pDC->MoveTo(xApexPoint, yApexPoint);  
  412. pDC->LineTo(xApexPoint + xAxisWidth, yApexPoint);
  413. break;
  414. case 2 :
  415. //draw y axis
  416. pDC->MoveTo(xApexPoint, yApexPoint);  
  417. pDC->LineTo(xApexPoint, yApexPoint - yAxisHeight);
  419. //draw x axis
  420. pDC->MoveTo(xApexPoint - (xAxisWidth / 2), yApexPoint);  
  421. pDC->LineTo(xApexPoint + (xAxisWidth / 2), yApexPoint);
  422. break;
  423. case 3 :
  424. //draw y axis
  425. pDC->MoveTo(xApexPoint, yApexPoint + (yAxisHeight / 2));  
  426. pDC->LineTo(xApexPoint, yApexPoint - (yAxisHeight / 2));
  428. //draw x axis
  429. pDC->MoveTo(xApexPoint, yApexPoint);  
  430. pDC->LineTo(xApexPoint + xAxisWidth, yApexPoint);
  431. break;
  432. case 4 :
  433. //draw y axis
  434. pDC->MoveTo(xApexPoint, yApexPoint + (yAxisHeight / 2));  
  435. pDC->LineTo(xApexPoint, yApexPoint - (yAxisHeight / 2));
  437. //draw x axis
  438. pDC->MoveTo(xApexPoint - (xAxisWidth / 2), yApexPoint);  
  439. pDC->LineTo(xApexPoint + (xAxisWidth / 2), yApexPoint);
  440. break;
  441. }
  442. pDC->SelectObject(pOldAxisPen);
  444. int tFontSize;
  445. //draw labels
  446. tFontSize = 16;
  447. if(maxWidth > maxHeight)
  448. {
  449. while((axisYLabel.GetLength() * (tFontSize / 2)) > maxHeight)
  450. {
  451. tFontSize -= 2;
  452. }
  453. }
  454. else
  455. {
  456. while((axisXLabel.GetLength() * (tFontSize / 2)) > maxWidth)
  457. {
  458. tFontSize -= 2;
  459. }
  460. }
  461. axisFont.CreateFont(tFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  462. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  463. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  464. sideFont.CreateFont(tFontSize, 0, 900, 0, 700, FALSE, FALSE, 0,
  465. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  466. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  468. pDC->SelectObject(&sideFont);
  469. pDC->GetTextMetrics(&tm);
  470. charWidth = tm.tmAveCharWidth;
  472. if(graphAlignment)
  473. {
  474. switch(graphQuadType)
  475. {
  476. case 1 :
  477. case 2 :
  478. pDC->TextOut(10, (yApexPoint - (yAxisHeight / 2)) + ((axisYLabel.GetLength() * charWidth) / 2), axisYLabel);
  479. break;
  480. case 3 :
  481. case 4 :
  482. pDC->TextOut(10, yApexPoint + ((axisYLabel.GetLength() * charWidth) / 2), axisYLabel);
  483. break;
  484. }
  487. pDC->SelectObject(&axisFont);
  488. pDC->GetTextMetrics(&tm);
  489. charWidth = tm.tmAveCharWidth;
  490. switch(graphQuadType)
  491. {
  492. case 1 :
  493. pDC->TextOut(xApexPoint + (xAxisWidth / 2) - ((axisXLabel.GetLength() / 2) * charWidth), maxHeight - 5 - 6, axisXLabel);
  494. break;
  495. case 2 :
  496. pDC->TextOut(xApexPoint - ((axisXLabel.GetLength() / 2) * charWidth), maxHeight - 5 - 6, axisXLabel);
  497. break;
  498. case 3 :
  499. pDC->TextOut(xApexPoint + (xAxisWidth / 2) - ((axisXLabel.GetLength() / 2) * charWidth), maxHeight - 5 - 6, axisXLabel);
  500. break;
  501. case 4 :
  502. pDC->TextOut(xApexPoint - ((axisXLabel.GetLength() / 2) * charWidth), maxHeight - 5 - 6, axisXLabel);
  503. break;
  504. }
  507. pDC->SelectObject(pOldFont);
  509. tickScale = 0.00;
  510. tickScale = (yAxisHeight - 10) / numTicks;
  512. //draw y axis ticks
  513. if(!inRedraw)
  514. {
  515. switch(graphQuadType)
  516. {
  517. case 1 :
  518. for(y = 1; y <= numTicks; y++) 
  519. {
  520. tickYLocation = (int)(yApexPoint - (y * tickScale));
  522. //draw tick mark
  523. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  524. pDC->LineTo(xApexPoint + 3, tickYLocation);
  526. if(graphHasGridLines)
  527. {
  528. //draw grid lines
  529. COLORREF gridLineColor;
  530. gridLineColor = DARK_GREY;
  531. CPen gridPen (PS_SOLID, 1, gridLineColor);
  532. CPen* pOldPen;
  533. pOldPen = pDC->SelectObject(&gridPen);
  534. pDC->MoveTo(xApexPoint, tickYLocation);
  535. pDC->LineTo(xApexPoint + xAxisWidth, tickYLocation);
  536. pDC->SelectObject(pOldPen);
  537. }
  539. //draw tick label
  540. CString tickLabel;
  541. tickLabel.Format("%d", minTick + (y * tickSpace));
  543. CFont yFont;
  544. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  545. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  546. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  547. pDC->SelectObject(&yFont);
  549. pDC->TextOut(xApexPoint - 10 - (tickLabel.GetLength() * (yTickFontSize / 2)), tickYLocation - 6, tickLabel);
  550. pDC->SelectObject(pOldFont);
  551. topYTick = tickYLocation;
  552. }
  553. break;
  554. pDC->SelectObject(pOldFont);
  555. case 2 :
  556. if(graphType == SCATTER_GRAPH)
  557. {
  558. double oldTickScale;
  559. int oldNumTicks;
  560. oldNumTicks = numTicks;
  561. oldTickScale = tickScale;
  563. numTicks /= 2;
  564. tickScale *= 2;
  565. for(y = 1; y <= numTicks; y++)  
  566. {
  567. tickYLocation = (int)(yApexPoint - (y * tickScale));
  569. //draw tick mark
  570. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  571. pDC->LineTo(xApexPoint + 3, tickYLocation);
  573. if(graphHasGridLines)
  574. {
  575. //draw grid lines
  576. COLORREF gridLineColor;
  577. gridLineColor = LIGHT_GREY;
  578. CPen gridPen (PS_SOLID, 1, gridLineColor);
  579. CPen* pOldPen;
  580. pOldPen = pDC->SelectObject(&gridPen);
  581. pDC->MoveTo(xApexPoint - (xAxisWidth / 2), tickYLocation);
  582. pDC->LineTo(xApexPoint + (xAxisWidth / 2), tickYLocation);
  583. pDC->SelectObject(pOldPen);
  584. }
  586. //draw tick label
  587. CString tickLabel;
  588. tickLabel.Format("%d", minTick + (y * tickSpace));
  590. CFont yFont;
  591. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  592. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  593. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  594. pDC->SelectObject(&yFont);
  596. pDC->TextOut(xApexPoint - (xAxisWidth / 2) - 10 - (tickLabel.GetLength() * (yTickFontSize / 2)), tickYLocation - 6, tickLabel);
  597. pDC->SelectObject(pOldFont);
  598. topYTick = tickYLocation;
  599. }
  600. //draw the 0
  601. pDC->TextOut(xApexPoint - (xAxisWidth / 2) - 10 - (yTickFontSize / 2), yApexPoint - 6, "0");
  603. //reset numTicks and tickScale back to normal
  604. tickScale = oldTickScale;
  605. numTicks = oldNumTicks;
  606. }
  607. else
  608. {
  609. for(y = 1; y <= numTicks; y++)  
  610. {
  611. tickYLocation = (int)(yApexPoint - (y * tickScale));
  613. //draw tick mark
  614. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  615. pDC->LineTo(xApexPoint + 3, tickYLocation);
  617. if(graphHasGridLines)
  618. {
  619. //draw grid lines
  620. COLORREF gridLineColor;
  621. gridLineColor = DARK_GREY;
  622. CPen gridPen (PS_SOLID, 1, gridLineColor);
  623. CPen* pOldPen;
  624. pOldPen = pDC->SelectObject(&gridPen);
  625. pDC->MoveTo(xApexPoint - (xAxisWidth / 2), tickYLocation);
  626. pDC->LineTo(xApexPoint + (xAxisWidth / 2), tickYLocation);
  627. pDC->SelectObject(pOldPen);
  628. }
  630. //draw tick label
  631. CString tickLabel;
  632. tickLabel.Format("%d", minTick + (y * tickSpace));
  634. CFont yFont;
  635. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  636. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  637. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  638. pDC->SelectObject(&yFont);
  640. pDC->TextOut(xApexPoint - (xAxisWidth / 2) - 10 - (tickLabel.GetLength() * (yTickFontSize / 2)), tickYLocation - 6, tickLabel);
  641. topYTick = tickYLocation;
  643. }
  644. //draw the 0
  645. pDC->TextOut(xApexPoint - (xAxisWidth / 2) - 10 - (yTickFontSize / 2), yApexPoint - 6, "0");
  646. }
  647. pDC->SelectObject(pOldFont);
  648. break;
  649. case 3 :
  650. for(y = 0; y <= numTicks / 2; y++) 
  651. {
  652. tickYLocation = (int)(yApexPoint + 5 - (yAxisHeight / 2) + (y * tickScale));
  654. //draw tick mark
  655. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  656. pDC->LineTo(xApexPoint + 3, tickYLocation);
  658. if(graphHasGridLines)
  659. {
  660. //draw grid lines
  661. COLORREF gridLineColor;
  662. gridLineColor = DARK_GREY;
  663. CPen gridPen (PS_SOLID, 1, gridLineColor);
  664. CPen* pOldPen;
  665. pOldPen = pDC->SelectObject(&gridPen);
  666. pDC->MoveTo(xApexPoint, tickYLocation);
  667. pDC->LineTo(xApexPoint, tickYLocation);
  668. pDC->SelectObject(pOldPen);
  669. }
  671. //draw tick label
  672. CString tickLabel;
  673. tickLabel.Format("%d", maxTick - (y * tickSpace));
  675. CFont yFont;
  676. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  677. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  678. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  679. pDC->SelectObject(&yFont);
  681. pDC->TextOut(xApexPoint - 10 - (tickLabel.GetLength() * (yTickFontSize / 2)), tickYLocation - 6, tickLabel);
  682. topYTick = tickYLocation;
  684. }
  685. //draw the 0
  686. pDC->TextOut(xApexPoint - (xAxisWidth / 2) - 10 - (yTickFontSize / 2), yApexPoint - 6, "0");
  688. for(; y <= numTicks; y++) 
  689. {
  690. tickYLocation = (int)(yApexPoint + 5 - (yAxisHeight / 2) + (y * tickScale));
  692. //draw tick mark
  693. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  694. pDC->LineTo(xApexPoint + 3, tickYLocation);
  696. if(graphHasGridLines)
  697. {
  698. //draw grid lines
  699. COLORREF gridLineColor;
  700. gridLineColor = DARK_GREY;
  701. CPen gridPen (PS_SOLID, 1, gridLineColor);
  702. CPen* pOldPen;
  703. pOldPen = pDC->SelectObject(&gridPen);
  704. pDC->MoveTo(xApexPoint, tickYLocation);
  705. pDC->LineTo(xApexPoint, tickYLocation);
  706. pDC->SelectObject(pOldPen);
  707. }
  709. //draw tick label
  710. CString tickLabel;
  711. tickLabel.Format("%d", minTick + ((numTicks - y) * tickSpace));
  713. pDC->TextOut(xApexPoint - 10 - (tickLabel.GetLength() * (yTickFontSize / 2)), tickYLocation - 6, tickLabel);
  714. topYTick = tickYLocation;
  716. }
  717. pDC->SelectObject(pOldFont);
  718. break;
  719. pDC->SelectObject(pOldFont);
  720. case 4 :
  721. for(y = 1; y <= numTicks / 2; y++) 
  722. {
  723. tickYLocation = (int)(yApexPoint - (y * tickScale));
  725. //draw tick mark
  726. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  727. pDC->LineTo(xApexPoint + 3, tickYLocation);
  729. if(graphHasGridLines)
  730. {
  731. //draw grid lines
  732. COLORREF gridLineColor;
  733. gridLineColor = DARK_GREY;
  734. CPen gridPen (PS_SOLID, 1, gridLineColor);
  735. CPen* pOldPen;
  736. pOldPen = pDC->SelectObject(&gridPen);
  737. pDC->MoveTo(xApexPoint - (xAxisWidth / 2), tickYLocation);
  738. pDC->LineTo(xApexPoint + (xAxisWidth / 2), tickYLocation);
  739. pDC->SelectObject(pOldPen);
  740. }
  742. //draw tick label
  743. CString tickLabel;
  744. tickLabel.Format("%d", minTick + (y * tickSpace));
  746. CFont yFont;
  747. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  748. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  749. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  750. pDC->SelectObject(&yFont);
  752. pDC->TextOut(xApexPoint - (xAxisWidth / 2) - 10 - (tickLabel.GetLength() * (yTickFontSize / 2)), tickYLocation - 6, tickLabel);
  753. topYTick = tickYLocation;
  755. }
  756. //draw the 0
  757. pDC->TextOut(xApexPoint - (xAxisWidth / 2) - 10 - (yTickFontSize / 2), yApexPoint - 6, "0");
  759. for(; y <= numTicks; y++)  
  760. {
  761. tickYLocation = (int)(yApexPoint - (yAxisHeight / 2) + (y * tickScale));
  763. //draw tick mark
  764. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  765. pDC->LineTo(xApexPoint + 3, tickYLocation);
  767. if(graphHasGridLines)
  768. {
  769. //draw grid lines
  770. COLORREF gridLineColor;
  771. gridLineColor = DARK_GREY;
  772. CPen gridPen (PS_SOLID, 1, gridLineColor);
  773. CPen* pOldPen;
  774. pOldPen = pDC->SelectObject(&gridPen);
  775. pDC->MoveTo(xApexPoint - (xAxisWidth / 2), tickYLocation);
  776. pDC->LineTo(xApexPoint + (xAxisWidth / 2), tickYLocation);
  777. pDC->SelectObject(pOldPen);
  778. }
  780. //draw tick label
  781. CString tickLabel;
  782. tickLabel.Format("%d", minTick + ((numTicks - y) * tickSpace));
  784. pDC->TextOut(xApexPoint - (xAxisWidth / 2) - 10 - (tickLabel.GetLength() * (yTickFontSize / 2)), tickYLocation - 6, tickLabel);
  785. topYTick = tickYLocation;
  787. }
  788. pDC->SelectObject(pOldFont);
  789. break;
  790. }
  791. }
  793. //draw X axis tick marks
  794. switch(graphQuadType)
  795. {
  796. case 1 :
  797. if(graphType != SCATTER_GRAPH)
  798. {
  799. POSITION pos;
  800. pos = graphSeries->GetHeadPosition();
  801. CGraphSeries* tmpSeries;
  802. for(int x = 1; x <= graphSeries->GetCount(); x++)
  803. {
  804. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  806. seriesSpace = xAxisWidth / graphSeries->GetCount();
  807. tickXLocation = xApexPoint + ((x * seriesSpace) - (seriesSpace / 2));
  809. pDC->MoveTo(tickXLocation,yApexPoint - 3);
  810. pDC->LineTo(tickXLocation,yApexPoint + 3);
  812. //draw tick label
  813. CString tickLabel;
  814. CFont xFont;
  815. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  816. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  817. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  818. pDC->SelectObject(&xFont);
  819. tickLabel = tmpSeries->GetLabel();
  820. if(!xAxisAlign)  //horizontal
  821. pDC->TextOut(tickXLocation - ((tickLabel.GetLength() * 8) / 2), yApexPoint + 8, tickLabel);
  822. else
  823. {
  824. CFont sideFont2;
  825. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  826. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  827. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  828. pDC->SelectObject(&sideFont2);
  829. pDC->GetTextMetrics(&tm);
  830. charWidth = tm.tmAveCharWidth;
  831. if(xAxisAlign < 180)
  832. pDC->TextOut(tickXLocation - 8, yApexPoint + 8 + (xAxisLabelLength * charWidth), tickLabel);
  833. else
  834. pDC->TextOut(tickXLocation + 2, yApexPoint + 8, tickLabel);
  836. pDC->SelectObject(pOldFont);
  837. }
  838. rightXTick = tickXLocation;
  839. }
  840. }
  841. else
  842. {
  843. //scatter graphs will use the same tick marking on both axis lines
  844. seriesSpace = (xAxisWidth - 20) / numTicks;
  845. for(int x = 1; x <= numTicks; x++)  
  846. {
  847. tickXLocation = xApexPoint + (x * seriesSpace);
  849. //draw tick mark
  850. pDC->MoveTo(tickXLocation, yApexPoint - 3);
  851. pDC->LineTo(tickXLocation, yApexPoint + 3);
  853. //draw tick label
  854. CString tickLabel;
  855. CFont xFont;
  856. tickLabel.Format("%d", x * tickSpace);
  858. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  859. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  860. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  861. pDC->SelectObject(&xFont);
  862. pDC->GetTextMetrics(&tm);
  863. charWidth = tm.tmAveCharWidth;
  865. pDC->TextOut(tickXLocation - (tickLabel.GetLength() * charWidth / 2), yApexPoint + 8, tickLabel);
  867. rightXTick = tickXLocation;
  868. pDC->SelectObject(pOldFont);
  869. }
  871. }
  872. break;
  873. case 2 :
  874. if(graphType != SCATTER_GRAPH)
  875. {
  876. POSITION pos;
  877. pos = graphSeries->GetHeadPosition();
  878. CGraphSeries* tmpSeries;
  879. seriesSpace = xAxisWidth / graphSeries->GetCount();
  880. for(x = 1; x <= graphSeries->GetCount() / 2; x++)
  881. {
  882. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  884. tickXLocation = xApexPoint - (xAxisWidth / 2) + ((x * seriesSpace) - (seriesSpace / 2));
  886. pDC->MoveTo(tickXLocation,yApexPoint - 3);
  887. pDC->LineTo(tickXLocation,yApexPoint + 3);
  889. if(!inRedraw)
  890. {
  891. //draw tick label
  892. CString tickLabel;
  893. tickLabel = tmpSeries->GetLabel();
  894. if(!xAxisAlign)  //horizontal
  895. {
  896. CFont xFont;
  897. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  898. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  899. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  900. pDC->SelectObject(&xFont);
  901. pDC->TextOut(tickXLocation - ((tickLabel.GetLength() * 8) / 2), yApexPoint + 8, tickLabel);
  902. pDC->SelectObject(pOldFont);
  903. }
  904. else
  905. {
  906. CFont sideFont2;
  907. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  908. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  909. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  910. pDC->SelectObject(&sideFont2);
  911. pDC->GetTextMetrics(&tm);
  912. charWidth = tm.tmAveCharWidth;
  913. if(xAxisAlign < 180)
  914. pDC->TextOut(tickXLocation - 8, yApexPoint + 8 + (xAxisLabelLength * charWidth), tickLabel);
  915. else
  916. pDC->TextOut(tickXLocation + 2, yApexPoint + 8, tickLabel);
  918. pDC->SelectObject(pOldFont);
  919. }
  920. }
  921. rightXTick = tickXLocation;
  922. }
  923. if((graphSeries->GetCount() % 2) > 0)
  924. {
  925. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  927. tickXLocation = xApexPoint;
  929. pDC->MoveTo(tickXLocation,yApexPoint - 3);
  930. pDC->LineTo(tickXLocation,yApexPoint + 3);
  932. if(!inRedraw)
  933. {
  934. //draw tick label
  935. CString tickLabel;
  936. tickLabel = tmpSeries->GetLabel();
  937. if(!xAxisAlign)  //horizontal
  938. {
  939. CFont xFont;
  940. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  941. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  942. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  943. pDC->SelectObject(&xFont);
  944. pDC->TextOut(tickXLocation - ((tickLabel.GetLength() * 8) / 2), yApexPoint + 8, tickLabel);
  945. pDC->SelectObject(pOldFont);
  946. }
  947. else
  948. {
  949. CFont sideFont2;
  950. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  951. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  952. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  953. pDC->SelectObject(&sideFont2);
  954. pDC->GetTextMetrics(&tm);
  955. charWidth = tm.tmAveCharWidth;
  956. if(xAxisAlign < 180)
  957. pDC->TextOut(tickXLocation - 8, yApexPoint + 8 + (xAxisLabelLength * charWidth), tickLabel);
  958. else
  959. pDC->TextOut(tickXLocation + 2, yApexPoint + 8, tickLabel);
  961. pDC->SelectObject(pOldFont);
  962. }
  963. }
  964. rightXTick = tickXLocation;
  965. x++;
  966. }
  967. for(; x <= graphSeries->GetCount(); x++)
  968. {
  969. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  971. tickXLocation = xApexPoint - (xAxisWidth / 2) + ((x * seriesSpace) - (seriesSpace / 2));
  973. pDC->MoveTo(tickXLocation,yApexPoint - 3);
  974. pDC->LineTo(tickXLocation,yApexPoint + 3);
  976. if(!inRedraw)
  977. {
  978. //draw tick label
  979. CString tickLabel;
  980. tickLabel = tmpSeries->GetLabel();
  981. if(!xAxisAlign)  //horizontal
  982. {
  983. CFont xFont;
  984. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  985. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  986. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  987. pDC->SelectObject(&xFont);
  988. pDC->TextOut(tickXLocation - ((tickLabel.GetLength() * 8) / 2), yApexPoint + 8, tickLabel);
  989. pDC->SelectObject(pOldFont);
  990. }
  991. else
  992. {
  993. CFont sideFont2;
  994. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  995. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  996. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  997. pDC->SelectObject(&sideFont2);
  998. pDC->GetTextMetrics(&tm);
  999. charWidth = tm.tmAveCharWidth;
  1000. if(xAxisAlign < 180)
  1001. pDC->TextOut(tickXLocation - 8, yApexPoint + 8 + (xAxisLabelLength * charWidth), tickLabel);
  1002. else
  1003. pDC->TextOut(tickXLocation + 2, yApexPoint + 8, tickLabel);
  1005. pDC->SelectObject(pOldFont);
  1006. }
  1007. }
  1008. rightXTick = tickXLocation;
  1009. }
  1010. }
  1011. else
  1012. {
  1013. //scatter graphs will use the same tick marking on both axis lines
  1014. seriesSpace = xAxisWidth / numTicks;
  1015. for(x = 0; x <= numTicks / 2; x++)  
  1016. {
  1017. tickXLocation = xApexPoint + 5 - (xAxisWidth / 2) + (x * seriesSpace);
  1019. //draw tick mark
  1020. pDC->MoveTo(tickXLocation, yApexPoint - 3);
  1021. pDC->LineTo(tickXLocation, yApexPoint + 3);
  1023. if(!inRedraw)
  1024. {
  1025. //draw tick label
  1026. CString tickLabel;
  1027. tickLabel.Format("%d", minTick + (x * tickSpace));
  1029. CFont xFont;
  1030. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1031. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1032. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1033. pDC->SelectObject(&xFont);
  1034. pDC->GetTextMetrics(&tm);
  1035. charWidth = tm.tmAveCharWidth;
  1037. pDC->TextOut(tickXLocation - (tickLabel.GetLength() * charWidth / 2), yApexPoint + 8, tickLabel);
  1038. }
  1039. rightXTick = tickXLocation;
  1040. pDC->SelectObject(pOldFont);
  1041. }
  1042. //draw the 0
  1043. tickXLocation = xApexPoint;
  1044. if(!inRedraw)
  1045. {
  1046. //draw tick label
  1048. CFont xFont;
  1049. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1050. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1051. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1052. pDC->SelectObject(&xFont);
  1053. pDC->GetTextMetrics(&tm);
  1054. charWidth = tm.tmAveCharWidth;
  1056. pDC->TextOut(tickXLocation - (charWidth / 2), yApexPoint + 8, "0");
  1057. }
  1059. for(; x <= numTicks; x++)  
  1060. {
  1061. tickXLocation = xApexPoint - (xAxisWidth / 2) + (x * seriesSpace);
  1063. //draw tick mark
  1064. pDC->MoveTo(tickXLocation, yApexPoint - 3);
  1065. pDC->LineTo(tickXLocation, yApexPoint + 3);
  1067. if(!inRedraw)
  1068. {
  1069. //draw tick label
  1070. CString tickLabel;
  1071. tickLabel.Format("%d", (x / 2) * tickSpace);
  1073. CFont xFont;
  1074. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1075. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1076. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1077. pDC->SelectObject(&xFont);
  1078. pDC->GetTextMetrics(&tm);
  1079. charWidth = tm.tmAveCharWidth;
  1081. pDC->TextOut(tickXLocation - (tickLabel.GetLength() * charWidth / 2), yApexPoint + 8, tickLabel);
  1082. }
  1083. rightXTick = tickXLocation;
  1084. pDC->SelectObject(pOldFont);
  1085. }
  1086. }
  1087. break;
  1088. case 3 :
  1089. if(graphType != SCATTER_GRAPH)
  1090. {
  1091. POSITION pos;
  1092. pos = graphSeries->GetHeadPosition();
  1093. CGraphSeries* tmpSeries;
  1094. for(int x = 1; x <= graphSeries->GetCount(); x++)
  1095. {
  1096. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1098. seriesSpace = xAxisWidth / graphSeries->GetCount();
  1099. tickXLocation = xApexPoint + ((x * seriesSpace) - (seriesSpace / 2));
  1101. pDC->MoveTo(tickXLocation,yApexPoint - 3);
  1102. pDC->LineTo(tickXLocation,yApexPoint + 3);
  1104. if(!inRedraw)
  1105. {
  1106. //draw tick label
  1107. CString tickLabel;
  1108. tickLabel = tmpSeries->GetLabel();
  1109. if(!xAxisAlign)  //horizontal
  1110. {
  1111. CFont xFont;
  1112. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1113. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1114. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1115. pDC->SelectObject(&xFont);
  1116. pDC->TextOut(tickXLocation - ((tickLabel.GetLength() * 8) / 2), yApexPoint + (yAxisHeight / 2) + 8, tickLabel);
  1117. pDC->SelectObject(pOldFont);
  1118. }
  1119. else
  1120. {
  1121. CFont sideFont2;
  1122. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  1123. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1124. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1125. pDC->SelectObject(&sideFont2);
  1126. pDC->GetTextMetrics(&tm);
  1127. charWidth = tm.tmAveCharWidth;
  1128. if(xAxisAlign < 180)
  1129. pDC->TextOut(tickXLocation - 8, yApexPoint + (yAxisHeight / 2) + 8 + (xAxisLabelLength * charWidth), tickLabel);
  1130. else
  1131. pDC->TextOut(tickXLocation + 2, yApexPoint + (yAxisHeight / 2) + 8, tickLabel);
  1133. pDC->SelectObject(pOldFont);
  1134. }
  1135. }
  1136. rightXTick = tickXLocation;
  1137. }
  1138. }
  1139. else
  1140. {
  1141. //scatter graphs will use the same tick marking on both axis lines
  1142. seriesSpace = (xAxisWidth - 20) / numTicks;
  1143. for(int x = 1; x <= numTicks; x++)  
  1144. {
  1145. tickXLocation = xApexPoint + (x * seriesSpace);
  1147. //draw tick mark
  1148. pDC->MoveTo(tickXLocation, yApexPoint - 3);
  1149. pDC->LineTo(tickXLocation, yApexPoint + 3);
  1151. if(!inRedraw)
  1152. {
  1153. //draw tick label
  1154. CString tickLabel;
  1155. tickLabel.Format("%d", x * tickSpace);
  1157. CFont xFont;
  1158. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1159. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1160. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1161. pDC->SelectObject(&xFont);
  1162. pDC->GetTextMetrics(&tm);
  1163. charWidth = tm.tmAveCharWidth;
  1165. pDC->TextOut(tickXLocation - (tickLabel.GetLength() * charWidth / 2), yApexPoint + (yAxisHeight / 2) + 8, tickLabel);
  1166. }
  1167. rightXTick = tickXLocation;
  1168. pDC->SelectObject(pOldFont);
  1169. }
  1171. }
  1172. break;
  1173. case 4 :
  1174. if(graphType != SCATTER_GRAPH)
  1175. {
  1176. POSITION pos;
  1177. pos = graphSeries->GetHeadPosition();
  1178. CGraphSeries* tmpSeries;
  1179. seriesSpace = xAxisWidth / graphSeries->GetCount();
  1180. for(x = 1; x <= graphSeries->GetCount() / 2; x++)
  1181. {
  1182. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1184. tickXLocation = xApexPoint - (xAxisWidth / 2) + ((x * seriesSpace) - (seriesSpace / 2));
  1186. pDC->MoveTo(tickXLocation,yApexPoint - 3);
  1187. pDC->LineTo(tickXLocation,yApexPoint + 3);
  1189. if(!inRedraw)
  1190. {
  1191. //draw tick label
  1192. CString tickLabel;
  1193. tickLabel = tmpSeries->GetLabel();
  1194. if(!xAxisAlign)  //horizontal
  1195. {
  1196. CFont xFont;
  1197. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1198. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1199. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1200. pDC->SelectObject(&xFont);
  1201. pDC->TextOut(tickXLocation - ((tickLabel.GetLength() * 8) / 2), yApexPoint + (yAxisHeight / 2) + 8, tickLabel);
  1202. pDC->SelectObject(pOldFont);
  1203. }
  1204. else
  1205. {
  1206. CFont sideFont2;
  1207. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  1208. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1209. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1210. pDC->SelectObject(&sideFont2);
  1211. pDC->GetTextMetrics(&tm);
  1212. charWidth = tm.tmAveCharWidth;
  1213. if(xAxisAlign < 180)
  1214. pDC->TextOut(tickXLocation - 8, yApexPoint + (yAxisHeight / 2) + 8 + (xAxisLabelLength * charWidth), tickLabel);
  1215. else
  1216. pDC->TextOut(tickXLocation + 2, yApexPoint + (yAxisHeight / 2) + 8, tickLabel);
  1218. pDC->SelectObject(pOldFont);
  1219. }
  1220. }
  1221. rightXTick = tickXLocation;
  1222. }
  1223. if((graphSeries->GetCount() % 2) > 0)
  1224. {
  1225. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1227. tickXLocation = xApexPoint;
  1229. pDC->MoveTo(tickXLocation,yApexPoint - 3);
  1230. pDC->LineTo(tickXLocation,yApexPoint + 3);
  1232. if(!inRedraw)
  1233. {
  1234. //draw tick label
  1235. CString tickLabel;
  1236. tickLabel = tmpSeries->GetLabel();
  1237. if(!xAxisAlign)  //horizontal
  1238. {
  1239. CFont xFont;
  1240. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1241. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1242. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1243. pDC->SelectObject(&xFont);
  1244. pDC->TextOut(tickXLocation - ((tickLabel.GetLength() * 8) / 2), yApexPoint + (yAxisHeight / 2) + 8, tickLabel);
  1245. pDC->SelectObject(pOldFont);
  1246. }
  1247. else
  1248. {
  1249. CFont sideFont2;
  1250. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  1251. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1252. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1253. pDC->SelectObject(&sideFont2);
  1254. pDC->GetTextMetrics(&tm);
  1255. charWidth = tm.tmAveCharWidth;
  1256. if(xAxisAlign < 180)
  1257. pDC->TextOut(tickXLocation - 8, yApexPoint + (yAxisHeight / 2) + 8 + (xAxisLabelLength * charWidth), tickLabel);
  1258. else
  1259. pDC->TextOut(tickXLocation + 2, yApexPoint + (yAxisHeight / 2) + 8, tickLabel);
  1261. pDC->SelectObject(pOldFont);
  1262. }
  1263. }
  1264. rightXTick = tickXLocation;
  1265. x++;
  1266. }
  1267. for(; x <= graphSeries->GetCount(); x++)
  1268. {
  1269. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1271. tickXLocation = xApexPoint - (xAxisWidth / 2) + ((x * seriesSpace) - (seriesSpace / 2));
  1273. pDC->MoveTo(tickXLocation,yApexPoint - 3);
  1274. pDC->LineTo(tickXLocation,yApexPoint + 3);
  1276. if(!inRedraw)
  1277. {
  1278. //draw tick label
  1279. CString tickLabel;
  1280. tickLabel = tmpSeries->GetLabel();
  1281. if(!xAxisAlign)  //horizontal
  1282. {
  1283. CFont xFont;
  1284. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1285. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1286. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1287. pDC->SelectObject(&xFont);
  1288. pDC->TextOut(tickXLocation - ((tickLabel.GetLength() * 8) / 2), yApexPoint + (yAxisHeight / 2) + 8, tickLabel);
  1289. pDC->SelectObject(pOldFont);
  1290. }
  1291. else
  1292. {
  1293. CFont sideFont2;
  1294. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  1295. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1296. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1297. pDC->SelectObject(&sideFont2);
  1298. pDC->GetTextMetrics(&tm);
  1299. charWidth = tm.tmAveCharWidth;
  1300. if(xAxisAlign < 180)
  1301. pDC->TextOut(tickXLocation - 8, yApexPoint + (yAxisHeight / 2) + 8 + (xAxisLabelLength * charWidth), tickLabel);
  1302. else
  1303. pDC->TextOut(tickXLocation + 2, yApexPoint + (yAxisHeight / 2) + 8, tickLabel);
  1305. pDC->SelectObject(pOldFont);
  1306. }
  1307. }
  1308. rightXTick = tickXLocation;
  1309. }
  1310. }
  1311. else
  1312. {
  1313. //scatter graphs will use the same tick marking on both axis lines
  1314. seriesSpace = (xAxisWidth - 20) / numTicks;
  1315. for(x = 1; x <= numTicks / 2; x++)  
  1316. {
  1317. tickXLocation = xApexPoint - (xAxisWidth / 2) + (x * seriesSpace);
  1319. //draw tick mark
  1320. pDC->MoveTo(tickXLocation, yApexPoint + (yAxisHeight / 2) - 3);
  1321. pDC->LineTo(tickXLocation, yApexPoint + (yAxisHeight / 2) + 3);
  1323. if(!inRedraw)
  1324. {
  1325. //draw tick label
  1326. CString tickLabel;
  1327. tickLabel.Format("%d", x * tickSpace);
  1329. CFont xFont;
  1330. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1331. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1332. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1333. pDC->SelectObject(&xFont);
  1334. pDC->GetTextMetrics(&tm);
  1335. charWidth = tm.tmAveCharWidth;
  1337. pDC->TextOut(tickXLocation - (tickLabel.GetLength() * charWidth / 2), yApexPoint + 8, tickLabel);
  1338. }
  1339. rightXTick = tickXLocation;
  1340. pDC->SelectObject(pOldFont);
  1341. }
  1342. //draw the 0
  1344. for(; x <= numTicks; x++)  
  1345. {
  1346. tickXLocation = xApexPoint - (xAxisWidth / 2) + (x * seriesSpace);
  1348. //draw tick mark
  1349. pDC->MoveTo(tickXLocation, yApexPoint + (yAxisHeight / 2) - 3);
  1350. pDC->LineTo(tickXLocation, yApexPoint + (yAxisHeight / 2) + 3);
  1352. if(!inRedraw)
  1353. {
  1354. //draw tick label
  1355. CString tickLabel;
  1356. tickLabel.Format("%d", x * tickSpace);
  1358. CFont xFont;
  1359. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1360. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1361. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1362. pDC->SelectObject(&xFont);
  1363. pDC->GetTextMetrics(&tm);
  1364. charWidth = tm.tmAveCharWidth;
  1366. pDC->TextOut(tickXLocation - (tickLabel.GetLength() * charWidth / 2), yApexPoint + 8, tickLabel);
  1367. }
  1368. rightXTick = tickXLocation;
  1369. pDC->SelectObject(pOldFont);
  1370. }
  1371. }
  1372. break;
  1373. }
  1374. }
  1375. else
  1376. {
  1377. //reverse above stuff and treat as horizontal graph
  1378. switch(graphQuadType)
  1379. {
  1380. case 1 :
  1381. pDC->TextOut(10, (yApexPoint - (yAxisHeight / 2)) + (axisYLabel.GetLength() / 2), axisXLabel);
  1383. pDC->SelectObject(&axisFont);
  1384. pDC->GetTextMetrics(&tm);
  1385. charWidth = tm.tmAveCharWidth;
  1386. labelHeight = tm.tmHeight + 10;
  1387. if(axisYLabel.GetLength() == 0)
  1388. labelHeight = 0;
  1389. pDC->TextOut(xApexPoint + (xAxisWidth / 2) - ((axisXLabel.GetLength() / 2) * charWidth), maxHeight - 5 - 6, axisYLabel);
  1391. pDC->SelectObject(pOldFont);
  1393. //to allow scalability (height may be less than tickRange)
  1394. tickScale = 0.00;
  1396. //draw y axis ticks
  1397. if(graphType != SCATTER_GRAPH)
  1398. {
  1399. tickScale = (yAxisHeight - 10) / seriesSize;
  1400. POSITION pos;
  1401. pos = graphSeries->GetHeadPosition();
  1402. CGraphSeries* tmpSeries;
  1403. for(y = 1; y <= graphSeries->GetCount(); y++)  
  1404. {
  1405. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1407. seriesSpace = yAxisHeight / graphSeries->GetCount();
  1408. tickYLocation = yApexPoint - ((y * seriesSpace) - (seriesSpace / 2));
  1410. //draw tick mark
  1411. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  1412. pDC->LineTo(xApexPoint + 3, tickYLocation);
  1414. if(!inRedraw)
  1415. {
  1416. //draw tick label
  1417. CString tickLabel;
  1418. tickLabel = tmpSeries->GetLabel();
  1420. CFont yFont;
  1421. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1422. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1423. DEFAULT_QUALITY, FIXED_PITCH | FF_ROMAN,"Arial");
  1424. pDC->SelectObject(&yFont);
  1425. charWidth = tm.tmAveCharWidth;
  1427. pDC->TextOut(xApexPoint - (xAxisLabelLength * charWidth) - 5, tickYLocation - (tm.tmHeight / 2), tickLabel);
  1428. }
  1429. topYTick = tickYLocation;
  1430. pDC->SelectObject(pOldFont);
  1431. }
  1432. }
  1433. else
  1434. {
  1435. //scatter graphs will use the same tick marking on both axis lines
  1436. for(y = 1; y <= numTicks; y++)  
  1437. {
  1438. tickScale = (yAxisHeight - 10) / numTicks;
  1439. tickYLocation = yApexPoint - (int)(y * tickScale);
  1441. //draw tick mark
  1442. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  1443. pDC->LineTo(xApexPoint + 3, tickYLocation);
  1445. if(!inRedraw)
  1446. {
  1447. //draw tick label
  1448. CString tickLabel;
  1449. tickLabel.Format("%d", y * tickSpace);
  1451. CFont yFont;
  1452. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1453. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1454. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1455. pDC->SelectObject(&yFont);
  1457. pDC->TextOut(xApexPoint - 10 - (tickLabel.GetLength() * (yTickFontSize / 2)), tickYLocation - 6, tickLabel);
  1458. }
  1459. topYTick = tickYLocation;
  1460. pDC->SelectObject(pOldFont);
  1461. }
  1462. }
  1464. //draw X axis tick marks
  1465. tickScale = (xAxisWidth - 10) / numTicks;
  1466. for(x = 1; x <= numTicks; x++)
  1467. {
  1468. tickXLocation = xApexPoint + (int)(x * tickScale);
  1470. pDC->MoveTo(tickXLocation,yApexPoint - 3);
  1471. pDC->LineTo(tickXLocation,yApexPoint + 3);
  1473. if(!inRedraw)
  1474. {
  1475. if(graphHasGridLines)
  1476. {
  1477. //draw grid lines
  1478. COLORREF gridLineColor;
  1479. gridLineColor = DARK_GREY;
  1480. CPen gridPen (PS_SOLID, 1, gridLineColor);
  1481. CPen* pOldPen;
  1482. pOldPen = pDC->SelectObject(&gridPen);
  1483. pDC->MoveTo(tickXLocation, yApexPoint);
  1484. pDC->LineTo(tickXLocation, yApexPoint - yAxisHeight);
  1485. pDC->SelectObject(pOldPen);
  1486. }
  1488. //draw tick label
  1489. CString tickLabel;
  1490. tickLabel.Format("%d", minTick + (x * tickSpace));
  1491. if(!xAxisAlign)  //horizontal
  1492. {
  1493. CFont xFont;
  1494. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1495. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1496. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1497. pDC->SelectObject(&xFont);
  1498. charWidth = tm.tmAveCharWidth;
  1499. pDC->TextOut(tickXLocation - ((tickLabel.GetLength() * charWidth) / 2), yApexPoint + 8, tickLabel);
  1500. pDC->SelectObject(pOldFont);
  1501. }
  1502. else
  1503. {
  1504. CFont sideFont2;
  1505. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  1506. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1507. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1508. pDC->SelectObject(&sideFont2);
  1509. pDC->GetTextMetrics(&tm);
  1510. charWidth = tm.tmAveCharWidth;
  1511. if(xAxisAlign < 180)
  1512. pDC->TextOut(tickXLocation - 8, yApexPoint + 8 + (xAxisLabelLength * charWidth), tickLabel);
  1513. else
  1514. pDC->TextOut(tickXLocation + 2, yApexPoint + 8, tickLabel);
  1516. pDC->SelectObject(pOldFont);
  1517. }
  1518. }
  1519. rightXTick = tickXLocation;
  1520. }
  1521. break;
  1522. case 2 :
  1523. pDC->TextOut(10, (yApexPoint - (yAxisHeight / 2)) + (axisYLabel.GetLength() / 2), axisXLabel);
  1525. pDC->SelectObject(&axisFont);
  1526. pDC->GetTextMetrics(&tm);
  1527. charWidth = tm.tmAveCharWidth;
  1528. labelHeight = tm.tmHeight + 10;
  1529. if(axisYLabel.GetLength() == 0)
  1530. labelHeight = 0;
  1531. pDC->TextOut(xApexPoint - ((axisXLabel.GetLength() / 2) * charWidth), maxHeight - 5 - 6, axisYLabel);
  1533. pDC->SelectObject(pOldFont);
  1535. //to allow scalability (height may be less than tickRange)
  1536. tickScale = 0.00;
  1537. seriesSpace = yAxisHeight / graphSeries->GetCount();
  1539. //draw y axis ticks
  1540. if(graphType != SCATTER_GRAPH)
  1541. {
  1542. tickScale = (yAxisHeight - 10) / seriesSize;
  1543. POSITION pos;
  1544. pos = graphSeries->GetHeadPosition();
  1545. CGraphSeries* tmpSeries;
  1546. for(y = 1; y <= graphSeries->GetCount(); y++)  
  1547. {
  1548. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1550. tickYLocation = yApexPoint - ((y * seriesSpace) - (seriesSpace / 2));
  1552. //draw tick mark
  1553. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  1554. pDC->LineTo(xApexPoint + 3, tickYLocation);
  1556. if(!inRedraw)
  1557. {
  1558. //draw tick label
  1559. CString tickLabel;
  1560. tickLabel = tmpSeries->GetLabel();
  1562. CFont yFont;
  1563. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1564. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1565. DEFAULT_QUALITY, FIXED_PITCH | FF_ROMAN,"Arial");
  1566. pDC->SelectObject(&yFont);
  1567. charWidth = tm.tmAveCharWidth;
  1569. pDC->TextOut(xApexPoint - (xAxisWidth / 2) - (xAxisLabelLength * charWidth) - 5, tickYLocation - (tm.tmHeight / 2), tickLabel);
  1570. }
  1571. topYTick = tickYLocation;
  1572. pDC->SelectObject(pOldFont);
  1573. }
  1574. topYTick = tickYLocation;
  1575. pDC->SelectObject(pOldFont);
  1576. }
  1577. else
  1578. {
  1579. //scatter graphs will use the same tick marking on both axis lines
  1580. int oldNumTicks;
  1581. oldNumTicks = numTicks;
  1582. numTicks /= 2;
  1584. for(y = 0; y <= numTicks; y++)  
  1585. {
  1586. tickScale = (yAxisHeight - 10) / numTicks;
  1587. tickYLocation = yApexPoint - (int)(y * tickScale);
  1589. //draw tick mark
  1590. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  1591. pDC->LineTo(xApexPoint + 3, tickYLocation);
  1593. if(!inRedraw)
  1594. {
  1595. //draw tick label
  1596. CString tickLabel;
  1597. tickLabel.Format("%d", (y * tickSpace));
  1599. CFont yFont;
  1600. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1601. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1602. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1603. pDC->SelectObject(&yFont);
  1605. pDC->TextOut(xApexPoint - (xAxisWidth / 2) - (tickLabel.GetLength() * (yTickFontSize / 2)) - 6, tickYLocation - 6, tickLabel);
  1606. }
  1607. topYTick = tickYLocation;
  1608. pDC->SelectObject(pOldFont);
  1609. }
  1610. numTicks = oldNumTicks;
  1611. }
  1613. //draw X axis tick marks
  1614. tickScale = (xAxisWidth - 10) / numTicks;
  1615. for(x = 0; x <= numTicks / 2; x++)
  1616. {
  1617. tickXLocation = xApexPoint - (xAxisWidth / 2) + (int)(x * tickScale) + 5;
  1619. if(!inRedraw)
  1620. {
  1621. pDC->MoveTo(tickXLocation,yApexPoint - 3);
  1622. pDC->LineTo(tickXLocation,yApexPoint + 3);
  1624. if(graphHasGridLines)
  1625. {
  1626. //draw grid lines
  1627. COLORREF gridLineColor;
  1628. gridLineColor = DARK_GREY;
  1629. CPen gridPen (PS_SOLID, 1, gridLineColor);
  1630. CPen* pOldPen;
  1631. pOldPen = pDC->SelectObject(&gridPen);
  1632. pDC->MoveTo(tickXLocation, yApexPoint - yAxisHeight);
  1633. pDC->LineTo(tickXLocation, yApexPoint);
  1634. pDC->SelectObject(pOldPen);
  1635. }
  1637. //draw tick label
  1638. CString tickLabel;
  1639. tickLabel.Format("%d", minTick + (x * tickSpace));
  1640. if(!xAxisAlign)  //horizontal
  1641. {
  1642. CFont xFont;
  1643. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1644. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1645. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1646. pDC->SelectObject(&xFont);
  1647. charWidth = tm.tmAveCharWidth;
  1648. pDC->TextOut(tickXLocation - ((tickLabel.GetLength() * charWidth) / 2), yApexPoint + 8, tickLabel);
  1649. pDC->SelectObject(pOldFont);
  1650. }
  1651. else
  1652. {
  1653. CFont sideFont2;
  1654. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  1655. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1656. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1657. pDC->SelectObject(&sideFont2);
  1658. pDC->GetTextMetrics(&tm);
  1659. charWidth = tm.tmAveCharWidth;
  1660. if(xAxisAlign < 180)
  1661. pDC->TextOut(tickXLocation - 8, yApexPoint + 8 + (xAxisLabelLength * charWidth), tickLabel);
  1662. else
  1663. pDC->TextOut(tickXLocation + 2, yApexPoint + 8, tickLabel);
  1665. pDC->SelectObject(pOldFont);
  1666. }
  1667. }
  1668. rightXTick = tickXLocation;
  1669. }
  1670. //draw the 0 location
  1671. tickXLocation = xApexPoint - (xAxisWidth / 2) + (int)(x * tickScale);
  1672. if(!inRedraw)
  1673. {
  1674. //draw tick label
  1675. if(!xAxisAlign)  //horizontal
  1676. {
  1677. CFont xFont;
  1678. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1679. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1680. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1681. pDC->SelectObject(&xFont);
  1682. charWidth = tm.tmAveCharWidth;
  1683. pDC->TextOut(tickXLocation - (charWidth / 2), yApexPoint + 8, "0");
  1684. pDC->SelectObject(pOldFont);
  1685. }
  1686. else
  1687. {
  1688. CFont sideFont2;
  1689. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  1690. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1691. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1692. pDC->SelectObject(&sideFont2);
  1693. pDC->GetTextMetrics(&tm);
  1694. charWidth = tm.tmAveCharWidth;
  1695. if(xAxisAlign < 180)
  1696. pDC->TextOut(tickXLocation - 8, yApexPoint + 8 + (xAxisLabelLength * charWidth), "0");
  1697. else
  1698. pDC->TextOut(tickXLocation + 2, yApexPoint + 8, "0");
  1700. pDC->SelectObject(pOldFont);
  1701. }
  1702. }
  1704. for(; x <= numTicks; x++)
  1705. {
  1706. tickXLocation = xApexPoint - (xAxisWidth / 2) + (int)(x * tickScale);
  1708. pDC->MoveTo(tickXLocation,yApexPoint - 3);
  1709. pDC->LineTo(tickXLocation,yApexPoint + 3);
  1711. if(!inRedraw)
  1712. {
  1713. if(graphHasGridLines)
  1714. {
  1715. //draw grid lines
  1716. COLORREF gridLineColor;
  1717. gridLineColor = DARK_GREY;
  1718. CPen gridPen (PS_SOLID, 1, gridLineColor);
  1719. CPen* pOldPen;
  1720. pOldPen = pDC->SelectObject(&gridPen);
  1721. pDC->MoveTo(tickXLocation, yApexPoint - yAxisHeight);
  1722. pDC->LineTo(tickXLocation, yApexPoint);
  1723. pDC->SelectObject(pOldPen);
  1724. }
  1726. //draw tick label
  1727. CString tickLabel;
  1728. tickLabel.Format("%d", minTick + (x * tickSpace));
  1729. if(!xAxisAlign)  //horizontal
  1730. {
  1731. CFont xFont;
  1732. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1733. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1734. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1735. pDC->SelectObject(&xFont);
  1736. charWidth = tm.tmAveCharWidth;
  1737. pDC->TextOut(tickXLocation - ((tickLabel.GetLength() * charWidth) / 2), yApexPoint + 8, tickLabel);
  1738. pDC->SelectObject(pOldFont);
  1739. }
  1740. else
  1741. {
  1742. CFont sideFont2;
  1743. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  1744. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1745. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1746. pDC->SelectObject(&sideFont2);
  1747. pDC->GetTextMetrics(&tm);
  1748. charWidth = tm.tmAveCharWidth;
  1749. if(xAxisAlign < 180)
  1750. pDC->TextOut(tickXLocation - 8, yApexPoint + 8 + (xAxisLabelLength * charWidth), tickLabel);
  1751. else
  1752. pDC->TextOut(tickXLocation + 2, yApexPoint + 8, tickLabel);
  1754. pDC->SelectObject(pOldFont);
  1755. }
  1756. }
  1757. rightXTick = tickXLocation;
  1758. }
  1759. break;
  1760. case 3 :
  1761. pDC->TextOut(10, yApexPoint - (axisYLabel.GetLength() / 2), axisXLabel);
  1763. pDC->SelectObject(&axisFont);
  1764. pDC->GetTextMetrics(&tm);
  1765. charWidth = tm.tmAveCharWidth;
  1766. labelHeight = tm.tmHeight + 10;
  1767. if(axisYLabel.GetLength() == 0)
  1768. labelHeight = 0;
  1769. pDC->TextOut(xApexPoint + (xAxisWidth / 2) - ((axisXLabel.GetLength() / 2) * charWidth), maxHeight - 5 - 6, axisYLabel);
  1771. pDC->SelectObject(pOldFont);
  1773. //to allow scalability (height may be less than tickRange)
  1774. tickScale = 0.00;
  1775. seriesSpace = yAxisHeight / graphSeries->GetCount();
  1777. //draw y axis ticks
  1778. if(graphType != SCATTER_GRAPH)
  1779. {
  1780. tickScale = (yAxisHeight - 10) / seriesSize;
  1781. POSITION pos;
  1782. pos = graphSeries->GetHeadPosition();
  1783. CGraphSeries* tmpSeries;
  1784. for(y = 1; y <= graphSeries->GetCount() / 2; y++)  
  1785. {
  1786. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1788. tickYLocation = yApexPoint - (yAxisHeight / 2) + ((y * seriesSpace) - (seriesSpace / 2));
  1790. //draw tick mark
  1791. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  1792. pDC->LineTo(xApexPoint + 3, tickYLocation);
  1794. if(!inRedraw)
  1795. {
  1796. //draw tick label
  1797. CString tickLabel;
  1798. tickLabel = tmpSeries->GetLabel();
  1800. CFont yFont;
  1801. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1802. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1803. DEFAULT_QUALITY, FIXED_PITCH | FF_ROMAN,"Arial");
  1804. pDC->SelectObject(&yFont);
  1805. charWidth = tm.tmAveCharWidth;
  1807. pDC->TextOut(xApexPoint - 5 - (tickLabel.GetLength() * (yTickFontSize / 2)), tickYLocation - 6, tickLabel);
  1808. }
  1809. topYTick = tickYLocation;
  1810. pDC->SelectObject(pOldFont);
  1811. }
  1812. //draw the 0 location
  1813. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1814. tickYLocation = yApexPoint;
  1815. //draw tick mark
  1816. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  1817. pDC->LineTo(xApexPoint + 3, tickYLocation);
  1819. if(!inRedraw)
  1820. {
  1821. //draw tick label
  1822. CString tickLabel;
  1823. tickLabel = tmpSeries->GetLabel();
  1825. CFont yFont;
  1826. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1827. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1828. DEFAULT_QUALITY, FIXED_PITCH | FF_ROMAN,"Arial");
  1829. pDC->SelectObject(&yFont);
  1830. charWidth = tm.tmAveCharWidth;
  1832. pDC->TextOut(xApexPoint - 5 - (tickLabel.GetLength() * (yTickFontSize / 2)), tickYLocation - 6, tickLabel);
  1833. }
  1834. topYTick = tickYLocation;
  1835. pDC->SelectObject(pOldFont);
  1836. y++;
  1838. for(; y <= graphSeries->GetCount(); y++)  
  1839. {
  1840. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1842. tickYLocation = yApexPoint - (yAxisHeight / 2) + ((y * seriesSpace) - (seriesSpace / 2));
  1844. //draw tick mark
  1845. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  1846. pDC->LineTo(xApexPoint + 3, tickYLocation);
  1848. if(!inRedraw)
  1849. {
  1850. //draw tick label
  1851. CString tickLabel;
  1852. tickLabel = tmpSeries->GetLabel();
  1854. CFont yFont;
  1855. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1856. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1857. DEFAULT_QUALITY, FIXED_PITCH | FF_ROMAN,"Arial");
  1858. pDC->SelectObject(&yFont);
  1859. charWidth = tm.tmAveCharWidth;
  1861. pDC->TextOut(xApexPoint - 5 - (tickLabel.GetLength() * (yTickFontSize / 2)), tickYLocation - 6, tickLabel);
  1862. }
  1863. topYTick = tickYLocation;
  1864. pDC->SelectObject(pOldFont);
  1865. }
  1866. }
  1867. else
  1868. {
  1869. //scatter graphs will use the same tick marking on both axis lines
  1870. for(y = 0; y < numTicks / 2; y++)  
  1871. {
  1872. tickScale = (yAxisHeight - 10) / numTicks;
  1873. tickYLocation = yApexPoint - (yAxisHeight / 2) + (int)(y * tickScale) + 5;
  1875. //draw tick mark
  1876. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  1877. pDC->LineTo(xApexPoint + 3, tickYLocation);
  1879. if(!inRedraw)
  1880. {
  1881. //draw tick label
  1882. CString tickLabel;
  1883. tickLabel.Format("%d", maxTick - (y * tickSpace));
  1885. CFont yFont;
  1886. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1887. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1888. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1889. pDC->SelectObject(&yFont);
  1891. pDC->TextOut(xApexPoint - (tickLabel.GetLength() * (yTickFontSize / 2)) - 8, tickYLocation - 6, tickLabel);
  1892. pDC->SelectObject(pOldFont);
  1893. }
  1894. }
  1895. //draw the 0 location
  1896. tickYLocation = yApexPoint;
  1897. //draw tick mark
  1898. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  1899. pDC->LineTo(xApexPoint + 3, tickYLocation);
  1901. if(!inRedraw)
  1902. {
  1903. //draw tick label
  1904. CFont yFont;
  1905. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1906. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1907. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1908. pDC->SelectObject(&yFont);
  1910. pDC->TextOut(xApexPoint - (yTickFontSize / 2) - 8, tickYLocation - 6, "0");
  1911. pDC->SelectObject(pOldFont);
  1912. }
  1913. y++;
  1915. for(; y <= numTicks; y++)  
  1916. {
  1917. tickScale = (yAxisHeight - 10) / numTicks;
  1918. tickYLocation = yApexPoint - (yAxisHeight / 2) + (int)(y * tickScale) + 5;
  1920. //draw tick mark
  1921. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  1922. pDC->LineTo(xApexPoint + 3, tickYLocation);
  1924. if(!inRedraw)
  1925. {
  1926. //draw tick label
  1927. CString tickLabel;
  1928. tickLabel.Format("%d", maxTick - (y * tickSpace));
  1930. CFont yFont;
  1931. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1932. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1933. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1934. pDC->SelectObject(&yFont);
  1936. pDC->TextOut(xApexPoint - (tickLabel.GetLength() * (yTickFontSize / 2)) - 5, tickYLocation - 6, tickLabel);
  1937. pDC->SelectObject(pOldFont);
  1938. }
  1939. topYTick = tickYLocation;
  1940. }
  1941. }
  1943. //draw X axis tick marks
  1944. int oldNumTicks;
  1945. oldNumTicks = numTicks;
  1946. numTicks /= 2;
  1947. tickScale = (xAxisWidth - 10) / numTicks;
  1949. for(x = 0; x <= numTicks; x++)
  1950. {
  1951. tickXLocation = xApexPoint + (int)(x * tickScale);
  1953. if(!inRedraw)
  1954. {
  1955. pDC->MoveTo(tickXLocation,yApexPoint - 3);
  1956. pDC->LineTo(tickXLocation,yApexPoint + 3);
  1958. if(graphHasGridLines)
  1959. {
  1960. //draw grid lines
  1961. COLORREF gridLineColor;
  1962. gridLineColor = DARK_GREY;
  1963. CPen gridPen (PS_SOLID, 1, gridLineColor);
  1964. CPen* pOldPen;
  1965. pOldPen = pDC->SelectObject(&gridPen);
  1966. pDC->MoveTo(tickXLocation, yApexPoint - (yAxisHeight / 2));
  1967. pDC->LineTo(tickXLocation, yApexPoint + (yAxisHeight / 2));
  1968. pDC->SelectObject(pOldPen);
  1969. }
  1971. //draw tick label
  1972. CString tickLabel;
  1973. tickLabel.Format("%d", (x * tickSpace * 2));
  1974. if(!xAxisAlign)  //horizontal
  1975. {
  1976. CFont xFont;
  1977. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  1978. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1979. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1980. pDC->SelectObject(&xFont);
  1981. charWidth = tm.tmAveCharWidth;
  1982. pDC->TextOut(tickXLocation - ((tickLabel.GetLength() * charWidth) / 2), yApexPoint + (yAxisHeight / 2) + 8, tickLabel);
  1983. pDC->SelectObject(pOldFont);
  1984. }
  1985. else
  1986. {
  1987. CFont sideFont2;
  1988. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  1989. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  1990. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  1991. pDC->SelectObject(&sideFont2);
  1992. pDC->GetTextMetrics(&tm);
  1993. charWidth = tm.tmAveCharWidth;
  1994. if(xAxisAlign < 180)
  1995. pDC->TextOut(tickXLocation - 8, yApexPoint + (yAxisHeight / 2) + 8 + (xAxisLabelLength * charWidth), tickLabel);
  1996. else
  1997. pDC->TextOut(tickXLocation + 2, yApexPoint + (yAxisHeight / 2) + 8, tickLabel);
  1999. pDC->SelectObject(pOldFont);
  2000. }
  2001. }
  2002. }
  2003. numTicks = oldNumTicks;
  2004. rightXTick = tickXLocation;
  2005. break;
  2006. case 4 :
  2007. pDC->TextOut(10, yApexPoint - (axisYLabel.GetLength() / 2), axisXLabel);
  2009. pDC->SelectObject(&axisFont);
  2010. pDC->GetTextMetrics(&tm);
  2011. charWidth = tm.tmAveCharWidth;
  2012. labelHeight = tm.tmHeight + 10;
  2013. if(axisYLabel.GetLength() == 0)
  2014. labelHeight = 0;
  2015. pDC->TextOut(xApexPoint - ((axisXLabel.GetLength() / 2) * charWidth), maxHeight - 5 - 6, axisYLabel);
  2017. pDC->SelectObject(pOldFont);
  2019. //to allow scalability (height may be less than tickRange)
  2020. tickScale = 0.00;
  2021. seriesSpace = yAxisHeight / graphSeries->GetCount();
  2023. //draw y axis ticks
  2024. if(graphType != SCATTER_GRAPH)
  2025. {
  2026. tickScale = (yAxisHeight - 10) / seriesSize;
  2027. POSITION pos;
  2028. pos = graphSeries->GetHeadPosition();
  2029. CGraphSeries* tmpSeries;
  2030. for(y = 1; y <= graphSeries->GetCount() / 2; y++)  
  2031. {
  2032. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  2034. tickYLocation = yApexPoint - (yAxisHeight / 2) + ((y * seriesSpace) - (seriesSpace / 2));
  2036. //draw tick mark
  2037. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  2038. pDC->LineTo(xApexPoint + 3, tickYLocation);
  2040. if(!inRedraw)
  2041. {
  2042. //draw tick label
  2043. CString tickLabel;
  2044. tickLabel = tmpSeries->GetLabel();
  2046. CFont yFont;
  2047. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  2048. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2049. DEFAULT_QUALITY, FIXED_PITCH | FF_ROMAN,"Arial");
  2050. pDC->SelectObject(&yFont);
  2051. charWidth = tm.tmAveCharWidth;
  2053. pDC->TextOut(xApexPoint - (xAxisWidth / 2) - (xAxisLabelLength * charWidth) - 5, tickYLocation - (tm.tmHeight / 2), tickLabel);
  2054. }
  2055. topYTick = tickYLocation;
  2056. pDC->SelectObject(pOldFont);
  2057. }
  2058. //draw the 0 location
  2059. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  2060. tickYLocation = yApexPoint;
  2061. //draw tick mark
  2062. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  2063. pDC->LineTo(xApexPoint + 3, tickYLocation);
  2065. if(!inRedraw)
  2066. {
  2067. //draw tick label
  2068. CString tickLabel;
  2069. tickLabel = tmpSeries->GetLabel();
  2071. CFont yFont;
  2072. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  2073. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2074. DEFAULT_QUALITY, FIXED_PITCH | FF_ROMAN,"Arial");
  2075. pDC->SelectObject(&yFont);
  2076. charWidth = tm.tmAveCharWidth;
  2078. pDC->TextOut(xApexPoint - (xAxisWidth / 2) - (xAxisLabelLength * charWidth) - 5, tickYLocation - (tm.tmHeight / 2), tickLabel);
  2079. }
  2080. topYTick = tickYLocation;
  2081. pDC->SelectObject(pOldFont);
  2082. y++;
  2084. for(; y <= graphSeries->GetCount(); y++)  
  2085. {
  2086. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  2088. tickYLocation = yApexPoint - (yAxisHeight / 2) + ((y * seriesSpace) - (seriesSpace / 2));
  2090. //draw tick mark
  2091. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  2092. pDC->LineTo(xApexPoint + 3, tickYLocation);
  2094. if(!inRedraw)
  2095. {
  2096. //draw tick label
  2097. CString tickLabel;
  2098. tickLabel = tmpSeries->GetLabel();
  2100. CFont yFont;
  2101. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  2102. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2103. DEFAULT_QUALITY, FIXED_PITCH | FF_ROMAN,"Arial");
  2104. pDC->SelectObject(&yFont);
  2105. charWidth = tm.tmAveCharWidth;
  2107. pDC->TextOut(xApexPoint - (xAxisWidth / 2) - (xAxisLabelLength * charWidth) - 5, tickYLocation - (tm.tmHeight / 2), tickLabel);
  2108. }
  2109. topYTick = tickYLocation;
  2110. pDC->SelectObject(pOldFont);
  2111. }
  2112. }
  2113. else
  2114. {
  2115. //scatter graphs will use the same tick marking on both axis lines
  2116. for(y = 1; y <= numTicks; y++)  
  2117. {
  2118. tickScale = (yAxisHeight - 10) / numTicks;
  2119. tickYLocation = yApexPoint - (yAxisHeight / 2) + (int)(y * tickScale);
  2121. //draw tick mark
  2122. pDC->MoveTo(xApexPoint - 3, tickYLocation);
  2123. pDC->LineTo(xApexPoint + 3, tickYLocation);
  2125. if(!inRedraw)
  2126. {
  2127. //draw tick label
  2128. CString tickLabel;
  2129. tickLabel.Format("%d", y * tickSpace);
  2131. CFont yFont;
  2132. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  2133. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2134. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2135. pDC->SelectObject(&yFont);
  2137. pDC->TextOut(xApexPoint - (xAxisWidth / 2) - (tickLabel.GetLength() * (yTickFontSize / 2)), tickYLocation - 6, tickLabel);
  2138. }
  2139. topYTick = tickYLocation;
  2140. pDC->SelectObject(pOldFont);
  2141. }
  2142. }
  2144. //draw X axis tick marks
  2145. tickScale = (xAxisWidth - 10) / numTicks;
  2146. for(x = 0; x <= numTicks / 2; x++)
  2147. {
  2148. tickXLocation = xApexPoint - (xAxisWidth / 2) + (int)(x * tickScale) + 5;
  2150. if(!inRedraw)
  2151. {
  2152. pDC->MoveTo(tickXLocation,yApexPoint - 3);
  2153. pDC->LineTo(tickXLocation,yApexPoint + 3);
  2155. if(graphHasGridLines)
  2156. {
  2157. //draw grid lines
  2158. COLORREF gridLineColor;
  2159. gridLineColor = DARK_GREY;
  2160. CPen gridPen (PS_SOLID, 1, gridLineColor);
  2161. CPen* pOldPen;
  2162. pOldPen = pDC->SelectObject(&gridPen);
  2163. pDC->MoveTo(tickXLocation, yApexPoint - (yAxisHeight / 2));
  2164. pDC->LineTo(tickXLocation, yApexPoint + (yAxisHeight / 2));
  2165. pDC->SelectObject(pOldPen);
  2166. }
  2168. //draw tick label
  2169. CString tickLabel;
  2170. tickLabel.Format("%d", minTick + (x * tickSpace));
  2171. if(!xAxisAlign)  //horizontal
  2172. {
  2173. CFont xFont;
  2174. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  2175. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2176. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2177. pDC->SelectObject(&xFont);
  2178. charWidth = tm.tmAveCharWidth;
  2179. pDC->TextOut(tickXLocation - ((tickLabel.GetLength() * charWidth) / 2), yApexPoint + (yAxisHeight / 2) + 8, tickLabel);
  2180. pDC->SelectObject(pOldFont);
  2181. }
  2182. else
  2183. {
  2184. CFont sideFont2;
  2185. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  2186. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2187. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2188. pDC->SelectObject(&sideFont2);
  2189. pDC->GetTextMetrics(&tm);
  2190. charWidth = tm.tmAveCharWidth;
  2191. if(xAxisAlign < 180)
  2192. pDC->TextOut(tickXLocation - 8, yApexPoint + (yAxisHeight / 2) + 8 + (xAxisLabelLength * charWidth), tickLabel);
  2193. else
  2194. pDC->TextOut(tickXLocation + 2, yApexPoint + (yAxisHeight / 2) + 8, tickLabel);
  2196. pDC->SelectObject(pOldFont);
  2197. }
  2198. }
  2199. rightXTick = tickXLocation;
  2200. }
  2201. //draw the 0 location
  2202. tickXLocation = xApexPoint - (xAxisWidth / 2) + (int)(x * tickScale);
  2203. if(!inRedraw)
  2204. {
  2205. if(graphHasGridLines)
  2206. {
  2207. //draw grid lines
  2208. COLORREF gridLineColor;
  2209. gridLineColor = DARK_GREY;
  2210. CPen gridPen (PS_SOLID, 1, gridLineColor);
  2211. CPen* pOldPen;
  2212. pOldPen = pDC->SelectObject(&gridPen);
  2213. pDC->MoveTo(tickXLocation, yApexPoint - (yAxisHeight / 2));
  2214. pDC->LineTo(tickXLocation, yApexPoint + (yAxisHeight / 2));
  2215. pDC->SelectObject(pOldPen);
  2216. }
  2218. //draw tick label
  2219. if(!xAxisAlign)  //horizontal
  2220. {
  2221. CFont xFont;
  2222. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  2223. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2224. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2225. pDC->SelectObject(&xFont);
  2226. charWidth = tm.tmAveCharWidth;
  2227. pDC->TextOut(tickXLocation - (charWidth / 2), yApexPoint + (yAxisHeight / 2) + 8, "0");
  2228. pDC->SelectObject(pOldFont);
  2229. }
  2230. else
  2231. {
  2232. CFont sideFont2;
  2233. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  2234. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2235. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2236. pDC->SelectObject(&sideFont2);
  2237. pDC->GetTextMetrics(&tm);
  2238. charWidth = tm.tmAveCharWidth;
  2239. if(xAxisAlign < 180)
  2240. pDC->TextOut(tickXLocation - 8, yApexPoint + (yAxisHeight / 2) + 8 + (xAxisLabelLength * charWidth), "0");
  2241. else
  2242. pDC->TextOut(tickXLocation + 2, yApexPoint + (yAxisHeight / 2) + 8, "0");
  2244. pDC->SelectObject(pOldFont);
  2245. }
  2246. }
  2247. x++;
  2249. for(; x <= numTicks; x++)
  2250. {
  2251. tickXLocation = xApexPoint - (xAxisWidth / 2) + (int)(x * tickScale);
  2253. pDC->MoveTo(tickXLocation,yApexPoint - 3);
  2254. pDC->LineTo(tickXLocation,yApexPoint + 3);
  2256. if(!inRedraw)
  2257. {
  2258. if(graphHasGridLines)
  2259. {
  2260. //draw grid lines
  2261. COLORREF gridLineColor;
  2262. gridLineColor = DARK_GREY;
  2263. CPen gridPen (PS_SOLID, 1, gridLineColor);
  2264. CPen* pOldPen;
  2265. pOldPen = pDC->SelectObject(&gridPen);
  2266. pDC->MoveTo(tickXLocation, yApexPoint - (yAxisHeight / 2));
  2267. pDC->LineTo(tickXLocation, yApexPoint + (yAxisHeight / 2));
  2268. pDC->SelectObject(pOldPen);
  2269. }
  2271. //draw tick label
  2272. CString tickLabel;
  2273. tickLabel.Format("%d", (x / 2) * tickSpace);
  2274. if(!xAxisAlign)  //horizontal
  2275. {
  2276. CFont xFont;
  2277. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  2278. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2279. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2280. pDC->SelectObject(&xFont);
  2281. charWidth = tm.tmAveCharWidth;
  2282. pDC->TextOut(tickXLocation - ((tickLabel.GetLength() * charWidth) / 2), yApexPoint + (yAxisHeight / 2) + 8, tickLabel);
  2283. pDC->SelectObject(pOldFont);
  2284. }
  2285. else
  2286. {
  2287. CFont sideFont2;
  2288. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  2289. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2290. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2291. pDC->SelectObject(&sideFont2);
  2292. pDC->GetTextMetrics(&tm);
  2293. charWidth = tm.tmAveCharWidth;
  2294. if(xAxisAlign < 180)
  2295. pDC->TextOut(tickXLocation - 8, yApexPoint + (yAxisHeight / 2) + 8 + (xAxisLabelLength * charWidth), tickLabel);
  2296. else
  2297. pDC->TextOut(tickXLocation + 2, yApexPoint + (yAxisHeight / 2) + 8, tickLabel);
  2299. pDC->SelectObject(pOldFont);
  2300. }
  2301. }
  2302. rightXTick = tickXLocation;
  2303. }
  2304. break;
  2305. }
  2306. }
  2307. break;
  2308. case BAR_GRAPH_3D :
  2309. case LINE_GRAPH_3D :
  2310. case STACKED_BAR_GRAPH_3D :
  2311. depth = (int)(yAxisHeight * depthRatio);
  2313. xApexPoint += depth;
  2314. yApexPoint -= depth;
  2315. xAxisWidth -= depth;
  2316. yAxisHeight -= depth;
  2317. //draw y axis
  2318. pDC->MoveTo(xApexPoint, yApexPoint);  
  2319. pDC->LineTo(xApexPoint, yApexPoint - yAxisHeight);
  2320. //draw x axis
  2321. pDC->MoveTo(xApexPoint, yApexPoint);  
  2322. pDC->LineTo(xApexPoint + xAxisWidth, yApexPoint);
  2324. //adjust graph settings for 3D look
  2325. yApexPoint += depth;
  2326. xApexPoint -= depth;
  2327. //foreground axis
  2328. pDC->MoveTo(xApexPoint, yApexPoint + (int)(depth * .2));  
  2329. pDC->LineTo(xApexPoint, yApexPoint - yAxisHeight);
  2330. pDC->MoveTo(xApexPoint - (int)(depth * .2), yApexPoint);  
  2331. pDC->LineTo(xApexPoint + xAxisWidth, yApexPoint);
  2332. //connecting line at apex
  2333. pDC->MoveTo(xApexPoint, yApexPoint);  
  2334. pDC->LineTo(xApexPoint + depth, yApexPoint - depth);
  2335. //connecting line at height
  2336. pDC->MoveTo(xApexPoint, yApexPoint - yAxisHeight);  
  2337. pDC->LineTo(xApexPoint + depth, yApexPoint - yAxisHeight - depth);
  2338. //connecting line at width
  2339. pDC->MoveTo(xApexPoint + xAxisWidth, yApexPoint);  
  2340. pDC->LineTo(xApexPoint + xAxisWidth + depth, yApexPoint - depth);
  2341. //top and right border lines
  2342. pDC->MoveTo(xApexPoint + depth, yApexPoint - yAxisHeight - depth);
  2343. pDC->LineTo(xApexPoint + xAxisWidth + depth, yApexPoint - yAxisHeight - depth);
  2344. pDC->LineTo(xApexPoint + xAxisWidth + depth, yApexPoint - depth);
  2346. //Tick marks ... and labels too
  2347. //draw labels
  2348. tFontSize = 16;
  2349. if(maxWidth > maxHeight)
  2350. {
  2351. while((axisYLabel.GetLength() * (tFontSize / 2)) > maxHeight)
  2352. {
  2353. tFontSize -= 2;
  2354. }
  2355. }
  2356. else
  2357. {
  2358. while((axisXLabel.GetLength() * (tFontSize / 2)) > maxWidth)
  2359. {
  2360. tFontSize -= 2;
  2361. }
  2362. }
  2363. axisFont.CreateFont(tFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  2364. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2365. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2366. sideFont.CreateFont(tFontSize, 0, 900, 0, 700, FALSE, FALSE, 0,
  2367. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2368. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2370. pDC->SelectObject(&sideFont);
  2371. pDC->GetTextMetrics(&tm);
  2372. charWidth = tm.tmAveCharWidth;
  2374. if(graphAlignment)
  2375. {
  2376. pDC->TextOut(10, (yApexPoint - (yAxisHeight / 2)) + ((axisYLabel.GetLength() * charWidth) / 2), axisYLabel);
  2378. pDC->SelectObject(&axisFont);
  2379. pDC->GetTextMetrics(&tm);
  2380. charWidth = tm.tmAveCharWidth;
  2381. pDC->TextOut(xApexPoint + (xAxisWidth / 2) - ((axisXLabel.GetLength() / 2) * charWidth), maxHeight - 5 - 6, axisXLabel);
  2383. pDC->SelectObject(pOldFont);
  2385. tickScale = 0.00;
  2386. tickScale = yAxisHeight / numTicks;
  2388. //draw y axis ticks
  2389. for(int y = 1; y <= numTicks; y++)  
  2390. {
  2391. tickYLocation = yApexPoint - (int)(y * tickScale);
  2393. //draw tick mark
  2394. pDC->MoveTo(xApexPoint - (int)(depth * .2), tickYLocation);
  2395. pDC->LineTo(xApexPoint, tickYLocation);
  2397. COLORREF gridLineColor;
  2398. CPen* pOldPen;
  2400. //draw grid lines
  2401. gridLineColor = DARK_GREY;
  2402. CPen gridPen (PS_SOLID, 1, gridLineColor);
  2403. pOldPen = pDC->SelectObject(&gridPen);
  2404. pDC->MoveTo(xApexPoint, tickYLocation);
  2405. pDC->LineTo(xApexPoint + depth, tickYLocation - depth);
  2406. if(graphHasGridLines)
  2407. {
  2408. pDC->LineTo(xApexPoint + xAxisWidth + depth, tickYLocation - depth);
  2409. }
  2410. pDC->SelectObject(pOldPen);
  2412. //draw tick label
  2413. CString tickLabel;
  2414. tickLabel.Format("%d", minTick + (y * tickSpace));
  2416. CFont yFont;
  2417. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  2418. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2419. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2420. pDC->SelectObject(&yFont);
  2422. pDC->TextOut(xApexPoint - 10 - (tickLabel.GetLength() * (yTickFontSize / 2)), tickYLocation - 6, tickLabel);
  2423. topYTick = tickYLocation;
  2424. pDC->SelectObject(pOldFont);
  2426. //draw 1/2 tick line (grey)
  2427. int midTickYLocation;
  2428. midTickYLocation = yApexPoint - (int)(y * tickScale * .5) - (int)((y - 1) * tickScale * .5);
  2430. //draw tick mark
  2431. pDC->MoveTo(xApexPoint - (int)(depth * .2), midTickYLocation);
  2432. pDC->LineTo(xApexPoint, midTickYLocation);
  2434. //draw grid lines
  2435. gridLineColor = LIGHT_GREY;
  2436. CPen midGridPen (PS_SOLID, 1, gridLineColor);
  2437. pOldPen = pDC->SelectObject(&midGridPen);
  2438. pDC->MoveTo(xApexPoint, midTickYLocation);
  2439. pDC->LineTo(xApexPoint + depth, midTickYLocation - depth);
  2440. if(graphHasGridLines)
  2441. {
  2442. pDC->LineTo(xApexPoint + xAxisWidth + depth, midTickYLocation - depth);
  2443. }
  2444. pDC->SelectObject(pOldPen);
  2445. }
  2447. //draw X axis tick marks
  2448. POSITION pos;
  2449. pos = graphSeries->GetHeadPosition();
  2450. CGraphSeries* tmpSeries;
  2451. for(int x = 1; x <= graphSeries->GetCount(); x++)
  2452. {
  2453. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  2455. seriesSpace = xAxisWidth / graphSeries->GetCount();
  2456. tickXLocation = xApexPoint + ((x * seriesSpace) - (seriesSpace / 2));
  2458. //unlike normal series, we put ticks here
  2459. //on the outsides of the series
  2460. pDC->MoveTo(xApexPoint + (x * seriesSpace),yApexPoint + (int)(depth * .2));
  2461. pDC->LineTo(xApexPoint + (x * seriesSpace),yApexPoint);
  2462. pDC->LineTo(xApexPoint + (x * seriesSpace) + depth,yApexPoint - depth);
  2464. //draw tick label
  2465. CString tickLabel;
  2466. tickLabel = tmpSeries->GetLabel();
  2467. if(!xAxisAlign)  //horizontal
  2468. pDC->TextOut(tickXLocation - ((tickLabel.GetLength() * 8) / 2), yApexPoint + 8, tickLabel);
  2469. else
  2470. {
  2471. CFont sideFont2;
  2472. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  2473. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2474. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2475. pDC->SelectObject(&sideFont2);
  2476. pDC->GetTextMetrics(&tm);
  2477. charWidth = tm.tmAveCharWidth;
  2478. if(xAxisAlign < 180)
  2479. pDC->TextOut(tickXLocation - 8, yApexPoint + 8 + (xAxisLabelLength * charWidth), tickLabel);
  2480. else
  2481. pDC->TextOut(tickXLocation + 2, yApexPoint + 8, tickLabel);
  2483. pDC->SelectObject(pOldFont);
  2484. }
  2485. rightXTick = tickXLocation;
  2486. }
  2487. }
  2488. else
  2489. {
  2490. //reverse above stuff and treat as horizontal graph
  2491. pDC->TextOut(10, (yApexPoint - (yAxisHeight / 2)) + (axisYLabel.GetLength() / 2), axisXLabel);
  2493. pDC->SelectObject(&axisFont);
  2494. pDC->GetTextMetrics(&tm);
  2495. charWidth = tm.tmAveCharWidth;
  2496. labelHeight = tm.tmHeight + 10;
  2497. if(axisYLabel.GetLength() == 0)
  2498. labelHeight = 0;
  2499. pDC->TextOut(xApexPoint + (xAxisWidth / 2) - ((axisXLabel.GetLength() / 2) * charWidth), maxHeight - 5 - 6, axisYLabel);
  2501. pDC->SelectObject(pOldFont);
  2503. tickScale = 0.00;
  2505. //draw y axis ticks
  2506. tickScale = (yAxisHeight - 10) / seriesSize;
  2507. POSITION pos;
  2508. pos = graphSeries->GetHeadPosition();
  2509. CGraphSeries* tmpSeries;
  2510. for(int y = 1; y <= graphSeries->GetCount(); y++)  
  2511. {
  2512. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  2514. seriesSpace = yAxisHeight / graphSeries->GetCount();
  2515. tickYLocation = yApexPoint - (y * seriesSpace);
  2517. //draw tick mark
  2518. //unlike normal series, we put ticks here on the 
  2519. //outside of the series
  2520. pDC->MoveTo(xApexPoint - (int)(depth * .2), tickYLocation);
  2521. pDC->LineTo(xApexPoint, tickYLocation);
  2522. pDC->LineTo(xApexPoint + depth,yApexPoint - (y * seriesSpace) - depth);
  2524. //draw tick label
  2525. CString tickLabel;
  2526. tickLabel = tmpSeries->GetLabel();
  2528. CFont yFont;
  2529. yFont.CreateFont(yTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  2530. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2531. DEFAULT_QUALITY, FIXED_PITCH | FF_ROMAN,"Arial");
  2532. pDC->SelectObject(&yFont);
  2533. charWidth = tm.tmAveCharWidth;
  2535. pDC->TextOut(xApexPoint - (xAxisLabelLength * charWidth) - 5, tickYLocation - (tm.tmHeight / 2), tickLabel);
  2537. topYTick = tickYLocation;
  2538. pDC->SelectObject(pOldFont);
  2539. }
  2541. //draw X axis tick marks
  2542. tickScale = (xAxisWidth - 10) / numTicks;
  2543. for(int x = 1; x <= numTicks; x++)
  2544. {
  2545. tickXLocation = xApexPoint + (int)(x * tickScale);
  2547. pDC->MoveTo(tickXLocation,yApexPoint + (int)(depth * .2));
  2548. pDC->LineTo(tickXLocation,yApexPoint);
  2550. COLORREF gridLineColor;
  2551. CPen* pOldPen;
  2553. //draw grid lines
  2554. gridLineColor = DARK_GREY;
  2555. CPen gridPen (PS_SOLID, 1, gridLineColor);
  2556. pOldPen = pDC->SelectObject(&gridPen);
  2557. pDC->MoveTo(tickXLocation, yApexPoint);
  2558. pDC->LineTo(tickXLocation + depth, yApexPoint - depth);
  2559. if(graphHasGridLines)
  2560. {
  2561. pDC->LineTo(tickXLocation + depth, yApexPoint - yAxisHeight - depth);
  2562. }
  2563. pDC->SelectObject(pOldPen);
  2565. //draw tick label
  2566. CString tickLabel;
  2567. tickLabel.Format("%d", minTick + (x * tickSpace));
  2568. if(!xAxisAlign)  //horizontal
  2569. {
  2570. CFont xFont;
  2571. xFont.CreateFont(xTickFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  2572. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2573. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2574. pDC->SelectObject(&xFont);
  2575. charWidth = tm.tmAveCharWidth;
  2576. pDC->TextOut(tickXLocation - ((tickLabel.GetLength() * charWidth) / 2), yApexPoint + 8, tickLabel);
  2577. pDC->SelectObject(pOldFont);
  2578. }
  2579. else
  2580. {
  2581. CFont sideFont2;
  2582. sideFont2.CreateFont(xTickFontSize, 0, (xAxisAlign * 10), 0, 700, FALSE, FALSE, 0,
  2583. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2584. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2585. pDC->SelectObject(&sideFont2);
  2586. pDC->GetTextMetrics(&tm);
  2587. charWidth = tm.tmAveCharWidth;
  2588. if(xAxisAlign < 180)
  2589. pDC->TextOut(tickXLocation - 8, yApexPoint + 8 + (xAxisLabelLength * charWidth), tickLabel);
  2590. else
  2591. pDC->TextOut(tickXLocation + 2, yApexPoint + 8, tickLabel);
  2593. pDC->SelectObject(pOldFont);
  2594. }
  2595. rightXTick = tickXLocation;
  2597. //draw 1/2 tick line (grey)
  2598. int midTickXLocation;
  2599. midTickXLocation = xApexPoint + (int)(x * tickScale * .5) + (int)((x - 1) * tickScale * .5);
  2601. //draw tick mark
  2602. pDC->MoveTo(midTickXLocation,yApexPoint + (int)(depth * .2));
  2603. pDC->LineTo(midTickXLocation,yApexPoint);
  2605. //draw grid lines
  2606. gridLineColor = LIGHT_GREY;
  2607. CPen midGridPen (PS_SOLID, 1, gridLineColor);
  2608. pDC->SelectObject(&midGridPen);
  2609. pDC->MoveTo(midTickXLocation, yApexPoint);
  2610. pDC->LineTo(midTickXLocation + depth, yApexPoint - depth);
  2611. if(graphHasGridLines)
  2612. {
  2613. pDC->LineTo(midTickXLocation + depth, yApexPoint - yAxisHeight - depth);
  2614. }
  2615. pDC->SelectObject(pOldPen);
  2616. }
  2617. }
  2619. break;
  2620. }
  2621. }
  2623. void CGraph::AddSeries(CGraphSeries* dataSet)
  2624. {
  2625. int numData = 0;
  2627. numData = dataSet->GetDataCount();
  2629. if(numData > seriesSize)
  2630. seriesSize = numData;
  2632. graphSeries->AddTail(dataSet);
  2633. }
  2635. void CGraph::SetXAxisLabel(CString label)
  2636. {
  2637. axisXLabel = label;
  2638. xAxisLabelLength = axisXLabel.GetLength();
  2639. }
  2641. void CGraph::SetYAxisLabel(CString label)
  2642. {
  2643. axisYLabel = label;
  2644. yAxisLabelLength = axisYLabel.GetLength();
  2645. }
  2647. void CGraph::DrawSeries(CDC* pDC)
  2648. {
  2649. switch(graphType)
  2650. {
  2651. case BAR_GRAPH :
  2652.  DrawBarSeries(pDC);
  2653.  break;
  2654. case LINE_GRAPH :
  2655.  DrawLineSeries(pDC);
  2656.  break;
  2657. case PIE_GRAPH :
  2658.  DrawPieSeries(pDC);
  2659.  break;
  2660. case SCATTER_GRAPH :
  2661.  DrawScatterSeries(pDC);
  2662.  break;
  2663. case BOX_WHISKER_GRAPH :
  2664.  DrawBoxWhiskerSeries(pDC);
  2665.  break;
  2666. case STACKED_BAR_GRAPH :
  2667.  DrawStackedBarSeries(pDC);
  2668.  break;
  2669. case XY_LINE_GRAPH :
  2670.  DrawXYLineSeries(pDC);
  2671.  break;
  2672. // case RADAR_GRAPH :
  2673. //  DrawRadarSeries(pDC);
  2674. //  break;
  2675. case BAR_GRAPH_3D :
  2676.  Draw3DBarSeries(pDC);
  2677.  break;
  2678. case LINE_GRAPH_3D :
  2679.  Draw3DLineSeries(pDC);
  2680.  break;
  2681. case STACKED_BAR_GRAPH_3D :
  2682.  Draw3DStackedBarSeries(pDC);
  2683.  break;
  2684. case PIE_GRAPH_3D :
  2685.  Draw3DPieSeries(pDC);
  2686.  break;
  2687. default :
  2688.  AfxMessageBox("No graph type to display");
  2689.  break;
  2690. }
  2692. }
  2694. void CGraph::SetLegend(int datagroup, CString label)
  2695. {
  2696. if(graphType != SCATTER_GRAPH) //scatter graphs don't need legends
  2697. {
  2698. graphLegend.SetLegendText(datagroup, label);
  2699. graphHasLegend = TRUE;
  2700. if(legendMaxText < label.GetLength())
  2701. legendMaxText = label.GetLength();
  2702. }
  2703. }
  2705. int CGraph::DrawLegend(CDC* pDC)
  2706. {
  2707. //determine size of legend
  2708. //12 chars per seriesSize + 6 for spacing (3 top and bottom) 
  2709. //+ 1 set for label title(3+12+6) + rectangle (2 chars) + 3 for final bottom buffer
  2710. int legendHeight = 23 + (seriesSize * 18) + 3;
  2711. int legendL, legendT, legendR, legendB;
  2712. int barL, barT, barR, barB;
  2713. TEXTMETRIC tm;
  2715. legendT = (maxHeight / 2) - (legendHeight / 2);
  2716. legendB = legendT + legendHeight;
  2717. legendR = maxWidth - 5;
  2718. legendL = legendR - ((graphLegend.GetLegendLength() * (int)(legendFontSize * .66)) + 25);
  2719. //allows 50 pixels for display of legend bar 45 + 5 space.
  2720. legendWidth = legendR - legendL;
  2722. pDC->Rectangle(legendL, legendT, legendR, legendB);
  2723. CFont legendTitleFont;
  2724. legendTitleFont.CreateFont(15, 0, 0, 0, 500, FALSE, FALSE, 0,
  2725. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2726. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2727. CFont* pOldFont = (CFont*) pDC->SelectObject(&legendTitleFont);
  2728. pDC->GetTextMetrics(&tm);
  2729. int charWidth = tm.tmAveCharWidth;
  2730. pDC->TextOut(legendL + (legendWidth / 2) - (3 * charWidth), 
  2731. legendT + 3, "图例");
  2732. pDC->SelectObject(pOldFont);
  2733. for(int i = 0; i < seriesSize; i++)
  2734. {
  2735. //top "Legend" text will use 12 + 3 top + 6 bottom (21 total)
  2736. //each legend label will need 3 chars on top, so the 24 in the offset
  2737. //each label than uses 12 + 3 below + 3 above next label, so 18
  2738. // in the i * offset.  
  2739. CFont legendFont;
  2740. legendFont.CreateFont(legendFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  2741. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2742. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2743. pOldFont = (CFont*) pDC->SelectObject(&legendFont);
  2745. pDC->TextOut(legendL + 5, legendT + 24 + (i * 18) + 1, graphLegend.GetLegendText(i));
  2747. pDC->SelectObject(pOldFont);
  2749. //draw bar
  2750. COLORREF barColor;
  2751. barColor = GetColor(i);
  2752. CBrush brush (barColor);
  2753. CBrush* pOldBrush;
  2754. pOldBrush = pDC->SelectObject(&brush);
  2756. barL = legendL + 5 + (legendMaxText * (legendFontSize / 2)) + 5;
  2757. barT = legendT + 24 + (i * 18) + 1, graphLegend.GetLegendText(i);
  2758. barR = legendR - 5;
  2759. barB = barT + 12;
  2760. pDC->Rectangle(barL, barT, barR, barB);
  2762. pDC->SelectObject(pOldBrush);
  2763. }
  2765. return legendL;
  2766. }
  2768. void CGraph::SetGraphTitle(CString title)
  2769. {
  2770. graphTitle = title;
  2771. }
  2773. void CGraph::SetXTickFontSize(int size)
  2774. {
  2775. xTickFontSize = size;
  2776. }
  2778. void CGraph::SetYTickFontSize(int size)
  2779. {
  2780. yTickFontSize = size;
  2781. }
  2783. void CGraph::SetLegendFontSize(int size)
  2784. {
  2785. legendFontSize = size;
  2786. }
  2789. int CGraph::PrintGraph(CDC* pDC, CPrintInfo* pInfo)
  2790. {
  2791. CString str;
  2792. CFont graphTitleFont, textFont;
  2793. TEXTMETRIC tm;
  2794. CString tickLabel;
  2796. maxHeight = pGraphT - pGraphB; 
  2797. maxWidth = pGraphR - pGraphL; 
  2799.     //titleFont is 24 point, bold
  2800. graphTitleFont.CreateFont(-480, 0, 0, 0, 400, FALSE, FALSE, 0, ANSI_CHARSET,
  2801. OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2802. DEFAULT_QUALITY, DEFAULT_PITCH || FF_ROMAN,
  2803. "Times New Roman");
  2805. //textFont is 12 point
  2806. textFont.CreateFont(-240, 0, 0, 0, 400, FALSE, FALSE, 0, ANSI_CHARSET,
  2807. OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2808. DEFAULT_QUALITY, DEFAULT_PITCH || FF_ROMAN,
  2809. "Times New Roman");
  2811. pDC->SetMapMode(MM_TWIPS);
  2812. CFont* pOldFont = (CFont*) pDC->SelectObject(&graphTitleFont);
  2813. pDC->GetTextMetrics(&tm);
  2815. int charWidth = tm.tmAveCharWidth;
  2816. int charHeight = tm.tmHeight;
  2817. //next line is centered....trust me !!
  2818. pDC->TextOut(pGraphL + (maxWidth / 2) - ((graphTitle.GetLength() / 2) * charWidth), pGraphT - 50, graphTitle);
  2820. pDC->SelectObject(pOldFont);
  2822. if((graphType == PIE_GRAPH) || (graphType == PIE_GRAPH_3D))
  2823. {
  2824. xAxisWidth = pGraphR - pGraphL - 200;
  2825. yAxisHeight = maxHeight - 600 - charHeight;
  2826. xApexPoint = pGraphL + 500;
  2827. yApexPoint = pGraphB + 500;
  2828. }
  2829. else
  2830. {
  2831. //compute label size for axis alignment
  2832. CFont sideFont, axisFont;
  2833. int tFontSize;
  2834. tFontSize = 16;
  2835. if(maxWidth > maxHeight)
  2836. {
  2837. while((axisYLabel.GetLength() * (tFontSize / 2)) > maxHeight)
  2838. {
  2839. tFontSize -= 2;
  2840. }
  2841. }
  2842. else
  2843. {
  2844. while((axisXLabel.GetLength() * (tFontSize / 2)) > maxWidth)
  2845. {
  2846. tFontSize -= 2;
  2847. }
  2848. }
  2849. //set tFontSize for printer
  2850. tFontSize *= -20;
  2851. axisFont.CreateFont(tFontSize, 0, 0, 0, 700, FALSE, FALSE, 0,
  2852. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2853. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2854. sideFont.CreateFont(tFontSize, 0, 900, 0, 700, FALSE, FALSE, 0,
  2855. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2856. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  2858. CFont* pOldFont = (CFont*) pDC->SelectObject(&sideFont);
  2859. pDC->GetTextMetrics(&tm);
  2860. int charWidth = tm.tmAveCharWidth;
  2861. int labelHeight = tm.tmHeight + 50;
  2862. if(graphAlignment)
  2863. {
  2864. if(axisXLabel.GetLength() == 0)
  2865. labelHeight = 0;
  2866. }
  2867. else
  2868. {
  2869. if(axisYLabel.GetLength() == 0)
  2870. labelHeight = 0;
  2871. }
  2872. pDC->SelectObject(pOldFont);
  2874. tickLabel.Format("%d", maxTick);
  2877. //determine axis specifications 
  2878. if(graphAlignment)
  2879. {
  2880. xApexPoint = pGraphL + (tickLabel.GetLength() * charWidth) + labelHeight + 100; 
  2882. if(!xAxisAlign)  //horizontal
  2883. {
  2884. yApexPoint = pGraphB + 50 + (labelHeight * 2);
  2885. }
  2886. else
  2887. {
  2888. yApexPoint = pGraphB + labelHeight + (xAxisLabelLength * labelHeight);
  2889. }
  2890. yAxisHeight = pGraphT - 200 - charHeight/*this is title height*/ - yApexPoint;
  2891. xAxisWidth = (maxWidth - 100) - xApexPoint;
  2893. }
  2894. else
  2895. {
  2896. xApexPoint = pGraphL + (xAxisLabelLength * charWidth) + labelHeight; 
  2898. yApexPoint = pGraphB + 50 + (labelHeight * 2);
  2899. yAxisHeight = pGraphT - 200 - charHeight/*this is title height*/ - yApexPoint;
  2900. xAxisWidth = (maxWidth - 100) - xApexPoint;
  2901. }
  2902. }
  2904. //draw legend
  2905. if(graphHasLegend)
  2906. {
  2907. int legendL = PrintLegend(pDC);
  2908. xAxisWidth = legendL - 200 - xApexPoint;
  2909. }
  2911. if(graphType != 2)  //not pie
  2912. {
  2913. //draw axis lines
  2914. PrintAxis(pDC);
  2915. }
  2917. //draw series data and labels
  2918. PrintSeries(pDC);
  2921. //update pGraphB value to pad some space below the graph
  2922. pGraphB -= 90;
  2923. return pGraphB;
  2924. }
  2927. int CGraph::PrintLegend(CDC *pDC)
  2928. {
  2929. CFont legendLabelFont, legendTitleFont;
  2930. TEXTMETRIC tm;
  2932. int legendL, legendT, legendR, legendB;
  2933. int barL, barT, barR, barB;
  2935. //legendLabelFont is 10 point
  2936. legendLabelFont.CreateFont(-200, 0, 0, 0, 400, FALSE, FALSE, 0, ANSI_CHARSET,
  2937. OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2938. DEFAULT_QUALITY, DEFAULT_PITCH || FF_ROMAN,
  2939. "Times New Roman");
  2941. //legendTitleFont is 12 point
  2942. legendTitleFont.CreateFont(-240, 0, 0, 0, 400, FALSE, FALSE, 0, ANSI_CHARSET,
  2943. OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  2944. DEFAULT_QUALITY, DEFAULT_PITCH || FF_ROMAN,
  2945. "Times New Roman");
  2947. CFont* pOldFont = (CFont*) pDC->SelectObject(&legendTitleFont);
  2948. pDC->GetTextMetrics(&tm);
  2949. int legendCharWidth = tm.tmAveCharWidth;
  2950. legendT = (((pGraphB - pGraphT) / 2) + pGraphT) + (((seriesSize + 1) / 2) * 240 + 300);
  2951. legendB = (((pGraphB - pGraphT) / 2) + pGraphT) - (((seriesSize + 1) / 2) * 240 + 300);
  2952. legendR = pGraphR - 100;
  2953. legendL = legendR - ((graphLegend.GetLegendLength() * legendCharWidth) + 1000);
  2954. legendWidth = legendR - legendL;
  2956. pDC->Rectangle(legendL, legendT, legendR, legendB);
  2957. pDC->TextOut(legendL + (legendWidth / 2) - 360, 
  2958. legendT - 160, "图例");
  2959. pDC->SelectObject(pOldFont);
  2960. for(int i = 0; i < seriesSize; i++)
  2961. {
  2962. pOldFont = (CFont*) pDC->SelectObject(&legendLabelFont);
  2963. pDC->GetTextMetrics(&tm);
  2965. int charWidth = tm.tmMaxCharWidth;
  2966. int charHeight = tm.tmHeight;
  2968. CString valuStr;
  2969. pDC->TextOut(legendL + 100, legendT - 500 - (i * charHeight), graphLegend.GetLegendText(i));
  2970. pDC->SelectObject(pOldFont);
  2972. //draw bar
  2973. COLORREF barColor;
  2974. barColor = GetColor(i);
  2975. CBrush brush (barColor);
  2976. CBrush* pOldBrush;
  2977. pOldBrush = pDC->SelectObject(&brush);