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

	// candidates for dojox.style (work on VML and SVG nodes)
	dojox.gfx._hasClass = function(/* DomNode */node, /* String */classStr) {
		// summary:
		// Returns whether or not the specified classes are a portion of the
		// class list currently applied to the node.
		// return (new
		// RegExp('(^|\\s+)'+classStr+'(\\s+|$)')).test(node.className) //
		// Boolean
		return ((" " + node.getAttribute("className") + " ").indexOf(" "
				+ classStr + " ") >= 0); // Boolean
	}

	dojox.gfx._addClass = function(/* DomNode */node, /* String */classStr) {
		// summary:
		// Adds the specified classes to the end of the class list on the
		// passed node.
		var cls = node.getAttribute("className");
		if ((" " + cls + " ").indexOf(" " + classStr + " ") < 0) {
			node.setAttribute("className", cls + (cls ? ' ' : '') + classStr);
		}
	}

	dojox.gfx._removeClass = function(/* DomNode */node, /* String */classStr) {
		// summary: Removes classes from node.
		node
				.setAttribute("className", node.getAttribute("className")
								.replace(
										new RegExp('(^|\\s+)' + classStr
												+ '(\\s+|$)'), "$1$2"));
	}

	// candidate for dojox.html.metrics (dynamic font resize handler is not
	// implemented here)

	// derived from Morris John's emResized measurer
	dojox.gfx._base._getFontMeasurements = function() {
		// summary
		// Returns an object that has pixel equivilents of standard font size
		// values.
		var heights = {
			'1em' : 0,
			'1ex' : 0,
			'100%' : 0,
			'12pt' : 0,
			'16px' : 0,
			'xx-small' : 0,
			'x-small' : 0,
			'small' : 0,
			'medium' : 0,
			'large' : 0,
			'x-large' : 0,
			'xx-large' : 0
		};

		if (dojo.isIE) {
			// we do a font-size fix if and only if one isn't applied already.
			// NOTE: If someone set the fontSize on the HTML Element, this will
			// kill it.
			dojo.doc.documentElement.style.fontSize = "100%";
		}

		// set up the measuring node.
		var div = dojo.doc.createElement("div");
		div.style.position = "absolute";
		div.style.left = "-100px";
		div.style.top = "0";
		div.style.width = "30px";
		div.style.height = "1000em";
		div.style.border = "0";
		div.style.margin = "0";
		div.style.padding = "0";
		div.style.outline = "0";
		div.style.lineHeight = "1";
		div.style.overflow = "hidden";
		dojo.body().appendChild(div);

		// do the measurements.
		for (var p in heights) {
			div.style.fontSize = p;
			heights[p] = Math.round(div.offsetHeight * 12 / 16) * 16 / 12
					/ 1000;
		}

		dojo.body().removeChild(div);
		div = null;
		return heights; // object
	};

	dojox.gfx._base._fontMeasurements = null;

	dojox.gfx._base._getCachedFontMeasurements = function(recalculate) {
		if (recalculate || !dojox.gfx._base._fontMeasurements) {
			dojox.gfx._base._fontMeasurements = dojox.gfx._base
					._getFontMeasurements();
		}
		return dojox.gfx._base._fontMeasurements;
	};

	// candidate for dojo.dom

	dojox.gfx._base._uniqueId = 0;
	dojox.gfx._base._getUniqueId = function() {
		// summary: returns a unique string for use with any DOM element
		var id;
		do {
			id = "dojoUnique" + (++dojox.gfx._base._uniqueId);
		} while (dojo.byId(id));
		return id;
	};

	dojo.mixin(dojox.gfx, {
		// summary: defines constants, prototypes, and utility functions

		// default shapes, which are used to fill in missing parameters
		defaultPath : {
			type : "path",
			path : ""
		},
		defaultPolyline : {
			type : "polyline",
			points : []
		},
		defaultRect : {
			type : "rect",
			x : 0,
			y : 0,
			width : 100,
			height : 100,
			r : 0
		},
		defaultEllipse : {
			type : "ellipse",
			cx : 0,
			cy : 0,
			rx : 200,
			ry : 100
		},
		defaultCircle : {
			type : "circle",
			cx : 0,
			cy : 0,
			r : 100
		},
		defaultLine : {
			type : "line",
			x1 : 0,
			y1 : 0,
			x2 : 100,
			y2 : 100
		},
		defaultImage : {
			type : "image",
			x : 0,
			y : 0,
			width : 0,
			height : 0,
			src : ""
		},
		defaultText : {
			type : "text",
			x : 0,
			y : 0,
			text : "",
			align : "start",
			decoration : "none",
			rotated : false,
			kerning : true
		},
		defaultTextPath : {
			type : "textpath",
			text : "",
			align : "start",
			decoration : "none",
			rotated : false,
			kerning : true
		},

		// default geometric attributes
		defaultStroke : {
			type : "stroke",
			color : "black",
			style : "solid",
			width : 1,
			cap : "butt",
			join : 4
		},
		defaultLinearGradient : {
			type : "linear",
			x1 : 0,
			y1 : 0,
			x2 : 100,
			y2 : 100,
			colors : [{
						offset : 0,
						color : "black"
					}, {
						offset : 1,
						color : "white"
					}]
		},
		defaultRadialGradient : {
			type : "radial",
			cx : 0,
			cy : 0,
			r : 100,
			colors : [{
						offset : 0,
						color : "black"
					}, {
						offset : 1,
						color : "white"
					}]
		},
		defaultPattern : {
			type : "pattern",
			x : 0,
			y : 0,
			width : 0,
			height : 0,
			src : ""
		},
		defaultFont : {
			type : "font",
			style : "normal",
			variant : "normal",
			weight : "normal",
			size : "10pt",
			family : "serif"
		},

		normalizeColor : function(/* Color */color) {
			// summary: converts any legal color representation to normalized
			// dojo.Color object
			return (color instanceof dojo.Color)
					? color
					: new dojo.Color(color); // dojo.Color
		},
		normalizeParameters : function(existed, update) {
			// summary: updates an existing object with properties from an
			// "update" object
			// existed: Object: the "target" object to be updated
			// update: Object: the "update" object, whose properties will be
			// used to update the existed object
			if (update) {
				var empty = {};
				for (var x in existed) {
					if (x in update && !(x in empty)) {
						existed[x] = update[x];
					}
				}
			}
			return existed; // Object
		},
		makeParameters : function(defaults, update) {
			// summary: copies the original object, and all copied properties
			// from the "update" object
			// defaults: Object: the object to be cloned before updating
			// update: Object: the object, which properties are to be cloned
			// during updating
			if (!update)
				return dojo.clone(defaults);
			var result = {};
			for (var i in defaults) {
				if (!(i in result)) {
					result[i] = dojo.clone((i in update)
							? update[i]
							: defaults[i]);
				}
			}
			return result; // Object
		},
		formatNumber : function(x, addSpace) {
			// summary: converts a number to a string using a fixed notation
			// x: Number: number to be converted
			// addSpace: Boolean?: if it is true, add a space before a positive
			// number
			var val = x.toString();
			if (val.indexOf("e") >= 0) {
				val = x.toFixed(4);
			} else {
				var point = val.indexOf(".");
				if (point >= 0 && val.length - point > 5) {
					val = x.toFixed(4);
				}
			}
			if (x < 0) {
				return val; // String
			}
			return addSpace ? " " + val : val; // String
		},
		// font operations
		makeFontString : function(font) {
			// summary: converts a font object to a CSS font string
			// font: Object: font object (see dojox.gfx.defaultFont)
			return font.style + " " + font.variant + " " + font.weight + " "
					+ font.size + " " + font.family; // Object
		},
		splitFontString : function(str) {
			// summary: converts a CSS font string to a font object
			// str: String: a CSS font string
			var font = dojo.clone(dojox.gfx.defaultFont);
			var t = str.split(/\s+/);
			do {
				if (t.length < 5) {
					break;
				}
				font.style = t[0];
				font.varian = t[1];
				font.weight = t[2];
				var i = t[3].indexOf("/");
				font.size = i < 0 ? t[3] : t[3].substring(0, i);
				var j = 4;
				if (i < 0) {
					if (t[4] == "/") {
						j = 6;
						break;
					}
					if (t[4].substr(0, 1) == "/") {
						j = 5;
						break;
					}
				}
				if (j + 3 > t.length) {
					break;
				}
				font.size = t[j];
				font.family = t[j + 1];
			} while (false);
			return font; // Object
		},
		// length operations
		cm_in_pt : 72 / 2.54, // Number: centimeters per inch
		mm_in_pt : 7.2 / 2.54, // Number: millimeters per inch
		px_in_pt : function() {
			// summary: returns a number of pixels per point
			return dojox.gfx._base._getCachedFontMeasurements()["12pt"] / 12; // Number
		},
		pt2px : function(len) {
			// summary: converts points to pixels
			// len: Number: a value in points
			return len * dojox.gfx.px_in_pt(); // Number
		},
		px2pt : function(len) {
			// summary: converts pixels to points
			// len: Number: a value in pixels
			return len / dojox.gfx.px_in_pt(); // Number
		},
		normalizedLength : function(len) {
			// summary: converts any length value to pixels
			// len: String: a length, e.g., "12pc"
			if (len.length == 0)
				return 0;
			if (len.length > 2) {
				var px_in_pt = dojox.gfx.px_in_pt();
				var val = parseFloat(len);
				switch (len.slice(-2)) {
					case "px" :
						return val;
					case "pt" :
						return val * px_in_pt;
					case "in" :
						return val * 72 * px_in_pt;
					case "pc" :
						return val * 12 * px_in_pt;
					case "mm" :
						return val / dojox.gfx.mm_in_pt * px_in_pt;
					case "cm" :
						return val / dojox.gfx.cm_in_pt * px_in_pt;
				}
			}
			return parseFloat(len); // Number
		},

		// a constant used to split a SVG/VML path into primitive components
		pathVmlRegExp : /([A-Za-z]+)|(\d+(\.\d+)?)|(\.\d+)|(-\d+(\.\d+)?)|(-\.\d+)/g,
		pathSvgRegExp : /([A-Za-z])|(\d+(\.\d+)?)|(\.\d+)|(-\d+(\.\d+)?)|(-\.\d+)/g,

		equalSources : function(a, b) {
			// summary: compares event sources, returns true if they are equal
			return a && b && a == b;
		}
	});

}