1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299

/**
 * @author Fabien BIZOT
 * http://lafabrick.com/blog
 * http://twitter.com/fabienbizot
 */
package com.lafabrick.uigfx.primitives
{
	import flash.display.Graphics;
	
	import spark.primitives.supportClasses.FilledElement;
	/**
	 * Draw a Pie primitive
	 * 
	 * @langversion 3.0
	 * @playerversion Flash 10
	 * @playerversion AIR 1.5
	 * @productversion Flex 4
	 * 
	 * 
	 * @example 
	 * <p>The following code draws a Pie primitive</p>
	 * <listing version="3.0" >
	 * &lt;uigfx:Pie 
	 *     angle="60" startAngle="20"
	 *     innerRadius="0.3"
	 *     offset="8" innerOffset="8"
	 *     width="400" height="250" 
	 *     horizontalCenter="0" verticalCenter="0"&gt;
	 *	
	 *     &lt;uigfx:stroke&gt;
	 *         &lt;s:SolidColorStroke color="#222222" /&gt;
	 *     &lt;/uigfx:stroke&gt;
	 *     
	 *     &lt;uigfx:fill&gt;
	 *         &lt;s:SolidColor color="#009EE0" /&gt;
	 *     &lt;/uigfx:fill&gt;
	 * 
	 *     &lt;uigfx:filters&gt;
	 *         &lt;s:DropShadowFilter color="#000000" inner="true" distance="1" blurX="4" blurY="4" quality="3" alpha="0.8" /&gt;
	 *     &lt;/uigfx:filters&gt;
	 *		
	 * &lt;/uigfx:Pie&gt;
	 * </listing>
	 */
	public class Pie extends FilledElement
	{
		/**
		 * Constructor
		 */
		public function Pie()
		{
			super();
		}
		
		private var _startAngle : Number = 0;
		private var _angle : Number = 0;
		
		private var _innerRadius : Number = 0;
		private var _gap : Number = 0;
		
		private var _offset : Number = 0;
		private var _innerOffset : Number = 0;
		
		private var _explosion : Number = 0;
		
		/**
		 * Defines an explode offset for the Pie (from center). Value expressed in pixel
		 */
		public function get explosion():Number
		{
			return _explosion;
		}
		/**
		 * @private
		 */
		public function set explosion(value:Number):void
		{
			_explosion = value;
			invalidateDisplayList();
		}
		
		/**
		 * Defines an external offset for the Pie. Value expressed in pixel
		 */
		public function get offset():Number
		{
			return _offset;
		}
		/**
		 * @private
		 */
		public function set offset(value:Number):void
		{
			_offset = value;
			invalidateDisplayList();
		}
		
		/**
		 * Defines an internal offset for the Pie. Value expressed in pixel
		 */
		public function get innerOffset():Number
		{
			return _innerOffset;
		}
		/**
		 * @private
		 */
		public function set innerOffset(value:Number):void
		{
			_innerOffset = value;
			invalidateDisplayList();
		}
		/**
		 * Defines the start angle (in degree) of the primitive
		 */
		public function get startAngle():Number
		{
			return _startAngle;
		}
		/**
		 * @private
		 */
		public function set startAngle(value:Number):void
		{
			_startAngle = value;
			invalidateDisplayList();
		}
		
		/**
		 * Defines the angle in degree of the primitive
		 */
		public function get angle():Number
		{
			return _angle;
		}
		/**
		 * @private
		 */
		public function set angle(value:Number):void
		{
			if( Math.abs( value ) > 360 ) value = 360;
			_angle = value;
			invalidateDisplayList();
		}
		/**
		 * Defines the inner radius of the primitive. Value is expressed as a percentage, with a number between 0 and 1
		 */
		public function get innerRadius():Number
		{
			return _innerRadius;
		}
		/**
		 * @private
		 */
		public function set innerRadius(value:Number):void
		{
			if( Math.abs( value ) > 1 ) value = 1;
			if( Math.abs( value ) < 0 ) value = 0;
			_innerRadius = value;
			invalidateDisplayList();
		}
		/**
		 * Defines the gap of the Pie. Value is expressed as a degree angle
		 */
		public function get gap():Number
		{
			return _gap;
		}
		/**
		 * @private
		 */
		public function set gap(value:Number):void
		{
			_gap = value;
			invalidateDisplayList();
		}
		/**
		 * @private
		 */
		private function getCosValue( angle : Number, value : Number ) : Number
		{
			return Math.cos( angle ) * value;
		}
		/**
		 * @private
		 */
		private function getSinValue( angle : Number, value : Number ) : Number
		{
			return Math.sin( angle ) * value;
		}
		
		/**
		 * Draw the primitive
		 */
		override protected function draw(g:Graphics) : void
		{
			var nangle : Number = Math.max( angle-gap, 0) / 180 * Math.PI;	
			var numSegments:Number = Math.ceil(Math.abs(nangle)/ (Math.PI/4) );
			var angleSegment:Number = nangle/numSegments;
			
			var theta:Number = -angleSegment;
			var radAngle : Number = -startAngle / 180 * Math.PI;
			
			var midRadAngle : Number;
	
			var controlx:Number;
			var controly:Number;
			var posx:Number;
			var posy:Number;
			
			var xoffset : Number = offset;
			var yoffset : Number = offset;
			
			var xinnerOffset : Number = innerOffset;
			var yinnerOffset : Number = innerOffset;

			var xexplosion : Number = explosion;
			var yexplosion : Number = explosion;
			
			if( width > height ) {
				yoffset = height/width * offset;
				yinnerOffset = height/width * innerOffset;
				yexplosion = height/width * explosion;
			}
			if( width < height ) {
				xoffset = width/height * offset;
				xinnerOffset = width/height * innerOffset;
				xexplosion = width/height * explosion;
			}
			
			var centerX : Number = drawX+width/2;
			var centerY : Number = drawY+height/2;
			
			if (numSegments > 0)
			{
				var segCount : Number = 0;
				
				posx =  centerX + getCosValue(radAngle, width/2+xoffset  + xexplosion );
				posy =  centerY + getSinValue(radAngle, height/2+yoffset + yexplosion );
				
				g.moveTo(posx, posy);
				
				for (; segCount < numSegments; segCount++)
				{
					
					radAngle += theta;
					midRadAngle = radAngle - theta / 2;
					
					posx = centerX + getCosValue( radAngle, width/2+xoffset + xexplosion);
					posy = centerY + getSinValue( radAngle, height/2+yoffset + yexplosion);
					
					controlx = centerX + getCosValue( midRadAngle, (width/2+xoffset + xexplosion) / Math.cos(theta / 2));
					controly = centerY + getSinValue( midRadAngle, (height/2+yoffset + yexplosion) / Math.cos(theta / 2));
					
					g.curveTo(controlx, controly, posx, posy);
				}
				
				if( innerRadius > 0  ) {
					posx = centerX + getCosValue( radAngle, Math.max(width*innerRadius/2 - xinnerOffset + xexplosion, 0));
					posy = centerY + getSinValue( radAngle, Math.max(height*innerRadius/2 - yinnerOffset + yexplosion, 0));
					
					if( gap == 0 && angle == 360 ){
						g.moveTo( posx, posy );
					}
					else {
						g.lineTo( posx, posy );
					}
					
					segCount = numSegments;
					for (; segCount>0; segCount--) {
						radAngle -= theta;
						midRadAngle = radAngle + theta / 2;
						
						posx=centerX + getCosValue( radAngle, Math.max(width*innerRadius/2 - xinnerOffset + xexplosion, 0));
						posy=centerY + getSinValue( radAngle, Math.max(height*innerRadius/2 - yinnerOffset + yexplosion, 0));
						
						controlx=centerX + getCosValue( midRadAngle, ( Math.max(width*innerRadius/2 - xinnerOffset + xexplosion, 0)) / Math.cos(theta/2) );
						controly=centerY + getSinValue( midRadAngle, ( Math.max(height*innerRadius/2 - yinnerOffset + yexplosion, 0)) / Math.cos(theta/2) );
						
						g.curveTo( controlx, controly, posx, posy );
					}
					
					if( gap > 0 ) {
						posx = centerX + getCosValue( radAngle, Math.max(width*innerRadius/2 - xinnerOffset + xexplosion, 0));
						posy = centerY + getSinValue( radAngle, Math.max(height*innerRadius/2 - yinnerOffset + yexplosion, 0));
						
						g.lineTo( posx, posy );
					}
				}
				
				else if( gap > 0 || (angle < 360 && angle > 0) ){
					
					g.lineTo( centerX, centerY );
				}
				
			}
		}
	}
}