Subversion Repositories Applications.papyrus

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

dojo._hasResource["dojox.charting.Theme"] = true;

dojo.provide("dojox.charting.Theme");

dojo.require("dojox.charting._color");

(function(){

	var dxc=dojox.charting;

	//	TODO: Legend information

	dxc.Theme=function(/*object?*/kwArgs){

		kwArgs=kwArgs||{};

		this.chart=dojo.mixin(dojo.clone(dxc.Theme._def.chart), kwArgs.chart||{});

		this.plotarea=dojo.mixin(dojo.clone(dxc.Theme._def.plotarea), kwArgs.plotarea||{});

		this.axis=dojo.mixin(dojo.clone(dxc.Theme._def.axis), kwArgs.axis||{});

		this.series=dojo.mixin(dojo.clone(dxc.Theme._def.series), kwArgs.series||{});

		this.marker=dojo.mixin(dojo.clone(dxc.Theme._def.marker), kwArgs.marker||{});

		this.markers=dojo.mixin(dojo.clone(dxc.Theme.Markers), kwArgs.markers||{});

		this.colors=[];

		this.antiAlias=("antiAlias" in kwArgs)?kwArgs.antiAlias:true;

		this.assignColors=("assignColors" in kwArgs)?kwArgs.assignColors:true;

		this.assignMarkers=("assignMarkers" in kwArgs)?kwArgs.assignMarkers:true;

		this._colorCache=null;

		//	push the colors, use _def colors if none passed.

		kwArgs.colors=kwArgs.colors||dxc.Theme._def.colors;

		dojo.forEach(kwArgs.colors, function(item){

			this.colors.push(item);

		}, this);

		//	private variables for color and marker indexing

		this._current={ color:0, marker: 0 };

		this._markers=[];

		this._buildMarkerArray();

	};

	//	"static" fields

	//	default markers.

	//	A marker is defined by an SVG path segment; it should be defined as

	//		relative motion, and with the assumption that the path segment

	//		will be moved to the value point (i.e prepend Mx,y)

	dxc.Theme.Markers={

		CIRCLE:"m-3,0 c0,-4 6,-4 6,0 m-6,0 c0,4 6,4 6,0",

		SQUARE:"m-3,-3 l0,6 6,0 0,-6 z",

		DIAMOND:"m0,-3 l3,3 -3,3 -3,-3 z",

		CROSS:"m0,-3 l0,6 m-3,-3 l6,0",

		X:"m-3,-3 l6,6 m0,-6 l-6,6",

		TRIANGLE:"m-3,3 l3,-6 3,6 z",

		TRIANGLE_INVERTED:"m-3,-3 l3,6 3,-6 z"

	};

	dxc.Theme._def={

		//	all objects are structs used directly in dojox.gfx

		chart:{

			stroke:null,

			fill: "white"

		},

		plotarea:{

			stroke:null,

			fill: "white"

		},

		//	TODO: label rotation on axis

		axis:{

			stroke:{ color:"#333",width:1 },							//	the axis itself

			line:{ color:"#ccc",width:1,style:"Dot",cap:"round" },		//	gridlines

			majorTick:{ color:"#666", width:1, length:6, position:"center" },	//	major ticks on axis

			minorTick:{ color:"#666", width:0.8, length:3, position:"center" },	//	minor ticks on axis

			font:"normal normal normal 7pt Tahoma",						//	labels on axis

			fontColor:"#333"											//	color of labels

		},

		series:{

			outline: {width: 2, color: "#ccc"},							//	line or outline

			stroke: {width: 2, color: "#333"},							//	line or outline

			fill: "#ccc",												//	fill, if appropriate

			font: "normal normal normal 7pt Tahoma",					//	if there's a label

			fontColor: "#000"											// 	color of labels

		},

		marker:{	//	any markers on a series.

			stroke: {width:1},											//	stroke or outline

			fill: "#333",												//	fill if needed

			font: "normal normal normal 7pt Tahoma",					//	label

			fontColor: "#000"

		},

		colors:[

			"#000","#111","#222","#333",

			"#444","#555","#666","#777",

			"#888","#999","#aaa","#bbb",

			"#ccc"

		]

	};

	//	prototype methods

	dojo.extend(dxc.Theme, {

		defineColors: function(obj){

			//	we can generate a set of colors based on keyword arguments

			var kwArgs=obj||{};

			//	deal with caching

			var cache=false;

			if(kwArgs.cache===undefined){ cache=true; }

			if(kwArgs.cache==true){ cache=true; }

			if(cache){

				this._colorCache=kwArgs;

			} else {

				var mix=this._colorCache||{};

				kwArgs=dojo.mixin(dojo.clone(mix), kwArgs);

			}

			var c=[], n=kwArgs.num||32;	//	the number of colors to generate

			if(kwArgs.colors){

				//	we have an array of colors predefined, so fix for the number of series.

				var l=kwArgs.colors.length;

				for(var i=0; i<n; i++){

					c.push(kwArgs.colors[i%l]);

				}

				this.colors=c;

			}

			else if(kwArgs.hue){

				//	single hue, generate a set based on brightness

				var s=kwArgs.saturation||100;	//	saturation

				var st=kwArgs.low||30;

				var end=kwArgs.high||90;

				var step=(end-st)/n;			//	brightness steps

				for(var i=0; i<n; i++){

					c.push(dxc._color.fromHsb(kwArgs.hue, s, st+(step*i)).toHex());

				}

				this.colors=c;

			}

			else if(kwArgs.stops){

				//	create color ranges that are either equally distributed, or

				//	(optionally) based on a passed "offset" property.  If you

				//	pass an array of Colors, it will equally distribute, if

				//	you pass an array of structs { color, offset }, it will

				//	use the offset (0.0 - 1.0) to distribute.  Note that offset

				//	values should be plotted on a line from 0.0 to 1.0--i.e.

				//	they should be additive.  For example:

				//	[ {color, offset:0}, { color, offset:0.2 }, { color, offset:0.5 }, { color, offset:1.0 } ]

				//

				//	If you use stops for colors, you MUST have a color at 0.0 and one

				//	at 1.0.

				//	figure out how many stops we have

				var l=kwArgs.stops.length;

				if(l<2){

					throw new Error(

						"dojox.charting.Theme::defineColors: when using stops to "

						+ "define a color range, you MUST specify at least 2 colors."

					);

				}

				//	figure out if the distribution is equal or not.  Note that

				//	colors may not exactly match the stops you define; because

				//	color generation is linear (i.e. evenly divided on a linear

				//	axis), it's very possible that a color will land in between

				//	two stops and not exactly *at* a stop.

				//

				//	The only two colors guaranteed will be the end stops (i.e.

				//	the first and last stop), which will *always* be set as

				//	the end stops.

				if(typeof(kwArgs.stops[0].offset)=="undefined"){

					//	set up equal offsets

					var off=1/(l-1);

					for(var i=0; i<l; i++){

						kwArgs.stops[i]={

							color:kwArgs.stops[i],

							offset:off*i

						};

					}

				}

				//	ensure the ends.

				kwArgs.stops[0].offset=0;

				kwArgs.stops[l-1].offset=1;

				kwArgs.stops.sort(function(a,b){ return a.offset-b.offset; });

				//	create the colors.

				//	first stop.

				c.push(kwArgs.stops[0].color.toHex());

				//	TODO: calculate the blend at n/steps and set the color

				//	last stop

				c.push(kwArgs.stops[l-1].color.toHex());

				this.colors=c;

			}

		},

		_buildMarkerArray: function(){

			this._markers=[];

			for(var p in this.markers){ this._markers.push(this.markers[p]); }

			//	reset the position

			this._current.marker=0;

		},

		addMarker:function(/* string */name, /*string*/segment){

			//	summary

			//	Add a custom marker to this theme.

			//

			//	example

			//	myTheme.addMarker("Ellipse", foo);

			this.markers[name]=segment;

			this._buildMarkerArray();

		},

		setMarkers:function(/* object */obj){

			//	summary

			//	Set all the markers of this theme at once.  obj should be

			//	a dictionary of keys and path segments.

			//

			//	example

			//	myTheme.setMarkers({ "CIRCLE": foo });

			this.markers=obj;

			this._buildMarkerArray();

		},

		next: function(/* string? */type){

			//	summary

			//	get either the next color or the next marker, depending on what was

			//	passed.  If type is not passed, it assumes color.

			//

			//	example

			//	var color=myTheme.next();

			//	var color=myTheme.next("color");

			//	var marker=myTheme.next("marker");

			if(!type) type="color";

			if(type=="color"){

				return this.colors[this._current.color++%this.colors.length];

			}

			else if(type=="marker"){

				return this._markers[this._current.marker++%this._markers.length];

			}

		},

		clear: function(){

			this._current = {color: 0, marker: 0};

		}

	});

})();

}