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

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

操作系统开发

开发平台：

Visual C++

Graph.cpp：源码内容
  1.  deltaY = radius * sin(degreeRadians2);
  2.  newXLocation = (int)(centerShadowXPie - deltaX);
  3.  newYLocation = (int)(centerShadowYPie - deltaY);
  4.  newTopX = (int)(centerXPie - deltaX);
  5.  newTopY = (int)(centerYPie - deltaY);
  6.  break;
  7. case 4 : //straight line to left of center
  8.  deltaX = radius;
  9.  deltaY = 1;
  10.  newXLocation = (int)(centerShadowXPie - deltaX);
  11.  newYLocation = (int)(centerShadowYPie - deltaY);
  12.  newTopX = (int)(centerXPie - deltaX);
  13.  newTopY = (int)(centerYPie - deltaY);
  14.  break;
  15. }
  17. if(s == 0)
  18. {
  19. lastYLocation -= 1;
  20. lastTopY -= 1;
  21. }
  23. COLORREF barColor;
  24. barColor = GetColor(s);
  25. int red, green, blue;
  26. red = GetRValue(barColor) - 35;
  27. green = GetGValue(barColor) - 35;
  28. blue = GetBValue(barColor) - 35;
  29. if(red < 0) red = 0;
  30. if(green < 0) green = 0;
  31. if(blue < 0) blue = 0;
  32. CPoint sp1 (lastXLocation, lastYLocation);
  33. CPoint sp2 (newXLocation, newYLocation);
  34. COLORREF shadowColor(RGB(red, green, blue));
  35. CPen shadowPen (PS_SOLID, 1, shadowColor);
  36. CBrush shadowBrush(shadowColor);
  37. pDC->SelectObject(&shadowPen);
  38. pDC->SelectObject(&shadowBrush);
  39. if((quadrant < 2) || (lastQuad < 2))
  40. {
  41. CPoint sidePolyArray[4];
  42. spa1.x = lastXLocation;
  43. spa1.y = lastYLocation;
  44. spa2.x = newXLocation;
  45. spa2.y = newYLocation;
  46. spa3.x = newTopX;
  47. spa3.y = newTopY;
  48. spa4.x = lastTopX;
  49. spa4.y = lastTopY;
  50. sidePolyArray[0] = spa1;
  51. sidePolyArray[1] = spa2;
  52. sidePolyArray[2] = spa3;
  53. sidePolyArray[3] = spa4;
  54. pDC->Polygon(sidePolyArray, 4);
  55. pDC->Pie(shadowRect, sp1, sp2);
  56. }
  57. else
  58. {
  59. CPoint sidePolyArray[3];
  60. spa1.x = newXLocation;
  61. spa1.y = newYLocation;
  62. spa2.x = newTopX;
  63. spa2.y = newTopY;
  64. spa3.x = lastTopX;
  65. spa3.y = lastTopY;
  66. sidePolyArray[0] = spa1;
  67. sidePolyArray[1] = spa2;
  68. sidePolyArray[2] = spa3;
  69. CPen oldShadowPen (PS_SOLID, 1, lastColor);
  70. pDC->SelectObject(&oldShadowPen);
  71. CBrush oldShadowBrush(lastColor);
  72. pDC->SelectObject(&oldShadowBrush);
  73. pDC->Pie(shadowRect, sp1, sp2);
  74. pDC->Polygon(sidePolyArray, 3);
  75. pDC->SelectObject(&shadowPen);
  76. pDC->SelectObject(&shadowBrush);
  77. }
  79. lastXLocation = newXLocation;
  80. lastYLocation = newYLocation;
  81. lastTopX = newTopX;
  82. lastTopY = newTopY;
  83. if((quadrant > 1) && (lastQuad < 2))
  84. {
  85. lastSidePolyArray[0] = spa1;
  86. lastSidePolyArray[1] = spa2;
  87. lastSidePolyArray[2] = spa3;
  88. lastSidePolyArray[3] = spa4;
  89. lastColor = shadowColor;
  90. }
  91. lastQuad = quadrant;
  92. pDC->SelectObject(pOldBrush);
  93. pDC->SelectObject(pOldPen);
  94. }
  95. }
  97. //draw normal pie
  98. lastXLocation = pieLeft;
  99. lastYLocation = centerYPie;
  101. dataSum = 0;
  102. for(s = 0; s < seriesSize; s++)
  103. {
  104. if(tmpSeries->GetData(s) > 0)
  105. {
  106. int seriesDataValue;
  107. seriesDataValue = tmpSeries->GetData(s);
  108. labelData = seriesDataValue / 2;
  109. dataSum += seriesDataValue;
  110. percent = (dataSum / totalSum) * 100;
  111. labelPercent = ((dataSum - labelData) / totalSum) * 100;
  112. degrees = (int)((360 * percent) / 100);
  113. labelDegrees = (int)((360 * labelPercent) / 100);
  115. //determine destination quadrant...
  116. //and set newXLocation and newYLocation values...
  117. //degress / 90 will never exceed 4.
  118. //this can tell us the quadrant of destination
  119. int quadrant = degrees / 90;  //truncates decimal
  120. int labelQuadrant = labelDegrees / 90;
  122. //using the law of sines to determine the deltas :
  123. //deltaX = radius * sin(90 - degrees)
  124. //deltaY = radius * sin(degrees)
  125. //we convert degrees into radians so sin() function works right
  126. //note :  in quad 1 and 3, we reverse the angle used to compute
  127. // the deltas, since the triangle plots reversed.
  128. switch(quadrant)
  129. {
  130. case 0 : //this is the base quadrant, so no manipulation needed
  131.  degreeRadians = degrees * (3.14159 / 180);
  132.  degreeRadians2 = (90 - degrees) * (3.14159 / 180);
  133.  deltaX = radius * sin(degreeRadians2);
  134.  deltaY = radius * sin(degreeRadians);
  135.  newXLocation = (int)(centerXPie - deltaX);
  136.  newYLocation = (int)(centerYPie + deltaY);
  137.  break;
  138. case 1 : //bottom right quadrant, subtract 90 from angle
  139.  degreeRadians = (degrees - 90) * (3.14159 / 180);
  140.  degreeRadians2 = (90 - (degrees - 90)) * (3.14159 / 180);
  141.  deltaX = radius * sin(degreeRadians);
  142.  deltaY = radius * sin(degreeRadians2);
  143.  newXLocation = (int)(centerXPie + deltaX);
  144.  newYLocation = (int)(centerYPie + deltaY);
  145.  break;
  146. case 2 : //top right quadrant, subtract 180 from angle
  147.  degreeRadians = (degrees - 180) * (3.14159 / 180);
  148.  degreeRadians2 = (90 - (degrees - 180)) * (3.14159 / 180);
  149.  deltaX = radius * sin(degreeRadians2);
  150.  deltaY = radius * sin(degreeRadians);
  151.  newXLocation = (int)(centerXPie + deltaX);
  152.  newYLocation = (int)(centerYPie - deltaY);
  153.  break;
  154. case 3 : //upper left quadrant, subtract 270 from angle
  155.  degreeRadians = (degrees - 270) * (3.14159 / 180);
  156.  degreeRadians2 = (90 - (degrees - 270)) * (3.14159 / 180);
  157.  deltaX = radius * sin(degreeRadians);
  158.  deltaY = radius * sin(degreeRadians2);
  159.  newXLocation = (int)(centerXPie - deltaX);
  160.  newYLocation = (int)(centerYPie - deltaY);
  161.  break;
  162. case 4 : //straight line to left of center
  163.  deltaX = radius;
  164.  deltaY = 1;
  165.  newXLocation = (int)(centerXPie - deltaX);
  166.  newYLocation = (int)(centerYPie - deltaY);
  167.  break;
  168. }
  170. switch(labelQuadrant)
  171. {
  172. //after getting X & Y location for label, we take
  173. //1/2 the delta between x y locations and center pie
  174. case 0 : 
  175.  labelDegreeRadians = labelDegrees * (3.14159 / 180);
  176.  labelDegreeRadians2 = (90 - labelDegrees) * (3.14159 / 180);
  177.  labelDeltaX = radius * sin(labelDegreeRadians2);
  178.  labelDeltaY = radius * sin(labelDegreeRadians);
  179.  labelXLocation = (int)(centerXPie - labelDeltaX);
  180.  labelYLocation = (int)(centerYPie + labelDeltaY);
  181.  labelLineXStart = labelXLocation + ((centerXPie - labelXLocation) / 2);
  182.  labelLineYStart = labelYLocation - ((labelYLocation - centerYPie) / 2);
  183.  labelLineXEnd = labelXLocation - (radius / 2);
  184.  labelLineYEnd = labelYLocation + (radius / 2);
  185.  break;
  186. case 1 : 
  187.  labelDegreeRadians = (labelDegrees - 90) * (3.14159 / 180);
  188.  labelDegreeRadians2 = (90 - (labelDegrees - 90)) * (3.14159 / 180);
  189.  labelDeltaX = radius * sin(labelDegreeRadians);
  190.  labelDeltaY = radius * sin(labelDegreeRadians2);
  191.  labelXLocation = (int)(centerXPie + labelDeltaX);
  192.  labelYLocation = (int)(centerYPie + labelDeltaY);
  193.  labelLineXStart = labelXLocation - ((labelXLocation - centerXPie) / 2);
  194.  labelLineYStart = labelYLocation - ((labelYLocation - centerYPie) / 2);
  195.  labelLineXEnd = labelXLocation + (radius / 2);
  196.  labelLineYEnd = labelYLocation + (radius / 2);
  197.  break;
  198. case 2 : 
  199.  labelDegreeRadians = (labelDegrees - 180) * (3.14159 / 180);
  200.  labelDegreeRadians2 = (90 - (labelDegrees - 180)) * (3.14159 / 180);
  201.  labelDeltaX = radius * sin(labelDegreeRadians2);
  202.  labelDeltaY = radius * sin(labelDegreeRadians);
  203.  labelXLocation = (int)(centerXPie + labelDeltaX);
  204.  labelYLocation = (int)(centerYPie - labelDeltaY);
  205.  labelLineXStart = labelXLocation - ((labelXLocation - centerXPie) / 2);
  206.  labelLineYStart = labelYLocation + ((centerYPie - labelYLocation) / 2);
  207.  labelLineXEnd = labelXLocation + (radius / 2);
  208.  labelLineYEnd = labelYLocation - (radius / 2);
  209.  break;
  210. case 3 : 
  211.  labelDegreeRadians = (labelDegrees - 270) * (3.14159 / 180);
  212.  labelDegreeRadians2 = (90 - (labelDegrees - 270)) * (3.14159 / 180);
  213.  labelDeltaX = radius * sin(labelDegreeRadians);
  214.  labelDeltaY = radius * sin(labelDegreeRadians2);
  215.  labelXLocation = (int)(centerXPie - labelDeltaX);
  216.  labelYLocation = (int)(centerYPie - labelDeltaY);
  217.  labelLineXStart = labelXLocation + ((centerXPie - labelXLocation) / 2);
  218.  labelLineYStart = labelYLocation + ((centerYPie - labelYLocation) / 2);
  219.  labelLineXEnd = labelXLocation - (radius / 2);
  220.  labelLineYEnd = labelYLocation - (radius / 2);
  221.  break;
  222. //there should never be a half point ending on 4, so leave it out
  223. }
  225. pieLabel = new CGraphPieLabel();
  227. pieLabel->lineXStart = labelLineXStart;
  228. pieLabel->lineYStart = labelLineYStart;
  229. pieLabel->lineXEnd = labelLineXEnd;
  230. pieLabel->lineYEnd = labelLineYEnd;
  231. switch(labelQuadrant)
  232. {
  233. case 0 : //label to left of line
  234.  pieLabel->topLeftX = labelLineXEnd - maxLabelWidth;
  235.  pieLabel->topLeftY = labelLineYEnd;
  236.  break;
  237. case 1 : //label to right of line
  238.  pieLabel->topLeftX = labelLineXEnd + 5;
  239.  pieLabel->topLeftY = labelLineYEnd;
  240.  break;
  241. case 2 : //label to right of line
  242.  pieLabel->topLeftX = labelLineXEnd + 5;
  243.  pieLabel->topLeftY = labelLineYEnd - maxLabelHeight;
  244.  break;
  245. case 3 : //label to left of line
  246.  pieLabel->topLeftX = labelLineXEnd - maxLabelWidth;
  247.  pieLabel->topLeftY = labelLineYEnd - maxLabelHeight;
  248.  break;
  249. }
  250. pieLabel->labelQuadrant = labelQuadrant;
  251. int roundPercent;
  252. roundPercent = (int)((seriesDataValue * 100) / totalSum);
  253. pieLabel->pieLabel.Format("%d%%", roundPercent);
  254. pieLabels->AddTail(pieLabel);
  256. if(s == 0)
  257. lastYLocation -= 1;
  259. COLORREF barColor;
  260. barColor = GetColor(s);
  261. CPoint p1 (lastXLocation, lastYLocation);
  262. CPoint p2 (newXLocation, newYLocation);
  263. CBrush brush (barColor);
  264. CPen piePen (PS_SOLID, 1, barColor);
  265. pDC->SelectObject(&piePen);
  266. pDC->SelectObject(&brush);
  267. pDC->Pie(pieRect, p1, p2); 
  269. lastXLocation = newXLocation;
  270. lastYLocation = newYLocation;
  271. }
  272. pDC->SelectObject(pOldBrush);
  273. pDC->SelectObject(pOldPen);
  274. }
  276. //draw lines and labels for pies slices
  277. POSITION labelPos;
  279. CBrush lineBrush (BLACK);
  280. CPen linePen (PS_SOLID, 1, BLACK);
  281. pDC->SelectObject(&lineBrush);
  282. pDC->SelectObject(&linePen);
  283. POSITION mainLinePos, checkLinePos;
  284. mainLinePos = pieLabels->GetHeadPosition();
  285. int numLinesDrawn = 0;
  286. CGraphPieLabel* currentLabel;
  287. CGraphPieLabel* tmpLabel;
  288. while(mainLinePos != NULL)
  289. {
  290. currentLabel = (CGraphPieLabel*)pieLabels->GetNext(mainLinePos);
  291. int r = 0;
  292. checkLinePos = pieLabels->GetHeadPosition();
  293. while(r < numLinesDrawn)
  294. {
  295. //check if any overlap in label areas
  296. tmpLabel = (CGraphPieLabel*)pieLabels->GetAt(checkLinePos);
  297. if((currentLabel->topLeftX > tmpLabel->topLeftX) &&
  298. (currentLabel->topLeftX < (tmpLabel->topLeftX + maxLabelWidth)) &&
  299. (currentLabel->topLeftY > tmpLabel->topLeftY) &&
  300. (currentLabel->topLeftY < (tmpLabel->topLeftY + maxLabelHeight)))
  301. {
  302. //OVERLAP !!!
  303. //move current label top left position up or down
  304. //depending on its quadrant
  305. if(currentLabel->labelQuadrant < 2)
  306. {
  307. //move label down to tmplabel topleft + height
  308. currentLabel->topLeftY = tmpLabel->topLeftY + maxLabelHeight;
  309. currentLabel->lineYEnd = tmpLabel->lineYEnd + maxLabelHeight;
  310. }
  311. else
  312. {
  313. //move label up to tmpLabel topleft - height
  314. currentLabel->topLeftY = tmpLabel->topLeftY - maxLabelHeight;
  315. currentLabel->lineYEnd = tmpLabel->lineYEnd - maxLabelHeight;
  316. }
  317. //reset r value to 0 so it starts over, just in
  318. //case we moved the label and it overlaps another
  319. r = 0;
  320. checkLinePos = pieLabels->GetHeadPosition();
  321. }
  322. else
  323. {
  324. r++;
  325. pieLabels->GetNext(checkLinePos);
  326. }
  328. }
  329. //draw the line and label
  330. pDC->MoveTo(currentLabel->lineXStart, currentLabel->lineYStart);
  331. pDC->LineTo(currentLabel->lineXEnd, currentLabel->lineYEnd);
  333. //write the label
  334. pDC->TextOut(currentLabel->topLeftX, currentLabel->topLeftY,
  335. currentLabel->pieLabel);
  336. numLinesDrawn++;
  337. }
  339. //now done, remove everything inside the label list
  340. labelPos = pieLabels->GetHeadPosition();
  341. while(labelPos != NULL)
  342. {
  343. pieLabel = (CGraphPieLabel*)pieLabels->GetNext(labelPos);
  344. delete pieLabel;
  345. }
  346. delete pieLabels;
  347. }
  348. pDC->SelectObject(pOldBrush);
  349. pDC->SelectObject(pOldPen);
  350. }
  352. void CGraph::Draw3DStackedBarSeries(CDC* pDC)
  353. {
  354. int barWidth;
  355. int barL, barT, barR, barB;
  356. int tickXLocation, tickYLocation;
  357. int seriesSpace;
  358. int barHeight;
  359. POSITION pos;
  360. CGraphSeries* tmpSeries;
  361. int blue;
  362. int red;
  363. int green;
  365. if(graphAlignment)
  366. {
  367. //determine width of barchart data blocks
  368. seriesSpace = xAxisWidth  / graphSeries->GetCount();
  369. barWidth = (int)(seriesSpace * .8);
  371. pos = graphSeries->GetHeadPosition();
  373. double dataScale = 0.00;
  374. dataScale = (yAxisHeight * 1.00) / (maxTick - minTick);
  375. for(int x = 1; x <= graphSeries->GetCount(); x++)
  376. {
  377. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  379. tickXLocation = xApexPoint + ((x * seriesSpace) - (seriesSpace / 2));
  381. barT = yApexPoint; //this is a running total;
  382. //it starts at yApexPoint so barB can
  383. //start there, then moves up by barHeight
  384. for(int s = 0; s < seriesSize; s++)
  385. {
  386. if(tmpSeries->GetData(s) > -1)
  387. {
  388. barHeight = (int)(((tmpSeries->GetData(s) - minTick) * 1.00) * dataScale);
  389. if(((tmpSeries->GetData(s) - minTick) > 0) && (barHeight < 1))
  390. barHeight = (int)dataScale;
  392. barB = barT;
  393. barL = tickXLocation - (barWidth / 2);
  394. if(barHeight > yAxisHeight)
  395. barT = barB - yAxisHeight;
  396. else
  397. barT = barB - barHeight;
  398. barR = barL + barWidth;
  400. COLORREF barColor;
  401. barColor = GetColor(s);
  402. CBrush brush (barColor);
  403. CPen rectPen (PS_SOLID, 1, barColor);
  404. CPen* pOldPen;
  405. pOldPen = pDC->SelectObject(&rectPen);
  406. CBrush* pOldBrush;
  407. pOldBrush = pDC->SelectObject(&brush);
  408. pDC->Rectangle(barL, barT, barR, barB);
  410. //now, we do the side
  411. //side is darker than front, so subtract
  412. //from color to make closer to black
  413. red = GetRValue(barColor);
  414. green = GetGValue(barColor);
  415. blue = GetBValue(barColor);
  416. int sideRed = red - 35;
  417. int sideGreen = green - 35;
  418. int sideBlue = blue - 35;
  419. if(sideRed < 0) sideRed = 0;
  420. if(sideGreen < 0) sideGreen = 0;
  421. if(sideBlue < 0) sideBlue = 0;
  422. COLORREF sideColor;
  423. sideColor = RGB(sideRed, sideGreen, sideBlue);
  424. CBrush sideBrush (sideColor);
  425. CPen sidePen (PS_SOLID, 1, sideColor);
  426. pDC->SelectObject(&sideBrush);
  427. pDC->SelectObject(&sidePen);
  428. CPoint sidePolyArray[4];
  429. CPoint sp1(barR, barT);
  430. CPoint sp2(barR, barB);
  431. CPoint sp3(barR + depth, barB - depth);
  432. CPoint sp4(barR + depth, barT - depth);
  433. sidePolyArray[0] = sp1;
  434. sidePolyArray[1] = sp2;
  435. sidePolyArray[2] = sp3;
  436. sidePolyArray[3] = sp4;
  438. pDC->Polygon(sidePolyArray, 4);
  440. //finally, the top
  441. int topRed = red + 35;
  442. int topGreen = green + 35;
  443. int topBlue = blue + 35;
  444. if(topRed > 255) topRed = 255;
  445. if(topGreen > 255) topGreen = 255;
  446. if(topBlue > 255) topBlue = 255;
  447. COLORREF topColor;
  448. topColor = RGB(topRed, topGreen, topBlue);
  449. CBrush topBrush (topColor);
  450. CPen topPen (PS_SOLID, 1, topColor);
  451. pDC->SelectObject(&topBrush);
  452. pDC->SelectObject(&topPen);
  453. CPoint topPolyArray[4];
  454. CPoint tp1(barL, barT);
  455. CPoint tp2(barR, barT);
  456. CPoint tp3(barR + depth, barT - depth);
  457. CPoint tp4(barL + depth, barT - depth);
  458. topPolyArray[0] = tp1;
  459. topPolyArray[1] = tp2;
  460. topPolyArray[2] = tp3;
  461. topPolyArray[3] = tp4;
  463. pDC->Polygon(topPolyArray, 4);
  465. pDC->SelectObject(pOldBrush);
  466. pDC->SelectObject(pOldPen);
  467. }
  468. }
  469. }
  470. }
  471. else
  472. {
  473. //determine width of barchart data blocks
  474. seriesSpace = yAxisHeight / graphSeries->GetCount();
  475. barHeight = (int)(seriesSpace * .8);
  477. pos = graphSeries->GetHeadPosition();
  479. double dataScale = 0.00;
  480. dataScale = ((xAxisWidth - 10) * 1.00) / (maxTick - minTick);
  481. for(int y = 1; y <= graphSeries->GetCount(); y++)
  482. {
  483. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  485. tickYLocation = yApexPoint - ((y * seriesSpace) - (seriesSpace / 2));
  487. barR = xApexPoint; //this is a running total;
  488. //it starts at xApexPoint so barL can
  489. //start there, then moves right by barWidth
  490. for(int s = 0; s < seriesSize; s++)
  491. {
  492. if(tmpSeries->GetData(s) > -1)
  493. {
  495. barWidth = (int)(((tmpSeries->GetData(s) - minTick) * 1.00) * dataScale);
  496. if(((tmpSeries->GetData(s) - minTick) > 0) && (barWidth < 1))
  497. barWidth = (int)dataScale;
  499. barL = barR;
  500. barT = tickYLocation - (barHeight / 2);
  501. barB = barT + barHeight;
  502. if(barWidth > xAxisWidth)
  503. barR = barL + xAxisWidth;
  504. else
  505. barR = barL + barWidth;
  507. COLORREF barColor;
  508. barColor = GetColor(s);
  509. CBrush brush (barColor);
  510. CBrush* pOldBrush;
  511. pOldBrush = pDC->SelectObject(&brush);
  512. CPen rectPen (PS_SOLID, 1, barColor);
  513. CPen* pOldPen;
  514. pOldPen = pDC->SelectObject(&rectPen);
  515. pDC->Rectangle(barL, barT, barR, barB);
  517. //now, we do the side
  518. //side is darker than front, so subtract
  519. //from color to make closer to black
  520. red = GetRValue(barColor);
  521. green = GetGValue(barColor);
  522. blue = GetBValue(barColor);
  523. int sideRed = red - 35;
  524. int sideGreen = green - 35;
  525. int sideBlue = blue - 35;
  526. if(sideRed < 0) sideRed = 0;
  527. if(sideGreen < 0) sideGreen = 0;
  528. if(sideBlue < 0) sideBlue = 0;
  529. COLORREF sideColor;
  530. sideColor = RGB(sideRed, sideGreen, sideBlue);
  531. CBrush sideBrush (sideColor);
  532. CPen sidePen (PS_SOLID, 1, sideColor);
  533. pDC->SelectObject(&sideBrush);
  534. pDC->SelectObject(&sidePen);
  535. CPoint sidePolyArray[4];
  536. CPoint sp1(barL, barT);
  537. CPoint sp2(barR, barT);
  538. CPoint sp3(barR + depth, barT - depth);
  539. CPoint sp4(barL + depth, barT - depth);
  540. sidePolyArray[0] = sp1;
  541. sidePolyArray[1] = sp2;
  542. sidePolyArray[2] = sp3;
  543. sidePolyArray[3] = sp4;
  545. pDC->Polygon(sidePolyArray, 4);
  547. //finally, the top
  548. int topRed = red + 35;
  549. int topGreen = green + 35;
  550. int topBlue = blue + 35;
  551. if(topRed > 255) topRed = 255;
  552. if(topGreen > 255) topGreen = 255;
  553. if(topBlue > 255) topBlue = 255;
  554. COLORREF topColor;
  555. topColor = RGB(topRed, topGreen, topBlue);
  556. CBrush topBrush (topColor);
  557. CPen topPen (PS_SOLID, 1, topColor);
  558. pDC->SelectObject(&topBrush);
  559. pDC->SelectObject(&topPen);
  560. CPoint topPolyArray[4];
  561. CPoint tp1(barR, barT);
  562. CPoint tp2(barR, barB);
  563. CPoint tp3(barR + depth, barB - depth);
  564. CPoint tp4(barR + depth, barT - depth);
  565. topPolyArray[0] = tp1;
  566. topPolyArray[1] = tp2;
  567. topPolyArray[2] = tp3;
  568. topPolyArray[3] = tp4;
  570. pDC->Polygon(topPolyArray, 4);
  572. pDC->SelectObject(pOldBrush);
  573. pDC->SelectObject(pOldPen);
  574. }
  575. }
  576. }
  577. }
  578. }
  581. void CGraph::PrintBarSeries(CDC* pDC)
  582. {
  583. int barWidth;
  584. int dataPlotSize;   //used to plot rects of data
  585. int barL, barT, barR, barB;
  586. int tickXLocation, tickYLocation;
  587. int seriesSpace;
  588. int barHeight;  //for scalability
  589. POSITION pos;
  590. CGraphSeries* tmpSeries;
  592. if(graphAlignment)
  593. {
  594. //determine width of barchart data blocks
  595. seriesSpace = xAxisWidth / graphSeries->GetCount();
  596. barWidth = (int)((seriesSpace * .6) / seriesSize);
  597. dataPlotSize = seriesSize * barWidth;
  599. pos = graphSeries->GetHeadPosition();
  601. for(int x = 1; x <= graphSeries->GetCount(); x++)
  602. {
  603. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  605. tickXLocation = xApexPoint + ((x * seriesSpace) - (seriesSpace / 2));
  607. for(int s = 0; s < seriesSize; s++)
  608. {
  609. if(tmpSeries->GetData(s) > -1)
  610. {
  611. double dataScale = 0.00;
  612. dataScale = ((yAxisHeight - 100) * 1.00) / (maxTick - minTick);
  613. barHeight = (int)(((tmpSeries->GetData(s) - minTick) * 1.00) * dataScale);
  614. if(((tmpSeries->GetData(s) - minTick) > 0) && (barHeight < 1))
  615. barHeight = (int)dataScale;
  617. barL = tickXLocation - (dataPlotSize / 2) + (s * barWidth);
  618. if(barHeight > yAxisHeight)
  619. barT = yApexPoint + yAxisHeight;
  620. else
  621. barT = yApexPoint + barHeight;
  622. barR = barL + barWidth;
  623. barB = yApexPoint;
  625. COLORREF barColor;
  626. barColor = GetColor(s);
  627. CBrush brush (barColor);
  628. CBrush* pOldBrush;
  629. pOldBrush = pDC->SelectObject(&brush);
  630. pDC->Rectangle(barL, barT, barR, barB);
  631. pDC->SelectObject(pOldBrush);
  632. }
  633. }
  634. }
  635. }
  636. else
  637. {
  638. //determine width of barchart data blocks
  639. seriesSpace = yAxisHeight / graphSeries->GetCount();
  640. barHeight = (int)((seriesSpace * .6) / seriesSize);
  641. dataPlotSize = seriesSize * barHeight;
  643. pos = graphSeries->GetHeadPosition();
  645. for(int y = 1; y <= graphSeries->GetCount(); y++)
  646. {
  647. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  649. tickYLocation = yApexPoint + ((y * seriesSpace) - (seriesSpace / 2));
  651. for(int s = 0; s < seriesSize; s++)
  652. {
  653. if(tmpSeries->GetData(s) > -1)
  654. {
  655. double dataScale = 0.00;
  656. dataScale = ((xAxisWidth - 100) * 1.00) / (maxTick - minTick);
  658. barWidth = (int)(((tmpSeries->GetData(s) - minTick) * 1.00) * dataScale);
  659. if(((tmpSeries->GetData(s) - minTick) > 0) && (barWidth < 1))
  660. barWidth = (int)dataScale;
  662. barL = xApexPoint;
  663. barT = tickYLocation - (dataPlotSize / 2) + (s * barHeight);
  664. barB = barT + barHeight;
  665. if(barWidth > xAxisWidth)
  666. barR = xApexPoint + xAxisWidth;
  667. else
  668. barR = xApexPoint + barWidth;
  670. COLORREF barColor;
  671. barColor = GetColor(s);
  672. CBrush brush (barColor);
  673. CBrush* pOldBrush;
  674. pOldBrush = pDC->SelectObject(&brush);
  675. pDC->Rectangle(barL, barT, barR, barB);
  676. pDC->SelectObject(pOldBrush);
  677. }
  678. }
  679. }
  680. }
  681. }
  683. void CGraph::PrintLineSeries(CDC* pDC)
  684. {
  685. int barWidth;
  686. int dataPlotSize;   //used to plot rects of data
  687. int tickXLocation, tickYLocation;
  688. int seriesSpace;
  689. int barHeight;  //for scalability
  690. POSITION pos;
  691. CGraphSeries* tmpSeries;
  693. int lastXLoc, lastYLoc;
  694. if(graphAlignment)
  695. {
  696. for(int s = 0; s < seriesSize; s++)
  697. {
  698. //determine width of barchart data blocks
  699. seriesSpace = xAxisWidth / graphSeries->GetCount();
  700. barWidth = (int)((seriesSpace * .6) / seriesSize);
  701. dataPlotSize = seriesSize * barWidth;
  703. pos = graphSeries->GetHeadPosition();
  705. for(int x = 1; x <= graphSeries->GetCount(); x++)
  706. {
  707. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  709. if(tmpSeries->GetData(s) > -1)
  710. {
  711. tickXLocation = xApexPoint + ((x * seriesSpace) - (seriesSpace / 2));
  713. barHeight = 0;
  714. double dataScale = 0.00;
  716. if((maxTick - minTick) != yAxisHeight)
  717. dataScale = ((yAxisHeight * 1.00) / ((maxTick - minTick) * 1.00)) * tickSpace;
  718. else dataScale = tickSpace * 15.00;
  720. int axisHeight = (int)(dataScale * numTicks);
  721. double barPercent = 0.00;
  722. barPercent = ((tmpSeries->GetData(s) - minTick) * 1.00) / maxTick;
  723. barHeight = (int)(barPercent * axisHeight);
  724. if(((tmpSeries->GetData(s) - minTick) > 0) && (barHeight < 1))
  725. barHeight = (int)dataScale;
  727. int yDataLocation = yApexPoint + barHeight;
  729. //now have x and y location of center of ellipse
  730. COLORREF barColor;
  731. barColor = GetColor(s);
  732. CBrush brush (barColor);
  733. CBrush* pOldBrush;
  734. pOldBrush = pDC->SelectObject(&brush);
  735. //draw line back to last data member
  736. if(x > 1)
  737. {
  738. CPen* pOldPen;
  739. CPen linePen (PS_SOLID, 20, barColor);
  740. pOldPen = pDC->SelectObject(&linePen);
  741. pDC->MoveTo(lastXLoc, lastYLoc);
  742. pDC->LineTo(tickXLocation, yDataLocation);
  743. pDC->SelectObject(pOldPen);
  744. }
  745. //now draw ellipse...
  746. pDC->Ellipse(tickXLocation + 60, yDataLocation + 60,
  747. tickXLocation - 60, yDataLocation - 60);
  748. lastXLoc = tickXLocation;
  749. lastYLoc = yDataLocation;
  750. pDC->SelectObject(pOldBrush);
  751. }
  752. }
  753. }
  754. }
  755. else
  756. {
  757. for(int s = 0; s < seriesSize; s++)
  758. {
  759. //determine width of barchart data blocks
  760. seriesSpace = yAxisHeight / graphSeries->GetCount();
  761. barHeight = (int)((seriesSpace * .6) / seriesSize);
  762. dataPlotSize = seriesSize * barHeight;
  764. pos = graphSeries->GetHeadPosition();
  766. for(int x = 1; x <= graphSeries->GetCount(); x++)
  767. {
  768. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  770. if(tmpSeries->GetData(s) > -1)
  771. {
  772. tickYLocation = yApexPoint + ((x * seriesSpace) - (seriesSpace / 2));
  774. barWidth = 0;
  775. double dataScale = 0.00;
  777. dataScale = ((xAxisWidth - 100) * 1.00) / (maxTick - minTick);
  779. int axisWidth = (int)(dataScale * (maxTick - minTick));
  780. double barPercent = 0.00;
  781. barPercent = ((tmpSeries->GetData(s) - minTick) * 1.00) / ((maxTick - minTick) * 1.00);
  782. barWidth = (int)(barPercent * axisWidth);
  783. if(((tmpSeries->GetData(s) - minTick) > 0) && (barHeight < 1))
  784. barWidth = (int)dataScale;
  786. int xDataLocation = xApexPoint + barWidth;
  788. //now have x and y location of center of ellipse
  789. COLORREF barColor;
  790. barColor = GetColor(s);
  791. CBrush brush (barColor);
  792. CBrush* pOldBrush;
  793. pOldBrush = pDC->SelectObject(&brush);
  794. //draw line back to last data member
  795. if(x > 1)
  796. {
  797. CPen* pOldPen;
  798. CPen linePen (PS_SOLID, 20, barColor);
  799. pOldPen = pDC->SelectObject(&linePen);
  800. pDC->MoveTo(lastXLoc, lastYLoc);
  801. pDC->LineTo(xDataLocation, tickYLocation);
  802. pDC->SelectObject(pOldPen);
  803. }
  804. //now draw ellipse...
  805. pDC->Ellipse(xDataLocation + 60, tickYLocation + 60,
  806. xDataLocation - 60, tickYLocation - 60);
  807. lastYLoc = tickYLocation;
  808. lastXLoc = xDataLocation;
  809. pDC->SelectObject(pOldBrush);
  810. }
  811. }
  812. }
  813. }
  814. }
  816. void CGraph::PrintPieSeries(CDC* pDC)
  817. {
  818. int seriesSpace;
  819. POSITION pos;
  820. CGraphSeries* tmpSeries;
  822. double dataSum = 0.00;  //for storing cumulative sum
  823. int lastXLocation, lastYLocation;
  824. int newXLocation, newYLocation;
  825. double percent = 0.00;
  826. int degrees;
  827. double totalSum = 0.00;
  828. int deltaXY;
  829. int radius;
  831. double labelData = 0.00;
  832. int labelXLocation, labelYLocation;
  833. double labelPercent = 0.00;
  834. int labelDegrees;
  835. int labelDeltaXY;
  836. int labelLineXStart, labelLineYStart;
  837. int labelLineXEnd, labelLineYEnd;
  838. int maxLabelWidth;
  839. int maxLabelHeight;
  840. TEXTMETRIC tm;
  842. lastXLocation = 0;
  843. lastYLocation = 0;
  845. pDC->GetTextMetrics(&tm);
  846. maxLabelWidth = tm.tmMaxCharWidth + 50;
  847. maxLabelHeight = tm.tmHeight + 30;
  849. //pie labels are stored in a list and drawn after entire pie
  850. //is completed.
  851. CObList *pieLabels;
  852. CGraphPieLabel *pieLabel;
  854. //determine width of pie display area
  855. if(xAxisWidth > yAxisHeight)
  856. seriesSpace = yAxisHeight / graphSeries->GetCount();
  857. else
  858. seriesSpace = xAxisWidth / graphSeries->GetCount();
  859. seriesSpace -= (3 * maxLabelWidth);  //allows text like 25%  (3 chars)
  861. //to plot a pie plus labels inside of series space, use the following :
  862. //(3 * radius) + (2 * label width) = series space 
  863. //so, 3*radius = series space - (2 * label width)
  864. // 1 radius = (series space - (2 * label width)) / 3
  865. radius = seriesSpace / 3;  //pie needs 2 radius, + 1 extra for line to labels = 3 for my divisor
  867. int centerYPie = pGraphT - (yAxisHeight / 2) - 500;
  869. pos = graphSeries->GetHeadPosition();
  870. for(int x = 1; x <= graphSeries->GetCount(); x++)
  871. {
  872. pieLabels = new CObList();
  874. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  875. totalSum = 0;
  876. for(int s = 0; s < seriesSize; s++)
  877. totalSum += tmpSeries->GetData(s);
  878. int pieLeft, pieRight;
  879. if(graphSeries->GetCount() == 1)
  880. {
  881. pieLeft = xApexPoint + (xAxisWidth / 2) - radius;
  882. }
  883. else
  884. {
  885. pieLeft = xApexPoint + 15 + ((x * 2 - 1) * ((xAxisWidth / graphSeries->GetCount()) / 2)) - radius;
  886. }
  887. pieRight = pieLeft + (2 * radius);
  888. CRect pieRect (pieLeft, 
  889. centerYPie + radius,
  890. pieRight, 
  891. centerYPie - radius);
  892. int centerXPie = pieLeft + radius;
  894. CFont pieFont;
  895. pieFont.CreateFont(xTickFontSize * 20, 0, 0, 0, 700, FALSE, FALSE, 0,
  896. ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
  897. DEFAULT_QUALITY, DEFAULT_PITCH | FF_ROMAN,"Arial");
  898. CFont* pOldFont = (CFont*) pDC->SelectObject(&pieFont);
  900. //plot series label
  901. pDC->TextOut(centerXPie - ((tmpSeries->GetLabel().GetLength() / 2) * ((xTickFontSize / 2) * 20)),
  902. centerYPie - radius - maxLabelHeight - 600, tmpSeries->GetLabel());
  903. pDC->SelectObject(pOldFont);
  905. lastXLocation = pieLeft;
  906. lastYLocation = centerYPie;
  908. dataSum = 0;
  909. for(s = 0; s < seriesSize; s++)
  910. {
  911. if(tmpSeries->GetData(s) > 0)
  912. {
  913. int seriesDataValue;
  914. seriesDataValue = tmpSeries->GetData(s);
  915. dataSum += seriesDataValue;
  916. percent = (dataSum * 100) / totalSum;
  917. degrees = (int)((360 * percent) / 100);
  919. labelData = tmpSeries->GetData(s) / 2;
  920. labelPercent = ((dataSum - labelData) / totalSum) * 100;
  921. labelDegrees = (int)((360 * labelPercent) / 100);
  923. //degress / 90 will never exceed 4.
  924. //this can tell us the quadrant of destination
  925. deltaXY = (degrees * radius) / 90;
  926. labelDeltaXY = (labelDegrees * radius) / 90;
  927. //deltaXY is change from start point of pie 0
  928. //this value is total change.  so if radius is 300
  929. //and degrees is 270, delta is 300.  The change 
  930. //would move both x and y 300 pixels.  For x, 100
  931. //to right is center, another 100 to right edge,
  932. //100 back to center.  For y, 100 to bottom, 100
  933. //back to center, 100 to top. thus gives 270 degree
  934. //rotation.
  936. //determine destination quadrant...
  937. //and set newXLocation and newYLocation values...
  938. int quadrant = degrees / 90;  //truncates decimal
  939. int labelQuadrant = labelDegrees / 90;
  940. switch(quadrant)
  941. {
  942. //in the computations below, the remarked line is
  943. //the original computation.  The line above it, for
  944. //actual use, is the simplified line, and gives the
  945. //exact same result
  946. case 0 : newXLocation = pieLeft + deltaXY;
  947.  newYLocation = centerYPie - deltaXY;
  948.  break;
  949. case 1 : newXLocation = pieLeft + deltaXY;
  950.  newYLocation = centerYPie - (2 * radius) + deltaXY;
  951.  break;
  952. case 2 : newXLocation = pieLeft + (4 * radius) - deltaXY;
  953.  newYLocation = centerYPie - (2 * radius) + deltaXY;
  954.  break;
  955. case 3 : newXLocation = pieLeft + (4 * radius) - deltaXY;
  956.  newYLocation = centerYPie + (4 * radius) - deltaXY;
  957.  break;
  958. case 4 : newXLocation = pieLeft;
  959.  newYLocation = centerYPie + 1;
  960.  break;
  961. }
  963. switch(labelQuadrant)
  964. {
  965. //after getting X & Y location for label, we take
  966. //1/2 the delta between x y locations and center pie
  967. case 0 : labelXLocation = pieLeft + labelDeltaXY;
  968.  labelYLocation = centerYPie - labelDeltaXY;
  969.  labelLineXStart = labelXLocation + ((centerXPie - labelXLocation) / 2);
  970.  labelLineYStart = labelYLocation - ((labelYLocation - centerYPie) / 2);
  971.  labelLineXEnd = labelXLocation - (radius / 2);
  972.  labelLineYEnd = labelYLocation - (radius / 2);
  973.  break;
  974. case 1 : labelXLocation = pieLeft + labelDeltaXY;
  975.  labelYLocation = centerYPie - (2 * radius) + labelDeltaXY;
  976.  labelLineXStart = labelXLocation - ((labelXLocation - centerXPie) / 2);
  977.  labelLineYStart = labelYLocation - ((labelYLocation - centerYPie) / 2);
  978.  labelLineXEnd = labelXLocation + (radius / 2);
  979.  labelLineYEnd = labelYLocation - (radius / 2);
  980.  break;
  981. case 2 : labelXLocation = pieLeft + (4 * radius) - labelDeltaXY;
  982.  labelYLocation = centerYPie - (2 * radius) + labelDeltaXY;
  983.  labelLineXStart = labelXLocation - ((labelXLocation - centerXPie) / 2);
  984.  labelLineYStart = labelYLocation - ((labelYLocation - centerYPie) / 2);
  985.  labelLineXEnd = labelXLocation + (radius / 2);
  986.  labelLineYEnd = labelYLocation + (radius / 2);
  987.  break;
  988. case 3 : labelXLocation = pieLeft + (4 * radius) - labelDeltaXY;
  989.  labelYLocation = centerYPie + (4 * radius) - labelDeltaXY;
  990.  labelLineXStart = labelXLocation + ((centerXPie - labelXLocation) / 2);
  991.  labelLineYStart = labelYLocation - ((labelYLocation - centerYPie) / 2);
  992.  labelLineXEnd = labelXLocation - (radius / 2);
  993.  labelLineYEnd = labelYLocation + (radius / 2);
  994.  break;
  995. //there should never be a half point ending on 4, so leave it out
  996. }
  998. pieLabel = new CGraphPieLabel();
  1000. pieLabel->lineXStart = labelLineXStart;
  1001. pieLabel->lineYStart = labelLineYStart;
  1002. pieLabel->lineXEnd = labelLineXEnd;
  1003. pieLabel->lineYEnd = labelLineYEnd;
  1004. switch(labelQuadrant)
  1005. {
  1006. case 0 : //label to left of line
  1007.  pieLabel->topLeftX = labelLineXEnd - maxLabelWidth;
  1008.  pieLabel->topLeftY = labelLineYEnd;
  1009.  break;
  1010. case 1 : //label to right of line
  1011.  pieLabel->topLeftX = labelLineXEnd + 50;
  1012.  pieLabel->topLeftY = labelLineYEnd;
  1013.  break;
  1014. case 2 : //label to right of line
  1015.  pieLabel->topLeftX = labelLineXEnd + 50;
  1016.  pieLabel->topLeftY = labelLineYEnd + maxLabelHeight;
  1017.  break;
  1018. case 3 : //label to left of line
  1019.  pieLabel->topLeftX = labelLineXEnd - maxLabelWidth;
  1020.  pieLabel->topLeftY = labelLineYEnd + maxLabelHeight;
  1021.  break;
  1022. }
  1023. pieLabel->labelQuadrant = labelQuadrant;
  1024. int roundPercent;
  1025. roundPercent = (int)((seriesDataValue * 100) / totalSum);
  1026. pieLabel->pieLabel.Format("%d%%", roundPercent);
  1027. pieLabels->AddTail(pieLabel);
  1029. if(s == 0)
  1030. lastYLocation -= 1;
  1032. CPoint p1 (lastXLocation, lastYLocation);
  1033. CPoint p2 (newXLocation, newYLocation);
  1034. COLORREF barColor;
  1035. barColor = GetColor(s);
  1036. CBrush brush (barColor);
  1037. CBrush* pOldBrush;
  1038. CPen piePen(PS_SOLID, 1, barColor);
  1039. CPen* pOldPen;
  1040. pOldBrush = pDC->SelectObject(&brush);
  1041. pOldPen = pDC->SelectObject(&piePen);
  1042. pDC->Pie(pieRect, p1, p2); 
  1043. pDC->SelectObject(pOldBrush);
  1044. pDC->SelectObject(pOldPen);
  1046. lastXLocation = newXLocation;
  1047. lastYLocation = newYLocation;
  1048. }
  1049. }
  1050. //draw lines and labels for pies slices
  1051. POSITION labelPos;
  1053. CBrush lineBrush (BLACK);
  1054. CBrush* pOldBrush;
  1055. pOldBrush = pDC->SelectObject(&lineBrush);
  1056. POSITION mainLinePos, checkLinePos;
  1057. mainLinePos = pieLabels->GetHeadPosition();
  1058. int numLinesDrawn = 0;
  1059. CGraphPieLabel* currentLabel;
  1060. CGraphPieLabel* tmpLabel;
  1061. while(mainLinePos != NULL)
  1062. {
  1063. currentLabel = (CGraphPieLabel*)pieLabels->GetNext(mainLinePos);
  1064. int r = 0;
  1065. checkLinePos = pieLabels->GetHeadPosition();
  1066. while(r < numLinesDrawn)
  1067. {
  1068. //check if any overlap in label areas
  1069. tmpLabel = (CGraphPieLabel*)pieLabels->GetAt(checkLinePos);
  1070. if((currentLabel->topLeftX > tmpLabel->topLeftX) &&
  1071. (currentLabel->topLeftX < (tmpLabel->topLeftX + maxLabelWidth)) &&
  1072. (currentLabel->topLeftY < tmpLabel->topLeftY) &&
  1073. (currentLabel->topLeftY > (tmpLabel->topLeftY - maxLabelHeight)))
  1074. {
  1075. //OVERLAP !!!
  1076. //move current label top left position up or down
  1077. //depending on its quadrant
  1078. if(currentLabel->labelQuadrant < 2)
  1079. {
  1080. //move label down to tmplabel topleft + height
  1081. currentLabel->topLeftY = tmpLabel->topLeftY - maxLabelHeight;
  1082. currentLabel->lineYEnd = tmpLabel->lineYEnd - maxLabelHeight;
  1083. }
  1084. else
  1085. {
  1086. //move label up to tmpLabel topleft - height
  1087. currentLabel->topLeftY = tmpLabel->topLeftY + maxLabelHeight;
  1088. currentLabel->lineYEnd = tmpLabel->lineYEnd + maxLabelHeight;
  1089. }
  1090. //reset r value to 0 so it starts over, just in
  1091. //case we moved the label and it overlaps another
  1092. r = 0;
  1093. checkLinePos = pieLabels->GetHeadPosition();
  1094. }
  1095. else
  1096. {
  1097. r++;
  1098. pieLabels->GetNext(checkLinePos);
  1099. }
  1101. }
  1102. //draw the line and label
  1103. pDC->MoveTo(currentLabel->lineXStart, currentLabel->lineYStart);
  1104. pDC->LineTo(currentLabel->lineXEnd, currentLabel->lineYEnd);
  1106. //write the label
  1107. pDC->TextOut(currentLabel->topLeftX, currentLabel->topLeftY,
  1108. currentLabel->pieLabel);
  1109. numLinesDrawn++;
  1110. }
  1112. pDC->SelectObject(pOldBrush);
  1114. //now done, remove everything inside the label list
  1115. labelPos = pieLabels->GetHeadPosition();
  1116. while(labelPos != NULL)
  1117. {
  1118. pieLabel = (CGraphPieLabel*)pieLabels->GetNext(labelPos);
  1119. delete pieLabel;
  1120. }
  1121. delete pieLabels;
  1122. }
  1123. }
  1126. void CGraph::PrintScatterSeries(CDC* pDC)
  1127. {
  1128. //rightXTick and topYTick contain the outer bounds of the axis ticks.
  1129. //So, if maxTick is 100 on both axis lines, then 100, 100 would be top
  1130. //right.  We will use the bounds to see spacing from apex points and then
  1131. //scale so any point can be plotted inside
  1133. double yAxisScale, xAxisScale;
  1134. int tickXLocation, tickYLocation;
  1136. //multiply each value by 1.00 to force result into a double value, and therefore
  1137. //make it more accurate in it's plot location.
  1138. yAxisScale = ((p_topYTick - yApexPoint) / (maxTick * 1.00));
  1139. xAxisScale = ((p_rightXTick - xApexPoint) / (maxTick * 1.00));
  1141. //points will now plot as ((value * scale) + apex point)
  1142. COLORREF barColor;
  1143. barColor = BLACK;
  1144. CBrush brush (barColor);
  1145. CBrush* pOldBrush;
  1146. pOldBrush = pDC->SelectObject(&brush);
  1148. POSITION pos;
  1149. CGraphSeries* tmpSeries;
  1150. for(pos = graphSeries->GetHeadPosition(); pos != NULL; graphSeries->GetNext(pos))
  1151. {
  1152. tmpSeries = (CGraphSeries*)graphSeries->GetAt(pos);
  1154. //multiply each value by 1.00 to force result into a double value, and therefore
  1155. //make it more accurate in it's plot location.
  1156. tickXLocation = (int)((tmpSeries->GetXDataValue() * 1.00) * xAxisScale) + xApexPoint;
  1157. tickYLocation = yApexPoint + (int)((tmpSeries->GetYDataValue() * 1.00) * yAxisScale);
  1159. //draw ellipse...
  1160. pDC->Ellipse(tickXLocation - 60, tickYLocation - 60,
  1161. tickXLocation + 60, tickYLocation + 60);
  1163. }
  1164. pDC->SelectObject(pOldBrush);
  1166. }
  1168. void CGraph::PrintBoxWhiskerSeries(CDC* pDC)
  1169. {
  1170. int upperQuartile;
  1171. int lowerQuartile;
  1172. int median;
  1173. int highValue;
  1174. int lowValue;
  1176. COLORREF barColor;
  1177. barColor = BLACK;
  1178. CBrush brush (barColor);
  1179. CBrush* pOldBrush;
  1180. pOldBrush = pDC->SelectObject(&brush);
  1182. int barWidth;
  1183. int barL, barT, barR, barB;
  1184. int tickXLocation, tickYLocation;
  1185. int seriesSpace;
  1186. int barHeight;
  1187. POSITION pos;
  1188. CGraphSeries* tmpSeries;
  1190. pos = graphSeries->GetHeadPosition();
  1191. CUIntArray dataArray;
  1192. CUIntArray sortedArray;
  1194. for(int x = 1; x <= graphSeries->GetCount(); x++)
  1195. {
  1196. dataArray.RemoveAll();
  1197. sortedArray.RemoveAll();
  1199. CObList *sortedData;
  1200. sortedData = new CObList();
  1201. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1202. seriesSize = tmpSeries->GetDataCount();
  1204. int dataValue;
  1205. for(int s = 0; s < seriesSize; s++)
  1206. {
  1207. dataValue = 0;
  1208. if(tmpSeries->GetData(s) > -1)
  1209. dataValue = tmpSeries->GetData(s);
  1210. dataArray.Add(dataValue);
  1211. }
  1213. //sort the array
  1214. dataValue = dataArray.GetAt(0);
  1215. sortedArray.Add(dataValue);
  1216. for(int d = 1; d < dataArray.GetSize(); d++)
  1217. {
  1218. dataValue = dataArray.GetAt(d);
  1219. BOOL placed = FALSE;
  1220. for(int s = 0; s < sortedArray.GetSize(); s++)
  1221. {
  1222. int tmpI = sortedArray.GetAt(s);
  1223. if(dataValue <= tmpI)
  1224. {
  1225. sortedArray.InsertAt(s, dataValue);
  1226. placed = TRUE;
  1227. break;
  1228. }
  1229. }
  1230. if(!placed) //add at end
  1231. sortedArray.Add(dataValue);
  1232. }
  1234. //sortedArray now contains the sorted list of all data in this
  1235. //series.  From here, we derive the other box-whisker data
  1237. int medialElement;
  1238. div_t div_result;
  1239. div_result = div(sortedArray.GetSize(), 2);
  1241. if(div_result.rem == 0) //even number of elements
  1242. {
  1243. //size is not 0 base, so below, I subtract 1 to 0 base it.
  1244. medialElement = (sortedArray.GetSize() / 2) - 1;
  1245. median = sortedArray.GetAt(medialElement) + 
  1246. ((sortedArray.GetAt(medialElement + 1) - 
  1247. sortedArray.GetAt(medialElement)) / 2);
  1248. highValue = sortedArray.GetAt(sortedArray.GetSize() - 1);
  1249. lowValue = sortedArray.GetAt(0);
  1250. div_t div2Result;
  1251. div2Result = div(medialElement + 1, 2);
  1252. if(div2Result.rem == 0) //even again
  1253. {
  1254. upperQuartile = sortedArray.GetAt(medialElement + 1 + (medialElement / 2)) +
  1255. (sortedArray.GetAt(medialElement + (medialElement / 2) + 2) -
  1256. sortedArray.GetAt(medialElement + (medialElement / 2))) / 2;
  1257. lowerQuartile = sortedArray.GetAt(medialElement / 2) +
  1258. ((sortedArray.GetAt((medialElement / 2) + 1) -
  1259. sortedArray.GetAt(medialElement / 2)) / 2);
  1260. }
  1261. else //odd
  1262. {
  1263. upperQuartile = sortedArray.GetAt(medialElement + 1 + (medialElement / 2));
  1264. lowerQuartile = sortedArray.GetAt(medialElement / 2);
  1265. }
  1266. }
  1267. else //odd number of elements
  1268. {
  1269. //size is not 0 base, so below, I subtract 1 to 0 base it.
  1270. medialElement = sortedArray.GetSize() / 2;
  1271. median = sortedArray.GetAt(medialElement);
  1272. highValue = sortedArray.GetAt(sortedArray.GetSize() - 1);
  1273. lowValue = sortedArray.GetAt(0);
  1274. div_t div2Result;
  1275. div2Result = div(medialElement, 2);
  1276. if(div2Result.rem == 0) //even 
  1277. {
  1278. upperQuartile = sortedArray.GetAt(medialElement + (medialElement / 2)) +
  1279. (sortedArray.GetAt(medialElement + (medialElement / 2) + 1) -
  1280. sortedArray.GetAt(medialElement + (medialElement / 2))) / 2;
  1281. lowerQuartile = sortedArray.GetAt((medialElement - 1) / 2) +
  1282. ((sortedArray.GetAt((medialElement + 1) / 2) -
  1283. sortedArray.GetAt((medialElement - 1) / 2)) / 2);
  1284. }
  1285. else //odd
  1286. {
  1287. upperQuartile = sortedArray.GetAt(medialElement + 1 + (medialElement / 2));
  1288. lowerQuartile = sortedArray.GetAt(medialElement / 2);
  1289. }
  1290. }
  1292. //data has been computed for median, high, low, and interquartile range
  1293. //now we can draw the series
  1295. if(graphAlignment)
  1296. {
  1297. seriesSpace = xAxisWidth / graphSeries->GetCount();
  1299. barWidth = (int)(seriesSpace * .8);
  1301. double tickScale = 0.00;
  1302. tickScale = (yAxisHeight - 100) / numTicks; //this must be consistent with PrintAxis()
  1304. tickXLocation = xApexPoint + ((x * seriesSpace) - (seriesSpace / 2));
  1306. barL = tickXLocation - (barWidth / 2);
  1307. barR = barL + barWidth;
  1308. double dataScale = 0.00;
  1309. dataScale = ((yAxisHeight - 60) * 1.00) / (maxTick - minTick);
  1311. //top cross bar (max value)
  1312. barHeight = (int)((highValue * 1.00) * tickScale);
  1313. barT = yApexPoint + barHeight;
  1314. barB = barT - 60;
  1315. pDC->Rectangle(barL, barT, barR, barB);
  1317. //bottom cross bar (min value)
  1318. barHeight = (int)((lowValue * 1.00) * tickScale);
  1319. barT = yApexPoint + barHeight;
  1320. barB = barT + 60;
  1321. pDC->Rectangle(barL, barT, barR, barB);
  1323. //vertical line (whisker)
  1324. barHeight = (int)((highValue * 1.00) * tickScale);
  1325. barT = yApexPoint + barHeight;
  1326. pDC->Rectangle(tickXLocation - 40, barT, tickXLocation + 40, barB);
  1328. //box (interquartile range, from upper quartile to lower quartile)
  1329. barHeight = (int)(upperQuartile * tickScale);
  1330. barT = yApexPoint + barHeight;
  1331. barHeight = (int)(lowerQuartile * tickScale);
  1332. barB = yApexPoint + barHeight;
  1333. pDC->Rectangle(barL, barT, barR, barB);
  1335. //draw median line (in RED)
  1336. CPen* pOldPen;
  1337. CPen linePen (PS_SOLID, 1, RED);
  1338. pOldPen = pDC->SelectObject(&linePen);
  1339. barHeight = (int)((median * 1.00) * tickScale);
  1340. pDC->MoveTo(barL, yApexPoint + barHeight);
  1341. pDC->LineTo(barR, yApexPoint + barHeight);
  1342. pDC->SelectObject(pOldPen);
  1343. }
  1344. else
  1345. {
  1346. seriesSpace = yAxisHeight / graphSeries->GetCount();
  1348. barHeight = (int)(seriesSpace * .8);
  1350. double tickScale = 0.00;
  1351. tickScale = (xAxisWidth - 200) / numTicks; //same as PrintAxis()
  1353. tickYLocation = yApexPoint + ((x * seriesSpace) - (seriesSpace / 2));
  1355. barT = tickYLocation + (barHeight / 2);
  1356. barB = barT - barHeight;
  1357. double dataScale = 0.00;
  1358. dataScale = ((xAxisWidth - 60) * 1.00) / (maxTick - minTick);
  1360. //top cross bar (max value)
  1361. barWidth = (int)((highValue * 1.00) * tickScale);
  1362. barR = xApexPoint + barWidth;
  1363. barL = barR - 60;
  1364. pDC->Rectangle(barL, barT, barR, barB);
  1366. //bottom cross bar (min value)
  1367. barWidth = (int)((lowValue * 1.00) * tickScale);
  1368. barR = xApexPoint + barWidth;
  1369. barL = barR + 60;
  1370. pDC->Rectangle(barL, barT, barR, barB);
  1372. //vertical line (whisker)
  1373. barWidth = (int)((highValue * 1.00) * tickScale);
  1374. barR = xApexPoint + barWidth;
  1375. pDC->Rectangle(barL, tickYLocation + 40, barR, tickYLocation - 40);
  1377. //box (interquartile range, from upper quartile to lower quartile)
  1378. barWidth = (int)(upperQuartile * tickScale);
  1379. barL = xApexPoint + barWidth;
  1380. barWidth = (int)(lowerQuartile * tickScale);
  1381. barR = xApexPoint + barWidth;
  1382. pDC->Rectangle(barL, barT, barR, barB);
  1384. //draw median line (in RED)
  1385. CPen* pOldPen;
  1386. CPen linePen (PS_SOLID, 1, RED);
  1387. pOldPen = pDC->SelectObject(&linePen);
  1388. barWidth = (int)((median * 1.00) * tickScale);
  1389. pDC->MoveTo(xApexPoint + barWidth, barT);
  1390. pDC->LineTo(xApexPoint + barWidth, barB);
  1391. pDC->SelectObject(pOldPen);
  1392. }
  1393. }
  1395. pDC->SelectObject(pOldBrush);
  1396. }
  1398. void CGraph::PrintStackedBarSeries(CDC* pDC)
  1399. {
  1400. int barWidth;
  1401. int barL, barT, barR, barB;
  1402. int tickXLocation, tickYLocation;
  1403. int seriesSpace;
  1404. int barHeight;  //for scalability
  1405. POSITION pos;
  1406. CGraphSeries* tmpSeries;
  1408. if(graphAlignment)
  1409. {
  1410. //determine width of barchart data blocks
  1411. seriesSpace = xAxisWidth / graphSeries->GetCount();
  1412. barWidth = (int)(seriesSpace * .6);
  1414. pos = graphSeries->GetHeadPosition();
  1416. double dataScale = 0.00;
  1417. dataScale = ((yAxisHeight - 100) * 1.00) / (maxTick - minTick);
  1418. for(int x = 1; x <= graphSeries->GetCount(); x++)
  1419. {
  1420. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1422. tickXLocation = xApexPoint + ((x * seriesSpace) - (seriesSpace / 2));
  1424. barT = yApexPoint; //this is a running total;
  1425. //it starts at yApexPoint so barB can
  1426. //start there, then moves up by barHeight
  1427. for(int s = 0; s < seriesSize; s++)
  1428. {
  1429. if(tmpSeries->GetData(s) > -1)
  1430. {
  1431. barHeight = (int)(((tmpSeries->GetData(s) - minTick) * 1.00) * dataScale);
  1432. if(((tmpSeries->GetData(s) - minTick) > 0) && (barHeight < 1))
  1433. barHeight = (int)dataScale;
  1435. barB = barT;
  1436. barL = tickXLocation - (barWidth / 2);
  1437. if(barHeight > yAxisHeight)
  1438. barT = barB + yAxisHeight;
  1439. else
  1440. barT = barB + barHeight;
  1441. barR = barL + barWidth;
  1443. COLORREF barColor;
  1444. barColor = GetColor(s);
  1445. CBrush brush (barColor);
  1446. CBrush* pOldBrush;
  1447. pOldBrush = pDC->SelectObject(&brush);
  1448. pDC->Rectangle(barL, barT, barR, barB);
  1449. pDC->SelectObject(pOldBrush);
  1450. }
  1451. }
  1452. }
  1453. }
  1454. else
  1455. {
  1456. //determine width of barchart data blocks
  1457. seriesSpace = yAxisHeight / graphSeries->GetCount();
  1458. barHeight = (int)(seriesSpace * .6);
  1460. pos = graphSeries->GetHeadPosition();
  1462. double dataScale = 0.00;
  1463. dataScale = ((xAxisWidth - 100) * 1.00) / (maxTick - minTick);
  1464. for(int y = 1; y <= graphSeries->GetCount(); y++)
  1465. {
  1466. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1468. tickYLocation = yApexPoint + ((y * seriesSpace) - (seriesSpace / 2));
  1470. barR = xApexPoint; //this is a running total;
  1471. //it starts at xApexPoint so barL can
  1472. //start there, then moves right by barWidth
  1473. for(int s = 0; s < seriesSize; s++)
  1474. {
  1475. if(tmpSeries->GetData(s) > -1)
  1476. {
  1478. barWidth = (int)(((tmpSeries->GetData(s) - minTick) * 1.00) * dataScale);
  1479. if(((tmpSeries->GetData(s) - minTick) > 0) && (barWidth < 1))
  1480. barWidth = (int)dataScale;
  1482. barL = barR;
  1483. barT = tickYLocation + (barHeight / 2);
  1484. barB = barT - barHeight;
  1485. if(barWidth > xAxisWidth)
  1486. barR = barL + xAxisWidth;
  1487. else
  1488. barR = barL + barWidth;
  1490. COLORREF barColor;
  1491. barColor = GetColor(s);
  1492. CBrush brush (barColor);
  1493. CBrush* pOldBrush;
  1494. pOldBrush = pDC->SelectObject(&brush);
  1495. pDC->Rectangle(barL, barT, barR, barB);
  1496. pDC->SelectObject(pOldBrush);
  1497. }
  1498. }
  1499. }
  1500. }
  1501. }
  1503. void CGraph::PrintXYLineSeries(CDC* pDC)
  1504. {
  1505. //same as Line graph, but without dots at the values
  1506. int barWidth;
  1507. int dataPlotSize;   //used to plot rects of data
  1508. int tickXLocation, tickYLocation;
  1509. int seriesSpace;
  1510. int barHeight;  //for scalability
  1511. POSITION pos;
  1512. CGraphSeries* tmpSeries;
  1514. int lastXLoc, lastYLoc;
  1515. if(graphAlignment)
  1516. {
  1517. for(int s = 0; s < seriesSize; s++)
  1518. {
  1519. //determine width of barchart data blocks
  1520. seriesSpace = xAxisWidth / graphSeries->GetCount();
  1521. barWidth = (int)((seriesSpace * .6) / seriesSize);
  1522. dataPlotSize = seriesSize * barWidth;
  1524. pos = graphSeries->GetHeadPosition();
  1526. for(int x = 1; x <= graphSeries->GetCount(); x++)
  1527. {
  1528. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1530. if(tmpSeries->GetData(s) > -1)
  1531. {
  1532. tickXLocation = xApexPoint + ((x * seriesSpace) - (seriesSpace / 2));
  1534. barHeight = 0;
  1535. double dataScale = 0.00;
  1537. if((maxTick - minTick) != yAxisHeight)
  1538. dataScale = ((yAxisHeight * 1.00) / ((maxTick - minTick) * 1.00)) * tickSpace;
  1539. else dataScale = tickSpace * 15.00;
  1541. int axisHeight = (int)(dataScale * numTicks);
  1542. double barPercent = 0.00;
  1543. barPercent = ((tmpSeries->GetData(s) - minTick) * 1.00) / maxTick;
  1544. barHeight = (int)(barPercent * axisHeight);
  1545. if(((tmpSeries->GetData(s) - minTick) > 0) && (barHeight < 1))
  1546. barHeight = (int)dataScale;
  1548. int yDataLocation = yApexPoint + barHeight;
  1550. //now have x and y location of center of ellipse
  1551. COLORREF barColor;
  1552. barColor = GetColor(s);
  1553. CBrush brush (barColor);
  1554. CBrush* pOldBrush;
  1555. pOldBrush = pDC->SelectObject(&brush);
  1556. //draw line back to last data member
  1557. if(x > 1)
  1558. {
  1559. CPen* pOldPen;
  1560. CPen linePen (PS_SOLID, 40, barColor);
  1561. pOldPen = pDC->SelectObject(&linePen);
  1562. pDC->MoveTo(lastXLoc, lastYLoc);
  1563. pDC->LineTo(tickXLocation, yDataLocation);
  1564. pDC->SelectObject(pOldPen);
  1565. }
  1566. lastXLoc = tickXLocation;
  1567. lastYLoc = yDataLocation;
  1568. pDC->SelectObject(pOldBrush);
  1569. }
  1570. }
  1571. }
  1572. }
  1573. else
  1574. {
  1575. for(int s = 0; s < seriesSize; s++)
  1576. {
  1577. //determine width of barchart data blocks
  1578. seriesSpace = yAxisHeight / graphSeries->GetCount();
  1579. barHeight = (int)((seriesSpace * .6) / seriesSize);
  1580. dataPlotSize = seriesSize * barHeight;
  1582. pos = graphSeries->GetHeadPosition();
  1584. for(int x = 1; x <= graphSeries->GetCount(); x++)
  1585. {
  1586. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1588. if(tmpSeries->GetData(s) > -1)
  1589. {
  1590. tickYLocation = yApexPoint + ((x * seriesSpace) - (seriesSpace / 2));
  1592. barWidth = 0;
  1593. double dataScale = 0.00;
  1595. dataScale = ((xAxisWidth - 100) * 1.00) / (maxTick - minTick);
  1597. int axisWidth = (int)(dataScale * (maxTick - minTick));
  1598. double barPercent = 0.00;
  1599. barPercent = ((tmpSeries->GetData(s) - minTick) * 1.00) / ((maxTick - minTick) * 1.00);
  1600. barWidth = (int)(barPercent * axisWidth);
  1601. if(((tmpSeries->GetData(s) - minTick) > 0) && (barHeight < 1))
  1602. barWidth = (int)dataScale;
  1604. int xDataLocation = xApexPoint + barWidth;
  1606. //now have x and y location of center of ellipse
  1607. COLORREF barColor;
  1608. barColor = GetColor(s);
  1609. CBrush brush (barColor);
  1610. CBrush* pOldBrush;
  1611. pOldBrush = pDC->SelectObject(&brush);
  1612. //draw line back to last data member
  1613. if(x > 1)
  1614. {
  1615. CPen* pOldPen;
  1616. CPen linePen (PS_SOLID, 40, barColor);
  1617. pOldPen = pDC->SelectObject(&linePen);
  1618. pDC->MoveTo(lastXLoc, lastYLoc);
  1619. pDC->LineTo(xDataLocation, tickYLocation);
  1620. pDC->SelectObject(pOldPen);
  1621. }
  1622. //now draw ellipse...
  1623. lastYLoc = tickYLocation;
  1624. lastXLoc = xDataLocation;
  1625. pDC->SelectObject(pOldBrush);
  1626. }
  1627. }
  1628. }
  1629. }
  1630. }
  1632. //void CGraph::PrintRadarSeries(CDC* pDC)
  1633. //{
  1634. //}
  1636. void CGraph::Print3DBarSeries(CDC* pDC)
  1637. {
  1638. int barWidth;
  1639. int dataPlotSize;   //used to plot rects of data
  1640. int barL, barT, barR, barB;
  1641. int tickXLocation, tickYLocation;
  1642. int seriesSpace;
  1643. int barHeight;
  1644. POSITION pos;
  1645. CGraphSeries* tmpSeries;
  1646. int blue;
  1647. int red;
  1648. int green;
  1650. if(graphAlignment)
  1651. {
  1652. //determine width of barchart data blocks
  1653. seriesSpace = (xAxisWidth - 100) / graphSeries->GetCount();
  1654. barWidth = (int)((seriesSpace * .8) / seriesSize);
  1655. dataPlotSize = seriesSize * barWidth;
  1657. pos = graphSeries->GetHeadPosition();
  1659. for(int x = 1; x <= graphSeries->GetCount(); x++)
  1660. {
  1661. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1663. tickXLocation = xApexPoint + ((x * seriesSpace) - (seriesSpace / 2));
  1665. for(int s = 0; s < seriesSize; s++)
  1666. {
  1667. if(tmpSeries->GetData(s) > -1)
  1668. {
  1669. double dataScale = 0.00;
  1670. dataScale = (yAxisHeight * 1.00) / (maxTick - minTick);
  1671. int dScale;
  1672. dScale = (int)dataScale;
  1673. barHeight = (int)(((tmpSeries->GetData(s) - minTick) * 1.00) * dScale);
  1674. if(((tmpSeries->GetData(s) - minTick) > 0) && (barHeight < 1))
  1675. barHeight = 1 * dScale;
  1677. barL = tickXLocation - (dataPlotSize / 2) + (s * barWidth);
  1678. if(barHeight > yAxisHeight)
  1679. barT = yApexPoint + yAxisHeight;
  1680. else
  1681. barT = yApexPoint + barHeight;
  1682. barR = barL + barWidth;
  1683. barB = yApexPoint;
  1685. COLORREF barColor;
  1686. barColor = GetColor(s);
  1687. CBrush brush (barColor);
  1688. CPen rectPen (PS_SOLID, 1, barColor);
  1689. CPen* pOldPen;
  1690. pOldPen = pDC->SelectObject(&rectPen);
  1691. CBrush* pOldBrush;
  1692. pOldBrush = pDC->SelectObject(&brush);
  1693. pDC->Rectangle(barL, barT, barR, barB);
  1695. //now, we do the side
  1696. //side is darker than front, so subtract
  1697. //from color to make closer to black
  1698. red = GetRValue(barColor);
  1699. green = GetGValue(barColor);
  1700. blue = GetBValue(barColor);
  1701. int sideRed = red - 35;
  1702. int sideGreen = green - 35;
  1703. int sideBlue = blue - 35;
  1704. if(sideRed < 0) sideRed = 0;
  1705. if(sideGreen < 0) sideGreen = 0;
  1706. if(sideBlue < 0) sideBlue = 0;
  1707. COLORREF sideColor;
  1708. sideColor = RGB(sideRed, sideGreen, sideBlue);
  1709. CBrush sideBrush (sideColor);
  1710. CPen sidePen (PS_SOLID, 1, sideColor);
  1711. pDC->SelectObject(&sideBrush);
  1712. pDC->SelectObject(&sidePen);
  1713. CPoint sidePolyArray[4];
  1714. CPoint sp1(barR, barT);
  1715. CPoint sp2(barR, barB);
  1716. CPoint sp3(barR + depth, barB + depth);
  1717. CPoint sp4(barR + depth, barT + depth);
  1718. sidePolyArray[0] = sp1;
  1719. sidePolyArray[1] = sp2;
  1720. sidePolyArray[2] = sp3;
  1721. sidePolyArray[3] = sp4;
  1723. pDC->Polygon(sidePolyArray, 4);
  1725. //finally, the top
  1726. int topRed = red + 35;
  1727. int topGreen = green + 35;
  1728. int topBlue = blue + 35;
  1729. if(topRed > 255) topRed = 255;
  1730. if(topGreen > 255) topGreen = 255;
  1731. if(topBlue > 255) topBlue = 255;
  1732. COLORREF topColor;
  1733. topColor = RGB(topRed, topGreen, topBlue);
  1734. CBrush topBrush (topColor);
  1735. CPen topPen (PS_SOLID, 1, topColor);
  1736. pDC->SelectObject(&topBrush);
  1737. pDC->SelectObject(&topPen);
  1738. CPoint topPolyArray[4];
  1739. CPoint tp1(barL, barT);
  1740. CPoint tp2(barR, barT);
  1741. CPoint tp3(barR + depth, barT + depth);
  1742. CPoint tp4(barL + depth, barT + depth);
  1743. topPolyArray[0] = tp1;
  1744. topPolyArray[1] = tp2;
  1745. topPolyArray[2] = tp3;
  1746. topPolyArray[3] = tp4;
  1748. pDC->Polygon(topPolyArray, 4);
  1750. pDC->SelectObject(pOldBrush);
  1751. pDC->SelectObject(pOldPen);
  1752. }
  1753. }
  1754. }
  1755. }
  1756. else
  1757. {
  1758. //determine width of barchart data blocks
  1759. seriesSpace = yAxisHeight / graphSeries->GetCount();
  1760. barHeight = (int)((seriesSpace * .8) / seriesSize);
  1761. dataPlotSize = seriesSize * barHeight;
  1763. pos = graphSeries->GetHeadPosition();
  1765. for(int y = 1; y <= graphSeries->GetCount(); y++)
  1766. {
  1767. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1769. tickYLocation = yApexPoint + ((y * seriesSpace) - (seriesSpace / 2));
  1771. for(int s = 0; s < seriesSize; s++)
  1772. {
  1773. if(tmpSeries->GetData(s) > -1)
  1774. {
  1775. double dataScale = 0.00;
  1776. dataScale = ((xAxisWidth - 200) * 1.00) / (maxTick - minTick);
  1777. barWidth = (int)(((tmpSeries->GetData(s) - minTick) * 1.00) * dataScale);
  1778. if(((tmpSeries->GetData(s) - minTick) > 0) && (barWidth < 1))
  1779. barWidth = (int)dataScale;
  1781. barL = xApexPoint;
  1782. barB = tickYLocation - (dataPlotSize / 2) + (s * barHeight);
  1783. barT = barB + barHeight;
  1784. if(barWidth > xAxisWidth)
  1785. barR = xApexPoint + xAxisWidth;
  1786. else
  1787. barR = xApexPoint + barWidth;
  1789. COLORREF barColor;
  1790. barColor = GetColor(s);
  1791. CBrush brush (barColor);
  1792. CBrush* pOldBrush;
  1793. pOldBrush = pDC->SelectObject(&brush);
  1794. CPen rectPen (PS_SOLID, 1, barColor);
  1795. CPen* pOldPen;
  1796. pOldPen = pDC->SelectObject(&rectPen);
  1797. pDC->Rectangle(barL, barT, barR, barB);
  1799. //now, we do the side
  1800. //side is darker than front, so subtract
  1801. //from color to make closer to black
  1802. red = GetRValue(barColor);
  1803. green = GetGValue(barColor);
  1804. blue = GetBValue(barColor);
  1805. int sideRed = red - 35;
  1806. int sideGreen = green - 35;
  1807. int sideBlue = blue - 35;
  1808. if(sideRed < 0) sideRed = 0;
  1809. if(sideGreen < 0) sideGreen = 0;
  1810. if(sideBlue < 0) sideBlue = 0;
  1811. COLORREF sideColor;
  1812. sideColor = RGB(sideRed, sideGreen, sideBlue);
  1813. CBrush sideBrush (sideColor);
  1814. CPen sidePen (PS_SOLID, 1, sideColor);
  1815. pDC->SelectObject(&sideBrush);
  1816. pDC->SelectObject(&sidePen);
  1817. CPoint sidePolyArray[4];
  1818. CPoint sp1(barL, barT);
  1819. CPoint sp2(barR, barT);
  1820. //I'm subtracting below to shorten the width of the 
  1821. //bar, since it was showing farther right than actual value
  1822. CPoint sp3(barR + depth - (seriesSize - s), barT + depth);
  1823. CPoint sp4(barL + depth - (seriesSize - s), barT + depth);
  1824. sidePolyArray[0] = sp1;
  1825. sidePolyArray[1] = sp2;
  1826. sidePolyArray[2] = sp3;
  1827. sidePolyArray[3] = sp4;
  1829. pDC->Polygon(sidePolyArray, 4);
  1831. //finally, the top
  1832. int topRed = red + 35;
  1833. int topGreen = green + 35;
  1834. int topBlue = blue + 35;
  1835. if(topRed > 255) topRed = 255;
  1836. if(topGreen > 255) topGreen = 255;
  1837. if(topBlue > 255) topBlue = 255;
  1838. COLORREF topColor;
  1839. topColor = RGB(topRed, topGreen, topBlue);
  1840. CBrush topBrush (topColor);
  1841. CPen topPen (PS_SOLID, 1, topColor);
  1842. pDC->SelectObject(&topBrush);
  1843. pDC->SelectObject(&topPen);
  1844. CPoint topPolyArray[4];
  1845. CPoint tp1(barR, barT);
  1846. CPoint tp2(barR, barB);
  1847. //I'm subtracting below to shorten the width of the 
  1848. //bar, since it was showing farther right than actual value
  1849. CPoint tp3(barR + depth - (seriesSize - s), barB + depth);
  1850. CPoint tp4(barR + depth - (seriesSize - s), barT + depth);
  1851. topPolyArray[0] = tp1;
  1852. topPolyArray[1] = tp2;
  1853. topPolyArray[2] = tp3;
  1854. topPolyArray[3] = tp4;
  1856. pDC->Polygon(topPolyArray, 4);
  1858. pDC->SelectObject(pOldBrush);
  1859. pDC->SelectObject(pOldPen);
  1860. }
  1861. }
  1862. }
  1863. }
  1864. }
  1866. void CGraph::Print3DLineSeries(CDC* pDC)
  1867. {
  1868. int barWidth;
  1869. int dataPlotSize;   //used to plot rects of data
  1870. int tickXLocation, tickYLocation;
  1871. int seriesSpace;
  1872. int barHeight;
  1873. POSITION pos;
  1874. CGraphSeries* tmpSeries;
  1875. int thick;
  1876. int blue;
  1877. int red;
  1878. int green;
  1879. CBrush* pOldBrush;
  1880. CPen* pOldPen;
  1882. thick = depth / 5;
  1884. int lastXLoc, lastYLoc;
  1885. if(graphAlignment)
  1886. {
  1887. for(int s = 0; s < seriesSize; s++)
  1888. {
  1889. //determine width of barchart data blocks
  1890. seriesSpace = (xAxisWidth - 100) / graphSeries->GetCount();
  1892. pos = graphSeries->GetHeadPosition();
  1893. int yDataLocation;
  1895. for(int x = 1; x <= graphSeries->GetCount(); x++)
  1896. {
  1897. tickXLocation = xApexPoint + ((x * seriesSpace) - (seriesSpace / 2));
  1898. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  1900. if(tmpSeries->GetData(s) > -1)
  1901. {
  1902. double dataScale = 0.00;
  1903. dataScale = (yAxisHeight * 1.00) / (maxTick - minTick);
  1904. int dScale;
  1905. dScale = (int)dataScale;
  1906. barHeight = (int)(((tmpSeries->GetData(s) - minTick) * 1.00) * dScale);
  1907. if(((tmpSeries->GetData(s) - minTick) > 0) && (barHeight < 1))
  1908. barHeight = 1 * dScale;
  1910. yDataLocation = yApexPoint + barHeight;
  1911. //now have x and y location of center of ellipse
  1912. COLORREF barColor;
  1913. barColor = GetColor(s);
  1914. red = GetRValue(barColor);
  1915. green = GetGValue(barColor);
  1916. blue = GetBValue(barColor);
  1917. CBrush brush (barColor);
  1918. pOldBrush = pDC->SelectObject(&brush);
  1919. //draw line back to last data member
  1920. if(x > 1)
  1921. {
  1922. CPen linePen (PS_SOLID, 1, barColor);
  1923. pOldPen = pDC->SelectObject(&linePen);
  1924. //front side of line
  1925. CPoint sidePolyArray[4];
  1926. CPoint sp1(lastXLoc, lastYLoc);
  1927. CPoint sp2(lastXLoc, lastYLoc - thick);
  1928. CPoint sp3(tickXLocation, yDataLocation - thick);
  1929. CPoint sp4(tickXLocation, yDataLocation);
  1930. sidePolyArray[0] = sp1;
  1931. sidePolyArray[1] = sp2;
  1932. sidePolyArray[2] = sp3;
  1933. sidePolyArray[3] = sp4;
  1934. pDC->Polygon(sidePolyArray, 4);
  1936. //top part of line, lighter than front
  1937. int topRed = red + 35;
  1938. int topGreen = green + 35;
  1939. int topBlue = blue + 35;
  1940. if(topRed > 255) topRed = 255;
  1941. if(topGreen > 255) topGreen = 255;
  1942. if(topBlue > 255) topBlue = 255;
  1943. COLORREF topColor;
  1944. topColor = RGB(topRed, topGreen, topBlue);
  1946. CPen topPen(PS_SOLID, 1, topColor);
  1947. CBrush topBrush(topColor);
  1948. pDC->SelectObject(&topPen);
  1949. pDC->SelectObject(&topBrush);
  1950. CPoint topPolyArray[4];
  1951. CPoint tp1(lastXLoc, lastYLoc);
  1952. CPoint tp2(lastXLoc + depth, lastYLoc + depth);
  1953. CPoint tp3(tickXLocation + depth, yDataLocation + depth);
  1954. CPoint tp4(tickXLocation, yDataLocation);
  1955. topPolyArray[0] = tp1;
  1956. topPolyArray[1] = tp2;
  1957. topPolyArray[2] = tp3;
  1958. topPolyArray[3] = tp4;
  1959. pDC->Polygon(topPolyArray, 4);
  1961. pDC->SelectObject(pOldBrush);
  1962. pDC->SelectObject(pOldPen);
  1963. }
  1964. lastXLoc = tickXLocation;
  1965. lastYLoc = yDataLocation;
  1966. }
  1967. }
  1968. if(x > 1)
  1969. {
  1970. //end point of line
  1971. int endRed = red - 35;
  1972. int endGreen = green - 35;
  1973. int endBlue = blue - 35;
  1974. if(endRed < 0) endRed = 0;
  1975. if(endGreen < 0) endGreen = 0;
  1976. if(endBlue < 0) endBlue = 0;
  1977. COLORREF endColor;
  1978. endColor = RGB(endRed, endGreen, endBlue);
  1980. CPen endPen(PS_SOLID, 1, endColor);
  1981. CBrush endBrush(endColor);
  1982. pDC->SelectObject(&endPen);
  1983. pDC->SelectObject(&endBrush);
  1984. CPoint endPolyArray[4];
  1985. CPoint ep1(tickXLocation, yDataLocation);
  1986. CPoint ep2(tickXLocation + depth, yDataLocation + depth);
  1987. CPoint ep3(tickXLocation + depth, yDataLocation + depth - thick);
  1988. CPoint ep4(tickXLocation, yDataLocation + thick);
  1989. endPolyArray[0] = ep1;
  1990. endPolyArray[1] = ep2;
  1991. endPolyArray[2] = ep3;
  1992. endPolyArray[3] = ep4;
  1993. pDC->Polygon(endPolyArray, 4);
  1995. pDC->SelectObject(pOldBrush);
  1996. pDC->SelectObject(pOldPen);
  1997. }
  1998. }
  1999. }
  2000. else
  2001. {
  2002. for(int s = 0; s < seriesSize; s++)
  2003. {
  2004. //determine width of barchart data blocks
  2005. seriesSpace = yAxisHeight / graphSeries->GetCount();
  2006. barHeight = (int)((seriesSpace * .6) / seriesSize);
  2007. dataPlotSize = seriesSize * barHeight;
  2009. pos = graphSeries->GetHeadPosition();
  2010. int xDataLocation;
  2012. for(int x = 1; x <= graphSeries->GetCount(); x++)
  2013. {
  2014. tickYLocation = yApexPoint + ((x * seriesSpace) - (seriesSpace / 2));
  2015. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  2017. if(tmpSeries->GetData(s) > -1)
  2018. {
  2019. double dataScale = 0.00;
  2020. dataScale = ((xAxisWidth - 200) * 1.00) / (maxTick - minTick);
  2021. barWidth = (int)(((tmpSeries->GetData(s) - minTick) * 1.00) * dataScale);
  2022. if(((tmpSeries->GetData(s) - minTick) > 0) && (barWidth < 1))
  2023. barWidth = (int)dataScale;
  2025. xDataLocation = xApexPoint + barWidth;
  2027. //now have x and y location of center of ellipse
  2028. COLORREF barColor;
  2029. barColor = GetColor(s);
  2030. red = GetRValue(barColor);
  2031. green = GetGValue(barColor);
  2032. blue = GetBValue(barColor);
  2033. CBrush brush (barColor);
  2034. pOldBrush = pDC->SelectObject(&brush);
  2035. //draw line back to last data member
  2036. if(x > 1)
  2037. {
  2038. CPen linePen (PS_SOLID, 1, barColor);
  2039. pOldPen = pDC->SelectObject(&linePen);
  2040. //front side of line
  2041. CPoint sidePolyArray[4];
  2042. CPoint sp1(lastXLoc, lastYLoc);
  2043. CPoint sp2(lastXLoc - thick, lastYLoc);
  2044. CPoint sp3(xDataLocation - thick, tickYLocation);
  2045. CPoint sp4(xDataLocation, tickYLocation);
  2046. sidePolyArray[0] = sp1;
  2047. sidePolyArray[1] = sp2;
  2048. sidePolyArray[2] = sp3;
  2049. sidePolyArray[3] = sp4;
  2050. pDC->Polygon(sidePolyArray, 4);
  2052. //top part of line, lighter than front
  2053. int topRed = red + 35;
  2054. int topGreen = green + 35;
  2055. int topBlue = blue + 35;
  2056. if(topRed > 255) topRed = 255;
  2057. if(topGreen > 255) topGreen = 255;
  2058. if(topBlue > 255) topBlue = 255;
  2059. COLORREF topColor;
  2060. topColor = RGB(topRed, topGreen, topBlue);
  2062. CPen topPen(PS_SOLID, 1, topColor);
  2063. CBrush topBrush(topColor);
  2064. pDC->SelectObject(&topPen);
  2065. pDC->SelectObject(&topBrush);
  2066. CPoint topPolyArray[4];
  2067. CPoint tp1(lastXLoc, lastYLoc);
  2068. CPoint tp2(lastXLoc + depth, lastYLoc + thick);
  2069. CPoint tp3(xDataLocation + depth, tickYLocation + thick);
  2070. CPoint tp4(xDataLocation, tickYLocation);
  2071. topPolyArray[0] = tp1;
  2072. topPolyArray[1] = tp2;
  2073. topPolyArray[2] = tp3;
  2074. topPolyArray[3] = tp4;
  2075. pDC->Polygon(topPolyArray, 4);
  2077. pDC->SelectObject(pOldBrush);
  2078. pDC->SelectObject(pOldPen);
  2079. }
  2080. lastYLoc = tickYLocation;
  2081. lastXLoc = xDataLocation;
  2082. }
  2083. }
  2084. if(x > 1)
  2085. {
  2086. //end point of line
  2087. int endRed = red - 35;
  2088. int endGreen = green - 35;
  2089. int endBlue = blue - 35;
  2090. if(endRed < 0) endRed = 0;
  2091. if(endGreen < 0) endGreen = 0;
  2092. if(endBlue < 0) endBlue = 0;
  2093. COLORREF endColor;
  2094. endColor = RGB(endRed, endGreen, endBlue);
  2096. CPen endPen(PS_SOLID, 1, endColor);
  2097. CBrush endBrush(endColor);
  2098. pDC->SelectObject(&endPen);
  2099. pDC->SelectObject(&endBrush);
  2100. CPoint endPolyArray[4];
  2101. CPoint ep1(xDataLocation, tickYLocation);
  2102. CPoint ep2(xDataLocation + depth, tickYLocation + thick);
  2103. CPoint ep3(xDataLocation + depth - thick, tickYLocation + thick);
  2104. CPoint ep4(xDataLocation - thick, tickYLocation);
  2105. endPolyArray[0] = ep1;
  2106. endPolyArray[1] = ep2;
  2107. endPolyArray[2] = ep3;
  2108. endPolyArray[3] = ep4;
  2109. pDC->Polygon(endPolyArray, 4);
  2111. pDC->SelectObject(pOldBrush);
  2112. pDC->SelectObject(pOldPen);
  2113. }
  2114. }
  2115. }
  2116. }
  2118. void CGraph::Print3DPieSeries(CDC* pDC)
  2119. {
  2120. double dataSum = 0.00;  //for storing cumulative sum
  2121. double labelData = 0.00;
  2122. int lastXLocation, lastYLocation;
  2123. int newXLocation, newYLocation;
  2124. int labelXLocation, labelYLocation;
  2125. double percent = 0.00;
  2126. double labelPercent = 0.00;
  2127. int degrees;
  2128. int labelDegrees;
  2129. double totalSum = 0.00;
  2130. int radius;
  2131. POSITION pos;
  2132. CGraphSeries* tmpSeries;
  2133. int seriesSpace;
  2134. int labelLineXStart, labelLineYStart;
  2135. int labelLineXEnd, labelLineYEnd;
  2136. int maxLabelWidth;
  2137. int maxLabelHeight;
  2138. TEXTMETRIC tm;
  2139. CPen* pOldPen;
  2140. CBrush* pOldBrush;
  2142. CPen tmpPen(PS_SOLID, 1, BLACK);
  2143. CBrush tmpBrush(WHITE);
  2144. pOldPen = pDC->SelectObject(&tmpPen);
  2145. pOldBrush = pDC->SelectObject(&tmpBrush);
  2147. //deltaX and deltaY will be based on distance from x and y
  2148. //axis for the new endpoint of the pie.  These values can 
  2149. //then be used to find the true distance between starting 
  2150. //line and ending line of pie boundary.
  2151. double deltaX, deltaY;
  2152. double degreeRadians, degreeRadians2;
  2153. double labelDeltaX, labelDeltaY;
  2154. double labelDegreeRadians, labelDegreeRadians2;
  2156. lastXLocation = 0;
  2157. lastYLocation = 0;
  2159. pDC->GetTextMetrics(&tm);
  2160. maxLabelWidth = tm.tmMaxCharWidth + 10;
  2161. maxLabelHeight = tm.tmHeight + 6;
  2163. //pie labels will be stored in a list and drawn after entire pie
  2164. //is completed.
  2165. CObList *pieLabels;
  2166. CGraphPieLabel *pieLabel;
  2168. //determine width of pie display area
  2169. if(xAxisWidth > yAxisHeight)
  2170. seriesSpace = yAxisHeight / graphSeries->GetCount();
  2171. else
  2172. seriesSpace = xAxisWidth / graphSeries->GetCount();
  2173. seriesSpace -= (3 * maxLabelWidth);  //allows text like 25%  (3 chars)
  2175. //to plot a pie plus labels inside of series space, use the following :
  2176. //(3 * radius) + (2 * label width) = series space 
  2177. //so, 3*radius = series space - (2 * label width)
  2178. // 1 radius = (series space - (2 * label width)) / 3
  2179. radius = seriesSpace / 3;  //pie needs 2 radius, + 1 extra for line to labels = 3 for my divisor
  2180. int depth = (int)(radius * depthRatio); //for shadow pie
  2182. int centerYPie = pGraphT - (yAxisHeight / 2) - 500 - depth;
  2184. pos = graphSeries->GetHeadPosition();
  2185. for(int x = 1; x <= graphSeries->GetCount(); x++)
  2186. {
  2187. pDC->SelectObject(pOldBrush);
  2188. pDC->SelectObject(pOldPen);
  2189. pieLabels = new CObList();
  2191. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  2192. totalSum = 0;
  2193. for(int s = 0; s < seriesSize; s++)
  2194. totalSum += tmpSeries->GetData(s);
  2195. int pieLeft, pieRight;
  2196. if(graphSeries->GetCount() == 1)
  2197. {
  2198. pieLeft = xApexPoint + (xAxisWidth / 2) - radius;
  2199. }
  2200. else
  2201. {
  2202. pieLeft = xApexPoint + 15 + ((x * 2 - 1) * ((xAxisWidth / graphSeries->GetCount()) / 2)) - radius;
  2203. }
  2204. pieRight = pieLeft + (2 * radius);
  2205. CRect pieRect (pieLeft, 
  2206. centerYPie + radius,
  2207. pieRight, 
  2208. centerYPie - radius);
  2209. CRect shadowRect (pieLeft + depth,
  2210. centerYPie + radius - depth,
  2211. pieRight + depth,
  2212. centerYPie - radius - depth);
  2213. int centerXPie = pieLeft + radius;
  2215. //plot series label
  2216. pDC->TextOut(centerXPie - ((tmpSeries->GetLabel().GetLength() / 2) * ((xTickFontSize / 2) * 20)),
  2217. centerYPie - radius - maxLabelHeight - 600 - depth, tmpSeries->GetLabel());
  2219. int centerShadowXPie;
  2220. int centerShadowYPie;
  2222. //draw shadow pie first
  2223. centerShadowYPie = centerYPie - depth;
  2224. centerShadowXPie = centerXPie + depth;
  2225. lastXLocation = centerShadowXPie - radius;
  2226. lastYLocation = centerShadowYPie;
  2228. int lastTopX = centerXPie - radius;
  2229. int lastTopY = centerYPie;
  2230. int newTopX, newTopY;
  2231. dataSum = 0;
  2232. int lastQuad = 0;
  2233. CPoint lastSidePolyArray[4];
  2234. COLORREF lastColor;
  2235. CPoint spa1;
  2236. CPoint spa2;
  2237. CPoint spa3;
  2238. CPoint spa4;
  2239. for(s = 0; s < seriesSize; s++)
  2240. {
  2241. if(tmpSeries->GetData(s) > 0)
  2242. {
  2243. int seriesDataValue;
  2244. seriesDataValue = tmpSeries->GetData(s);
  2245. dataSum += seriesDataValue;
  2246. percent = (dataSum / totalSum) * 100;
  2247. degrees = (int)((360 * percent) / 100);
  2249. //determine destination quadrant...
  2250. //and set newXLocation and newYLocation values...
  2251. //degrees / 90 will never exceed 4.
  2252. //this can tell us the quadrant of destination
  2253. int quadrant = degrees / 90;  //truncates decimal
  2255. //using the law of sines to determine the deltas :
  2256. //deltaX = radius * sin(90 - degrees)
  2257. //deltaY = radius * sin(degrees)
  2258. //we convert degrees into radians so sin() function works right
  2259. //note :  in quad 1 and 3, we reverse the angle used to compute
  2260. // the deltas, since the triangle plots reversed.
  2261. switch(quadrant)
  2262. {
  2263. case 0 : //this is the base quadrant, so no manipulation needed
  2264.  degreeRadians = degrees * (3.14159 / 180);
  2265.  degreeRadians2 = (90 - degrees) * (3.14159 / 180);
  2266.  deltaX = radius * sin(degreeRadians2);
  2267.  deltaY = radius * sin(degreeRadians);
  2268.  newXLocation = (int)(centerShadowXPie - deltaX);
  2269.  newYLocation = (int)(centerShadowYPie - deltaY);
  2270.  newTopX = (int)(centerXPie - deltaX);
  2271.  newTopY = (int)(centerYPie - deltaY);
  2272.  break;
  2273. case 1 : //bottom right quadrant, subtract 90 from angle
  2274.  degreeRadians = (degrees - 90) * (3.14159 / 180);
  2275.  degreeRadians2 = (90 - (degrees - 90)) * (3.14159 / 180);
  2276.  deltaX = radius * sin(degreeRadians);
  2277.  deltaY = radius * sin(degreeRadians2);
  2278.  newXLocation = (int)(centerShadowXPie + deltaX);
  2279.  newYLocation = (int)(centerShadowYPie - deltaY);
  2280.  newTopX = (int)(centerXPie + deltaX);
  2281.  newTopY = (int)(centerYPie - deltaY);
  2282.  break;
  2283. case 2 : //top right quadrant, subtract 180 from angle
  2284.  degreeRadians = (degrees - 180) * (3.14159 / 180);
  2285.  degreeRadians2 = (90 - (degrees - 180)) * (3.14159 / 180);
  2286.  deltaX = radius * sin(degreeRadians2);
  2287.  deltaY = radius * sin(degreeRadians);
  2288.  newXLocation = (int)(centerShadowXPie + deltaX);
  2289.  newYLocation = (int)(centerShadowYPie + deltaY);
  2290.  newTopX = (int)(centerXPie + deltaX);
  2291.  newTopY = (int)(centerYPie + deltaY);
  2292.  break;
  2293. case 3 : //upper left quadrant, subtract 270 from angle
  2294.  degreeRadians = (degrees - 270) * (3.14159 / 180);
  2295.  degreeRadians2 = (90 - (degrees - 270)) * (3.14159 / 180);
  2296.  deltaX = radius * sin(degreeRadians);
  2297.  deltaY = radius * sin(degreeRadians2);
  2298.  newXLocation = (int)(centerShadowXPie - deltaX);
  2299.  newYLocation = (int)(centerShadowYPie + deltaY);
  2300.  newTopX = (int)(centerXPie - deltaX);
  2301.  newTopY = (int)(centerYPie + deltaY);
  2302.  break;
  2303. case 4 : //straight line to left of center
  2304.  deltaX = radius;
  2305.  deltaY = 1;
  2306.  newXLocation = (int)(centerShadowXPie - deltaX);
  2307.  newYLocation = (int)(centerShadowYPie + deltaY);
  2308.  newTopX = (int)(centerXPie - deltaX);
  2309.  newTopY = (int)(centerYPie + deltaY);
  2310.  break;
  2311. }
  2313. if(s == 0)
  2314. {
  2315. lastYLocation += 1;
  2316. lastTopY += 1;
  2317. }
  2319. COLORREF barColor;
  2320. barColor = GetColor(s);
  2321. int red, green, blue;
  2322. red = GetRValue(barColor) - 35;
  2323. green = GetGValue(barColor) - 35;
  2324. blue = GetBValue(barColor) - 35;
  2325. if(red < 0) red = 0;
  2326. if(green < 0) green = 0;
  2327. if(blue < 0) blue = 0;
  2328. CPoint sp1 (lastXLocation, lastYLocation);
  2329. CPoint sp2 (newXLocation, newYLocation);
  2330. COLORREF shadowColor(RGB(red, green, blue));
  2331. CPen shadowPen (PS_SOLID, 1, shadowColor);
  2332. CBrush shadowBrush(shadowColor);
  2333. pDC->SelectObject(&shadowPen);
  2334. pDC->SelectObject(&shadowBrush);
  2335. if((quadrant < 2) || (lastQuad < 2))
  2336. {
  2337. CPoint sidePolyArray[4];
  2338. spa1.x = lastXLocation;
  2339. spa1.y = lastYLocation;
  2340. spa2.x = newXLocation;
  2341. spa2.y = newYLocation;
  2342. spa3.x = newTopX;
  2343. spa3.y = newTopY;
  2344. spa4.x = lastTopX;
  2345. spa4.y = lastTopY;
  2346. sidePolyArray[0] = spa1;
  2347. sidePolyArray[1] = spa2;
  2348. sidePolyArray[2] = spa3;
  2349. sidePolyArray[3] = spa4;
  2350. pDC->Polygon(sidePolyArray, 4);
  2351. pDC->Pie(shadowRect, sp1, sp2);
  2352. }
  2353. else
  2354. {
  2355. CPoint sidePolyArray[3];
  2356. spa1.x = newXLocation;
  2357. spa1.y = newYLocation;
  2358. spa2.x = newTopX;
  2359. spa2.y = newTopY;
  2360. spa3.x = lastTopX;
  2361. spa3.y = lastTopY;
  2362. sidePolyArray[0] = spa1;
  2363. sidePolyArray[1] = spa2;
  2364. sidePolyArray[2] = spa3;
  2365. CPen oldShadowPen (PS_SOLID, 1, lastColor);
  2366. pDC->SelectObject(&oldShadowPen);
  2367. CBrush oldShadowBrush(lastColor);
  2368. pDC->SelectObject(&oldShadowBrush);
  2369. pDC->Pie(shadowRect, sp1, sp2);
  2370. pDC->Polygon(sidePolyArray, 3);
  2371. pDC->SelectObject(&shadowPen);
  2372. pDC->SelectObject(&shadowBrush);
  2373. }
  2375. lastXLocation = newXLocation;
  2376. lastYLocation = newYLocation;
  2377. lastTopX = newTopX;
  2378. lastTopY = newTopY;
  2379. if((quadrant > 1) && (lastQuad < 2))
  2380. {
  2381. lastSidePolyArray[0] = spa1;
  2382. lastSidePolyArray[1] = spa2;
  2383. lastSidePolyArray[2] = spa3;
  2384. lastSidePolyArray[3] = spa4;
  2385. lastColor = shadowColor;
  2386. }
  2387. lastQuad = quadrant;
  2388. pDC->SelectObject(pOldBrush);
  2389. pDC->SelectObject(pOldPen);
  2390. }
  2391. }
  2393. //draw normal pie
  2394. lastXLocation = pieLeft;
  2395. lastYLocation = centerYPie;
  2397. dataSum = 0;
  2398. for(s = 0; s < seriesSize; s++)
  2399. {
  2400. if(tmpSeries->GetData(s) > 0)
  2401. {
  2402. int seriesDataValue;
  2403. seriesDataValue = tmpSeries->GetData(s);
  2404. labelData = seriesDataValue / 2;
  2405. dataSum += seriesDataValue;
  2406. percent = (dataSum / totalSum) * 100;
  2407. labelPercent = ((dataSum - labelData) / totalSum) * 100;
  2408. degrees = (int)((360 * percent) / 100);
  2409. labelDegrees = (int)((360 * labelPercent) / 100);
  2411. //determine destination quadrant...
  2412. //and set newXLocation and newYLocation values...
  2413. //degress / 90 will never exceed 4.
  2414. //this can tell us the quadrant of destination
  2415. int quadrant = degrees / 90;  //truncates decimal
  2416. int labelQuadrant = labelDegrees / 90;
  2418. //using the law of sines to determine the deltas :
  2419. //deltaX = radius * sin(90 - degrees)
  2420. //deltaY = radius * sin(degrees)
  2421. //we convert degrees into radians so sin() function works right
  2422. //note :  in quad 1 and 3, we reverse the angle used to compute
  2423. // the deltas, since the triangle plots reversed.
  2424. switch(quadrant)
  2425. {
  2426. case 0 : //this is the base quadrant, so no manipulation needed
  2427.  degreeRadians = degrees * (3.14159 / 180);
  2428.  degreeRadians2 = (90 - degrees) * (3.14159 / 180);
  2429.  deltaX = radius * sin(degreeRadians2);
  2430.  deltaY = radius * sin(degreeRadians);
  2431.  newXLocation = (int)(centerXPie - deltaX);
  2432.  newYLocation = (int)(centerYPie - deltaY);
  2433.  break;
  2434. case 1 : //bottom right quadrant, subtract 90 from angle
  2435.  degreeRadians = (degrees - 90) * (3.14159 / 180);
  2436.  degreeRadians2 = (90 - (degrees - 90)) * (3.14159 / 180);
  2437.  deltaX = radius * sin(degreeRadians);
  2438.  deltaY = radius * sin(degreeRadians2);
  2439.  newXLocation = (int)(centerXPie + deltaX);
  2440.  newYLocation = (int)(centerYPie - deltaY);
  2441.  break;
  2442. case 2 : //top right quadrant, subtract 180 from angle
  2443.  degreeRadians = (degrees - 180) * (3.14159 / 180);
  2444.  degreeRadians2 = (90 - (degrees - 180)) * (3.14159 / 180);
  2445.  deltaX = radius * sin(degreeRadians2);
  2446.  deltaY = radius * sin(degreeRadians);
  2447.  newXLocation = (int)(centerXPie + deltaX);
  2448.  newYLocation = (int)(centerYPie + deltaY);
  2449.  break;
  2450. case 3 : //upper left quadrant, subtract 270 from angle
  2451.  degreeRadians = (degrees - 270) * (3.14159 / 180);
  2452.  degreeRadians2 = (90 - (degrees - 270)) * (3.14159 / 180);
  2453.  deltaX = radius * sin(degreeRadians);
  2454.  deltaY = radius * sin(degreeRadians2);
  2455.  newXLocation = (int)(centerXPie - deltaX);
  2456.  newYLocation = (int)(centerYPie + deltaY);
  2457.  break;
  2458. case 4 : //straight line to left of center
  2459.  deltaX = radius;
  2460.  deltaY = 1;
  2461.  newXLocation = (int)(centerXPie - deltaX);
  2462.  newYLocation = (int)(centerYPie + deltaY);
  2463.  break;
  2464. }
  2466. switch(labelQuadrant)
  2467. {
  2468. //after getting X & Y location for label, we take
  2469. //1/2 the delta between x y locations and center pie
  2470. case 0 : 
  2471.  labelDegreeRadians = labelDegrees * (3.14159 / 180);
  2472.  labelDegreeRadians2 = (90 - labelDegrees) * (3.14159 / 180);
  2473.  labelDeltaX = radius * sin(labelDegreeRadians2);
  2474.  labelDeltaY = radius * sin(labelDegreeRadians);
  2475.  labelXLocation = (int)(centerXPie - labelDeltaX);
  2476.  labelYLocation = (int)(centerYPie - labelDeltaY);
  2477.  labelLineXStart = labelXLocation + ((centerXPie - labelXLocation) / 2);
  2478.  labelLineYStart = labelYLocation - ((labelYLocation - centerYPie) / 2);
  2479.  labelLineXEnd = labelXLocation - (radius / 2);
  2480.  labelLineYEnd = labelYLocation - (radius / 2);
  2481.  break;
  2482. case 1 : 
  2483.  labelDegreeRadians = (labelDegrees - 90) * (3.14159 / 180);
  2484.  labelDegreeRadians2 = (90 - (labelDegrees - 90)) * (3.14159 / 180);
  2485.  labelDeltaX = radius * sin(labelDegreeRadians);
  2486.  labelDeltaY = radius * sin(labelDegreeRadians2);
  2487.  labelXLocation = (int)(centerXPie + labelDeltaX);
  2488.  labelYLocation = (int)(centerYPie - labelDeltaY);
  2489.  labelLineXStart = labelXLocation - ((labelXLocation - centerXPie) / 2);
  2490.  labelLineYStart = labelYLocation - ((labelYLocation - centerYPie) / 2);
  2491.  labelLineXEnd = labelXLocation + (radius / 2);
  2492.  labelLineYEnd = labelYLocation - (radius / 2);
  2493.  break;
  2494. case 2 : 
  2495.  labelDegreeRadians = (labelDegrees - 180) * (3.14159 / 180);
  2496.  labelDegreeRadians2 = (90 - (labelDegrees - 180)) * (3.14159 / 180);
  2497.  labelDeltaX = radius * sin(labelDegreeRadians2);
  2498.  labelDeltaY = radius * sin(labelDegreeRadians);
  2499.  labelXLocation = (int)(centerXPie + labelDeltaX);
  2500.  labelYLocation = (int)(centerYPie + labelDeltaY);
  2501.  labelLineXStart = labelXLocation - ((labelXLocation - centerXPie) / 2);
  2502.  labelLineYStart = labelYLocation - ((labelYLocation - centerYPie) / 2);
  2503.  labelLineXEnd = labelXLocation + (radius / 2);
  2504.  labelLineYEnd = labelYLocation + (radius / 2);
  2505.  break;
  2506. case 3 : 
  2507.  labelDegreeRadians = (labelDegrees - 270) * (3.14159 / 180);
  2508.  labelDegreeRadians2 = (90 - (labelDegrees - 270)) * (3.14159 / 180);
  2509.  labelDeltaX = radius * sin(labelDegreeRadians);
  2510.  labelDeltaY = radius * sin(labelDegreeRadians2);
  2511.  labelXLocation = (int)(centerXPie - labelDeltaX);
  2512.  labelYLocation = (int)(centerYPie + labelDeltaY);
  2513.  labelLineXStart = labelXLocation + ((centerXPie - labelXLocation) / 2);
  2514.  labelLineYStart = labelYLocation - ((labelYLocation - centerYPie) / 2);
  2515.  labelLineXEnd = labelXLocation - (radius / 2);
  2516.  labelLineYEnd = labelYLocation + (radius / 2);
  2517.  break;
  2518. //there should never be a half point ending on 4, so leave it out
  2519. }
  2521. pieLabel = new CGraphPieLabel();
  2523. pieLabel->lineXStart = labelLineXStart;
  2524. pieLabel->lineYStart = labelLineYStart;
  2525. pieLabel->lineXEnd = labelLineXEnd;
  2526. pieLabel->lineYEnd = labelLineYEnd;
  2527. switch(labelQuadrant)
  2528. {
  2529. case 0 : //label to left of line
  2530.  pieLabel->topLeftX = labelLineXEnd - maxLabelWidth;
  2531.  pieLabel->topLeftY = labelLineYEnd;
  2532.  break;
  2533. case 1 : //label to right of line
  2534.  pieLabel->topLeftX = labelLineXEnd + 50;
  2535.  pieLabel->topLeftY = labelLineYEnd;
  2536.  break;
  2537. case 2 : //label to right of line
  2538.  pieLabel->topLeftX = labelLineXEnd + 50;
  2539.  pieLabel->topLeftY = labelLineYEnd + maxLabelHeight;
  2540.  break;
  2541. case 3 : //label to left of line
  2542.  pieLabel->topLeftX = labelLineXEnd - maxLabelWidth;
  2543.  pieLabel->topLeftY = labelLineYEnd + maxLabelHeight;
  2544.  break;
  2545. }
  2546. pieLabel->labelQuadrant = labelQuadrant;
  2547. int roundPercent;
  2548. roundPercent = (int)((seriesDataValue * 100) / totalSum);
  2549. pieLabel->pieLabel.Format("%d%%", roundPercent);
  2550. pieLabels->AddTail(pieLabel);
  2552. if(s == 0)
  2553. lastYLocation += 1;
  2555. COLORREF barColor;
  2556. barColor = GetColor(s);
  2557. CPoint p1 (lastXLocation, lastYLocation);
  2558. CPoint p2 (newXLocation, newYLocation);
  2559. CBrush brush (barColor);
  2560. CPen piePen (PS_SOLID, 1, barColor);
  2561. pDC->SelectObject(&piePen);
  2562. pDC->SelectObject(&brush);
  2563. pDC->Pie(pieRect, p1, p2); 
  2565. lastXLocation = newXLocation;
  2566. lastYLocation = newYLocation;
  2567. }
  2568. pDC->SelectObject(pOldBrush);
  2569. pDC->SelectObject(pOldPen);
  2570. }
  2572. //draw lines and labels for pies slices
  2573. POSITION labelPos;
  2575. CBrush lineBrush (BLACK);
  2576. CPen linePen (PS_SOLID, 1, BLACK);
  2577. pDC->SelectObject(&lineBrush);
  2578. pDC->SelectObject(&linePen);
  2579. POSITION mainLinePos, checkLinePos;
  2580. mainLinePos = pieLabels->GetHeadPosition();
  2581. int numLinesDrawn = 0;
  2582. CGraphPieLabel* currentLabel;
  2583. CGraphPieLabel* tmpLabel;
  2584. while(mainLinePos != NULL)
  2585. {
  2586. currentLabel = (CGraphPieLabel*)pieLabels->GetNext(mainLinePos);
  2587. int r = 0;
  2588. checkLinePos = pieLabels->GetHeadPosition();
  2589. while(r < numLinesDrawn)
  2590. {
  2591. //check if any overlap in label areas
  2592. tmpLabel = (CGraphPieLabel*)pieLabels->GetAt(checkLinePos);
  2593. if((currentLabel->topLeftX > tmpLabel->topLeftX) &&
  2594. (currentLabel->topLeftX < (tmpLabel->topLeftX - maxLabelWidth)) &&
  2595. (currentLabel->topLeftY > tmpLabel->topLeftY) &&
  2596. (currentLabel->topLeftY < (tmpLabel->topLeftY - maxLabelHeight)))
  2597. {
  2598. //OVERLAP !!!
  2599. //move current label top left position up or down
  2600. //depending on its quadrant
  2601. if(currentLabel->labelQuadrant < 2)
  2602. {
  2603. //move label down to tmplabel topleft + height
  2604. currentLabel->topLeftY = tmpLabel->topLeftY - maxLabelHeight;
  2605. currentLabel->lineYEnd = tmpLabel->lineYEnd - maxLabelHeight;
  2606. }
  2607. else
  2608. {
  2609. //move label up to tmpLabel topleft - height
  2610. currentLabel->topLeftY = tmpLabel->topLeftY + maxLabelHeight;
  2611. currentLabel->lineYEnd = tmpLabel->lineYEnd + maxLabelHeight;
  2612. }
  2613. //reset r value to 0 so it starts over, just in
  2614. //case we moved the label and it overlaps another
  2615. r = 0;
  2616. checkLinePos = pieLabels->GetHeadPosition();
  2617. }
  2618. else
  2619. {
  2620. r++;
  2621. pieLabels->GetNext(checkLinePos);
  2622. }
  2624. }
  2625. //draw the line and label
  2626. pDC->MoveTo(currentLabel->lineXStart, currentLabel->lineYStart);
  2627. pDC->LineTo(currentLabel->lineXEnd, currentLabel->lineYEnd);
  2629. //write the label
  2630. pDC->TextOut(currentLabel->topLeftX, currentLabel->topLeftY,
  2631. currentLabel->pieLabel);
  2632. numLinesDrawn++;
  2633. }
  2635. //now done, remove everything inside the label list
  2636. labelPos = pieLabels->GetHeadPosition();
  2637. while(labelPos != NULL)
  2638. {
  2639. pieLabel = (CGraphPieLabel*)pieLabels->GetNext(labelPos);
  2640. delete pieLabel;
  2641. }
  2642. delete pieLabels;
  2643. }
  2644. pDC->SelectObject(pOldBrush);
  2645. pDC->SelectObject(pOldPen);
  2646. }
  2648. void CGraph::Print3DStackedBarSeries(CDC* pDC)
  2649. {
  2650. int barWidth;
  2651. int barL, barT, barR, barB;
  2652. int tickXLocation, tickYLocation;
  2653. int seriesSpace;
  2654. int barHeight;
  2655. POSITION pos;
  2656. CGraphSeries* tmpSeries;
  2657. int blue;
  2658. int red;
  2659. int green;
  2661. if(graphAlignment)
  2662. {
  2663. //determine width of barchart data blocks
  2664. seriesSpace = xAxisWidth  / graphSeries->GetCount();
  2665. barWidth = (int)(seriesSpace * .8);
  2667. pos = graphSeries->GetHeadPosition();
  2669. double dataScale = 0.00;
  2670. dataScale = (yAxisHeight * 1.00) / (maxTick - minTick);
  2671. for(int x = 1; x <= graphSeries->GetCount(); x++)
  2672. {
  2673. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  2675. tickXLocation = xApexPoint + ((x * seriesSpace) - (seriesSpace / 2));
  2677. barT = yApexPoint; //this is a running total;
  2678. //it starts at yApexPoint so barB can
  2679. //start there, then moves up by barHeight
  2680. for(int s = 0; s < seriesSize; s++)
  2681. {
  2682. if(tmpSeries->GetData(s) > -1)
  2683. {
  2684. barHeight = (int)(((tmpSeries->GetData(s) - minTick) * 1.00) * dataScale);
  2685. if(((tmpSeries->GetData(s) - minTick) > 0) && (barHeight < 1))
  2686. barHeight = (int)dataScale;
  2688. barB = barT;
  2689. barL = tickXLocation - (barWidth / 2);
  2690. if(barHeight > yAxisHeight)
  2691. barT = barB + yAxisHeight;
  2692. else
  2693. barT = barB + barHeight;
  2694. barR = barL + barWidth;
  2696. COLORREF barColor;
  2697. barColor = GetColor(s);
  2698. CBrush brush (barColor);
  2699. CPen rectPen (PS_SOLID, 1, barColor);
  2700. CPen* pOldPen;
  2701. pOldPen = pDC->SelectObject(&rectPen);
  2702. CBrush* pOldBrush;
  2703. pOldBrush = pDC->SelectObject(&brush);
  2704. pDC->Rectangle(barL, barT, barR, barB);
  2706. //now, we do the side
  2707. //side is darker than front, so subtract
  2708. //from color to make closer to black
  2709. red = GetRValue(barColor);
  2710. green = GetGValue(barColor);
  2711. blue = GetBValue(barColor);
  2712. int sideRed = red - 35;
  2713. int sideGreen = green - 35;
  2714. int sideBlue = blue - 35;
  2715. if(sideRed < 0) sideRed = 0;
  2716. if(sideGreen < 0) sideGreen = 0;
  2717. if(sideBlue < 0) sideBlue = 0;
  2718. COLORREF sideColor;
  2719. sideColor = RGB(sideRed, sideGreen, sideBlue);
  2720. CBrush sideBrush (sideColor);
  2721. CPen sidePen (PS_SOLID, 1, sideColor);
  2722. pDC->SelectObject(&sideBrush);
  2723. pDC->SelectObject(&sidePen);
  2724. CPoint sidePolyArray[4];
  2725. CPoint sp1(barR, barT);
  2726. CPoint sp2(barR, barB);
  2727. CPoint sp3(barR + depth, barB + depth);
  2728. CPoint sp4(barR + depth, barT + depth);
  2729. sidePolyArray[0] = sp1;
  2730. sidePolyArray[1] = sp2;
  2731. sidePolyArray[2] = sp3;
  2732. sidePolyArray[3] = sp4;
  2734. pDC->Polygon(sidePolyArray, 4);
  2736. //finally, the top
  2737. int topRed = red + 35;
  2738. int topGreen = green + 35;
  2739. int topBlue = blue + 35;
  2740. if(topRed > 255) topRed = 255;
  2741. if(topGreen > 255) topGreen = 255;
  2742. if(topBlue > 255) topBlue = 255;
  2743. COLORREF topColor;
  2744. topColor = RGB(topRed, topGreen, topBlue);
  2745. CBrush topBrush (topColor);
  2746. CPen topPen (PS_SOLID, 1, topColor);
  2747. pDC->SelectObject(&topBrush);
  2748. pDC->SelectObject(&topPen);
  2749. CPoint topPolyArray[4];
  2750. CPoint tp1(barL, barT);
  2751. CPoint tp2(barR, barT);
  2752. CPoint tp3(barR + depth, barT + depth);
  2753. CPoint tp4(barL + depth, barT + depth);
  2754. topPolyArray[0] = tp1;
  2755. topPolyArray[1] = tp2;
  2756. topPolyArray[2] = tp3;
  2757. topPolyArray[3] = tp4;
  2759. pDC->Polygon(topPolyArray, 4);
  2761. pDC->SelectObject(pOldBrush);
  2762. pDC->SelectObject(pOldPen);
  2763. }
  2764. }
  2765. }
  2766. }
  2767. else
  2768. {
  2769. //determine width of barchart data blocks
  2770. seriesSpace = yAxisHeight / graphSeries->GetCount();
  2771. barHeight = (int)(seriesSpace * .8);
  2773. pos = graphSeries->GetHeadPosition();
  2775. double dataScale = 0.00;
  2776. dataScale = ((xAxisWidth - 10) * 1.00) / (maxTick - minTick);
  2777. for(int y = 1; y <= graphSeries->GetCount(); y++)
  2778. {
  2779. tmpSeries = (CGraphSeries*)graphSeries->GetNext(pos);
  2781. tickYLocation = yApexPoint + ((y * seriesSpace) - (seriesSpace / 2));
  2783. barR = xApexPoint; //this is a running total;
  2784. //it starts at xApexPoint so barL can
  2785. //start there, then moves right by barWidth
  2786. for(int s = 0; s < seriesSize; s++)
  2787. {
  2788. if(tmpSeries->GetData(s) > -1)
  2789. {
  2791. barWidth = (int)(((tmpSeries->GetData(s) - minTick) * 1.00) * dataScale);
  2792. if(((tmpSeries->GetData(s) - minTick) > 0) && (barWidth < 1))
  2793. barWidth = (int)dataScale;
  2795. barL = barR;
  2796. barT = tickYLocation + (barHeight / 2);
  2797. barB = barT - barHeight;
  2798. if(barWidth > xAxisWidth)
  2799. barR = barL + xAxisWidth;
  2800. else
  2801. barR = barL + barWidth;
  2803. COLORREF barColor;
  2804. barColor = GetColor(s);
  2805. CBrush brush (barColor);
  2806. CBrush* pOldBrush;
  2807. pOldBrush = pDC->SelectObject(&brush);
  2808. CPen rectPen (PS_SOLID, 1, barColor);
  2809. CPen* pOldPen;
  2810. pOldPen = pDC->SelectObject(&rectPen);
  2811. pDC->Rectangle(barL, barT, barR, barB);
  2813. //now, we do the side
  2814. //side is darker than front, so subtract
  2815. //from color to make closer to black
  2816. red = GetRValue(barColor);
  2817. green = GetGValue(barColor);
  2818. blue = GetBValue(barColor);
  2819. int sideRed = red - 35;
  2820. int sideGreen = green - 35;
  2821. int sideBlue = blue - 35;
  2822. if(sideRed < 0) sideRed = 0;
  2823. if(sideGreen < 0) sideGreen = 0;
  2824. if(sideBlue < 0) sideBlue = 0;
  2825. COLORREF sideColor;
  2826. sideColor = RGB(sideRed, sideGreen, sideBlue);
  2827. CBrush sideBrush (sideColor);
  2828. CPen sidePen (PS_SOLID, 1, sideColor);
  2829. pDC->SelectObject(&sideBrush);
  2830. pDC->SelectObject(&sidePen);
  2831. CPoint sidePolyArray[4];
  2832. CPoint sp1(barL, barT);
  2833. CPoint sp2(barR, barT);
  2834. CPoint sp3(barR + depth, barT + depth);
  2835. CPoint sp4(barL + depth, barT + depth);
  2836. sidePolyArray[0] = sp1;
  2837. sidePolyArray[1] = sp2;
  2838. sidePolyArray[2] = sp3;
  2839. sidePolyArray[3] = sp4;
  2841. pDC->Polygon(sidePolyArray, 4);
  2843. //finally, the top
  2844. int topRed = red + 35;
  2845. int topGreen = green + 35;
  2846. int topBlue = blue + 35;
  2847. if(topRed > 255) topRed = 255;
  2848. if(topGreen > 255) topGreen = 255;
  2849. if(topBlue > 255) topBlue = 255;
  2850. COLORREF topColor;
  2851. topColor = RGB(topRed, topGreen, topBlue);
  2852. CBrush topBrush (topColor);
  2853. CPen topPen (PS_SOLID, 1, topColor);
  2854. pDC->SelectObject(&topBrush);
  2855. pDC->SelectObject(&topPen);
  2856. CPoint topPolyArray[4];
  2857. CPoint tp1(barR, barT);
  2858. CPoint tp2(barR, barB);
  2859. CPoint tp3(barR + depth, barB + depth);
  2860. CPoint tp4(barR + depth, barT + depth);
  2861. topPolyArray[0] = tp1;
  2862. topPolyArray[1] = tp2;
  2863. topPolyArray[2] = tp3;
  2864. topPolyArray[3] = tp4;
  2866. pDC->Polygon(topPolyArray, 4);
  2868. pDC->SelectObject(pOldBrush);
  2869. pDC->SelectObject(pOldPen);
  2870. }
  2871. }
  2872. }
  2873. }
  2874. }
  2876. void CGraph::RemoveSeries(CString label)
  2877. {
  2878. POSITION pos;
  2879. CGraphSeries* pSeries;
  2880. pos = graphSeries->GetHeadPosition();
  2881. while(pos != NULL)
  2882. {
  2883. pSeries = (CGraphSeries*)graphSeries->GetAt(pos);
  2884. if(pSeries->GetLabel().Compare(label) == 0)
  2885. {
  2886. graphSeries->RemoveAt(pos);
  2887. delete pSeries;
  2888. break;
  2889. }
  2890. graphSeries->GetNext(pos);
  2891. }
  2892. }
  2894. void CGraph::RemoveColor(int dataGroup)
  2895. {
  2896. POSITION pos;
  2897. CGraphDataColor* dataColor;
  2898. pos = colorList->GetHeadPosition();
  2899. for(int i = 0; i < dataGroup; i++)
  2900. {
  2901. dataColor = (CGraphDataColor*)colorList->GetNext(pos);
  2902. }
  2903. colorList->RemoveAt(pos);
  2904. delete dataColor;
  2905. }
  2907. void CGraph::RemoveLegend(int dataGroup)
  2908. {
  2909. graphLegend.Remove(dataGroup);
  2910. }
  2912. void CGraph::RemoveAllSeries()
  2913. {
  2914. POSITION pos;
  2915. CGraphSeries* pSeries;
  2916. pos = graphSeries->GetHeadPosition();
  2917. while(pos != NULL)
  2918. {
  2919. pSeries = (CGraphSeries*) graphSeries->GetAt( pos );
  2920. graphSeries->RemoveAt(pos);
  2921. delete pSeries;
  2922. }
  2924. graphSeries->RemoveAll();
  2925. }
  2927. void CGraph::RemoveAllColors()
  2928. {
  2929. POSITION pos;
  2930. CGraphDataColor* dataColor;
  2931. pos = colorList->GetHeadPosition();
  2932. while(pos != NULL)
  2933. {
  2934. dataColor = (CGraphDataColor*) colorList->GetAt( pos );
  2935. colorList->RemoveAt(pos);
  2936. delete dataColor;
  2937. }
  2939. colorList->RemoveAll();
  2940. }
  2942. void CGraph::RemoveAllLegends()
  2943. {
  2944. graphLegend.RemoveAll();
  2945. }
  2947. void CGraph::RemoveAllData()
  2948. {
  2949. RemoveAllSeries();
  2950. RemoveAllLegends();
  2951. RemoveAllColors();
  2952. }
  2954. void CGraph::Set3DDepthRatio(double ratio)
  2955. {
  2956. depthRatio = ratio;
  2957. }
  2959. void CGraph::SetGraphQuadType(int quads)
  2960. {
  2961. if(graphType == BAR_GRAPH)
  2962. {
  2963. if((quads < 1) || (quads > 4))
  2964. graphQuadType = 1;
  2965. else
  2966. {
  2967. graphQuadType = quads;
  2968. quadSetManually = TRUE;
  2969. }
  2970. }
  2971. }
  2973. void CGraph::Set3DLineBase(int x, int y)
  2974. {
  2975. line3DXBase = x;
  2976. line3DYBase = y;
  2977. }