Subversion Repositories Applications.papyrus

/*

	Copyright (c) 2004-2007, The Dojo Foundation

	All Rights Reserved.

	Licensed under the Academic Free License version 2.1 or above OR the

	modified BSD license. For more information on Dojo licensing, see:

		http://dojotoolkit.org/book/dojo-book-0-9/introduction/licensing

*/

/*

	This is a compiled version of Dojo, built for deployment and not for

	development. To get an editable version, please visit:

		http://dojotoolkit.org

	for documentation and information on getting the source.

*/

if(!dojo._hasResource["dojo.colors"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojo.colors"] = true;

dojo.provide("dojo.colors");

(function(){

	// this is a standard convertion prescribed by the CSS3 Color Module

	var hue2rgb = function(m1, m2, h){

		if(h < 0){ ++h; }

		if(h > 1){ --h; }

		var h6 = 6 * h;

		if(h6 < 1){ return m1 + (m2 - m1) * h6; }

		if(2 * h < 1){ return m2; }

		if(3 * h < 2){ return m1 + (m2 - m1) * (2 / 3 - h) * 6; }

		return m1;

	};

	dojo.colorFromRgb = function(/*String*/ color, /*dojo.Color?*/ obj){

		// summary:

		//		get rgb(a) array from css-style color declarations

		// description:

		//		this function can handle all 4 CSS3 Color Module formats: rgb,

		//		rgba, hsl, hsla, including rgb(a) with percentage values.

		var m = color.toLowerCase().match(/^(rgba?|hsla?)\(([\s\.\-,%0-9]+)\)/);

		if(m){

			var c = m[2].split(/\s*,\s*/), l = c.length, t = m[1];

			if((t == "rgb" && l == 3) || (t == "rgba" && l == 4)){

				var r = c[0];

				if(r.charAt(r.length - 1) == "%"){

					// 3 rgb percentage values

					var a = dojo.map(c, function(x){

						return parseFloat(x) * 2.56;

					});

					if(l == 4){ a[3] = c[3]; }

					return dojo.colorFromArray(a, obj);	// dojo.Color

				}

				return dojo.colorFromArray(c, obj);	// dojo.Color

			}

			if((t == "hsl" && l == 3) || (t == "hsla" && l == 4)){

				// normalize hsl values

				var H = ((parseFloat(c[0]) % 360) + 360) % 360 / 360,

					S = parseFloat(c[1]) / 100,

					L = parseFloat(c[2]) / 100,

					// calculate rgb according to the algorithm

					// recommended by the CSS3 Color Module

					m2 = L <= 0.5 ? L * (S + 1) : L + S - L * S,

					m1 = 2 * L - m2,

					a = [hue2rgb(m1, m2, H + 1 / 3) * 256,

						hue2rgb(m1, m2, H) * 256, hue2rgb(m1, m2, H - 1 / 3) * 256, 1];

				if(l == 4){ a[3] = c[3]; }

				return dojo.colorFromArray(a, obj);	// dojo.Color

			}

		}

		return null;	// dojo.Color

	};

	var confine = function(c, low, high){

		// summary:

		//		sanitize a color component by making sure it is a number,

		//		and clamping it to valid values

		c = Number(c);

		return isNaN(c) ? high : c < low ? low : c > high ? high : c;	// Number

	};

	dojo.Color.prototype.sanitize = function(){

		// summary: makes sure that the object has correct attributes

		var t = this;

		t.r = Math.round(confine(t.r, 0, 255));

		t.g = Math.round(confine(t.g, 0, 255));

		t.b = Math.round(confine(t.b, 0, 255));

		t.a = confine(t.a, 0, 1);

		return this;	// dojo.Color

	};

})();

dojo.colors.makeGrey = function(/*Number*/ g, /*Number?*/ a){

	// summary: creates a greyscale color with an optional alpha

	return dojo.colorFromArray([g, g, g, a]);

};

// mixin all CSS3 named colors not already in _base, along with SVG 1.0 variant spellings

dojo.Color.named = dojo.mixin({

	aliceblue:	[240,248,255],

	antiquewhite:	[250,235,215],

	aquamarine:	[127,255,212],

	azure:	[240,255,255],

	beige:	[245,245,220],

	bisque:	[255,228,196],

	blanchedalmond:	[255,235,205],

	blueviolet:	[138,43,226],

	brown:	[165,42,42],

	burlywood:	[222,184,135],

	cadetblue:	[95,158,160],

	chartreuse:	[127,255,0],

	chocolate:	[210,105,30],

	coral:	[255,127,80],

	cornflowerblue:	[100,149,237],

	cornsilk:	[255,248,220],

	crimson:	[220,20,60],

	cyan:	[0,255,255],

	darkblue:	[0,0,139],

	darkcyan:	[0,139,139],

	darkgoldenrod:	[184,134,11],

	darkgray:	[169,169,169],

	darkgreen:	[0,100,0],

	darkgrey:	[169,169,169],

	darkkhaki:	[189,183,107],

	darkmagenta:	[139,0,139],

	darkolivegreen:	[85,107,47],

	darkorange:	[255,140,0],

	darkorchid:	[153,50,204],

	darkred:	[139,0,0],

	darksalmon:	[233,150,122],

	darkseagreen:	[143,188,143],

	darkslateblue:	[72,61,139],

	darkslategray:	[47,79,79],

	darkslategrey:	[47,79,79],

	darkturquoise:	[0,206,209],

	darkviolet:	[148,0,211],

	deeppink:	[255,20,147],

	deepskyblue:	[0,191,255],

	dimgray:	[105,105,105],

	dimgrey:	[105,105,105],

	dodgerblue:	[30,144,255],

	firebrick:	[178,34,34],

	floralwhite:	[255,250,240],

	forestgreen:	[34,139,34],

	gainsboro:	[220,220,220],

	ghostwhite:	[248,248,255],

	gold:	[255,215,0],

	goldenrod:	[218,165,32],

	greenyellow:	[173,255,47],

	grey:	[128,128,128],

	honeydew:	[240,255,240],

	hotpink:	[255,105,180],

	indianred:	[205,92,92],

	indigo:	[75,0,130],

	ivory:	[255,255,240],

	khaki:	[240,230,140],

	lavender:	[230,230,250],

	lavenderblush:	[255,240,245],

	lawngreen:	[124,252,0],

	lemonchiffon:	[255,250,205],

	lightblue:	[173,216,230],

	lightcoral:	[240,128,128],

	lightcyan:	[224,255,255],

	lightgoldenrodyellow:	[250,250,210],

	lightgray:	[211,211,211],

	lightgreen:	[144,238,144],

	lightgrey:	[211,211,211],

	lightpink:	[255,182,193],

	lightsalmon:	[255,160,122],

	lightseagreen:	[32,178,170],

	lightskyblue:	[135,206,250],

	lightslategray:	[119,136,153],

	lightslategrey:	[119,136,153],

	lightsteelblue:	[176,196,222],

	lightyellow:	[255,255,224],

	limegreen:	[50,205,50],

	linen:	[250,240,230],

	magenta:	[255,0,255],

	mediumaquamarine:	[102,205,170],

	mediumblue:	[0,0,205],

	mediumorchid:	[186,85,211],

	mediumpurple:	[147,112,219],

	mediumseagreen:	[60,179,113],

	mediumslateblue:	[123,104,238],

	mediumspringgreen:	[0,250,154],

	mediumturquoise:	[72,209,204],

	mediumvioletred:	[199,21,133],

	midnightblue:	[25,25,112],

	mintcream:	[245,255,250],

	mistyrose:	[255,228,225],

	moccasin:	[255,228,181],

	navajowhite:	[255,222,173],

	oldlace:	[253,245,230],

	olivedrab:	[107,142,35],

	orange:	[255,165,0],

	orangered:	[255,69,0],

	orchid:	[218,112,214],

	palegoldenrod:	[238,232,170],

	palegreen:	[152,251,152],

	paleturquoise:	[175,238,238],

	palevioletred:	[219,112,147],

	papayawhip:	[255,239,213],

	peachpuff:	[255,218,185],

	peru:	[205,133,63],

	pink:	[255,192,203],

	plum:	[221,160,221],

	powderblue:	[176,224,230],

	rosybrown:	[188,143,143],

	royalblue:	[65,105,225],

	saddlebrown:	[139,69,19],

	salmon:	[250,128,114],

	sandybrown:	[244,164,96],

	seagreen:	[46,139,87],

	seashell:	[255,245,238],

	sienna:	[160,82,45],

	skyblue:	[135,206,235],

	slateblue:	[106,90,205],

	slategray:	[112,128,144],

	slategrey:	[112,128,144],

	snow:	[255,250,250],

	springgreen:	[0,255,127],

	steelblue:	[70,130,180],

	tan:	[210,180,140],

	thistle:	[216,191,216],

	tomato:	[255,99,71],

	transparent: [0, 0, 0, 0],

	turquoise:	[64,224,208],

	violet:	[238,130,238],

	wheat:	[245,222,179],

	whitesmoke:	[245,245,245],

	yellowgreen:	[154,205,50]

}, dojo.Color.named);

}

if(!dojo._hasResource["dojo.i18n"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojo.i18n"] = true;

dojo.provide("dojo.i18n");

dojo.i18n.getLocalization = function(/*String*/packageName, /*String*/bundleName, /*String?*/locale){

	//	summary:

	//		Returns an Object containing the localization for a given resource

	//		bundle in a package, matching the specified locale.

	//	description:

	//		Returns a hash containing name/value pairs in its prototypesuch

	//		that values can be easily overridden.  Throws an exception if the

	//		bundle is not found.  Bundle must have already been loaded by

	//		dojo.requireLocalization() or by a build optimization step.  NOTE:

	//		try not to call this method as part of an object property

	//		definition (var foo = { bar: dojo.i18n.getLocalization() }).  In

	//		some loading situations, the bundle may not be available in time

	//		for the object definition.  Instead, call this method inside a

	//		function that is run after all modules load or the page loads (like

	//		in dojo.adOnLoad()), or in a widget lifecycle method.

	//	packageName:

	//		package which is associated with this resource

	//	bundleName:

	//		the base filename of the resource bundle (without the ".js" suffix)

	//	locale:

	//		the variant to load (optional).  By default, the locale defined by

	//		the host environment: dojo.locale

	locale = dojo.i18n.normalizeLocale(locale);

	// look for nearest locale match

	var elements = locale.split('-');

	var module = [packageName,"nls",bundleName].join('.');

	var bundle = dojo._loadedModules[module];

	if(bundle){

		var localization;

		for(var i = elements.length; i > 0; i--){

			var loc = elements.slice(0, i).join('_');

			if(bundle[loc]){

				localization = bundle[loc];

				break;

			}

		}

		if(!localization){

			localization = bundle.ROOT;

		}

		// make a singleton prototype so that the caller won't accidentally change the values globally

		if(localization){

			var clazz = function(){};

			clazz.prototype = localization;

			return new clazz(); // Object

		}

	}

	throw new Error("Bundle not found: " + bundleName + " in " + packageName+" , locale=" + locale);

};

dojo.i18n.normalizeLocale = function(/*String?*/locale){

	//	summary:

	//		Returns canonical form of locale, as used by Dojo.

	//

	//  description:

	//		All variants are case-insensitive and are separated by '-' as specified in RFC 3066.

	//		If no locale is specified, the dojo.locale is returned.  dojo.locale is defined by

	//		the user agent's locale unless overridden by djConfig.

	var result = locale ? locale.toLowerCase() : dojo.locale;

	if(result == "root"){

		result = "ROOT";

	}

	return result; // String

};

dojo.i18n._requireLocalization = function(/*String*/moduleName, /*String*/bundleName, /*String?*/locale, /*String?*/availableFlatLocales){

	//	summary:

	//		See dojo.requireLocalization()

	//	description:

	// 		Called by the bootstrap, but factored out so that it is only

	// 		included in the build when needed.

	var targetLocale = dojo.i18n.normalizeLocale(locale);

 	var bundlePackage = [moduleName, "nls", bundleName].join(".");

	// NOTE:

	//		When loading these resources, the packaging does not match what is

	//		on disk.  This is an implementation detail, as this is just a

	//		private data structure to hold the loaded resources.  e.g.

	//		tests/hello/nls/en-us/salutations.js is loaded as the object

	//		tests.hello.nls.salutations.en_us={...} The structure on disk is

	//		intended to be most convenient for developers and translators, but

	//		in memory it is more logical and efficient to store in a different

	//		order.  Locales cannot use dashes, since the resulting path will

	//		not evaluate as valid JS, so we translate them to underscores.

	//Find the best-match locale to load if we have available flat locales.

	var bestLocale = "";

	if(availableFlatLocales){

		var flatLocales = availableFlatLocales.split(",");

		for(var i = 0; i < flatLocales.length; i++){

			//Locale must match from start of string.

			if(targetLocale.indexOf(flatLocales[i]) == 0){

				if(flatLocales[i].length > bestLocale.length){

					bestLocale = flatLocales[i];

				}

			}

		}

		if(!bestLocale){

			bestLocale = "ROOT";

		}

	}

	//See if the desired locale is already loaded.

	var tempLocale = availableFlatLocales ? bestLocale : targetLocale;

	var bundle = dojo._loadedModules[bundlePackage];

	var localizedBundle = null;

	if(bundle){

		if(djConfig.localizationComplete && bundle._built){return;}

		var jsLoc = tempLocale.replace(/-/g, '_');

		var translationPackage = bundlePackage+"."+jsLoc;

		localizedBundle = dojo._loadedModules[translationPackage];

	}

	if(!localizedBundle){

		bundle = dojo["provide"](bundlePackage);

		var syms = dojo._getModuleSymbols(moduleName);

		var modpath = syms.concat("nls").join("/");

		var parent;

		dojo.i18n._searchLocalePath(tempLocale, availableFlatLocales, function(loc){

			var jsLoc = loc.replace(/-/g, '_');

			var translationPackage = bundlePackage + "." + jsLoc;

			var loaded = false;

			if(!dojo._loadedModules[translationPackage]){

				// Mark loaded whether it's found or not, so that further load attempts will not be made

				dojo["provide"](translationPackage);

				var module = [modpath];

				if(loc != "ROOT"){module.push(loc);}

				module.push(bundleName);

				var filespec = module.join("/") + '.js';

				loaded = dojo._loadPath(filespec, null, function(hash){

					// Use singleton with prototype to point to parent bundle, then mix-in result from loadPath

					var clazz = function(){};

					clazz.prototype = parent;

					bundle[jsLoc] = new clazz();

					for(var j in hash){ bundle[jsLoc][j] = hash[j]; }

				});

			}else{

				loaded = true;

			}

			if(loaded && bundle[jsLoc]){

				parent = bundle[jsLoc];

			}else{

				bundle[jsLoc] = parent;

			}

			if(availableFlatLocales){

				//Stop the locale path searching if we know the availableFlatLocales, since

				//the first call to this function will load the only bundle that is needed.

				return true;

			}

		});

	}

	//Save the best locale bundle as the target locale bundle when we know the

	//the available bundles.

	if(availableFlatLocales && targetLocale != bestLocale){

		bundle[targetLocale.replace(/-/g, '_')] = bundle[bestLocale.replace(/-/g, '_')];

	}

};

(function(){

	// If other locales are used, dojo.requireLocalization should load them as

	// well, by default.

	//

	// Override dojo.requireLocalization to do load the default bundle, then

	// iterate through the extraLocale list and load those translations as

	// well, unless a particular locale was requested.

	var extra = djConfig.extraLocale;

	if(extra){

		if(!extra instanceof Array){

			extra = [extra];

		}

		var req = dojo.i18n._requireLocalization;

		dojo.i18n._requireLocalization = function(m, b, locale, availableFlatLocales){

			req(m,b,locale, availableFlatLocales);

			if(locale){return;}

			for(var i=0; i<extra.length; i++){

				req(m,b,extra[i], availableFlatLocales);

			}

		};

	}

})();

dojo.i18n._searchLocalePath = function(/*String*/locale, /*Boolean*/down, /*Function*/searchFunc){

	//	summary:

	//		A helper method to assist in searching for locale-based resources.

	//		Will iterate through the variants of a particular locale, either up

	//		or down, executing a callback function.  For example, "en-us" and

	//		true will try "en-us" followed by "en" and finally "ROOT".

	locale = dojo.i18n.normalizeLocale(locale);

	var elements = locale.split('-');

	var searchlist = [];

	for(var i = elements.length; i > 0; i--){

		searchlist.push(elements.slice(0, i).join('-'));

	}

	searchlist.push(false);

	if(down){searchlist.reverse();}

	for(var j = searchlist.length - 1; j >= 0; j--){

		var loc = searchlist[j] || "ROOT";

		var stop = searchFunc(loc);

		if(stop){ break; }

	}

};

dojo.i18n._preloadLocalizations = function(/*String*/bundlePrefix, /*Array*/localesGenerated){

	//	summary:

	//		Load built, flattened resource bundles, if available for all

	//		locales used in the page. Only called by built layer files.

	function preload(locale){

		locale = dojo.i18n.normalizeLocale(locale);

		dojo.i18n._searchLocalePath(locale, true, function(loc){

			for(var i=0; i<localesGenerated.length;i++){

				if(localesGenerated[i] == loc){

					dojo["require"](bundlePrefix+"_"+loc);

					return true; // Boolean

				}

			}

			return false; // Boolean

		});

	}

	preload();

	var extra = djConfig.extraLocale||[];

	for(var i=0; i<extra.length; i++){

		preload(extra[i]);

	}

};

}

if(!dojo._hasResource["dijit.ColorPalette"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dijit.ColorPalette"] = true;

dojo.provide("dijit.ColorPalette");

dojo.declare(

		"dijit.ColorPalette",

		[dijit._Widget, dijit._Templated],

{

	// summary

	//		Grid showing various colors, so the user can pick a certain color

	// defaultTimeout: Number

	//		number of milliseconds before a held key or button becomes typematic

	defaultTimeout: 500,

	// timeoutChangeRate: Number

	//		fraction of time used to change the typematic timer between events

	//		1.0 means that each typematic event fires at defaultTimeout intervals

	//		< 1.0 means that each typematic event fires at an increasing faster rate

	timeoutChangeRate: 0.90,

	// palette: String

	//		Size of grid, either "7x10" or "3x4".

	palette: "7x10",

	//_value: String

	//		The value of the selected color.

	value: null,

	//_currentFocus: Integer

	//		Index of the currently focused color.

	_currentFocus: 0,

	// _xDim: Integer

	//		This is the number of colors horizontally across.

	_xDim: null,

	// _yDim: Integer

	///		This is the number of colors vertically down.

	_yDim: null,

	// _palettes: Map

	// 		This represents the value of the colors.

	//		The first level is a hashmap of the different arrays available

	//		The next two dimensions represent the columns and rows of colors.

	_palettes: {

		"7x10":	[["white", "seashell", "cornsilk", "lemonchiffon","lightyellow", "palegreen", "paleturquoise", "lightcyan",	"lavender", "plum"],

				["lightgray", "pink", "bisque", "moccasin", "khaki", "lightgreen", "lightseagreen", "lightskyblue", "cornflowerblue", "violet"],

				["silver", "lightcoral", "sandybrown", "orange", "palegoldenrod", "chartreuse", "mediumturquoise", 	"skyblue", "mediumslateblue","orchid"],

				["gray", "red", "orangered", "darkorange", "yellow", "limegreen", 	"darkseagreen", "royalblue", "slateblue", "mediumorchid"],

				["dimgray", "crimson", 	"chocolate", "coral", "gold", "forestgreen", "seagreen", "blue", "blueviolet", "darkorchid"],

				["darkslategray","firebrick","saddlebrown", "sienna", "olive", "green", "darkcyan", "mediumblue","darkslateblue", "darkmagenta" ],

				["black", "darkred", "maroon", "brown", "darkolivegreen", "darkgreen", "midnightblue", "navy", "indigo", 	"purple"]],

		"3x4": [["white", "lime", "green", "blue"],

			["silver", "yellow", "fuchsia", "navy"],

			["gray", "red", "purple", "black"]]

	},

	// _imagePaths: Map

	//		This is stores the path to the palette images

	_imagePaths: {

		"7x10": dojo.moduleUrl("dijit", "templates/colors7x10.png"),

		"3x4": dojo.moduleUrl("dijit", "templates/colors3x4.png")

	},

	// _paletteCoords: Map

	//		This is a map that is used to calculate the coordinates of the

	//		images that make up the palette.

	_paletteCoords: {

		"leftOffset": 4, "topOffset": 4,

		"cWidth": 20, "cHeight": 20

	},

	// templatePath: String

	//		Path to the template of this widget.

	templateString:"<div class=\"dijitInline dijitColorPalette\">\n\t<div class=\"dijitColorPaletteInner\" dojoAttachPoint=\"divNode\" waiRole=\"grid\" tabIndex=\"-1\">\n\t\t<img class=\"dijitColorPaletteUnder\" dojoAttachPoint=\"imageNode\" waiRole=\"presentation\">\n\t</div>\t\n</div>\n",

	// _paletteDims: Object

	//		Size of the supported palettes for alignment purposes.

	_paletteDims: {

		"7x10": {"width": "206px", "height": "145px"},

		"3x4": {"width": "86px", "height": "64px"}

	},

	postCreate: function(){

		// A name has to be given to the colorMap, this needs to be unique per Palette.

		dojo.mixin(this.divNode.style, this._paletteDims[this.palette]);

		this.imageNode.setAttribute("src", this._imagePaths[this.palette]);

		var choices = this._palettes[this.palette];

		this.domNode.style.position = "relative";

		this._highlightNodes = [];

		this.colorNames = dojo.i18n.getLocalization("dojo", "colors", this.lang);

		var url= dojo.moduleUrl("dijit", "templates/blank.gif");

		var colorObject = new dojo.Color(),

		    coords = this._paletteCoords;

		for(var row=0; row < choices.length; row++){

			for(var col=0; col < choices[row].length; col++) {

                var highlightNode = document.createElement("img");

                highlightNode.src = url;

                dojo.addClass(highlightNode, "dijitPaletteImg");

                var color = choices[row][col],

                        colorValue = colorObject.setColor(dojo.Color.named[color]);

                highlightNode.alt = this.colorNames[color];

                highlightNode.color = colorValue.toHex();

                var highlightStyle = highlightNode.style;

                highlightStyle.color = highlightStyle.backgroundColor = highlightNode.color;

                dojo.forEach(["Dijitclick", "MouseOut", "MouseOver", "Blur", "Focus"], function(handler) {

                    this.connect(highlightNode, "on" + handler.toLowerCase(), "_onColor" + handler);

                }, this);

                this.divNode.appendChild(highlightNode);

                highlightStyle.top = coords.topOffset + (row * coords.cHeight) + "px";

                highlightStyle.left = coords.leftOffset + (col * coords.cWidth) + "px";

                highlightNode.setAttribute("tabIndex", "-1");

                highlightNode.title = this.colorNames[color];

                dijit.setWaiRole(highlightNode, "gridcell");

                highlightNode.index = this._highlightNodes.length;

                this._highlightNodes.push(highlightNode);

            }

		}

		this._highlightNodes[this._currentFocus].tabIndex = 0;

		this._xDim = choices[0].length;

		this._yDim = choices.length;

		// Now set all events

		// The palette itself is navigated to with the tab key on the keyboard

		// Keyboard navigation within the Palette is with the arrow keys

		// Spacebar selects the color.

		// For the up key the index is changed by negative the x dimension.

		var keyIncrementMap = {

			UP_ARROW: -this._xDim,

			// The down key the index is increase by the x dimension.

			DOWN_ARROW: this._xDim,

			// Right and left move the index by 1.

			RIGHT_ARROW: 1,

			LEFT_ARROW: -1

		};

		for(var key in keyIncrementMap){

			this._connects.push(dijit.typematic.addKeyListener(this.domNode,

				{keyCode:dojo.keys[key], ctrlKey:false, altKey:false, shiftKey:false},

				this,

				function(){

					var increment = keyIncrementMap[key];

					return function(count){ this._navigateByKey(increment, count); };

				}(),

				this.timeoutChangeRate, this.defaultTimeout));

		}

	},

	focus: function(){

		// summary:

		//		Focus this ColorPalette.

		dijit.focus(this._highlightNodes[this._currentFocus]);

	},

	onChange: function(color){

		// summary:

		//		Callback when a color is selected.

		// color: String

		//		Hex value corresponding to color.

//		console.debug("Color selected is: "+color);

	},

	_onColorDijitclick: function(/*Event*/ evt){

		// summary:

		//		Handler for click, enter key & space key. Selects the color.

		// evt:

		//		The event.

		var target = evt.currentTarget;

		if (this._currentFocus != target.index){

			this._currentFocus = target.index;

			dijit.focus(target);

		}

		this._selectColor(target);

		dojo.stopEvent(evt);

	},

	_onColorMouseOut: function(/*Event*/ evt){

		// summary:

		//		Handler for onMouseOut. Removes highlight.

		// evt:

		//		The mouse event.

		dojo.removeClass(evt.currentTarget, "dijitPaletteImgHighlight");

	},

	_onColorMouseOver: function(/*Event*/ evt){

		// summary:

		//		Handler for onMouseOver. Highlights the color.

		// evt:

		//		The mouse event.

		var target = evt.currentTarget;

		target.tabIndex = 0;

		target.focus();

	},

	_onColorBlur: function(/*Event*/ evt){

		// summary:

		//		Handler for onBlur. Removes highlight and sets

		//		the first color as the palette's tab point.

		// evt:

		//		The blur event.

		dojo.removeClass(evt.currentTarget, "dijitPaletteImgHighlight");

		evt.currentTarget.tabIndex = -1;

		this._currentFocus = 0;

		this._highlightNodes[0].tabIndex = 0;

	},

	_onColorFocus: function(/*Event*/ evt){

		// summary:

		//		Handler for onFocus. Highlights the color.

		// evt:

		//		The focus event.

		if(this._currentFocus != evt.currentTarget.index){

			this._highlightNodes[this._currentFocus].tabIndex = -1;

		}

		this._currentFocus = evt.currentTarget.index;

		dojo.addClass(evt.currentTarget, "dijitPaletteImgHighlight");

	},

	_selectColor: function(selectNode){

		// summary:

		// 		This selects a color. It triggers the onChange event

		// area:

		//		The area node that covers the color being selected.

		this.onChange(this.value = selectNode.color);

	},

	_navigateByKey: function(increment, typeCount){

		// summary:we

		// 	  	This is the callback for typematic.

		// 		It changes the focus and the highlighed color.

		// increment:

		// 		How much the key is navigated.

		// typeCount:

		//		How many times typematic has fired.

		// typecount == -1 means the key is released.

		if(typeCount == -1){ return; }

		var newFocusIndex = this._currentFocus + increment;

		if(newFocusIndex < this._highlightNodes.length && newFocusIndex > -1)

		{

			var focusNode = this._highlightNodes[newFocusIndex];

			focusNode.tabIndex = 0;

			focusNode.focus();

		}

	}

});

}

if(!dojo._hasResource["dijit.Declaration"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dijit.Declaration"] = true;

dojo.provide("dijit.Declaration");

dojo.declare(

	"dijit.Declaration",

	dijit._Widget,

	{

		// summary:

		//		The Declaration widget allows a user to declare new widget

		//		classes directly from a snippet of markup.

		_noScript: true,

		widgetClass: "",

		replaceVars: true,

		defaults: null,

		mixins: [],

		buildRendering: function(){

			var src = this.srcNodeRef.parentNode.removeChild(this.srcNodeRef);

			var preambles = dojo.query("> script[type='dojo/method'][event='preamble']", src).orphan();

			var scripts = dojo.query("> script[type^='dojo/']", src).orphan();

			var srcType = src.nodeName;

			var propList = this.defaults||{};

			// map array of strings like [ "dijit.form.Button" ] to array of mixin objects

			// (note that dojo.map(this.mixins, dojo.getObject) doesn't work because it passes

			// a bogus third argument to getObject(), confusing it)

			this.mixins = this.mixins.length ?

				dojo.map(this.mixins, function(name){ return dojo.getObject(name); } ) :

				[ dijit._Widget, dijit._Templated ];

			if(preambles.length){

				// we only support one preamble. So be it.

				propList.preamble = dojo.parser._functionFromScript(preambles[0]);

			}

			var parsedScripts = dojo.map(scripts, function(s){

				var evt = s.getAttribute("event")||"postscript";

				return {

					event: evt,

					func: dojo.parser._functionFromScript(s)

				};

			});

			// do the connects for each <script type="dojo/connect" event="foo"> block and make

			// all <script type="dojo/method"> tags execute right after construction

			this.mixins.push(function(){

				dojo.forEach(parsedScripts, function(s){

					dojo.connect(this, s.event, this, s.func);

				}, this);

			});

			propList.widgetsInTemplate = true;

			propList._skipNodeCache = true;

			propList.templateString = "<"+srcType+" class='"+src.className+"' dojoAttachPoint='"+(src.getAttribute("dojoAttachPoint")||'')+"' dojoAttachEvent='"+(src.getAttribute("dojoAttachEvent")||'')+"' >"+src.innerHTML.replace(/\%7B/g,"{").replace(/\%7D/g,"}")+"</"+srcType+">";

			// console.debug(propList.templateString);

			// strip things so we don't create stuff under us in the initial setup phase

			dojo.query("[dojoType]", src).forEach(function(node){

				node.removeAttribute("dojoType");

			});

			// create the new widget class

			dojo.declare(

				this.widgetClass,

				this.mixins,

				propList

			);

		}

	}

);

}

if(!dojo._hasResource["dojo.dnd.common"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojo.dnd.common"] = true;

dojo.provide("dojo.dnd.common");

dojo.dnd._copyKey = navigator.appVersion.indexOf("Macintosh") < 0 ? "ctrlKey" : "metaKey";

dojo.dnd.getCopyKeyState = function(e) {

	// summary: abstracts away the difference between selection on Mac and PC,

	//	and returns the state of the "copy" key to be pressed.

	// e: Event: mouse event

	return e[dojo.dnd._copyKey];	// Boolean

};

dojo.dnd._uniqueId = 0;

dojo.dnd.getUniqueId = function(){

	// summary: returns a unique string for use with any DOM element

	var id;

	do{

		id = "dojoUnique" + (++dojo.dnd._uniqueId);

	}while(dojo.byId(id));

	return id;

};

dojo.dnd._empty = {};

dojo.dnd.isFormElement = function(/*Event*/ e){

	// summary: returns true, if user clicked on a form element

	var t = e.target;

	if(t.nodeType == 3 /*TEXT_NODE*/){

		t = t.parentNode;

	}

	return " button textarea input select option ".indexOf(" " + t.tagName.toLowerCase() + " ") >= 0;	// Boolean

};

}

if(!dojo._hasResource["dojo.dnd.autoscroll"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojo.dnd.autoscroll"] = true;

dojo.provide("dojo.dnd.autoscroll");

dojo.dnd.getViewport = function(){

	// summary: returns a viewport size (visible part of the window)

	// FIXME: need more docs!!

	var d = dojo.doc, dd = d.documentElement, w = window, b = dojo.body();

	if(dojo.isMozilla){

		return {w: dd.clientWidth, h: w.innerHeight};	// Object

	}else if(!dojo.isOpera && w.innerWidth){

		return {w: w.innerWidth, h: w.innerHeight};		// Object

	}else if (!dojo.isOpera && dd && dd.clientWidth){

		return {w: dd.clientWidth, h: dd.clientHeight};	// Object

	}else if (b.clientWidth){

		return {w: b.clientWidth, h: b.clientHeight};	// Object

	}

	return null;	// Object

};

dojo.dnd.V_TRIGGER_AUTOSCROLL = 32;

dojo.dnd.H_TRIGGER_AUTOSCROLL = 32;

dojo.dnd.V_AUTOSCROLL_VALUE = 16;

dojo.dnd.H_AUTOSCROLL_VALUE = 16;

dojo.dnd.autoScroll = function(e){

	// summary:

	//		a handler for onmousemove event, which scrolls the window, if

	//		necesary

	// e: Event:

	//		onmousemove event

	// FIXME: needs more docs!

	var v = dojo.dnd.getViewport(), dx = 0, dy = 0;

	if(e.clientX < dojo.dnd.H_TRIGGER_AUTOSCROLL){

		dx = -dojo.dnd.H_AUTOSCROLL_VALUE;

	}else if(e.clientX > v.w - dojo.dnd.H_TRIGGER_AUTOSCROLL){

		dx = dojo.dnd.H_AUTOSCROLL_VALUE;

	}

	if(e.clientY < dojo.dnd.V_TRIGGER_AUTOSCROLL){

		dy = -dojo.dnd.V_AUTOSCROLL_VALUE;

	}else if(e.clientY > v.h - dojo.dnd.V_TRIGGER_AUTOSCROLL){

		dy = dojo.dnd.V_AUTOSCROLL_VALUE;

	}

	window.scrollBy(dx, dy);

};

dojo.dnd._validNodes = {"div": 1, "p": 1, "td": 1};

dojo.dnd._validOverflow = {"auto": 1, "scroll": 1};

dojo.dnd.autoScrollNodes = function(e){

	// summary:

	//		a handler for onmousemove event, which scrolls the first avaialble

	//		Dom element, it falls back to dojo.dnd.autoScroll()

	// e: Event:

	//		onmousemove event

	// FIXME: needs more docs!

	for(var n = e.target; n;){

		if(n.nodeType == 1 && (n.tagName.toLowerCase() in dojo.dnd._validNodes)){

			var s = dojo.getComputedStyle(n);

			if(s.overflow.toLowerCase() in dojo.dnd._validOverflow){

				var b = dojo._getContentBox(n, s), t = dojo._abs(n, true);

				// console.debug(b.l, b.t, t.x, t.y, n.scrollLeft, n.scrollTop);

				b.l += t.x + n.scrollLeft;

				b.t += t.y + n.scrollTop;

				var w = Math.min(dojo.dnd.H_TRIGGER_AUTOSCROLL, b.w / 2),

					h = Math.min(dojo.dnd.V_TRIGGER_AUTOSCROLL, b.h / 2),

					rx = e.pageX - b.l, ry = e.pageY - b.t, dx = 0, dy = 0;

				if(rx > 0 && rx < b.w){

					if(rx < w){

						dx = -dojo.dnd.H_AUTOSCROLL_VALUE;

					}else if(rx > b.w - w){

						dx = dojo.dnd.H_AUTOSCROLL_VALUE;

					}

				}

				//console.debug("ry =", ry, "b.h =", b.h, "h =", h);

				if(ry > 0 && ry < b.h){

					if(ry < h){

						dy = -dojo.dnd.V_AUTOSCROLL_VALUE;

					}else if(ry > b.h - h){

						dy = dojo.dnd.V_AUTOSCROLL_VALUE;

					}

				}

				var oldLeft = n.scrollLeft, oldTop = n.scrollTop;

				n.scrollLeft = n.scrollLeft + dx;

				n.scrollTop  = n.scrollTop  + dy;

				// if(dx || dy){ console.debug(oldLeft + ", " + oldTop + "\n" + dx + ", " + dy + "\n" + n.scrollLeft + ", " + n.scrollTop); }

				if(oldLeft != n.scrollLeft || oldTop != n.scrollTop){ return; }

			}

		}

		try{

			n = n.parentNode;

		}catch(x){

			n = null;

		}

	}

	dojo.dnd.autoScroll(e);

};

}

if(!dojo._hasResource["dojo.dnd.Mover"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dojo.dnd.Mover"] = true;

dojo.provide("dojo.dnd.Mover");

dojo.declare("dojo.dnd.Mover", null, {

	constructor: function(node, e, host){

		// summary: an object, which makes a node follow the mouse,

		//	used as a default mover, and as a base class for custom movers

		// node: Node: a node (or node's id) to be moved

		// e: Event: a mouse event, which started the move;

		//	only pageX and pageY properties are used

		// host: Object?: object which implements the functionality of the move,

		//	 and defines proper events (onMoveStart and onMoveStop)

		this.node = dojo.byId(node);

		this.marginBox = {l: e.pageX, t: e.pageY};

		this.mouseButton = e.button;

		var h = this.host = host, d = node.ownerDocument,

			firstEvent = dojo.connect(d, "onmousemove", this, "onFirstMove");

		this.events = [

			dojo.connect(d, "onmousemove", this, "onMouseMove"),

			dojo.connect(d, "onmouseup",   this, "onMouseUp"),

			// cancel text selection and text dragging

			dojo.connect(d, "ondragstart",   dojo, "stopEvent"),

			dojo.connect(d, "onselectstart", dojo, "stopEvent"),

			firstEvent

		];

		// notify that the move has started

		if(h && h.onMoveStart){

			h.onMoveStart(this);

		}

	},

	// mouse event processors

	onMouseMove: function(e){

		// summary: event processor for onmousemove