?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updates referencesource to .NET 4.7
[mono-project.git] / mcs / class / referencesource / System.Web.DataVisualization / Common / General / ChartArea.cs
blob86b909780d48becd3f74d947fc2ec270f7352a38
1 //-------------------------------------------------------------
2 // <copyright company=’Microsoft Corporation’>
3 // Copyright © Microsoft Corporation. All Rights Reserved.
4 // </copyright>
5 //-------------------------------------------------------------
6 // @owner=alexgor, deliant
7 //=================================================================
8 // File: ChartArea.cs
9 //
10 // Namespace: System.Web.UI.WebControls[Windows.Forms].Charting
11 //
12 // Classes: ChartArea
13 //
14 // Purpose: The ChartArea class represents one chart area within
15 // a chart image, and is used to plot one or more chart
16 // series. The number of chart series that can be plotted
17 // in a chart area is unlimited.
18 //
19 // Reviewed: GS - August 6, 2002
20 // AG - August 7, 2002
21 // AG - Microsoft 16, 2007
22 //
23 //===================================================================
24
25 #region Used namespaces
26 using System;
27 using System.Collections;
28 using System.Collections.Specialized;
29 using System.ComponentModel;
30 using System.ComponentModel.Design;
31 using System.Data;
32 using System.Drawing;
33 using System.Drawing.Design;
34 using System.Drawing.Drawing2D;
35 using System.Globalization;
36 using System.Diagnostics.CodeAnalysis;
37
38 #if Microsoft_CONTROL
39
40 using System.Windows.Forms.DataVisualization.Charting.Data;
41 using System.Windows.Forms.DataVisualization.Charting.ChartTypes;
42 using System.Windows.Forms.DataVisualization.Charting.Utilities;
43 using System.Windows.Forms.DataVisualization.Charting.Borders3D;
44 using System.Windows.Forms.DataVisualization.Charting;
45 using System.ComponentModel.Design.Serialization;
46 using System.Reflection;
47 using System.Windows.Forms.Design;
48 #else
49 using System.Web;
50 using System.Web.UI;
51 using System.Web.UI.DataVisualization.Charting;
52 using System.Web.UI.DataVisualization.Charting.Data;
53 using System.Web.UI.DataVisualization.Charting.ChartTypes;
54 using System.Web.UI.DataVisualization.Charting.Utilities;
55 using System.Web.UI.DataVisualization.Charting.Borders3D;
56 #endif
57
58
59 #endregion
60
61 #if Microsoft_CONTROL
62 namespace System.Windows.Forms.DataVisualization.Charting
63 #else
64 namespace System.Web.UI.DataVisualization.Charting
65 #endif
66 {
67 #region Chart area aligment enumerations
68
69 /// <summary>
70 /// An enumeration of the alignment orientations of a ChartArea
71 /// </summary>
72 [Flags]
73 public enum AreaAlignmentOrientations
74 {
75 /// <summary>
76 /// Chart areas are not automatically aligned.
77 /// </summary>
78 None = 0,
79
80 /// <summary>
81 /// Chart areas are aligned vertically.
82 /// </summary>
83 Vertical = 1,
84
85 /// <summary>
86 /// Chart areas are aligned horizontally.
87 /// </summary>
88 Horizontal = 2,
89
90 /// <summary>
91 /// Chart areas are aligned using all values (horizontally and vertically).
92 /// </summary>
93 All = Vertical | Horizontal
94 }
95
96 /// <summary>
97 /// An enumeration of the alignment styles of a ChartArea
98 /// </summary>
99 [Flags]
100 public enum AreaAlignmentStyles
101 {
102 /// <summary>
103 /// Chart areas are not automatically aligned.
104 /// </summary>
105 None = 0,
106
107 /// <summary>
108 /// Chart areas are aligned by positions.
109 /// </summary>
110 Position = 1,
111
112 /// <summary>
113 /// Chart areas are aligned by inner plot positions.
114 /// </summary>
115 PlotPosition = 2,
116
117 /// <summary>
118 /// Chart areas are aligned by axes views.
119 /// </summary>
120 AxesView = 4,
121
122 #if Microsoft_CONTROL
123
124 /// <summary>
125 /// Cursor and Selection alignment.
126 /// </summary>
127 Cursor = 8,
128
129 /// <summary>
130 /// Complete alignment.
131 /// </summary>
132 All = Position | PlotPosition | Cursor | AxesView
133 #else // Microsoft_CONTROL
134
135 /// <summary>
136 /// Complete alignment.
137 /// </summary>
138 All = Position | PlotPosition | AxesView
139
140 #endif // Microsoft_CONTROL
141 }
142
143 #endregion
144
145 /// <summary>
146 /// The ChartArea class is used to create and display a chart
147 /// area within a chart image. The chart area is a rectangular
148 /// area on a chart image. It has 4 axes, horizontal and vertical grids.
149 /// A chart area can contain more than one different chart type.
150 /// The number of chart series that can be plotted in a chart area
151 /// is unlimited.
152 ///
153 /// ChartArea class exposes all the properties and methods
154 /// of its base ChartArea3D class.
155 /// </summary>
156 [
157 DefaultProperty("Axes"),
158 SRDescription("DescriptionAttributeChartArea_ChartArea"),
159 ]
160 #if ASPPERM_35
161 [AspNetHostingPermission(System.Security.Permissions.SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
162 [AspNetHostingPermission(System.Security.Permissions.SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
163 #endif
164 public partial class ChartArea : ChartNamedElement
165 {
166 #region Chart Area Fields
167
168 /// <summary>
169 /// Plot area position
170 /// </summary>
171 internal ElementPosition PlotAreaPosition;
172
173 // Private data members, which store properties values
174 private Axis[] _axisArray = new Axis[4];
175 private Color _backColor = Color.Empty;
176 private ChartHatchStyle _backHatchStyle = ChartHatchStyle.None;
177 private string _backImage = "";
178 private ChartImageWrapMode _backImageWrapMode = ChartImageWrapMode.Tile;
179 private Color _backImageTransparentColor = Color.Empty;
180 private ChartImageAlignmentStyle _backImageAlignment = ChartImageAlignmentStyle.TopLeft;
181 private GradientStyle _backGradientStyle = GradientStyle.None;
182 private Color _backSecondaryColor = Color.Empty;
183 private Color _borderColor = Color.Black;
184 private int _borderWidth = 1;
185 private ChartDashStyle _borderDashStyle = ChartDashStyle.NotSet;
186 private int _shadowOffset = 0;
187 private Color _shadowColor = Color.FromArgb(128, 0, 0, 0);
188 private ElementPosition _areaPosition = null;
189 private ElementPosition _innerPlotPosition = null;
190 internal int IterationCounter = 0;
191
192 private bool _isSameFontSizeForAllAxes = false;
193 internal float axesAutoFontSize = 8f;
194
195 private string _alignWithChartArea = Constants.NotSetValue;
196 private AreaAlignmentOrientations _alignmentOrientation = AreaAlignmentOrientations.Vertical;
197 private AreaAlignmentStyles _alignmentStyle = AreaAlignmentStyles.All;
198 private int _circularSectorNumber = int.MinValue;
199 private int _circularUsePolygons = int.MinValue;
200
201 // Flag indicates that chart area is acurrently aligned
202 internal bool alignmentInProcess = false;
203
204 // Chart area position before adjustments
205 internal RectangleF originalAreaPosition = RectangleF.Empty;
206
207 // Chart area inner plot position before adjustments
208 internal RectangleF originalInnerPlotPosition = RectangleF.Empty;
209
210 // Chart area position before adjustments
211 internal RectangleF lastAreaPosition = RectangleF.Empty;
212
213
214 // Center of the circulat chart area
215 internal PointF circularCenter = PointF.Empty;
216
217 private ArrayList _circularAxisList = null;
218
219 #if Microsoft_CONTROL
220 // Buffered plotting area image
221 internal Bitmap areaBufferBitmap = null;
222
223 private Cursor _cursorX = new Cursor();
224 private Cursor _cursorY = new Cursor();
225 #endif
226
227 // Area SmartLabel class
228 internal SmartLabel smartLabels = new SmartLabel();
229
230 // Gets or sets a flag that specifies whether the chart area is visible.
231 private bool _visible = true;
232
233 #endregion
234
235 #region Chart Area Cursor properties
236
237 #if Microsoft_CONTROL
238
239 /// <summary>
240 /// Gets or sets a Cursor object that is used for cursors and selected ranges along the X-axis.
241 /// </summary>
242 [
243 SRCategory("CategoryAttributeCursor"),
244 Bindable(true),
245 DefaultValue(null),
246 SRDescription("DescriptionAttributeChartArea_CursorX"),
247 DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
248 TypeConverter(typeof(NoNameExpandableObjectConverter)),
249 ]
250 public Cursor CursorX
251 {
252 get
253 {
254 return _cursorX;
255 }
256 set
257 {
258 _cursorX = value;
259
260 // Initialize chart object
261 _cursorX.Initialize(this, AxisName.X);
262 }
263 }
264
265 /// <summary>
266 /// Gets or sets a Cursor object that is used for cursors and selected ranges along the Y-axis.
267 /// </summary>
268 [
269 SRCategory("CategoryAttributeCursor"),
270 Bindable(true),
271 DefaultValue(null),
272 SRDescription("DescriptionAttributeChartArea_CursorY"),
273 DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
274 TypeConverter(typeof(NoNameExpandableObjectConverter)),
275 ]
276 public Cursor CursorY
277 {
278 get
279 {
280 return _cursorY;
281 }
282 set
283 {
284 _cursorY = value;
285
286 // Initialize chart object
287 _cursorY.Initialize(this, AxisName.Y);
288 }
289 }
290
291 #endif // Microsoft_CONTROL
292
293 #endregion
294
295 #region Chart Area properties
296
297 /// <summary>
298 /// Gets or sets a flag that specifies whether the chart area is visible.
299 /// </summary>
300 /// <remarks>
301 /// When this flag is set to false, all series, legends, titles and annotation objects
302 /// associated with the chart area will also be hidden.
303 /// </remarks>
304 /// <value>
305 /// <b>True</b> if the chart area is visible; <b>false</b> otherwise.
306 /// </value>
307 [
308 SRCategory("CategoryAttributeAppearance"),
309 DefaultValue(true),
310 SRDescription("DescriptionAttributeChartArea_Visible"),
311 ParenthesizePropertyNameAttribute(true),
312 ]
313 virtual public bool Visible
314 {
315 get
316 {
317 return _visible;
318 }
319 set
320 {
321 _visible = value;
322 this.Invalidate();
323 }
324 }
325
326 /// <summary>
327 /// Gets or sets the name of the ChartArea object to which this chart area should be aligned.
328 /// </summary>
329 [
330 SRCategory("CategoryAttributeAlignment"),
331 Bindable(true),
332 DefaultValue(Constants.NotSetValue),
333 SRDescription("DescriptionAttributeChartArea_AlignWithChartArea"),
334 TypeConverter(typeof(LegendAreaNameConverter)),
335 #if !Microsoft_CONTROL
336 PersistenceMode(PersistenceMode.Attribute)
337 #endif
338 ]
339 public string AlignWithChartArea
340 {
341 get
342 {
343 return _alignWithChartArea;
344 }
345 set
346 {
347 if (value != _alignWithChartArea)
348 {
349 if (String.IsNullOrEmpty(value))
350 {
351 _alignWithChartArea = Constants.NotSetValue;
352 }
353 else
354 {
355 if (Chart != null && Chart.ChartAreas != null)
356 {
357 Chart.ChartAreas.VerifyNameReference(value);
358 }
359 _alignWithChartArea = value;
360 }
361 Invalidate();
362 }
363 }
364 }
365
366 /// <summary>
367 /// Gets or sets the alignment orientation of a chart area.
368 /// </summary>
369 [
370 SRCategory("CategoryAttributeAlignment"),
371 Bindable(true),
372 DefaultValue(AreaAlignmentOrientations.Vertical),
373 SRDescription("DescriptionAttributeChartArea_AlignOrientation"),
374 Editor(Editors.FlagsEnumUITypeEditor.Editor, Editors.FlagsEnumUITypeEditor.Base),
375 #if !Microsoft_CONTROL
376 PersistenceMode(PersistenceMode.Attribute)
377 #endif
378 ]
379 public AreaAlignmentOrientations AlignmentOrientation
380 {
381 get
382 {
383 return _alignmentOrientation;
384 }
385 set
386 {
387 _alignmentOrientation = value;
388 Invalidate();
389 }
390 }
391
392
393 /// <summary>
394 /// Gets or sets the alignment style of the ChartArea.
395 /// </summary>
396 [
397 SRCategory("CategoryAttributeAlignment"),
398 Bindable(true),
399 DefaultValue(AreaAlignmentStyles.All),
400 SRDescription("DescriptionAttributeChartArea_AlignType"),
401 Editor(Editors.FlagsEnumUITypeEditor.Editor, Editors.FlagsEnumUITypeEditor.Base),
402 #if !Microsoft_CONTROL
403 PersistenceMode(PersistenceMode.Attribute)
404 #endif
405 ]
406 public AreaAlignmentStyles AlignmentStyle
407 {
408 get
409 {
410 return _alignmentStyle;
411 }
412 set
413 {
414 _alignmentStyle = value;
415 Invalidate();
416 }
417 }
418
419 /// <summary>
420 /// Gets or sets an array that represents all axes for a chart area.
421 /// </summary>
422 [
423 SRCategory("CategoryAttributeAxes"),
424 Bindable(true),
425 SRDescription("DescriptionAttributeChartArea_Axes"),
426 TypeConverter(typeof(AxesArrayConverter)),
427 Editor(Editors.AxesArrayEditor.Editor, Editors.AxesArrayEditor.Base),
428 DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden),
429 SerializationVisibilityAttribute(SerializationVisibility.Hidden)
430 ]
431 [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
432 public Axis[] Axes
433 {
434 get
435 {
436 return _axisArray;
437 }
438 set
439 {
440 AxisX = value[0];
441 AxisY = value[1];
442 AxisX2 = value[2];
443 AxisY2 = value[3];
444 Invalidate();
445 }
446 }
447
448 /// <summary>
449 /// Avoid serialization of the axes array
450 /// </summary>
451 [EditorBrowsableAttribute(EditorBrowsableState.Never)]
452 internal bool ShouldSerializeAxes()
453 {
454 return false;
455 }
456
457 /// <summary>
458 /// Gets or sets an Axis object that represents the primary Y-axis.
459 /// </summary>
460 [
461 SRCategory("CategoryAttributeAxis"),
462 Bindable(true),
463 Browsable(false),
464 SRDescription("DescriptionAttributeChartArea_AxisY"),
465 #if Microsoft_CONTROL
466 DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
467 #else
468 PersistenceMode(PersistenceMode.InnerProperty),
469 #endif
470 TypeConverter(typeof(NoNameExpandableObjectConverter))
471 ]
472 public Axis AxisY
473 {
474 get
475 {
476 return axisY;
477 }
478 set
479 {
480 axisY = value;
481 axisY.Initialize(this, AxisName.Y);
482 _axisArray[1] = axisY;
483 Invalidate();
484 }
485 }
486
487 /// <summary>
488 /// Gets or sets an Axis object that represents the primary X-axis.
489 /// </summary>
490 [
491 SRCategory("CategoryAttributeAxis"),
492 Bindable(true),
493 Browsable(false),
494 SRDescription("DescriptionAttributeChartArea_AxisX"),
495 #if Microsoft_CONTROL
496 DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
497 #else
498 PersistenceMode(PersistenceMode.InnerProperty),
499 #endif
500 TypeConverter(typeof(NoNameExpandableObjectConverter))
501 ]
502 public Axis AxisX
503 {
504 get
505 {
506 return axisX;
507 }
508 set
509 {
510 axisX = value;
511 axisX.Initialize(this, AxisName.X);
512 _axisArray[0] = axisX;
513 Invalidate();
514 }
515 }
516
517 /// <summary>
518 /// Gets or sets an Axis object that represents the secondary X-axis.
519 /// </summary>
520 [
521 SRCategory("CategoryAttributeAxis"),
522 Bindable(true),
523 Browsable(false),
524 SRDescription("DescriptionAttributeChartArea_AxisX2"),
525 #if Microsoft_CONTROL
526 DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
527 #else
528 PersistenceMode(PersistenceMode.InnerProperty),
529 #endif
530 TypeConverter(typeof(NoNameExpandableObjectConverter))
531 ]
532 public Axis AxisX2
533 {
534 get
535 {
536 return axisX2;
537 }
538 set
539 {
540 axisX2 = value;
541 axisX2.Initialize(this, AxisName.X2);
542 _axisArray[2] = axisX2;
543 Invalidate();
544 }
545 }
546
547 /// <summary>
548 /// Gets or sets an Axis object that represents the secondary Y-axis.
549 /// </summary>
550 [
551 SRCategory("CategoryAttributeAxis"),
552 Bindable(true),
553 Browsable(false),
554 SRDescription("DescriptionAttributeChartArea_AxisY2"),
555 #if Microsoft_CONTROL
556 DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
557 #else
558 PersistenceMode(PersistenceMode.InnerProperty),
559 #endif
560 TypeConverter(typeof(NoNameExpandableObjectConverter))
561 ]
562 public Axis AxisY2
563 {
564 get
565 {
566 return axisY2;
567 }
568 set
569 {
570 axisY2 = value;
571 axisY2.Initialize(this, AxisName.Y2);
572 _axisArray[3] = axisY2;
573 Invalidate();
574 }
575 }
576
577 /// <summary>
578 /// Gets or sets an ElementPosition object, which defines the position of a chart area object within the chart image.
579 /// </summary>
580 [
581 SRCategory("CategoryAttributeAppearance"),
582 Bindable(true),
583 SRDescription("DescriptionAttributeChartArea_Position"),
584 #if Microsoft_CONTROL
585 DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
586 #else
587 PersistenceMode(PersistenceMode.InnerProperty),
588 #endif
589 NotifyParentPropertyAttribute(true),
590 TypeConverter(typeof(ElementPositionConverter)),
591 SerializationVisibilityAttribute(SerializationVisibility.Element)
592 ]
593 public ElementPosition Position
594 {
595 get
596 {
597 // Serialize only position values if Auto set to false
598 if(this.Chart != null && this.Chart.serializationStatus == SerializationStatus.Saving )
599 {
600 if(_areaPosition.Auto)
601 {
602 return new ElementPosition();
603 }
604 else
605 {
606 ElementPosition newPosition = new ElementPosition();
607 #if Microsoft_CONTROL
608 newPosition.Auto = false;
609 #else
610 newPosition.Auto = true;
611 #endif
612 newPosition.SetPositionNoAuto(_areaPosition.X, _areaPosition.Y, _areaPosition.Width, _areaPosition.Height);
613 return newPosition;
614 }
615 }
616 return _areaPosition;
617 }
618 set
619 {
620 _areaPosition = value;
621 _areaPosition.Parent = this;
622 _areaPosition.resetAreaAutoPosition = true;
623 Invalidate();
624 }
625 }
626
627 /// <summary>
628 /// Determoines if this position should be serialized.
629 /// </summary>
630 /// <returns></returns>
631 internal bool ShouldSerializePosition()
632 {
633 return !this.Position.Auto;
634 }
635
636 /// <summary>
637 /// Gets or sets an ElementPosition object, which defines the inner plot position of a chart area object.
638 /// </summary>
639 [
640 SRCategory("CategoryAttributeAppearance"),
641 Bindable(true),
642 SRDescription("DescriptionAttributeChartArea_InnerPlotPosition"),
643 #if Microsoft_CONTROL
644 DesignerSerializationVisibility(DesignerSerializationVisibility.Content),
645 #else
646 PersistenceMode(PersistenceMode.InnerProperty),
647 #endif
648 NotifyParentPropertyAttribute(true),
649 TypeConverter(typeof(ElementPositionConverter)),
650 SerializationVisibilityAttribute(SerializationVisibility.Element)
651 ]
652 public ElementPosition InnerPlotPosition
653 {
654 get
655 {
656 // Serialize only position values if Auto set to false
657 if (this.Common != null && this.Common.Chart != null && this.Common.Chart.serializationStatus == SerializationStatus.Saving)
658 {
659 if(_innerPlotPosition.Auto)
660 {
661 return new ElementPosition();
662 }
663 else
664 {
665 ElementPosition newPosition = new ElementPosition();
666 #if Microsoft_CONTROL
667 newPosition.Auto = false;
668 #else
669 newPosition.Auto = true;
670 #endif
671 newPosition.SetPositionNoAuto(_innerPlotPosition.X, _innerPlotPosition.Y, _innerPlotPosition.Width, _innerPlotPosition.Height);
672 return newPosition;
673 }
674 }
675 return _innerPlotPosition;
676 }
677 set
678 {
679 _innerPlotPosition = value;
680 _innerPlotPosition.Parent = this;
681 Invalidate();
682 }
683 }
684
685 /// <summary>
686 /// Determoines if this position should be serialized.
687 /// </summary>
688 /// <returns></returns>
689 internal bool ShouldSerializeInnerPlotPosition()
690 {
691 return !this.InnerPlotPosition.Auto;
692 }
693
694 /// <summary>
695 /// Gets or sets the background color of a ChartArea object.
696 /// </summary>
697 [
698
699 SRCategory("CategoryAttributeAppearance"),
700 Bindable(true),
701 DefaultValue(typeof(Color), ""),
702 SRDescription("DescriptionAttributeBackColor"),
703 NotifyParentPropertyAttribute(true),
704 TypeConverter(typeof(ColorConverter)),
705 Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
706 #if !Microsoft_CONTROL
707 PersistenceMode(PersistenceMode.Attribute)
708 #endif
709 ]
710 public Color BackColor
711 {
712 get
713 {
714 return _backColor;
715 }
716 set
717 {
718 _backColor = value;
719 Invalidate();
720 }
721 }
722
723 /// <summary>
724 /// Gets or sets the hatching style of a ChartArea object.
725 /// </summary>
726 [
727
728
729 SRCategory("CategoryAttributeAppearance"),
730 Bindable(true),
731 DefaultValue(ChartHatchStyle.None),
732 NotifyParentPropertyAttribute(true),
733 SRDescription("DescriptionAttributeBackHatchStyle"),
734 #if !Microsoft_CONTROL
735 PersistenceMode(PersistenceMode.Attribute),
736 #endif
737 Editor(Editors.HatchStyleEditor.Editor, Editors.HatchStyleEditor.Base)
738
739 ]
740 public ChartHatchStyle BackHatchStyle
741 {
742 get
743 {
744 return _backHatchStyle;
745 }
746 set
747 {
748 _backHatchStyle = value;
749 Invalidate();
750 }
751 }
752
753 /// <summary>
754 /// Gets or sets the background image of a ChartArea object.
755 /// </summary>
756 [
757 SRCategory("CategoryAttributeAppearance"),
758 Bindable(true),
759 DefaultValue(""),
760 SRDescription("DescriptionAttributeBackImage"),
761 Editor(Editors.ImageValueEditor.Editor, Editors.ImageValueEditor.Base),
762 #if !Microsoft_CONTROL
763 PersistenceMode(PersistenceMode.Attribute),
764 #endif
765 NotifyParentPropertyAttribute(true)
766 ]
767 public string BackImage
768 {
769 get
770 {
771 return _backImage;
772 }
773 set
774 {
775 _backImage = value;
776 Invalidate();
777 }
778 }
779
780 /// <summary>
781 /// Gets or sets the drawing mode of the background image of a ChartArea object.
782 /// </summary>
783 [
784 SRCategory("CategoryAttributeAppearance"),
785 Bindable(true),
786 DefaultValue(ChartImageWrapMode.Tile),
787 NotifyParentPropertyAttribute(true),
788 SRDescription("DescriptionAttributeImageWrapMode"),
789 #if !Microsoft_CONTROL
790 PersistenceMode(PersistenceMode.Attribute)
791 #endif
792 ]
793 public ChartImageWrapMode BackImageWrapMode
794 {
795 get
796 {
797 return _backImageWrapMode;
798 }
799 set
800 {
801 _backImageWrapMode = value;
802 Invalidate();
803 }
804 }
805
806 /// <summary>
807 /// Gets or sets the color of a ChartArea object's background image that will be drawn as transparent.
808 /// </summary>
809 [
810 SRCategory("CategoryAttributeAppearance"),
811 Bindable(true),
812 DefaultValue(typeof(Color), ""),
813 NotifyParentPropertyAttribute(true),
814 SRDescription("DescriptionAttributeImageTransparentColor"),
815 TypeConverter(typeof(ColorConverter)),
816 Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
817 #if !Microsoft_CONTROL
818 PersistenceMode(PersistenceMode.Attribute)
819 #endif
820 ]
821 public Color BackImageTransparentColor
822 {
823 get
824 {
825 return _backImageTransparentColor;
826 }
827 set
828 {
829 _backImageTransparentColor = value;
830 Invalidate();
831 }
832 }
833
834 /// <summary>
835 /// Gets or sets the alignment of a ChartArea object.
836 /// </summary>
837 [
838 SRCategory("CategoryAttributeAppearance"),
839 Bindable(true),
840 DefaultValue(ChartImageAlignmentStyle.TopLeft),
841 NotifyParentPropertyAttribute(true),
842 SRDescription("DescriptionAttributeBackImageAlign"),
843 #if !Microsoft_CONTROL
844 PersistenceMode(PersistenceMode.Attribute)
845 #endif
846 ]
847 public ChartImageAlignmentStyle BackImageAlignment
848 {
849 get
850 {
851 return _backImageAlignment;
852 }
853 set
854 {
855 _backImageAlignment = value;
856 Invalidate();
857 }
858 }
859
860 /// <summary>
861 /// Gets or sets the orientation of a chart element's gradient,
862 /// and also determines whether or not a gradient is used.
863 /// </summary>
864 [
865
866 SRCategory("CategoryAttributeAppearance"),
867 Bindable(true),
868 DefaultValue(GradientStyle.None),
869 NotifyParentPropertyAttribute(true),
870 SRDescription("DescriptionAttributeBackGradientStyle"),
871 #if !Microsoft_CONTROL
872 PersistenceMode(PersistenceMode.Attribute),
873 #endif
874 Editor(Editors.GradientEditor.Editor, Editors.GradientEditor.Base)
875 ]
876 public GradientStyle BackGradientStyle
877 {
878 get
879 {
880 return _backGradientStyle;
881 }
882 set
883 {
884 _backGradientStyle = value;
885 Invalidate();
886 }
887 }
888
889 /// <summary>
890 /// Gets or sets the secondary color of a ChartArea object.
891 /// </summary>
892 [
893
894 SRCategory("CategoryAttributeAppearance"),
895 Bindable(true),
896 DefaultValue(typeof(Color), ""),
897 NotifyParentPropertyAttribute(true),
898 SRDescription("DescriptionAttributeBackSecondaryColor"),
899 TypeConverter(typeof(ColorConverter)),
900 Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
901 #if !Microsoft_CONTROL
902 PersistenceMode(PersistenceMode.Attribute)
903 #endif
904 ]
905 public Color BackSecondaryColor
906 {
907 get
908 {
909 return _backSecondaryColor;
910 }
911 set
912 {
913 _backSecondaryColor = value;
914 Invalidate();
915 }
916 }
917
918 /// <summary>
919 /// Gets or sets the shadow color of a ChartArea object.
920 /// </summary>
921 [
922 SRCategory("CategoryAttributeAppearance"),
923 Bindable(true),
924 DefaultValue(typeof(Color), "128,0,0,0"),
925 SRDescription("DescriptionAttributeShadowColor"),
926 NotifyParentPropertyAttribute(true),
927 TypeConverter(typeof(ColorConverter)),
928 Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
929 #if !Microsoft_CONTROL
930 PersistenceMode(PersistenceMode.Attribute)
931 #endif
932 ]
933 public Color ShadowColor
934 {
935 get
936 {
937 return _shadowColor;
938 }
939 set
940 {
941 _shadowColor = value;
942 Invalidate();
943 }
944 }
945
946 /// <summary>
947 /// Gets or sets the shadow offset (in pixels) of a ChartArea object.
948 /// </summary>
949 [
950 SRCategory("CategoryAttributeAppearance"),
951 Bindable(true),
952 DefaultValue(0),
953 SRDescription("DescriptionAttributeShadowOffset"),
954 NotifyParentPropertyAttribute(true),
955 #if !Microsoft_CONTROL
956 PersistenceMode(PersistenceMode.Attribute)
957 #endif
958 ]
959 public int ShadowOffset
960 {
961 get
962 {
963 return _shadowOffset;
964 }
965 set
966 {
967 _shadowOffset = value;
968 Invalidate();
969 }
970 }
971
972 /// <summary>
973 /// Gets or sets the border color of a ChartArea object.
974 /// </summary>
975 [
976
977 SRCategory("CategoryAttributeAppearance"),
978 Bindable(true),
979 DefaultValue(typeof(Color), "Black"),
980 SRDescription("DescriptionAttributeBorderColor"),
981 NotifyParentPropertyAttribute(true),
982 TypeConverter(typeof(ColorConverter)),
983 Editor(Editors.ChartColorEditor.Editor, Editors.ChartColorEditor.Base),
984 #if !Microsoft_CONTROL
985 PersistenceMode(PersistenceMode.Attribute)
986 #endif
987 ]
988 public Color BorderColor
989 {
990 get
991 {
992 return _borderColor;
993 }
994 set
995 {
996 _borderColor = value;
997 Invalidate();
998 }
999 }
1000
1001 /// <summary>
1002 /// Gets or sets the border width of a ChartArea object.
1003 /// </summary>
1004 [
1005
1006 SRCategory("CategoryAttributeAppearance"),
1007 Bindable(true),
1008 DefaultValue(1),
1009 SRDescription("DescriptionAttributeBorderWidth"),
1010 NotifyParentPropertyAttribute(true),
1011 #if !Microsoft_CONTROL
1012 PersistenceMode(PersistenceMode.Attribute)
1013 #endif
1014 ]
1015 public int BorderWidth
1016 {
1017 get
1018 {
1019 return _borderWidth;
1020 }
1021 set
1022 {
1023 if(value < 0)
1024 {
1025 throw (new ArgumentOutOfRangeException("value", SR.ExceptionBorderWidthIsNegative));
1026 }
1027 _borderWidth = value;
1028 Invalidate();
1029 }
1030 }
1031
1032 /// <summary>
1033 /// Gets or sets the style of the border line of a ChartArea object.
1034 /// </summary>
1035 [
1036
1037 SRCategory("CategoryAttributeAppearance"),
1038 Bindable(true),
1039 DefaultValue(ChartDashStyle.NotSet),
1040 SRDescription("DescriptionAttributeBorderDashStyle"),
1041 NotifyParentPropertyAttribute(true),
1042 #if !Microsoft_CONTROL
1043 PersistenceMode(PersistenceMode.Attribute)
1044 #endif
1045 ]
1046 public ChartDashStyle BorderDashStyle
1047 {
1048 get
1049 {
1050 return _borderDashStyle;
1051 }
1052 set
1053 {
1054 _borderDashStyle = value;
1055 Invalidate();
1056 }
1057 }
1058
1059 /// <summary>
1060 /// Gets or sets the unique name of a ChartArea object.
1061 /// </summary>
1062 [
1063
1064 SRCategory("CategoryAttributeMisc"),
1065 Bindable(true),
1066 SRDescription("DescriptionAttributeChartArea_Name"),
1067 NotifyParentPropertyAttribute(true),
1068 #if !Microsoft_CONTROL
1069 PersistenceMode(PersistenceMode.Attribute)
1070 #endif
1071 ]
1072 public override string Name
1073 {
1074 get
1075 {
1076 return base.Name;
1077 }
1078 set
1079 {
1080 base.Name = value;
1081 }
1082 }
1083
1084 /// <summary>
1085 /// Gets or sets a Boolean that determines if the labels of the axes for all chart area
1086 /// , which have LabelsAutoFit property set to true, are of equal size.
1087 /// </summary>
1088 [
1089 SRCategory("CategoryAttributeAppearance"),
1090 Bindable(true),
1091 DefaultValue(false),
1092 SRDescription("DescriptionAttributeChartArea_EquallySizedAxesFont"),
1093 NotifyParentPropertyAttribute(true),
1094 #if !Microsoft_CONTROL
1095 PersistenceMode(PersistenceMode.Attribute)
1096 #endif
1097 ]
1098 public bool IsSameFontSizeForAllAxes
1099 {
1100 get
1101 {
1102 return _isSameFontSizeForAllAxes;
1103 }
1104 set
1105 {
1106 _isSameFontSizeForAllAxes = value;
1107 Invalidate();
1108 }
1109 }
1110
1111
1112 #endregion
1113
1114 #region Constructors
1115 /// <summary>
1116 /// ChartArea constructor.
1117 /// </summary>
1118 public ChartArea()
1119 {
1120 Initialize();
1121 }
1122
1123 /// <summary>
1124 /// ChartArea constructor.
1125 /// </summary>
1126 /// <param name="name">The name.</param>
1127 public ChartArea(string name) : base(name)
1128 {
1129 Initialize();
1130 }
1131 #endregion
1132
1133 #region Chart Area Methods
1134 /// <summary>
1135 /// Restores series order and X axis reversed mode for the 3D charts.
1136 /// </summary>
1137 internal void Restore3DAnglesAndReverseMode()
1138 {
1139 if(this.Area3DStyle.Enable3D && !this.chartAreaIsCurcular)
1140 {
1141 // Restore axis "IsReversed" property and old Y angle
1142 this.AxisX.IsReversed = oldReverseX;
1143 this.AxisX2.IsReversed = oldReverseX;
1144 this.AxisY.IsReversed = oldReverseY;
1145 this.AxisY2.IsReversed = oldReverseY;
1146 this.Area3DStyle.Rotation = oldYAngle;
1147 }
1148 }
1149
1150 /// <summary>
1151 /// Sets series order and X axis reversed mode for the 3D charts.
1152 /// </summary>
1153 internal void Set3DAnglesAndReverseMode()
1154 {
1155 // Clear series reversed flag
1156 _reverseSeriesOrder = false;
1157
1158 // If 3D charting is enabled
1159 if(this.Area3DStyle.Enable3D)
1160 {
1161 // Make sure primary & secondary axis has the same IsReversed settings
1162 // This is a limitation for the 3D chart required for labels drawing.
1163 this.AxisX2.IsReversed = this.AxisX.IsReversed;
1164 this.AxisY2.IsReversed = this.AxisY.IsReversed;
1165
1166 // Remember reversed order of X & Y axis and Angles
1167 oldReverseX = this.AxisX.IsReversed;
1168 oldReverseY = this.AxisY.IsReversed;
1169 oldYAngle = this.Area3DStyle.Rotation;
1170
1171 // Check if Y angle
1172 if(this.Area3DStyle.Rotation > 90 || this.Area3DStyle.Rotation < -90)
1173 {
1174 // This method depends on the 'switchValueAxes' field which is calculated based on the chart types
1175 // of the series associated with the chart area. We need to call SetData method to make sure this field
1176 // is correctly initialized. Because we only need to collect information about the series, we pass 'false'
1177 // as parameters to limit the amount of work this function does.
1178 this.SetData(false, false);
1179
1180 // Reversed series order
1181 _reverseSeriesOrder = true;
1182
1183 // Reversed primary and secondary X axis
1184 if(!this.switchValueAxes)
1185 {
1186 this.AxisX.IsReversed = !this.AxisX.IsReversed;
1187 this.AxisX2.IsReversed = !this.AxisX2.IsReversed;
1188 }
1189
1190 // Reversed primary and secondary Y axis for chart types like Bar
1191 else
1192 {
1193 this.AxisY.IsReversed = !this.AxisY.IsReversed;
1194 this.AxisY2.IsReversed = !this.AxisY2.IsReversed;
1195 }
1196
1197 // Adjust Y angle
1198 if(this.Area3DStyle.Rotation > 90)
1199 {
1200 this.Area3DStyle.Rotation = (this.Area3DStyle.Rotation - 90) - 90;
1201 }
1202 else if(this.Area3DStyle.Rotation < -90)
1203 {
1204 this.Area3DStyle.Rotation = (this.Area3DStyle.Rotation + 90) + 90;
1205 }
1206 }
1207 }
1208 }
1209
1210 /// <summary>
1211 /// Save all automatic values like Minimum and Maximum.
1212 /// </summary>
1213 internal void SetTempValues()
1214 {
1215 // Save non automatic area position
1216 if(!this.Position.Auto)
1217 {
1218 this.originalAreaPosition = this.Position.ToRectangleF();
1219 }
1220
1221 // Save non automatic area inner plot position
1222 if(!this.InnerPlotPosition.Auto)
1223 {
1224 this.originalInnerPlotPosition = this.InnerPlotPosition.ToRectangleF();
1225 }
1226
1227 this._circularSectorNumber = int.MinValue;
1228 this._circularUsePolygons = int.MinValue;
1229 this._circularAxisList = null;
1230
1231 // Save Minimum and maximum values for all axes
1232 axisX.StoreAxisValues();
1233 axisX2.StoreAxisValues();
1234 axisY.StoreAxisValues();
1235 axisY2.StoreAxisValues();
1236 }
1237
1238 /// <summary>
1239 /// Load all automatic values like Minimum and Maximum with original values.
1240 /// </summary>
1241 internal void GetTempValues()
1242 {
1243 // Take Minimum and maximum values for all axes
1244 axisX.ResetAxisValues();
1245 axisX2.ResetAxisValues();
1246 axisY.ResetAxisValues();
1247 axisY2.ResetAxisValues();
1248
1249 // Restore non automatic area position
1250 if(!this.originalAreaPosition.IsEmpty)
1251 {
1252 this.lastAreaPosition = this.Position.ToRectangleF();
1253 this.Position.SetPositionNoAuto(this.originalAreaPosition.X, this.originalAreaPosition.Y, this.originalAreaPosition.Width, this.originalAreaPosition.Height);
1254 this.originalAreaPosition = RectangleF.Empty;
1255 }
1256
1257 // Save non automatic area inner plot position
1258 if(!this.originalInnerPlotPosition.IsEmpty)
1259 {
1260 this.InnerPlotPosition.SetPositionNoAuto(this.originalInnerPlotPosition.X, this.originalInnerPlotPosition.Y, this.originalInnerPlotPosition.Width, this.originalInnerPlotPosition.Height);
1261 this.originalInnerPlotPosition = RectangleF.Empty;
1262 }
1263 }
1264
1265 /// <summary>
1266 /// Initialize Chart area and axes
1267 /// </summary>
1268 internal void Initialize()
1269 {
1270 // Initialize 3D style class
1271 _area3DStyle = new ChartArea3DStyle(this);
1272
1273 // Create axes for this chart area.
1274 axisY = new Axis( );
1275 axisX = new Axis( );
1276 axisX2 = new Axis( );
1277 axisY2 = new Axis( );
1278
1279 // Initialize axes;
1280 axisX.Initialize(this, AxisName.X);
1281 axisY.Initialize(this, AxisName.Y);
1282 axisX2.Initialize(this, AxisName.X2);
1283 axisY2.Initialize(this, AxisName.Y2);
1284
1285 // Initialize axes array
1286 _axisArray[0] = axisX;
1287 _axisArray[1] = axisY;
1288 _axisArray[2] = axisX2;
1289 _axisArray[3] = axisY2;
1290
1291 // Set flag to reset auto values for all areas
1292 _areaPosition = new ElementPosition(this);
1293 _areaPosition.resetAreaAutoPosition = true;
1294
1295 _innerPlotPosition = new ElementPosition(this);
1296
1297 // Set the position of the new chart area
1298 if( PlotAreaPosition == null )
1299 {
1300 PlotAreaPosition = new ElementPosition(this);
1301 }
1302
1303 #if Microsoft_CONTROL
1304
1305 // Initialize cursor class
1306 this._cursorX.Initialize(this, AxisName.X);
1307 this._cursorY.Initialize(this, AxisName.Y);
1308
1309 #endif // Microsoft_CONTROL
1310 }
1311
1312 /// <summary>
1313 /// Minimum and maximum do not have to be calculated
1314 /// from data series every time. It is very time
1315 /// consuming. Minimum and maximum are buffered
1316 /// and only when this flags are set Minimum and
1317 /// Maximum are refreshed from data.
1318 /// </summary>
1319 internal void ResetMinMaxFromData()
1320 {
1321 _axisArray[0].refreshMinMaxFromData = true;
1322 _axisArray[1].refreshMinMaxFromData = true;
1323 _axisArray[2].refreshMinMaxFromData = true;
1324 _axisArray[3].refreshMinMaxFromData = true;
1325 }
1326
1327 /// <summary>
1328 /// Recalculates the axes scale of a chart area.
1329 /// </summary>
1330 public void RecalculateAxesScale()
1331 {
1332 // Read axis Max/Min from data
1333 ResetMinMaxFromData();
1334
1335 #if Microsoft_CONTROL
1336 Set3DAnglesAndReverseMode();
1337 SetTempValues();
1338 #endif
1339
1340 // Initialize area position
1341 _axisArray[0].ReCalc( PlotAreaPosition );
1342 _axisArray[1].ReCalc( PlotAreaPosition );
1343 _axisArray[2].ReCalc( PlotAreaPosition );
1344 _axisArray[3].ReCalc( PlotAreaPosition );
1345
1346 // Find all Data and chart types which belong
1347 // to this chart area an set default values
1348 SetData();
1349
1350 #if Microsoft_CONTROL
1351 Restore3DAnglesAndReverseMode();
1352 GetTempValues();
1353 #endif
1354 }
1355
1356 /// <summary>
1357 /// RecalculateAxesScale the chart area
1358 /// </summary>
1359 internal void ReCalcInternal()
1360 {
1361 // Initialize area position
1362 _axisArray[0].ReCalc( PlotAreaPosition );
1363 _axisArray[1].ReCalc( PlotAreaPosition );
1364 _axisArray[2].ReCalc( PlotAreaPosition );
1365 _axisArray[3].ReCalc( PlotAreaPosition );
1366
1367 // Find all Data and chart types which belong
1368 // to this chart area an set default values
1369 SetData();
1370 }
1371
1372
1373 /// <summary>
1374 /// Reset auto calculated chart area values.
1375 /// </summary>
1376 internal void ResetAutoValues()
1377 {
1378 _axisArray[0].ResetAutoValues();
1379 _axisArray[1].ResetAutoValues();
1380 _axisArray[2].ResetAutoValues();
1381 _axisArray[3].ResetAutoValues();
1382 }
1383
1384 /// <summary>
1385 /// Calculates Position for the background.
1386 /// </summary>
1387 /// <param name="withScrollBars">Calculate with scroll bars</param>
1388 /// <returns>Background rectangle</returns>
1389 internal RectangleF GetBackgroundPosition( bool withScrollBars )
1390 {
1391 // For pie and doughnut, which do not have axes, the position
1392 // for the background is Chart area position not plotting
1393 // area position.
1394 RectangleF backgroundPosition = PlotAreaPosition.ToRectangleF();
1395 if( !requireAxes )
1396 {
1397 backgroundPosition = Position.ToRectangleF();
1398 }
1399
1400 // Without scroll bars
1401 if( !withScrollBars )
1402 {
1403 return backgroundPosition;
1404 }
1405
1406 // Add scroll bar rectangles to the area background
1407 RectangleF backgroundPositionWithScrollBars = new RectangleF(backgroundPosition.Location, backgroundPosition.Size);
1408
1409 #if Microsoft_CONTROL
1410
1411 if( requireAxes )
1412 {
1413 // Loop through all axis
1414 foreach(Axis axis in this.Axes)
1415 {
1416 // Find axis with visible scroll bars
1417 if(axis.ScrollBar.IsVisible && axis.ScrollBar.IsPositionedInside)
1418 {
1419 // Change size of the background rectangle depending on the axis position
1420 if(axis.AxisPosition == AxisPosition.Bottom)
1421 {
1422 backgroundPositionWithScrollBars.Height += (float)axis.ScrollBar.GetScrollBarRelativeSize();
1423 }
1424 else if(axis.AxisPosition == AxisPosition.Top)
1425 {
1426 backgroundPositionWithScrollBars.Y -= (float)axis.ScrollBar.GetScrollBarRelativeSize();
1427 backgroundPositionWithScrollBars.Height += (float)axis.ScrollBar.GetScrollBarRelativeSize();
1428 }
1429 else if(axis.AxisPosition == AxisPosition.Left)
1430 {
1431 backgroundPositionWithScrollBars.X -= (float)axis.ScrollBar.GetScrollBarRelativeSize();
1432 backgroundPositionWithScrollBars.Width += (float)axis.ScrollBar.GetScrollBarRelativeSize();
1433 }
1434 else if(axis.AxisPosition == AxisPosition.Left)
1435 {
1436 backgroundPositionWithScrollBars.Width += (float)axis.ScrollBar.GetScrollBarRelativeSize();
1437 }
1438 }
1439 }
1440 }
1441
1442 #endif // Microsoft_CONTROL
1443 return backgroundPositionWithScrollBars;
1444 }
1445
1446 /// <summary>
1447 /// Call when the chart area is resized.
1448 /// </summary>
1449 /// <param name="chartGraph">Chart graphics object.</param>
1450 internal void Resize(ChartGraphics chartGraph)
1451 {
1452 // Initialize plotting area position
1453 RectangleF plottingRect = Position.ToRectangleF();
1454 if(!InnerPlotPosition.Auto)
1455 {
1456 plottingRect.X += (Position.Width / 100F) * InnerPlotPosition.X;
1457 plottingRect.Y += (Position.Height / 100F) * InnerPlotPosition.Y;
1458 plottingRect.Width = (Position.Width / 100F) * InnerPlotPosition.Width;
1459 plottingRect.Height = (Position.Height / 100F) * InnerPlotPosition.Height;
1460 }
1461
1462 //******************************************************
1463 //** Calculate number of vertical and horizontal axis
1464 //******************************************************
1465 int verticalAxes = 0;
1466 int horizontalAxes = 0;
1467 foreach(Axis axis in this.Axes)
1468 {
1469 if(axis.enabled)
1470 {
1471 if(axis.AxisPosition == AxisPosition.Bottom)
1472 {
1473 ++horizontalAxes;
1474 }
1475 else if(axis.AxisPosition == AxisPosition.Top)
1476 {
1477 ++horizontalAxes;
1478 }
1479 else if(axis.AxisPosition == AxisPosition.Left)
1480 {
1481 ++verticalAxes;
1482 }
1483 else if(axis.AxisPosition == AxisPosition.Right)
1484 {
1485 ++verticalAxes;
1486 }
1487 }
1488 }
1489 if(horizontalAxes <= 0 )
1490 {
1491 horizontalAxes = 1;
1492 }
1493 if(verticalAxes <= 0 )
1494 {
1495 verticalAxes = 1;
1496 }
1497
1498
1499 //******************************************************
1500 //** Find same auto-fit font size
1501 //******************************************************
1502 Axis[] axisArray = (this.switchValueAxes) ?
1503 new Axis[] {this.AxisX, this.AxisX2, this.AxisY, this.AxisY2} :
1504 new Axis[] {this.AxisY, this.AxisY2, this.AxisX, this.AxisX2};
1505 if(this.IsSameFontSizeForAllAxes)
1506 {
1507 axesAutoFontSize = 20;
1508 foreach(Axis axis in axisArray)
1509 {
1510 // Process only enabled axis
1511 if(axis.enabled)
1512 {
1513 // Resize axis
1514 if(axis.AxisPosition == AxisPosition.Bottom || axis.AxisPosition == AxisPosition.Top)
1515 {
1516 axis.Resize(chartGraph, this.PlotAreaPosition, plottingRect, horizontalAxes, InnerPlotPosition.Auto);
1517 }
1518 else
1519 {
1520 axis.Resize(chartGraph, this.PlotAreaPosition, plottingRect, verticalAxes, InnerPlotPosition.Auto);
1521 }
1522
1523 // Calculate smallest font size
1524 if(axis.IsLabelAutoFit && axis.autoLabelFont != null)
1525 {
1526 axesAutoFontSize = Math.Min(axesAutoFontSize, axis.autoLabelFont.Size);
1527 }
1528 }
1529 }
1530 }
1531
1532 //******************************************************
1533 //** Adjust plotting area position according to the axes
1534 //** elements (title, labels, tick marks) size.
1535 //******************************************************
1536 RectangleF rectLabelSideSpacing = RectangleF.Empty;
1537 foreach(Axis axis in axisArray)
1538 {
1539 // Process only enabled axis
1540 if( ! axis.enabled )
1541 {
1542 //******************************************************
1543 //** Adjust for the 3D Wall Width for disabled axis
1544 //******************************************************
1545 if(InnerPlotPosition.Auto && this.Area3DStyle.Enable3D && !this.chartAreaIsCurcular)
1546 {
1547 SizeF areaWallSize = chartGraph.GetRelativeSize(new SizeF(this.Area3DStyle.WallWidth, this.Area3DStyle.WallWidth));
1548 if(axis.AxisPosition == AxisPosition.Bottom)
1549 {
1550 plottingRect.Height -= areaWallSize.Height;
1551 }
1552 else if(axis.AxisPosition == AxisPosition.Top)
1553 {
1554 plottingRect.Y += areaWallSize.Height;
1555 plottingRect.Height -= areaWallSize.Height;
1556 }
1557 else if(axis.AxisPosition == AxisPosition.Right)
1558 {
1559 plottingRect.Width -= areaWallSize.Width;
1560 }
1561 else if(axis.AxisPosition == AxisPosition.Left)
1562 {
1563 plottingRect.X += areaWallSize.Width;
1564 plottingRect.Width -= areaWallSize.Width;
1565 }
1566 }
1567
1568 continue;
1569 }
1570
1571 //******************************************************
1572 //** Calculate axes elements position
1573 //******************************************************
1574 if(axis.AxisPosition == AxisPosition.Bottom || axis.AxisPosition == AxisPosition.Top)
1575 {
1576 axis.Resize(chartGraph, this.PlotAreaPosition, plottingRect, horizontalAxes, InnerPlotPosition.Auto);
1577 }
1578 else
1579 {
1580 axis.Resize(chartGraph, this.PlotAreaPosition, plottingRect, verticalAxes, InnerPlotPosition.Auto);
1581 }
1582
1583 // Shift top/bottom labels so they will not overlap with left/right labels
1584 PreventTopBottomAxesLabelsOverlapping(axis);
1585
1586 //******************************************************
1587 //** Check axis position
1588 //******************************************************
1589 float axisPosition = (float)axis.GetAxisPosition();
1590 if(axis.AxisPosition == AxisPosition.Bottom)
1591 {
1592 if(!axis.GetIsMarksNextToAxis())
1593 {
1594 axisPosition = plottingRect.Bottom;
1595 }
1596 axisPosition = plottingRect.Bottom - axisPosition;
1597 }
1598 else if(axis.AxisPosition == AxisPosition.Top)
1599 {
1600 if(!axis.GetIsMarksNextToAxis())
1601 {
1602 axisPosition = plottingRect.Y;
1603 }
1604 axisPosition = axisPosition - plottingRect.Top;
1605 }
1606 else if(axis.AxisPosition == AxisPosition.Right)
1607 {
1608 if(!axis.GetIsMarksNextToAxis())
1609 {
1610 axisPosition = plottingRect.Right;
1611 }
1612 axisPosition = plottingRect.Right - axisPosition;
1613 }
1614 else if(axis.AxisPosition == AxisPosition.Left)
1615 {
1616 if(!axis.GetIsMarksNextToAxis())
1617 {
1618 axisPosition = plottingRect.X;
1619 }
1620 axisPosition = axisPosition - plottingRect.Left;
1621 }
1622
1623 //******************************************************
1624 //** Adjust axis elements size with axis position
1625 //******************************************************
1626 // Calculate total size of axis elements
1627 float axisSize = axis.markSize + axis.labelSize;
1628
1629 #if SUBAXES
1630 // Add sub-axis size
1631 if(!this.chartAreaIsCurcular && !this.Area3DStyle.Enable3D)
1632 {
1633 foreach(SubAxis subAxis in axis.SubAxes)
1634 {
1635 axisSize += subAxis.markSize + subAxis.labelSize + subAxis.titleSize;
1636 }
1637 }
1638 #endif // SUBAXES
1639
1640 // Adjust depending on the axis position
1641 axisSize -= axisPosition;
1642 if(axisSize < 0)
1643 {
1644 axisSize = 0;
1645 }
1646
1647
1648 // Add axis title and scroll bar size (always outside of plotting area)
1649 axisSize += axis.titleSize + axis.scrollBarSize;
1650
1651
1652 // Calculate horizontal axes size for circualar area
1653 if(this.chartAreaIsCurcular &&
1654 (axis.AxisPosition == AxisPosition.Top || axis.AxisPosition == AxisPosition.Bottom) )
1655 {
1656 axisSize = axis.titleSize + axis.markSize + axis.scrollBarSize;
1657 }
1658
1659 //******************************************************
1660 //** Adjust plotting area
1661 //******************************************************
1662 if(InnerPlotPosition.Auto)
1663 {
1664 if(axis.AxisPosition == AxisPosition.Bottom)
1665 {
1666 plottingRect.Height -= axisSize;
1667 }
1668 else if(axis.AxisPosition == AxisPosition.Top)
1669 {
1670 plottingRect.Y += axisSize;
1671 plottingRect.Height -= axisSize;
1672 }
1673 else if(axis.AxisPosition == AxisPosition.Left)
1674 {
1675 plottingRect.X += axisSize;
1676 plottingRect.Width -= axisSize;
1677 }
1678 else if(axis.AxisPosition == AxisPosition.Right)
1679 {
1680 plottingRect.Width -= axisSize;
1681 }
1682
1683 // Check if labels side offset should be processed
1684 bool addLabelsSideOffsets = true;
1685
1686 // Update the plotting area depending on the size required for labels on the sides
1687 if (addLabelsSideOffsets)
1688 {
1689 if (axis.AxisPosition == AxisPosition.Bottom || axis.AxisPosition == AxisPosition.Top)
1690 {
1691 if (axis.labelNearOffset != 0 && axis.labelNearOffset < Position.X)
1692 {
1693 float offset = Position.X - axis.labelNearOffset;
1694 if (Math.Abs(offset) > plottingRect.Width * 0.3f)
1695 {
1696 offset = plottingRect.Width * 0.3f;
1697 }
1698
1699 // NOTE: Code was removed to solve an issue with extra space when labels angle = 45
1700 //rectLabelSideSpacing.Width = (float)Math.Max(offset, rectLabelSideSpacing.Width);
1701 rectLabelSideSpacing.X = (float)Math.Max(offset, rectLabelSideSpacing.X);
1702 }
1703
1704 if (axis.labelFarOffset > Position.Right)
1705 {
1706 if ((axis.labelFarOffset - Position.Right) < plottingRect.Width * 0.3f)
1707 {
1708 rectLabelSideSpacing.Width = (float)Math.Max(axis.labelFarOffset - Position.Right, rectLabelSideSpacing.Width);
1709 }
1710 else
1711 {
1712 rectLabelSideSpacing.Width = (float)Math.Max(plottingRect.Width * 0.3f, rectLabelSideSpacing.Width);
1713 }
1714 }
1715 }
1716
1717 else
1718 {
1719 if (axis.labelNearOffset != 0 && axis.labelNearOffset < Position.Y)
1720 {
1721 float offset = Position.Y - axis.labelNearOffset;
1722 if (Math.Abs(offset) > plottingRect.Height * 0.3f)
1723 {
1724 offset = plottingRect.Height * 0.3f;
1725 }
1726
1727 // NOTE: Code was removed to solve an issue with extra space when labels angle = 45
1728 //rectLabelSideSpacing.Height = (float)Math.Max(offset, rectLabelSideSpacing.Height);
1729 rectLabelSideSpacing.Y = (float)Math.Max(offset, rectLabelSideSpacing.Y);
1730 }
1731
1732 if (axis.labelFarOffset > Position.Bottom)
1733 {
1734 if ((axis.labelFarOffset - Position.Bottom) < plottingRect.Height * 0.3f)
1735 {
1736 rectLabelSideSpacing.Height = (float)Math.Max(axis.labelFarOffset - Position.Bottom, rectLabelSideSpacing.Height);
1737 }
1738 else
1739 {
1740 rectLabelSideSpacing.Height = (float)Math.Max(plottingRect.Height * 0.3f, rectLabelSideSpacing.Height);
1741 }
1742 }
1743 }
1744 }
1745 }
1746 }
1747
1748 //******************************************************
1749 //** Make sure there is enough space
1750 //** for labels on the chart sides
1751 //******************************************************
1752 if (!this.chartAreaIsCurcular)
1753 {
1754 if (rectLabelSideSpacing.Y > 0 && rectLabelSideSpacing.Y > plottingRect.Y - Position.Y)
1755 {
1756 float delta = (plottingRect.Y - Position.Y) - rectLabelSideSpacing.Y;
1757 plottingRect.Y -= delta;
1758 plottingRect.Height += delta;
1759 }
1760 if (rectLabelSideSpacing.X > 0 && rectLabelSideSpacing.X > plottingRect.X - Position.X)
1761 {
1762 float delta = (plottingRect.X - Position.X) - rectLabelSideSpacing.X;
1763 plottingRect.X -= delta;
1764 plottingRect.Width += delta;
1765 }
1766 if (rectLabelSideSpacing.Height > 0 && rectLabelSideSpacing.Height > Position.Bottom - plottingRect.Bottom)
1767 {
1768 plottingRect.Height += (Position.Bottom - plottingRect.Bottom) - rectLabelSideSpacing.Height;
1769 }
1770 if (rectLabelSideSpacing.Width > 0 && rectLabelSideSpacing.Width > Position.Right - plottingRect.Right)
1771 {
1772 plottingRect.Width += (Position.Right - plottingRect.Right) - rectLabelSideSpacing.Width;
1773 }
1774 }
1775
1776 //******************************************************
1777 //** Plotting area must be square for the circular
1778 //** chart area (in pixels).
1779 //******************************************************
1780 if(this.chartAreaIsCurcular)
1781 {
1782 // Adjust area to fit the axis title
1783 float xTitleSize = (float)Math.Max(this.AxisY.titleSize, this.AxisY2.titleSize);
1784 if(xTitleSize > 0)
1785 {
1786 plottingRect.X += xTitleSize;
1787 plottingRect.Width -= 2f * xTitleSize;
1788 }
1789 float yTitleSize = (float)Math.Max(this.AxisX.titleSize, this.AxisX2.titleSize);
1790 if(yTitleSize > 0)
1791 {
1792 plottingRect.Y += yTitleSize;
1793 plottingRect.Height -= 2f * yTitleSize;
1794 }
1795
1796 // Make a square plotting rect
1797 RectangleF rect = chartGraph.GetAbsoluteRectangle( plottingRect );
1798 if(rect.Width > rect.Height)
1799 {
1800 rect.X += (rect.Width - rect.Height) / 2f;
1801 rect.Width = rect.Height;
1802 }
1803 else
1804 {
1805 rect.Y += (rect.Height - rect.Width) / 2f;
1806 rect.Height = rect.Width;
1807 }
1808 plottingRect = chartGraph.GetRelativeRectangle( rect );
1809
1810 // Remember circular chart area center
1811 this.circularCenter = new PointF(plottingRect.X + plottingRect.Width/2f, plottingRect.Y + plottingRect.Height/2f);
1812
1813 // Calculate auto-fit font of the circular axis labels and update area position
1814 FitCircularLabels(chartGraph, this.PlotAreaPosition, ref plottingRect, xTitleSize, yTitleSize);
1815 }
1816
1817 //******************************************************
1818 //** Set plotting area position
1819 //******************************************************
1820 if(plottingRect.Width < 0f)
1821 {
1822 plottingRect.Width = 0f;
1823 }
1824 if(plottingRect.Height < 0f)
1825 {
1826 plottingRect.Height = 0f;
1827 }
1828 PlotAreaPosition.FromRectangleF(plottingRect);
1829 InnerPlotPosition.SetPositionNoAuto(
1830 (float)Math.Round((plottingRect.X - Position.X) / (Position.Width / 100F), 5),
1831 (float)Math.Round((plottingRect.Y - Position.Y) / (Position.Height / 100F), 5),
1832 (float)Math.Round(plottingRect.Width / (Position.Width / 100F), 5),
1833 (float)Math.Round(plottingRect.Height / (Position.Height / 100F), 5));
1834
1835
1836 //******************************************************
1837 //** Adjust label font size for axis, which were
1838 //** automatically calculated after the opposite axis
1839 //** change the size of plotting area.
1840 //******************************************************
1841 this.AxisY2.AdjustLabelFontAtSecondPass(chartGraph, InnerPlotPosition.Auto);
1842 this.AxisY.AdjustLabelFontAtSecondPass(chartGraph, InnerPlotPosition.Auto);
1843 if(InnerPlotPosition.Auto)
1844 {
1845 this.AxisX2.AdjustLabelFontAtSecondPass(chartGraph, InnerPlotPosition.Auto);
1846 this.AxisX.AdjustLabelFontAtSecondPass(chartGraph, InnerPlotPosition.Auto);
1847 }
1848
1849 }
1850
1851 /// <summary>
1852 /// Finds axis by it's position. Can be Null.
1853 /// </summary>
1854 /// <param name="axisPosition">Axis position to find</param>
1855 /// <returns>Found axis.</returns>
1856 private Axis FindAxis(AxisPosition axisPosition)
1857 {
1858 foreach(Axis axis in this.Axes)
1859 {
1860 if(axis.AxisPosition == axisPosition)
1861 {
1862 return axis;
1863 }
1864 }
1865 return null;
1866 }
1867
1868 /// <summary>
1869 /// Shift top/bottom labels so they will not overlap with left/right labels.
1870 /// </summary>
1871 /// <param name="axis">Axis to shift up/down.</param>
1872 private void PreventTopBottomAxesLabelsOverlapping(Axis axis)
1873 {
1874 // If axis is not on the edge of the chart area do not
1875 // try to adjust it's position when axis labels overlap
1876 // labels of the oppositie axis.
1877 if( !axis.IsAxisOnAreaEdge )
1878 {
1879 return;
1880 }
1881
1882 // Shift bottom axis labels down
1883 if(axis.AxisPosition == AxisPosition.Bottom)
1884 {
1885 // Get labels position
1886 float labelsPosition = (float)axis.GetAxisPosition();
1887 if( !axis.GetIsMarksNextToAxis() )
1888 {
1889 labelsPosition = axis.PlotAreaPosition.Bottom;
1890 }
1891
1892 // Only adjust labels outside plotting area
1893 if(Math.Round(labelsPosition, 2) < Math.Round(axis.PlotAreaPosition.Bottom, 2))
1894 {
1895 return;
1896 }
1897
1898 // Check if labels may overlap with Left axis
1899 Axis leftAxis = FindAxis(AxisPosition.Left);
1900 if(leftAxis != null &&
1901 leftAxis.enabled &&
1902 leftAxis.labelFarOffset != 0 &&
1903 leftAxis.labelFarOffset > labelsPosition &&
1904 axis.labelNearOffset != 0 &&
1905 axis.labelNearOffset < PlotAreaPosition.X)
1906 {
1907 float overlap = (float)(leftAxis.labelFarOffset - labelsPosition) * 0.75f;
1908 if(overlap > axis.markSize)
1909 {
1910 axis.markSize += overlap - axis.markSize;
1911 }
1912 }
1913
1914 // Check if labels may overlap with Right axis
1915 Axis rightAxis = FindAxis(AxisPosition.Right);
1916 if(rightAxis != null &&
1917 rightAxis.enabled &&
1918 rightAxis.labelFarOffset != 0 &&
1919 rightAxis.labelFarOffset > labelsPosition &&
1920 axis.labelFarOffset != 0 &&
1921 axis.labelFarOffset > PlotAreaPosition.Right)
1922 {
1923 float overlap = (float)(rightAxis.labelFarOffset - labelsPosition) * 0.75f;
1924 if(overlap > axis.markSize)
1925 {
1926 axis.markSize += overlap - axis.markSize;
1927 }
1928 }
1929 }
1930
1931 // Shift top axis labels up
1932 else if(axis.AxisPosition == AxisPosition.Top)
1933 {
1934 // Get labels position
1935 float labelsPosition = (float)axis.GetAxisPosition();
1936 if( !axis.GetIsMarksNextToAxis() )
1937 {
1938 labelsPosition = axis.PlotAreaPosition.Y;
1939 }
1940
1941 // Only adjust labels outside plotting area
1942 if(Math.Round(labelsPosition, 2) < Math.Round(axis.PlotAreaPosition.Y, 2))
1943 {
1944 return;
1945 }
1946
1947 // Check if labels may overlap with Left axis
1948 Axis leftAxis = FindAxis(AxisPosition.Left);
1949 if(leftAxis != null &&
1950 leftAxis.enabled &&
1951 leftAxis.labelNearOffset != 0 &&
1952 leftAxis.labelNearOffset < labelsPosition &&
1953 axis.labelNearOffset != 0 &&
1954 axis.labelNearOffset < PlotAreaPosition.X)
1955 {
1956 float overlap = (float)(labelsPosition - leftAxis.labelNearOffset) * 0.75f;
1957 if(overlap > axis.markSize)
1958 {
1959 axis.markSize += overlap - axis.markSize;
1960 }
1961 }
1962
1963 // Check if labels may overlap with Right axis
1964 Axis rightAxis = FindAxis(AxisPosition.Right);
1965 if(rightAxis != null &&
1966 rightAxis.enabled &&
1967 rightAxis.labelNearOffset != 0 &&
1968 rightAxis.labelNearOffset < labelsPosition &&
1969 axis.labelFarOffset != 0 &&
1970 axis.labelFarOffset > PlotAreaPosition.Right)
1971 {
1972 float overlap = (float)(labelsPosition - rightAxis.labelNearOffset) * 0.75f;
1973 if(overlap > axis.markSize)
1974 {
1975 axis.markSize += overlap - axis.markSize;
1976 }
1977 }
1978 }
1979
1980 }
1981
1982 #endregion
1983
1984 #region Painting and Selection Methods
1985
1986 /// <summary>
1987 /// Draws chart area background and/or border.
1988 /// </summary>
1989 /// <param name="graph">Chart graphics.</param>
1990 /// <param name="position">Background position.</param>
1991 /// <param name="borderOnly">Draws chart area border only.</param>
1992 private void PaintAreaBack(ChartGraphics graph, RectangleF position, bool borderOnly)
1993 {
1994 if(!borderOnly)
1995 {
1996 // Draw background
1997 if(!this.Area3DStyle.Enable3D || !requireAxes || chartAreaIsCurcular)
1998 {
1999 // 3D Pie Chart doesn't need scene
2000 // Draw 2D background
2001 graph.FillRectangleRel(
2002 position,
2003 BackColor,
2004 BackHatchStyle,
2005 BackImage,
2006 BackImageWrapMode,
2007 BackImageTransparentColor,
2008 BackImageAlignment,
2009 BackGradientStyle,
2010 BackSecondaryColor,
2011 (requireAxes) ? Color.Empty : BorderColor,
2012 (requireAxes) ? 0 : BorderWidth,
2013 BorderDashStyle,
2014 ShadowColor,
2015 ShadowOffset,
2016 PenAlignment.Outset,
2017 chartAreaIsCurcular,
2018 (chartAreaIsCurcular && this.CircularUsePolygons) ? this.CircularSectorsNumber : 0,
2019 this.Area3DStyle.Enable3D);
2020 }
2021 else
2022 {
2023 // Draw chart area 3D scene
2024 this.DrawArea3DScene(graph, position);
2025 }
2026 }
2027 else
2028 {
2029 if(!this.Area3DStyle.Enable3D || !requireAxes || chartAreaIsCurcular)
2030 {
2031 // Draw chart area border
2032 if(BorderColor != Color.Empty && BorderWidth > 0)
2033 {
2034 graph.FillRectangleRel( position,
2035 Color.Transparent,
2036 ChartHatchStyle.None,
2037 "",
2038 ChartImageWrapMode.Tile,
2039 Color.Empty,
2040 ChartImageAlignmentStyle.Center,
2041 GradientStyle.None,
2042 Color.Empty,
2043 BorderColor,
2044 BorderWidth,
2045 BorderDashStyle,
2046 Color.Empty,
2047 0,
2048 PenAlignment.Outset,
2049 chartAreaIsCurcular,
2050 (chartAreaIsCurcular && this.CircularUsePolygons) ? this.CircularSectorsNumber : 0,
2051 this.Area3DStyle.Enable3D);
2052 }
2053 }
2054
2055 }
2056 }
2057
2058 /// <summary>
2059 /// Paint the chart area.
2060 /// </summary>
2061 /// <param name="graph">Chart graphics.</param>
2062 internal void Paint( ChartGraphics graph )
2063 {
2064 // Check if plot area position was recalculated.
2065 // If not and non-auto InnerPlotPosition & Position were
2066 // specified - do all needed calculations
2067 if (PlotAreaPosition.Width == 0 &&
2068 PlotAreaPosition.Height == 0 &&
2069 !InnerPlotPosition.Auto
2070 && !Position.Auto)
2071 {
2072 // Initialize plotting area position
2073 RectangleF plottingRect = Position.ToRectangleF();
2074 if (!InnerPlotPosition.Auto)
2075 {
2076 plottingRect.X += (Position.Width / 100F) * InnerPlotPosition.X;
2077 plottingRect.Y += (Position.Height / 100F) * InnerPlotPosition.Y;
2078 plottingRect.Width = (Position.Width / 100F) * InnerPlotPosition.Width;
2079 plottingRect.Height = (Position.Height / 100F) * InnerPlotPosition.Height;
2080 }
2081
2082 PlotAreaPosition.FromRectangleF(plottingRect);
2083 }
2084
2085 // Get background position rectangle.
2086 RectangleF backgroundPositionWithScrollBars = GetBackgroundPosition(true);
2087 RectangleF backgroundPosition = GetBackgroundPosition(false);
2088
2089 // Add hot region for plotting area.
2090 if (Common.ProcessModeRegions)
2091 {
2092 Common.HotRegionsList.AddHotRegion(backgroundPosition, this, ChartElementType.PlottingArea, true);
2093 }
2094 // Draw background
2095 PaintAreaBack(graph, backgroundPositionWithScrollBars, false);
2096
2097 // Call BackPaint event
2098 Common.Chart.CallOnPrePaint(new ChartPaintEventArgs(this, graph, Common, PlotAreaPosition));
2099
2100 // Draw chart types without axes - Pie.
2101 if (!requireAxes && ChartTypes.Count != 0)
2102 {
2103 // Find first chart type that do not require axis (like Pie) and draw it.
2104 // Chart types that do not require axes (circular charts) cannot be combined with
2105 // any other chart types.
2106 // NOTE: Fixes issues #4672 and #4692
2107 for (int chartTypeIndex = 0; chartTypeIndex < ChartTypes.Count; chartTypeIndex++)
2108 {
2109 IChartType chartType = Common.ChartTypeRegistry.GetChartType((string)ChartTypes[chartTypeIndex]);
2110 if (!chartType.RequireAxes)
2111 {
2112 chartType.Paint(graph, Common, this, null);
2113 break;
2114 }
2115 }
2116
2117 // Call Paint event
2118 Common.Chart.CallOnPostPaint(new ChartPaintEventArgs(this, graph, Common, PlotAreaPosition));
2119 return;
2120 }
2121
2122
2123
2124 // Reset Smart Labels
2125 this.smartLabels.Reset();
2126
2127
2128
2129 // Set values for optimized drawing
2130 foreach (Axis currentAxis in this._axisArray)
2131 {
2132 currentAxis.optimizedGetPosition = true;
2133 currentAxis.paintViewMax = currentAxis.ViewMaximum;
2134 currentAxis.paintViewMin = currentAxis.ViewMinimum;
2135 currentAxis.paintRange = currentAxis.paintViewMax - currentAxis.paintViewMin;
2136 currentAxis.paintAreaPosition = PlotAreaPosition.ToRectangleF();
2137 if (currentAxis.ChartArea != null && currentAxis.ChartArea.chartAreaIsCurcular)
2138 {
2139 // Update position for circular chart area
2140 currentAxis.paintAreaPosition.Width /= 2.0f;
2141 currentAxis.paintAreaPosition.Height /= 2.0f;
2142 }
2143 currentAxis.paintAreaPositionBottom = currentAxis.paintAreaPosition.Y + currentAxis.paintAreaPosition.Height;
2144 currentAxis.paintAreaPositionRight = currentAxis.paintAreaPosition.X + currentAxis.paintAreaPosition.Width;
2145 if (currentAxis.AxisPosition == AxisPosition.Top || currentAxis.AxisPosition == AxisPosition.Bottom)
2146 currentAxis.paintChartAreaSize = currentAxis.paintAreaPosition.Width;
2147 else
2148 currentAxis.paintChartAreaSize = currentAxis.paintAreaPosition.Height;
2149
2150 currentAxis.valueMultiplier = 0.0;
2151 if (currentAxis.paintRange != 0)
2152 {
2153 currentAxis.valueMultiplier = currentAxis.paintChartAreaSize / currentAxis.paintRange;
2154 }
2155 }
2156
2157 // Draw Axis Striplines (only when StripWidth > 0)
2158 bool useScaleSegments = false;
2159 Axis[] axesArray = new Axis[] { axisY, axisY2, axisX, axisX2 };
2160 foreach (Axis currentAxis in axesArray)
2161 {
2162
2163 useScaleSegments = (currentAxis.ScaleSegments.Count > 0);
2164
2165 if (!useScaleSegments)
2166 {
2167 currentAxis.PaintStrips(graph, false);
2168 }
2169
2170 else
2171 {
2172 foreach (AxisScaleSegment scaleSegment in currentAxis.ScaleSegments)
2173 {
2174 scaleSegment.SetTempAxisScaleAndInterval();
2175
2176 currentAxis.PaintStrips(graph, false);
2177
2178 scaleSegment.RestoreAxisScaleAndInterval();
2179 }
2180 }
2181 }
2182
2183 // Draw Axis Grids
2184 axesArray = new Axis[] { axisY, axisX2, axisY2, axisX };
2185 foreach (Axis currentAxis in axesArray)
2186 {
2187
2188 useScaleSegments = (currentAxis.ScaleSegments.Count > 0);
2189
2190 if (!useScaleSegments)
2191 {
2192 currentAxis.PaintGrids(graph);
2193 }
2194
2195 else
2196 {
2197 foreach (AxisScaleSegment scaleSegment in currentAxis.ScaleSegments)
2198 {
2199 scaleSegment.SetTempAxisScaleAndInterval();
2200
2201 currentAxis.PaintGrids(graph);
2202
2203 scaleSegment.RestoreAxisScaleAndInterval();
2204 }
2205 }
2206
2207 }
2208
2209 // Draw Axis Striplines (only when StripWidth == 0)
2210 foreach (Axis currentAxis in axesArray)
2211 {
2212
2213 useScaleSegments = (currentAxis.ScaleSegments.Count > 0);
2214
2215 if (!useScaleSegments)
2216 {
2217 currentAxis.PaintStrips(graph, true);
2218 }
2219
2220 else
2221 {
2222 foreach (AxisScaleSegment scaleSegment in currentAxis.ScaleSegments)
2223 {
2224 scaleSegment.SetTempAxisScaleAndInterval();
2225
2226 currentAxis.PaintStrips(graph, true);
2227
2228 scaleSegment.RestoreAxisScaleAndInterval();
2229 }
2230 }
2231
2232 }
2233
2234 // Draw Axis elements on the back of the 3D scene
2235 if (this.Area3DStyle.Enable3D && !this.chartAreaIsCurcular)
2236 {
2237 foreach (Axis currentAxis in axesArray)
2238 {
2239
2240 useScaleSegments = (currentAxis.ScaleSegments.Count > 0);
2241
2242 if (!useScaleSegments)
2243 {
2244 currentAxis.PrePaint(graph);
2245 }
2246
2247 else
2248 {
2249 foreach (AxisScaleSegment scaleSegment in currentAxis.ScaleSegments)
2250 {
2251 scaleSegment.SetTempAxisScaleAndInterval();
2252
2253 currentAxis.PrePaint(graph);
2254
2255 scaleSegment.RestoreAxisScaleAndInterval();
2256 }
2257
2258 }
2259
2260 }
2261 }
2262
2263 // Draws chart area border
2264 bool borderDrawn = false;
2265 if (this.Area3DStyle.Enable3D || !IsBorderOnTopSeries())
2266 {
2267 borderDrawn = true;
2268 PaintAreaBack(graph, backgroundPosition, true);
2269 }
2270
2271 // Draw chart types
2272 if (!this.Area3DStyle.Enable3D || this.chartAreaIsCurcular)
2273 {
2274 // Drawing in 2D space
2275
2276 // NOTE: Fixes issue #6443 and #5385
2277 // If two chart series of the same type (for example Line) are separated
2278 // by other series (for example Area) the order is not correct.
2279 // Old implementation draws ALL series that belongs to the chart type.
2280 ArrayList typeAndSeries = this.GetChartTypesAndSeriesToDraw();
2281
2282 // Draw series by chart type or by series
2283 foreach (ChartTypeAndSeriesInfo chartTypeInfo in typeAndSeries)
2284 {
2285 this.IterationCounter = 0;
2286 IChartType type = Common.ChartTypeRegistry.GetChartType(chartTypeInfo.ChartType);
2287
2288 // If 'chartTypeInfo.Series' set to NULL all series of that chart type are drawn at once
2289 type.Paint(graph, Common, this, chartTypeInfo.Series);
2290 }
2291 }
2292 else
2293 {
2294 // Drawing in 3D space
2295 PaintChartSeries3D(graph);
2296 }
2297
2298 // Draw area border if it wasn't drawn prior to the series
2299 if (!borderDrawn)
2300 {
2301 PaintAreaBack(graph, backgroundPosition, true);
2302 }
2303
2304 // Draw Axis
2305 foreach (Axis currentAxis in axesArray)
2306 {
2307
2308 useScaleSegments = (currentAxis.ScaleSegments.Count > 0);
2309
2310 if (!useScaleSegments)
2311 {
2312 // Paint axis and Reset temp axis offset for side-by-side charts like column
2313 currentAxis.Paint(graph);
2314 }
2315
2316 else
2317 {
2318 // Some of the axis elements like grid lines and tickmarks
2319 // are drawn for each segment
2320 foreach (AxisScaleSegment scaleSegment in currentAxis.ScaleSegments)
2321 {
2322 scaleSegment.SetTempAxisScaleAndInterval();
2323
2324 currentAxis.PaintOnSegmentedScalePassOne(graph);
2325
2326 scaleSegment.RestoreAxisScaleAndInterval();
2327 }
2328
2329 // Other elements like labels, title, axis line are drawn once
2330 currentAxis.PaintOnSegmentedScalePassTwo(graph);
2331 }
2332
2333 }
2334
2335 // Call Paint event
2336 Common.Chart.CallOnPostPaint(new ChartPaintEventArgs(this, graph, Common, PlotAreaPosition));
2337
2338 // Draw axis scale break lines
2339 axesArray = new Axis[] { axisY, axisY2 };
2340 foreach (Axis currentAxis in axesArray)
2341 {
2342 for (int segmentIndex = 0; segmentIndex < (currentAxis.ScaleSegments.Count - 1); segmentIndex++)
2343 {
2344 currentAxis.ScaleSegments[segmentIndex].PaintBreakLine(graph, currentAxis.ScaleSegments[segmentIndex + 1]);
2345
2346 }
2347 }
2348
2349 // Reset values for optimized drawing
2350 foreach (Axis curentAxis in this._axisArray)
2351 {
2352 curentAxis.optimizedGetPosition = false;
2353
2354
2355 // Reset preffered number of intervals on the axis
2356 curentAxis.prefferedNumberofIntervals = 5;
2357
2358 // Reset flag that scale segments are used
2359 curentAxis.scaleSegmentsUsed = false;
2360
2361
2362 }
2363 }
2364
2365 /// <summary>
2366 /// Checks if chart area border should be drawn on top of series.
2367 /// </summary>
2368 /// <returns>True if border should be darwn on top.</returns>
2369 private bool IsBorderOnTopSeries()
2370 {
2371 // For most of the chart types chart area border is drawn on top.
2372 bool result = true;
2373 foreach( Series series in this.Common.Chart.Series )
2374 {
2375 if(series.ChartArea == this.Name)
2376 {
2377 // It is common for the Bubble and Point chart types to draw markers
2378 // partially outside of the chart area. By drawing the border before
2379 // series we avoiding the possibility of drawing the border line on
2380 // top of the marker.
2381 if(series.ChartType == SeriesChartType.Bubble ||
2382 series.ChartType == SeriesChartType.Point)
2383 {
2384 return false;
2385 }
2386 }
2387 }
2388 return result;
2389 }
2390
2391 /// <summary>
2392 /// Paint the chart area cursors.
2393 /// </summary>
2394 /// <param name="graph">Chart graphics.</param>
2395 /// <param name="cursorOnly">Indicates that only cursors are redrawn.</param>
2396 [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", Justification = "These parameters are used when compiling for the Microsoft version of Chart")]
2397 internal void PaintCursors( ChartGraphics graph, bool cursorOnly )
2398 {
2399 // Cursors and selection are supoorted only in 2D charts
2400 if(this.Area3DStyle.Enable3D == true)
2401 {
2402 return;
2403 }
2404
2405 // Do not draw cursor/selection for chart types that do not require axis (like Pie)
2406 if(!this.requireAxes)
2407 {
2408 return;
2409 }
2410
2411 // Cursors and selection are not supoorted in circular areas
2412 if(this.chartAreaIsCurcular)
2413 {
2414 return;
2415 }
2416
2417 // Do not draw cursor/selection while printing
2418 if(this.Common != null &&
2419 this.Common.ChartPicture != null &&
2420 this.Common.ChartPicture.isPrinting)
2421 {
2422 return;
2423 }
2424
2425 // Do not draw cursor/selection when chart area is not visible
2426 // because either width or height is set to zero
2427 if(this.Position.Width == 0f ||
2428 this.Position.Height == 0f)
2429 {
2430 return;
2431 }
2432
2433 #if Microsoft_CONTROL
2434
2435 Chart chart = this.Common.Chart;
2436 ChartPicture chartPicture = Common.ChartPicture;
2437
2438 // Check if cursor should be drawn
2439 if(!double.IsNaN(_cursorX.SelectionStart) ||
2440 !double.IsNaN(_cursorX.SelectionEnd) ||
2441 !double.IsNaN(_cursorX.Position) ||
2442 !double.IsNaN(_cursorY.SelectionStart) ||
2443 !double.IsNaN(_cursorY.SelectionEnd) ||
2444 !double.IsNaN(_cursorY.Position))
2445 {
2446
2447 if(!chartPicture.backgroundRestored &&
2448 !chartPicture.isSelectionMode )
2449 {
2450 chartPicture.backgroundRestored = true;
2451
2452 Rectangle chartPosition = new Rectangle(0, 0, chartPicture.Width, chartPicture.Height);
2453
2454 // Get chart area position
2455 Rectangle absAreaPlotPosition = Rectangle.Round(graph.GetAbsoluteRectangle(PlotAreaPosition.ToRectangleF()));
2456 int maxCursorWidth = (CursorY.LineWidth > CursorX.LineWidth) ? CursorY.LineWidth + 1 : CursorX.LineWidth + 1;
2457 absAreaPlotPosition.Inflate(maxCursorWidth, maxCursorWidth);
2458 absAreaPlotPosition.Intersect(new Rectangle(0, 0, chart.Width, chart.Height));
2459
2460 // Create area buffer bitmap
2461 if(areaBufferBitmap == null ||
2462 chartPicture.nonTopLevelChartBuffer == null ||
2463 !cursorOnly)
2464 {
2465 // Dispose previous bitmap
2466 if(areaBufferBitmap != null)
2467 {
2468 areaBufferBitmap.Dispose();
2469 areaBufferBitmap = null;
2470 }
2471 if(chartPicture.nonTopLevelChartBuffer != null)
2472 {
2473 chartPicture.nonTopLevelChartBuffer.Dispose();
2474 chartPicture.nonTopLevelChartBuffer = null;
2475 }
2476
2477
2478 // Copy chart area plotting rectangle from the chart's dubble buffer image into area dubble buffer image
2479 if(chart.paintBufferBitmap != null)
2480 {
2481 areaBufferBitmap = chart.paintBufferBitmap.Clone(absAreaPlotPosition, chart.paintBufferBitmap.PixelFormat);
2482 }
2483
2484 // Copy whole chart from the chart's dubble buffer image into area dubble buffer image
2485 if(chart.paintBufferBitmap != null &&
2486 chart.paintBufferBitmap.Size.Width >= chartPosition.Size.Width &&
2487 chart.paintBufferBitmap.Size.Height >= chartPosition.Size.Height)
2488 {
2489 chartPicture.nonTopLevelChartBuffer = chart.paintBufferBitmap.Clone(
2490 chartPosition, chart.paintBufferBitmap.PixelFormat);
2491 }
2492
2493 }
2494 else if(cursorOnly && chartPicture.nonTopLevelChartBuffer != null)
2495 {
2496 // Restore previous background
2497 chart.paintBufferBitmapGraphics.DrawImageUnscaled(
2498 chartPicture.nonTopLevelChartBuffer,
2499 chartPosition);
2500 }
2501 }
2502
2503 // Draw chart area cursors and range selection
2504
2505 _cursorY.Paint(graph);
2506 _cursorX.Paint(graph);
2507
2508 }
2509 #endif // Microsoft_CONTROL
2510
2511 }
2512
2513 #endregion
2514
2515 #region Circular chart area methods
2516
2517 /// <summary>
2518 /// Gets a circular chart type interface that belongs to this chart area.
2519 /// </summary>
2520 /// <returns>ICircularChartType interface or null.</returns>
2521 internal ICircularChartType GetCircularChartType()
2522 {
2523 // Get number of sectors in circular chart area
2524 foreach(Series series in this.Common.DataManager.Series)
2525 {
2526 if(series.IsVisible() && series.ChartArea == this.Name)
2527 {
2528 ICircularChartType type = Common.ChartTypeRegistry.GetChartType(series.ChartTypeName) as ICircularChartType;;
2529 if(type != null)
2530 {
2531 return type;
2532 }
2533 }
2534 }
2535 return null;
2536 }
2537
2538 /// <summary>
2539 /// Calculate size of the circular axis labels and sets auto-fit font.
2540 /// </summary>
2541 /// <param name="chartGraph">Chart graphics object.</param>
2542 /// <param name="chartAreaPosition">The Chart area position.</param>
2543 /// <param name="plotArea">Plotting area size.</param>
2544 /// <param name="xTitleSize">Size of title on the axis.</param>
2545 /// <param name="yTitleSize">Size of title on the axis.</param>
2546 internal void FitCircularLabels(
2547 ChartGraphics chartGraph,
2548 ElementPosition chartAreaPosition,
2549 ref RectangleF plotArea,
2550 float xTitleSize,
2551 float yTitleSize)
2552 {
2553 // Check if axis labels are enabled
2554 if(!this.AxisX.LabelStyle.Enabled)
2555 {
2556 return;
2557 }
2558
2559 // Get absolute titles size
2560 SizeF titleSize = chartGraph.GetAbsoluteSize(new SizeF(xTitleSize, yTitleSize));
2561
2562 // Get absolute position of area
2563 RectangleF plotAreaRectAbs = chartGraph.GetAbsoluteRectangle( plotArea );
2564 RectangleF areaRectAbs = chartGraph.GetAbsoluteRectangle( chartAreaPosition.ToRectangleF());
2565
2566 // Get absolute markers size and spacing
2567 float spacing = chartGraph.GetAbsolutePoint(new PointF(0, this.AxisX.markSize + Axis.elementSpacing)).Y;
2568
2569 // Get circular axis list
2570 ArrayList axisList = GetCircularAxisList();
2571
2572 // Get circular axis labels style
2573 CircularAxisLabelsStyle labelsStyle = GetCircularAxisLabelsStyle();
2574
2575 //*****************************************************************
2576 //** Calculate the auto-fit font if required
2577 //*****************************************************************
2578 if(this.AxisX.LabelStyle.Enabled && this.AxisX.IsLabelAutoFit)
2579 {
2580 // Set max auto fit font
2581 this.AxisX.autoLabelFont = Common.ChartPicture.FontCache.GetFont(
2582 this.AxisX.LabelStyle.Font.FontFamily,
2583 14,
2584 this.AxisX.LabelStyle.Font.Style,
2585 GraphicsUnit.Point);
2586
2587 // Get estimated labels size
2588 float labelsSizeEstimate = GetCircularLabelsSize(chartGraph, areaRectAbs, plotAreaRectAbs, titleSize);
2589 labelsSizeEstimate = (float)Math.Min(labelsSizeEstimate * 1.1f, plotAreaRectAbs.Width / 5f);
2590 labelsSizeEstimate += spacing;
2591
2592 // Calculate auto-fit font
2593 this.AxisX.GetCircularAxisLabelsAutoFitFont(chartGraph, axisList, labelsStyle, plotAreaRectAbs, areaRectAbs, labelsSizeEstimate);
2594 }
2595
2596 //*****************************************************************
2597 //** Shrink plot area size proportionally
2598 //*****************************************************************
2599
2600 // Get labels size
2601 float labelsSize = GetCircularLabelsSize(chartGraph, areaRectAbs, plotAreaRectAbs, titleSize);
2602
2603 // Check if change size is smaller than radius
2604 labelsSize = (float)Math.Min(labelsSize, plotAreaRectAbs.Width / 2.5f);
2605 labelsSize += spacing;
2606
2607 plotAreaRectAbs.X += labelsSize;
2608 plotAreaRectAbs.Width -= 2f * labelsSize;
2609 plotAreaRectAbs.Y += labelsSize;
2610 plotAreaRectAbs.Height -= 2f * labelsSize;
2611
2612 // Restrict minimum plot area size
2613 if(plotAreaRectAbs.Width < 1.0f)
2614 {
2615 plotAreaRectAbs.Width = 1.0f;
2616 }
2617 if(plotAreaRectAbs.Height < 1.0f)
2618 {
2619 plotAreaRectAbs.Height = 1.0f;
2620 }
2621
2622 plotArea = chartGraph.GetRelativeRectangle( plotAreaRectAbs );
2623
2624
2625 //*****************************************************************
2626 //** Set axes labels size
2627 //*****************************************************************
2628 SizeF relativeLabelSize = chartGraph.GetRelativeSize(new SizeF(labelsSize, labelsSize));
2629 this.AxisX.labelSize = relativeLabelSize.Height;
2630 this.AxisX2.labelSize = relativeLabelSize.Height;
2631 this.AxisY.labelSize = relativeLabelSize.Width;
2632 this.AxisY2.labelSize = relativeLabelSize.Width;
2633
2634 }
2635
2636 /// <summary>
2637 /// Calculate size of the circular axis labels.
2638 /// </summary>
2639 /// <param name="chartGraph">Chart graphics object.</param>
2640 /// <param name="areaRectAbs">The Chart area position.</param>
2641 /// <param name="plotAreaRectAbs">Plotting area size.</param>
2642 /// <param name="titleSize">Size of title on the axes.</param>
2643 /// <returns>Circulat labels style.</returns>
2644 internal float GetCircularLabelsSize(
2645 ChartGraphics chartGraph,
2646 RectangleF areaRectAbs,
2647 RectangleF plotAreaRectAbs,
2648 SizeF titleSize)
2649 {
2650 // Find current horiz. and vert. spacing between plotting and chart areas
2651 SizeF areaDiff = new SizeF(plotAreaRectAbs.X - areaRectAbs.X, plotAreaRectAbs.Y - areaRectAbs.Y);
2652 areaDiff.Width -= titleSize.Width;
2653 areaDiff.Height -= titleSize.Height;
2654
2655 // Get absolute center of the area
2656 PointF areaCenterAbs = chartGraph.GetAbsolutePoint(this.circularCenter);
2657
2658 // Get circular axis list
2659 ArrayList axisList = GetCircularAxisList();
2660
2661 // Get circular axis labels style
2662 CircularAxisLabelsStyle labelsStyle = GetCircularAxisLabelsStyle();
2663
2664 // Defines on how much (pixels) the circular chart area radius should be reduced
2665 float labelsSize = 0f;
2666
2667 //*****************************************************************
2668 //** Loop through all axis labels
2669 //*****************************************************************
2670 foreach(CircularChartAreaAxis axis in axisList)
2671 {
2672 //*****************************************************************
2673 //** Measure label text
2674 //*****************************************************************
2675 SizeF textSize = chartGraph.MeasureString(
2676 axis.Title.Replace("\\n", "\n"),
2677 (this.AxisX.autoLabelFont == null) ? this.AxisX.LabelStyle.Font : this.AxisX.autoLabelFont);
2678 textSize.Width = (float)Math.Ceiling(textSize.Width * 1.1f);
2679 textSize.Height = (float)Math.Ceiling(textSize.Height * 1.1f);
2680
2681
2682 //*****************************************************************
2683 //** Calculate area size change depending on labels style
2684 //*****************************************************************
2685 if(labelsStyle == CircularAxisLabelsStyle.Circular)
2686 {
2687 labelsSize = (float)Math.Max(
2688 labelsSize,
2689 textSize.Height);
2690 }
2691 else if(labelsStyle == CircularAxisLabelsStyle.Radial)
2692 {
2693 float textAngle = axis.AxisPosition + 90;
2694
2695 // For angled text find it's X and Y components
2696 float width = (float)Math.Cos(textAngle/180F*Math.PI) * textSize.Width;
2697 float height = (float)Math.Sin(textAngle/180F*Math.PI) * textSize.Width;
2698 width = (float)Math.Abs(Math.Ceiling(width));
2699 height = (float)Math.Abs(Math.Ceiling(height));
2700
2701 // Reduce text size by current spacing between plotting area and chart area
2702 width -= areaDiff.Width;
2703 height -= areaDiff.Height;
2704 if(width < 0)
2705 width = 0;
2706 if(height < 0)
2707 height = 0;
2708
2709
2710 labelsSize = (float)Math.Max(
2711 labelsSize,
2712 Math.Max(width, height));
2713 }
2714 else if(labelsStyle == CircularAxisLabelsStyle.Horizontal)
2715 {
2716 // Get text angle
2717 float textAngle = axis.AxisPosition;
2718 if(textAngle > 180f)
2719 {
2720 textAngle -= 180f;
2721 }
2722
2723 // Get label rotated position
2724 PointF[] labelPosition = new PointF[] { new PointF(areaCenterAbs.X, plotAreaRectAbs.Y) };
2725 Matrix newMatrix = new Matrix();
2726 newMatrix.RotateAt(textAngle, areaCenterAbs);
2727 newMatrix.TransformPoints(labelPosition);
2728
2729 // Calculate width
2730 float width = textSize.Width;
2731 width -= areaRectAbs.Right - labelPosition[0].X;
2732 if(width < 0f)
2733 {
2734 width = 0f;
2735 }
2736
2737 labelsSize = (float)Math.Max(
2738 labelsSize,
2739 Math.Max(width, textSize.Height));
2740 }
2741 }
2742
2743 return labelsSize;
2744 }
2745
2746 /// <summary>
2747 /// True if polygons should be used instead of the circles for the chart area.
2748 /// </summary>
2749 internal bool CircularUsePolygons
2750 {
2751 get
2752 {
2753 // Check if value was precalculated
2754 if(this._circularUsePolygons == int.MinValue)
2755 {
2756 _circularUsePolygons = 0;
2757
2758 // Look for custom properties in series
2759 foreach(Series series in this.Common.DataManager.Series)
2760 {
2761 if(series.ChartArea == this.Name && series.IsVisible())
2762 {
2763 // Get custom attribute
2764 if (series.IsCustomPropertySet(CustomPropertyName.AreaDrawingStyle))
2765 {
2766 if(String.Compare(series[CustomPropertyName.AreaDrawingStyle], "Polygon", StringComparison.OrdinalIgnoreCase) == 0)
2767 {
2768 _circularUsePolygons = 1;
2769 }
2770 else if (String.Compare(series[CustomPropertyName.AreaDrawingStyle], "Circle", StringComparison.OrdinalIgnoreCase) == 0)
2771 {
2772 _circularUsePolygons = 0;
2773 }
2774 else
2775 {
2776 throw(new InvalidOperationException(SR.ExceptionCustomAttributeValueInvalid( series[CustomPropertyName.AreaDrawingStyle], "AreaDrawingStyle")));
2777 }
2778 break;
2779 }
2780 }
2781 }
2782 }
2783
2784 return (this._circularUsePolygons == 1);
2785 }
2786 }
2787
2788 /// <summary>
2789 /// Gets circular area axis labels style.
2790 /// </summary>
2791 /// <returns>Axis labels style.</returns>
2792 internal CircularAxisLabelsStyle GetCircularAxisLabelsStyle()
2793 {
2794 CircularAxisLabelsStyle style = CircularAxisLabelsStyle.Auto;
2795
2796 // Get maximum number of points in all series
2797 foreach(Series series in this.Common.DataManager.Series)
2798 {
2799 if(series.IsVisible() && series.ChartArea == this.Name && series.IsCustomPropertySet(CustomPropertyName.CircularLabelsStyle))
2800 {
2801 string styleName = series[CustomPropertyName.CircularLabelsStyle];
2802 if(String.Compare( styleName, "Auto", StringComparison.OrdinalIgnoreCase) == 0 )
2803 {
2804 style = CircularAxisLabelsStyle.Auto;
2805 }
2806 else if(String.Compare( styleName,"Circular", StringComparison.OrdinalIgnoreCase) == 0)
2807 {
2808 style = CircularAxisLabelsStyle.Circular;
2809 }
2810 else if(String.Compare( styleName,"Radial", StringComparison.OrdinalIgnoreCase) == 0)
2811 {
2812 style = CircularAxisLabelsStyle.Radial;
2813 }
2814 else if (String.Compare(styleName, "Horizontal", StringComparison.OrdinalIgnoreCase) == 0)
2815 {
2816 style = CircularAxisLabelsStyle.Horizontal;
2817 }
2818 else
2819 {
2820 throw(new InvalidOperationException(SR.ExceptionCustomAttributeValueInvalid( styleName, "CircularLabelsStyle")));
2821 }
2822
2823 }
2824 }
2825
2826 // Get auto style
2827 if(style == CircularAxisLabelsStyle.Auto)
2828 {
2829 int sectorNumber = CircularSectorsNumber;
2830 style = CircularAxisLabelsStyle.Horizontal;
2831 if(sectorNumber > 30)
2832 {
2833 style = CircularAxisLabelsStyle.Radial;
2834 }
2835 }
2836
2837 return style;
2838 }
2839
2840 /// <summary>
2841 /// Number of sectors in the circular area.
2842 /// </summary>
2843 internal int CircularSectorsNumber
2844 {
2845 get
2846 {
2847 // Check if value was precalculated
2848 if(this._circularSectorNumber == int.MinValue)
2849 {
2850 this._circularSectorNumber = GetCircularSectorNumber();
2851 }
2852
2853 return this._circularSectorNumber;
2854 }
2855 }
2856
2857 /// <summary>
2858 /// Gets number of sectors in the circular chart area.
2859 /// </summary>
2860 /// <returns>Number of sectors.</returns>
2861 private int GetCircularSectorNumber()
2862 {
2863 ICircularChartType type = this.GetCircularChartType();
2864 if(type != null)
2865 {
2866 return type.GetNumerOfSectors(this, this.Common.DataManager.Series);
2867 }
2868 return 0;
2869 }
2870
2871 /// <summary>
2872 /// Fills a list of circular axis.
2873 /// </summary>
2874 /// <returns>Axes list.</returns>
2875 internal ArrayList GetCircularAxisList()
2876 {
2877 // Check if list was already created
2878 if(_circularAxisList == null)
2879 {
2880 _circularAxisList = new ArrayList();
2881
2882 // Loop through all sectors
2883 int sectorNumber = GetCircularSectorNumber();
2884 for(int sectorIndex = 0; sectorIndex < sectorNumber; sectorIndex++)
2885 {
2886 // Create new axis object
2887 CircularChartAreaAxis axis = new CircularChartAreaAxis(sectorIndex * 360f/sectorNumber);
2888
2889 // Check if custom X axis labels will be used
2890 if(this.AxisX.CustomLabels.Count > 0)
2891 {
2892 if(sectorIndex < this.AxisX.CustomLabels.Count)
2893 {
2894 axis.Title = this.AxisX.CustomLabels[sectorIndex].Text;
2895 axis.TitleForeColor = this.AxisX.CustomLabels[sectorIndex].ForeColor;
2896 }
2897 }
2898 else
2899 {
2900 // Get axis title from all series
2901 foreach(Series series in this.Common.DataManager.Series)
2902 {
2903 if(series.IsVisible() && series.ChartArea == this.Name && sectorIndex < series.Points.Count)
2904 {
2905 if(series.Points[sectorIndex].AxisLabel.Length > 0)
2906 {
2907 axis.Title = series.Points[sectorIndex].AxisLabel;
2908 break;
2909 }
2910 }
2911 }
2912 }
2913
2914 // Add axis into the list
2915 _circularAxisList.Add(axis);
2916 }
2917
2918 }
2919 return _circularAxisList;
2920 }
2921
2922 /// <summary>
2923 /// Converts circular position of the X axis to angle in degrees.
2924 /// </summary>
2925 /// <param name="position">X axis position.</param>
2926 /// <returns>Angle in degrees.</returns>
2927 internal float CircularPositionToAngle(double position)
2928 {
2929 // Get X axis scale size
2930 double scaleRatio = 360.0 / Math.Abs(this.AxisX.Maximum - this.AxisX.Minimum);
2931
2932 return (float)(position * scaleRatio + this.AxisX.Crossing);
2933 }
2934
2935 #endregion
2936
2937 #region 2D Series drawing order methods
2938
2939 /// <summary>
2940 /// Helper method that returns a list of 'ChartTypeAndSeriesInfo' objects.
2941 /// This list is used for chart area series drawing in 2D mode. Each
2942 /// object may represent an individual series or all series that belong
2943 /// to one chart type.
2944 ///
2945 /// This method is intended to fix issues #6443 and #5385 when area chart
2946 /// type incorrectly overlaps point or line chart type.
2947 /// </summary>
2948 /// <returns>List of 'ChartTypeAndSeriesInfo' objects.</returns>
2949 private ArrayList GetChartTypesAndSeriesToDraw()
2950 {
2951 ArrayList resultList = new ArrayList();
2952
2953 // Build chart type or series position based lists
2954 if (this.ChartTypes.Count > 1 &&
2955 (this.ChartTypes.Contains(ChartTypeNames.Area)
2956 || this.ChartTypes.Contains(ChartTypeNames.SplineArea)
2957 )
2958 )
2959 {
2960 // Array of chart type names that do not require furher processing
2961 ArrayList processedChartType = new ArrayList();
2962 ArrayList splitChartType = new ArrayList();
2963
2964 // Draw using the exact order in the series collection
2965 int seriesIndex = 0;
2966 foreach (Series series in this.Common.DataManager.Series)
2967 {
2968 // Check if series is visible and belongs to the chart area
2969 if (series.ChartArea==this.Name && series.IsVisible() && series.Points.Count > 0)
2970 {
2971 // Check if this chart type was already processed
2972 if (!processedChartType.Contains(series.ChartTypeName))
2973 {
2974 // Check if curent chart type can be individually processed
2975 bool canBeIndividuallyProcessed = false;
2976 if (series.ChartType == SeriesChartType.Point ||
2977 series.ChartType == SeriesChartType.Line ||
2978 series.ChartType == SeriesChartType.Spline ||
2979 series.ChartType == SeriesChartType.StepLine)
2980 {
2981 canBeIndividuallyProcessed = true;
2982 }
2983
2984 if (!canBeIndividuallyProcessed)
2985 {
2986 // Add a record to process all series of that chart type at once
2987 resultList.Add(new ChartTypeAndSeriesInfo(series.ChartTypeName));
2988 processedChartType.Add(series.ChartTypeName);
2989 }
2990 else
2991 {
2992 // Check if curent chart type has more that 1 series and they are split
2993 // by other series
2994 bool chartTypeIsSplit = false;
2995
2996 if (splitChartType.Contains(series.ChartTypeName))
2997 {
2998 chartTypeIsSplit = true;
2999 }
3000 else
3001 {
3002 bool otherChartTypeFound = false;
3003 for (int curentSeriesIndex = seriesIndex + 1; curentSeriesIndex < this.Common.DataManager.Series.Count; curentSeriesIndex++)
3004 {
3005 if (series.ChartTypeName == this.Common.DataManager.Series[curentSeriesIndex].ChartTypeName)
3006 {
3007 if (otherChartTypeFound)
3008 {
3009 chartTypeIsSplit = true;
3010 splitChartType.Add(series.ChartTypeName);
3011 }
3012 }
3013 else
3014 {
3015 if (this.Common.DataManager.Series[curentSeriesIndex].ChartType == SeriesChartType.Area ||
3016 this.Common.DataManager.Series[curentSeriesIndex].ChartType == SeriesChartType.SplineArea)
3017 {
3018 otherChartTypeFound = true;
3019 }
3020 }
3021 }
3022 }
3023
3024 if (chartTypeIsSplit)
3025 {
3026 // Add a record to process this series individually
3027 resultList.Add(new ChartTypeAndSeriesInfo(series));
3028 }
3029 else
3030 {
3031 // Add a record to process all series of that chart type at once
3032 resultList.Add(new ChartTypeAndSeriesInfo(series.ChartTypeName));
3033 processedChartType.Add(series.ChartTypeName);
3034 }
3035 }
3036 }
3037 }
3038
3039 ++seriesIndex;
3040 }
3041 }
3042 else
3043 {
3044 foreach (string chartType in this.ChartTypes)
3045 {
3046 resultList.Add(new ChartTypeAndSeriesInfo(chartType));
3047 }
3048 }
3049
3050 return resultList;
3051 }
3052
3053 /// <summary>
3054 /// Internal data structure that stores chart type name and optionally series object.
3055 /// </summary>
3056 internal class ChartTypeAndSeriesInfo
3057 {
3058 /// <summary>
3059 /// Object constructor.
3060 /// </summary>
3061 public ChartTypeAndSeriesInfo()
3062 {
3063 }
3064
3065 /// <summary>
3066 /// Object constructor.
3067 /// </summary>
3068 /// <param name="chartType">Chart type name to initialize with.</param>
3069 public ChartTypeAndSeriesInfo(string chartType)
3070 {
3071 this.ChartType = chartType;
3072 }
3073
3074 /// <summary>
3075 /// Object constructor.
3076 /// </summary>
3077 /// <param name="series">Series to initialize with.</param>
3078 public ChartTypeAndSeriesInfo(Series series)
3079 {
3080 this.ChartType = series.ChartTypeName;
3081 this.Series = series;
3082 }
3083
3084 // Chart type name
3085 internal string ChartType = string.Empty;
3086
3087 // Series object. Can be set to NULL!
3088 internal Series Series = null;
3089
3090 }
3091
3092 #endregion // 2D Series drawing order methods
3093
3094 #region IDisposable Members
3095
3096 /// <summary>
3097 /// Releases unmanaged and - optionally - managed resources
3098 /// </summary>
3099 /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
3100 [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2213:DisposableFieldsShouldBeDisposed", MessageId = "axisX")]
3101 [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2213:DisposableFieldsShouldBeDisposed", MessageId = "axisX2")]
3102 [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2213:DisposableFieldsShouldBeDisposed", MessageId = "axisY")]
3103 [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA2213:DisposableFieldsShouldBeDisposed", MessageId = "axisY2")]
3104 protected override void Dispose(bool disposing)
3105 {
3106 if (disposing)
3107 {
3108 // Dispose managed resources
3109 if (this._axisArray != null)
3110 {
3111 foreach (Axis axis in this._axisArray)
3112 {
3113 axis.Dispose();
3114 }
3115 this._axisArray = null;
3116 }
3117 if ( this._areaPosition != null)
3118 {
3119 this._areaPosition.Dispose();
3120 this._areaPosition = null;
3121 }
3122 if (this._innerPlotPosition != null)
3123 {
3124 this._innerPlotPosition.Dispose();
3125 this._innerPlotPosition = null;
3126 }
3127 if (this.PlotAreaPosition != null)
3128 {
3129 this.PlotAreaPosition.Dispose();
3130 this.PlotAreaPosition = null;
3131 }
3132 #if Microsoft_CONTROL
3133 if (this.areaBufferBitmap != null)
3134 {
3135 this.areaBufferBitmap.Dispose();
3136 this.areaBufferBitmap = null;
3137 }
3138 if (this._cursorX != null)
3139 {
3140 this._cursorX.Dispose();
3141 this._cursorX = null;
3142 }
3143 if (this._cursorY != null)
3144 {
3145 this._cursorY.Dispose();
3146 this._cursorY = null;
3147 }
3148 #endif
3149 }
3150 base.Dispose(disposing);
3151 }
3152
3153
3154 #endregion
3155
3156 }
3157 }
Mirror of the official Mono project git repository