if (!dojo._hasResource["dojox.gfx.arc"]) { // _hasResource checks added by
											// build. Do not use _hasResource
											// directly in your code.
	dojo._hasResource["dojox.gfx.arc"] = true;
	dojo.provide("dojox.gfx.arc");

	dojo.require("dojox.gfx.matrix");

	(function() {
		var m = dojox.gfx.matrix, unitArcAsBezier = function(alpha) {
			// summary: return a start point, 1st and 2nd control points, and an
			// end point of
			// a an arc, which is reflected on the x axis
			// alpha: Number: angle in radians, the arc will be 2 * angle size
			var cosa = Math.cos(alpha), sina = Math.sin(alpha), p2 = {
				x : cosa + (4 / 3) * (1 - cosa),
				y : sina - (4 / 3) * cosa * (1 - cosa) / sina
			};
			return { // Object
				s : {
					x : cosa,
					y : -sina
				},
				c1 : {
					x : p2.x,
					y : -p2.y
				},
				c2 : p2,
				e : {
					x : cosa,
					y : sina
				}
			};
		}, twoPI = 2 * Math.PI, pi4 = Math.PI / 4, pi8 = Math.PI / 8, pi48 = pi4
				+ pi8, curvePI4 = unitArcAsBezier(pi8);

		dojo.mixin(dojox.gfx.arc, {
			unitArcAsBezier : unitArcAsBezier,
			curvePI4 : curvePI4,
			arcAsBezier : function(last, rx, ry, xRotg, large, sweep, x, y) {
				// summary: calculates an arc as a series of Bezier curves
				// given the last point and a standard set of SVG arc
				// parameters,
				// it returns an array of arrays of parameters to form a series
				// of
				// absolute Bezier curves.
				// last: Object: a point-like object as a start of the arc
				// rx: Number: a horizontal radius for the virtual ellipse
				// ry: Number: a vertical radius for the virtual ellipse
				// xRotg: Number: a rotation of an x axis of the virtual ellipse
				// in degrees
				// large: Boolean: which part of the ellipse will be used (the
				// larger arc if true)
				// sweep: Boolean: direction of the arc (CW if true)
				// x: Number: the x coordinate of the end point of the arc
				// y: Number: the y coordinate of the end point of the arc

				// calculate parameters
				large = Boolean(large);
				sweep = Boolean(sweep);
				var xRot = m._degToRad(xRotg), rx2 = rx * rx, ry2 = ry * ry, pa = m
						.multiplyPoint(m.rotate(-xRot), {
									x : (last.x - x) / 2,
									y : (last.y - y) / 2
								}), pax2 = pa.x * pa.x, pay2 = pa.y * pa.y, c1 = Math
						.sqrt((rx2 * ry2 - rx2 * pay2 - ry2 * pax2)
								/ (rx2 * pay2 + ry2 * pax2));
				if (isNaN(c1)) {
					c1 = 0;
				}
				var ca = {
					x : c1 * rx * pa.y / ry,
					y : -c1 * ry * pa.x / rx
				};
				if (large == sweep) {
					ca = {
						x : -ca.x,
						y : -ca.y
					};
				}
				// the center
				var c = m.multiplyPoint(
						[m.translate((last.x + x) / 2, (last.y + y) / 2),
								m.rotate(xRot)], ca);
				// calculate the elliptic transformation
				var elliptic_transform = m.normalize([m.translate(c.x, c.y),
						m.rotate(xRot), m.scale(rx, ry)]);
				// start, end, and size of our arc
				var inversed = m.invert(elliptic_transform), sp = m
						.multiplyPoint(inversed, last), ep = m.multiplyPoint(
						inversed, x, y), startAngle = Math.atan2(sp.y, sp.x), endAngle = Math
						.atan2(ep.y, ep.x), theta = startAngle - endAngle; // size
																			// of
																			// our
																			// arc
																			// in
																			// radians
				if (sweep) {
					theta = -theta;
				}
				if (theta < 0) {
					theta += twoPI;
				} else if (theta > twoPI) {
					theta -= twoPI;
				}

				// draw curve chunks
				var alpha = pi8, curve = curvePI4, step = sweep
						? alpha
						: -alpha, result = [];
				for (var angle = theta; angle > 0; angle -= pi4) {
					if (angle < pi48) {
						alpha = angle / 2;
						curve = unitArcAsBezier(alpha);
						step = sweep ? alpha : -alpha;
						angle = 0; // stop the loop
					}
					var c1, c2, e, M = m.normalize([elliptic_transform,
							m.rotate(startAngle + step)]);
					if (sweep) {
						c1 = m.multiplyPoint(M, curve.c1);
						c2 = m.multiplyPoint(M, curve.c2);
						e = m.multiplyPoint(M, curve.e);
					} else {
						c1 = m.multiplyPoint(M, curve.c2);
						c2 = m.multiplyPoint(M, curve.c1);
						e = m.multiplyPoint(M, curve.s);
					}
					// draw the curve
					result.push([c1.x, c1.y, c2.x, c2.y, e.x, e.y]);
					startAngle += 2 * step;
				}
				return result; // Object
			}
		});
	})();

}