function Renderer_setThematism(thematism) {
	this.thematism=thematism;
	this.dynamic=true;
}

function Renderer_setProperty(name,value) {
	this.changed=true;
	this.properties[name]=value;
	if(name=='selectable')
		this.setSelectable(value);
}

function Renderer_getProperty(name) {
	return this.properties[name];
}

function Renderer_setLayer(layer) {
	this.layer=layer;
}

function Renderer_init(stream) {
	Renderer.styleReader.read(stream,this);
}

function Renderer_hasChanged() {
	var result=this.changed;
	this.changed=false;
	return result;
}

function Renderer_hasManageableProperty(property,dynamic) {
	if(this.manageableProperties[property]) {
		if(dynamic) {
			if(this.thematism)
				return this.thematism.themas[property];
			else
				return false;
		}
		else
			return true;
	}
	return false;
}

function Renderer_hasThema(property) {
	return (this.thematism && this.thematism.themas[property]);
}

function Renderer_copyProperties(result) {
	for(var propName in this.properties)
		result.setProperty(propName,this.properties[propName]);
}


function Renderer_initRenderer() {
	this.changed=false;
	this.properties=new Array();
	this.thematism=null;
	this.manageableProperties=new Array();
	this.manageableProperties['visibility']='visibility';
	this.manageableProperties['opacity']='opacity';
}

function Renderer_getElementCount() {
	if(this.thematism)
		return this.thematism.descriptions.length;
	return 1;
}

function Renderer() {
	this.initRenderer();	
}

Renderer.implementations=new Array();

function BaseRenderer_draw(layer,canvas) {
	
}

function BaseRenderer_updateObject(renderable,layer) {
	
}

function BaseRenderer_getSample(format,width,height) {
	return '';
}


function BaseRenderer() {
	this.initRenderer();
}

BaseRenderer.prototype.setProperty=Renderer_setProperty;
BaseRenderer.prototype.getProperty=Renderer_getProperty;
BaseRenderer.prototype.setLayer=Renderer_setLayer;
BaseRenderer.prototype.init=Renderer_init;
BaseRenderer.prototype.hasChanged=Renderer_hasChanged;
BaseRenderer.prototype.hasThema=Renderer_hasThema;
BaseRenderer.prototype.initRenderer=Renderer_initRenderer;
BaseRenderer.prototype.setThematism=Renderer_setThematism;
BaseRenderer.prototype.getElementCount=Renderer_getElementCount;
BaseRenderer.prototype.hasManageableProperty=Renderer_hasManageableProperty;
BaseRenderer.prototype.draw=BaseRenderer_draw;
BaseRenderer.prototype.updateObject=BaseRenderer_updateObject;
BaseRenderer.prototype.getSample=BaseRenderer_getSample;

function VirtualRenderer_draw(layer,canvas) {
	
	
}

function VirtualRenderer_staticFill() {
	return (this.getProperty('fill') || this.getProperty('fillpattern')) && !this.hasThema('fill') && !this.hasThema('fillpattern');
}

function VirtualRenderer_dynamicFill() {
	return this.hasThema('fill') || this.hasThema('fillpattern');
}

function VirtualRenderer_solidFill() {
	return !this.getProperty('fillpattern') && !this.hasThema('fillpattern');
}

function VirtualRenderer_updateObject(renderable,layer) {
	if(this.hasThema('color')) {
		layer.implementation.setObjectColor(renderable.object,this.thematism.themas['color'].process(renderable.properties));
	}
	if(this.hasThema('stroke')) {
		layer.implementation.setObjectStroke(renderable.object,this.thematism.themas['stroke'].process(renderable.properties));
	}

	if(this.dynamicFill()) {
		if(this.solidFill())
			layer.implementation.setObjectFill(renderable.object,this.thematism.themas['fill'].process(renderable.properties));
		else {
			if(this.hasThema('fill') && this.hasThema('fillpattern'))
				layer.implementation.setObjectFillPattern(renderable.object,this.thematism.themas['fillpattern'].process(renderable.properties),this.thematism.themas['fill'].process(renderable.properties),true);
			else if(this.hasThema('fill') && !this.hasThema('fillpattern'))
				layer.implementation.setObjectFillPattern(renderable.object,this.getProperty('fillpattern'),this.thematism.themas['fill'].process(renderable.properties),true);
			else if(!this.hasThema('fill') && this.hasThema('fillpattern'))
				layer.implementation.setObjectFillPattern(renderable.object,this.thematism.themas['fillpattern'].process(renderable.properties),this.getProperty('fill'),false);
			
		}
	}
}

function VirtualRenderer_getSample(format,width,height) {
	return '';
}

function VirtualRenderer_setSelectable(value) {
	if(value) {
		this.setProperty('stroke',3);
		this.setProperty('color','none');
		this.setProperty('fill','none');
	}
}

function VirtualRenderer_clone() {
	var result=new ArealRenderer();
	this.copyProperties(result);
	return result;
}

function VirtualRenderer_getPointerEvents() {
	return 'fill';
}

function VirtualRenderer() {
	this.initRenderer();
	
}

VirtualRenderer.prototype.setProperty=Renderer_setProperty;
VirtualRenderer.prototype.getProperty=Renderer_getProperty;
VirtualRenderer.prototype.setLayer=Renderer_setLayer;
VirtualRenderer.prototype.init=Renderer_init;
VirtualRenderer.prototype.hasChanged=Renderer_hasChanged;
VirtualRenderer.prototype.hasThema=Renderer_hasThema;
VirtualRenderer.prototype.initRenderer=Renderer_initRenderer;
VirtualRenderer.prototype.setThematism=Renderer_setThematism;
VirtualRenderer.prototype.getElementCount=Renderer_getElementCount;
VirtualRenderer.prototype.hasManageableProperty=Renderer_hasManageableProperty;
VirtualRenderer.prototype.draw=VirtualRenderer_draw;
VirtualRenderer.prototype.updateObject=VirtualRenderer_updateObject;
VirtualRenderer.prototype.getSample=VirtualRenderer_getSample;
VirtualRenderer.prototype.staticFill=VirtualRenderer_staticFill;
VirtualRenderer.prototype.dynamicFill=VirtualRenderer_dynamicFill;
VirtualRenderer.prototype.solidFill=VirtualRenderer_solidFill;
VirtualRenderer.prototype.clone=VirtualRenderer_clone;
VirtualRenderer.prototype.copyProperties=Renderer_copyProperties;
VirtualRenderer.prototype.setSelectable=VirtualRenderer_setSelectable;
VirtualRenderer.prototype.getPointerEvents=VirtualRenderer_getPointerEvents;

function LinearRenderer_draw(layer,canvas) {
	if(this.getProperty('color') && !this.hasThema('color'))
		layer.implementation.setColor(canvas,this.getProperty('color'));
	if(this.getProperty('stroke') && !this.hasThema('stroke'))
		layer.implementation.setStroke(canvas,parseInt(this.getProperty('stroke')));
}

function LinearRenderer_updateObject(renderable,layer) {
	if(this.thematism.themas['color']) {
		layer.implementation.setObjectColor(renderable.object,this.thematism.themas['color'].process(renderable.properties));
	}
	if(this.thematism.themas['stroke']) {
		layer.implementation.setObjectStroke(renderable.object,this.thematism.themas['stroke'].process(renderable.properties));
	}
}

function LinearRenderer_getSample(format,width,height) {
	if(format=='VML') {
		if(this.dynamic) {
			var posx1=Math.floor(width/3);
			var posx2=Math.floor(width-width/3);
			var posy1=Math.floor(height/3);
			var posy2=Math.floor(height-height/3);
			var html='<v:polyline style="position:absolute;left:0px;top:1px" points="0px,'+height+'px '+posx1+'px,'+posy1+'px"><v:stroke color="red" weight="1"/></v:polyline>';
			html+='<v:polyline style="position:absolute;left:0px;top:1px" points="'+posx1+'px,'+posy1+'px '+posx2+'px,'+posy2+'px '+width+'px,0px"><v:stroke color="blue" weight="1"/></v:polyline>';
			return html;
		} else {
			var posx1=Math.floor(width/3);
			var posx2=Math.floor(width-width/3);
			var posy1=Math.floor(height/3);
			var posy2=Math.floor(height-height/3);
			return '<v:polyline style="position:absolute;left:0px;top:1px" points="0px,'+height+'px '+posx1+'px,'+posy1+'px '+posx2+'px,'+posy2+'px '+width+'px,0px"><v:stroke color="'+this.getProperty('color')+'" weight="'+this.getProperty('stroke')+'"/></v:polyline>';
		}
	}
}

function LinearRenderer_setSelectable(value) {
	if(value) {
		this.setProperty('color','none');
		this.setProperty('stroke',3);
	}
}

function LinearRenderer_clone() {
	var result=new LinearRenderer();
	this.copyProperties(result);
	return result;
}

function LinearRenderer_getPointerEvents() {
	return 'stroke';
}

function LinearRenderer() {
	this.initRenderer();
	this.manageableProperties['stroke']='stroke';
	this.manageableProperties['color']='color';
}

LinearRenderer.prototype.setProperty=Renderer_setProperty;
LinearRenderer.prototype.getProperty=Renderer_getProperty;
LinearRenderer.prototype.setLayer=Renderer_setLayer;
LinearRenderer.prototype.init=Renderer_init;
LinearRenderer.prototype.hasChanged=Renderer_hasChanged;
LinearRenderer.prototype.hasThema=Renderer_hasThema;
LinearRenderer.prototype.initRenderer=Renderer_initRenderer;
LinearRenderer.prototype.setThematism=Renderer_setThematism;
LinearRenderer.prototype.getElementCount=Renderer_getElementCount;
LinearRenderer.prototype.hasManageableProperty=Renderer_hasManageableProperty;
LinearRenderer.prototype.draw=LinearRenderer_draw;
LinearRenderer.prototype.updateObject=LinearRenderer_updateObject;
LinearRenderer.prototype.getSample=LinearRenderer_getSample;
LinearRenderer.prototype.clone=LinearRenderer_clone;
LinearRenderer.prototype.copyProperties=Renderer_copyProperties;
LinearRenderer.prototype.setSelectable=LinearRenderer_setSelectable;
LinearRenderer.prototype.getPointerEvents=LinearRenderer_getPointerEvents;


function TextRenderer_draw(layer,canvas) {
	if(this.getProperty('color') && !this.hasThema('color'))
		layer.implementation.setColor(canvas,this.getProperty('color'));
	if(this.getProperty('stroke') && !this.hasThema('stroke'))
		layer.implementation.setStroke(canvas,parseInt(this.getProperty('stroke')));
}

function TextRenderer_updateObject(renderable,layer) {
	if(this.thematism.themas['color']) {
		layer.implementation.setObjectColor(renderable.object,this.thematism.themas['color'].process(renderable.properties));
	}
	if(this.thematism.themas['stroke']) {
		layer.implementation.setObjectStroke(renderable.object,this.thematism.themas['stroke'].process(renderable.properties));
	}
}

function TextRenderer_getSample(format,width,height) {
	if(format=='VML') {
		if(this.dynamic) {
			var posx1=Math.floor(width/3);
			var posx2=Math.floor(width-width/3);
			var posy1=Math.floor(height/3);
			var posy2=Math.floor(height-height/3);
			var html='<v:polyline style="position:absolute;left:0px;top:1px" points="0px,'+height+'px '+posx1+'px,'+posy1+'px"><v:stroke color="red" weight="1"/></v:polyline>';
			html+='<v:polyline style="position:absolute;left:0px;top:1px" points="'+posx1+'px,'+posy1+'px '+posx2+'px,'+posy2+'px '+width+'px,0px"><v:stroke color="blue" weight="1"/></v:polyline>';
			return html;
		} else {
			var posx1=Math.floor(width/3);
			var posx2=Math.floor(width-width/3);
			var posy1=Math.floor(height/3);
			var posy2=Math.floor(height-height/3);
			
			return '<div style="position:absolute;top:1px;left:5px"><font size="2" color="'+this.getProperty('fill')+'">T</font></div>';
		}
	}
}

function TextRenderer_setSelectable(value) {
	if(value) {
		this.setProperty('color','none');
		this.setProperty('stroke',3);
	}
}

function TextRenderer_clone() {
	var result=new TextRenderer();
	this.copyProperties(result);
	return result;
}

function TextRenderer_getPointerEvents() {
	return 'stroke';
}

function TextRenderer() {
	this.initRenderer();
	this.manageableProperties['stroke']='stroke';
	this.manageableProperties['color']='color';
}

TextRenderer.prototype.setProperty=Renderer_setProperty;
TextRenderer.prototype.getProperty=Renderer_getProperty;
TextRenderer.prototype.setLayer=Renderer_setLayer;
TextRenderer.prototype.init=Renderer_init;
TextRenderer.prototype.hasChanged=Renderer_hasChanged;
TextRenderer.prototype.hasThema=Renderer_hasThema;
TextRenderer.prototype.initRenderer=Renderer_initRenderer;
TextRenderer.prototype.setThematism=Renderer_setThematism;
TextRenderer.prototype.getElementCount=Renderer_getElementCount;
TextRenderer.prototype.hasManageableProperty=Renderer_hasManageableProperty;
TextRenderer.prototype.draw=TextRenderer_draw;
TextRenderer.prototype.updateObject=TextRenderer_updateObject;
TextRenderer.prototype.getSample=TextRenderer_getSample;
TextRenderer.prototype.clone=TextRenderer_clone;
TextRenderer.prototype.copyProperties=Renderer_copyProperties;
TextRenderer.prototype.setSelectable=TextRenderer_setSelectable;
TextRenderer.prototype.getPointerEvents=TextRenderer_getPointerEvents;

function ArealRenderer_draw(layer,canvas) {
	if(this.getProperty('color') && !this.hasThema('color'))
		layer.implementation.setColor(canvas,this.getProperty('color'));
	if(this.getProperty('stroke') && !this.hasThema('stroke'))
		layer.implementation.setStroke(canvas,parseInt(this.getProperty('stroke')));
	if(this.staticFill()) {
		if(this.solidFill())
			layer.implementation.setFill(canvas,this.getProperty('fill'));
		else
			layer.implementation.setFillPattern(canvas,this.getProperty('fillpattern'),this.getProperty('fill'));
	}
	
}

function ArealRenderer_staticFill() {
	return (this.getProperty('fill') || this.getProperty('fillpattern')) && !this.hasThema('fill') && !this.hasThema('fillpattern');
}

function ArealRenderer_dynamicFill() {
	return this.hasThema('fill') || this.hasThema('fillpattern');
}

function ArealRenderer_solidFill() {
	return !this.getProperty('fillpattern') && !this.hasThema('fillpattern');
}

function ArealRenderer_updateObject(renderable,layer) {
	if(this.hasThema('color')) {
		layer.implementation.setObjectColor(renderable.object,this.thematism.themas['color'].process(renderable.properties));
	}
	if(this.hasThema('stroke')) {
		layer.implementation.setObjectStroke(renderable.object,this.thematism.themas['stroke'].process(renderable.properties));
	}

	if(this.dynamicFill()) {
		if(this.solidFill())
			layer.implementation.setObjectFill(renderable.object,this.thematism.themas['fill'].process(renderable.properties));
		else {
			if(this.hasThema('fill') && this.hasThema('fillpattern'))
				layer.implementation.setObjectFillPattern(renderable.object,this.thematism.themas['fillpattern'].process(renderable.properties),this.thematism.themas['fill'].process(renderable.properties),true);
			else if(this.hasThema('fill') && !this.hasThema('fillpattern'))
				layer.implementation.setObjectFillPattern(renderable.object,this.getProperty('fillpattern'),this.thematism.themas['fill'].process(renderable.properties),true);
			else if(!this.hasThema('fill') && this.hasThema('fillpattern'))
				layer.implementation.setObjectFillPattern(renderable.object,this.thematism.themas['fillpattern'].process(renderable.properties),this.getProperty('fill'),false);
			
		}
	}
}

function ArealRenderer_getSample(format,width,height) {
	if(format=='VML') {
		if(this.dynamic) {
			var posy1=Math.floor(height/4);
			var posy2=Math.floor(height-height/4);
			var posx=Math.floor(width/2);
			return '<v:polyline style="position:absolute;left:0px;top:1px" points="1px,'+posy1+'px '+posx+'px,'+posy1+'px '+posx+'px,'+posy2+'px 1px,'+posy2+'px 1px,'+posy1+'px"><v:stroke color="red" weight="1"/><v:fill color="red"></v:fill></v:polyline><v:polyline style="position:absolute;left:0px;top:1px" points="'+(posx+1)+'px,'+posy1+'px '+width+'px,'+posy1+'px '+width+'px,'+posy2+'px '+(posx+1)+'px,'+posy2+'px '+(posx+1)+'px,'+posy1+'px"><v:stroke color="blue" weight="1"/><v:fill color="blue"></v:fill></v:polyline>';
		} else {

			var pos1=Math.floor(height/4);
			var pos2=Math.floor(height-height/4);
			// TODO: implementare altri pattern
			if(this.getProperty('fillpattern')=='oblique') {
				var posx=Math.floor(width/2);
				var pos3=Math.floor(height/2);
				
				
				var html='<v:polyline style="position:absolute;left:0px;top:1px" points="1px,'+pos1+'px '+width+'px,'+pos1+'px '+width+'px,'+pos2+'px 1px,'+pos2+'px 1px,'+pos1+'px"><v:stroke color="'+this.getProperty('color')+'" weight="'+this.getProperty('stroke')+'"/></v:polyline>';
				html += '<v:polyline style="position:absolute;left:0px;top:1px" points="'+posx+'px,'+pos1+'px '+width+'px,'+pos3+'px"><v:stroke color="'+this.getProperty('fill')+'" weight="'+this.getProperty('stroke')+'" color="'+this.getProperty('fill')+'"/></v:polyline>';
				html += '<v:polyline style="position:absolute;left:0px;top:1px" points="1px,'+pos3+'px '+posx+'px,'+pos2+'px"><v:stroke color="'+this.getProperty('fill')+'" weight="'+this.getProperty('stroke')+'" color="'+this.getProperty('fill')+'"/></v:polyline>';
				return html;
			}  else if(this.getProperty('fillpattern')=='vertical') {
				var posx=Math.floor(width/2);
				var pos3=Math.floor(height/2);
				var posx1=Math.floor(width/3);
				var posx2=Math.floor(width/3*2);
				var html='<v:polyline style="position:absolute;left:0px;top:1px" points="1px,'+pos1+'px '+width+'px,'+pos1+'px '+width+'px,'+pos2+'px 1px,'+pos2+'px 1px,'+pos1+'px"><v:stroke color="'+this.getProperty('color')+'" weight="'+this.getProperty('stroke')+'"/></v:polyline>';
				html += '<v:polyline style="position:absolute;left:0px;top:1px" points="'+posx1+'px,'+pos1+'px '+posx1+'px,'+pos2+'px"><v:stroke color="'+this.getProperty('fill')+'" weight="'+this.getProperty('stroke')+'" color="'+this.getProperty('fill')+'"/></v:polyline>';
				html += '<v:polyline style="position:absolute;left:0px;top:1px" points="'+posx2+'px,'+pos1+'px '+posx2+'px,'+pos2+'px"><v:stroke color="'+this.getProperty('fill')+'" weight="'+this.getProperty('stroke')+'" color="'+this.getProperty('fill')+'"/></v:polyline>';
				return html;
			} else {
				var fill='white';
				if(this.getProperty('fill'))
					fill=this.getProperty('fill');
				return '<v:polyline style="position:absolute;left:0px;top:1px" points="1px,'+pos1+'px '+width+'px,'+pos1+'px '+width+'px,'+pos2+'px 1px,'+pos2+'px 1px,'+pos1+'px"><v:stroke color="'+this.getProperty('color')+'" weight="'+this.getProperty('stroke')+'"/><v:fill color="'+fill+'"></v:fill></v:polyline>';
			}
		}
	}
}

function ArealRenderer_setSelectable(value) {
	if(value) {
		this.setProperty('stroke',3);
		this.setProperty('color','none');
		this.setProperty('fill','none');
	}
}

function ArealRenderer_clone() {
	var result=new ArealRenderer();
	this.copyProperties(result);
	return result;
}

function ArealRenderer_getPointerEvents() {
	return 'fill';
}

function ArealRenderer() {
	this.initRenderer();
	this.manageableProperties['stroke']='stroke';
	this.manageableProperties['color']='color';
	this.manageableProperties['fill']='color';
	this.manageableProperties['fillpattern']='pattern';
}

ArealRenderer.prototype.setProperty=Renderer_setProperty;
ArealRenderer.prototype.getProperty=Renderer_getProperty;
ArealRenderer.prototype.setLayer=Renderer_setLayer;
ArealRenderer.prototype.init=Renderer_init;
ArealRenderer.prototype.hasChanged=Renderer_hasChanged;
ArealRenderer.prototype.hasThema=Renderer_hasThema;
ArealRenderer.prototype.initRenderer=Renderer_initRenderer;
ArealRenderer.prototype.setThematism=Renderer_setThematism;
ArealRenderer.prototype.getElementCount=Renderer_getElementCount;
ArealRenderer.prototype.hasManageableProperty=Renderer_hasManageableProperty;
ArealRenderer.prototype.draw=ArealRenderer_draw;
ArealRenderer.prototype.updateObject=ArealRenderer_updateObject;
ArealRenderer.prototype.getSample=ArealRenderer_getSample;
ArealRenderer.prototype.staticFill=ArealRenderer_staticFill;
ArealRenderer.prototype.dynamicFill=ArealRenderer_dynamicFill;
ArealRenderer.prototype.solidFill=ArealRenderer_solidFill;
ArealRenderer.prototype.clone=ArealRenderer_clone;
ArealRenderer.prototype.copyProperties=Renderer_copyProperties;
ArealRenderer.prototype.setSelectable=ArealRenderer_setSelectable;
ArealRenderer.prototype.getPointerEvents=ArealRenderer_getPointerEvents;

function PunctualRenderer_draw(layer,canvas) {
	if(this.getProperty('color') && !this.hasThema('color'))
		layer.implementation.setColor(canvas,this.getProperty('color'));
	
	if(this.getProperty('size') && !this.hasThema('size'))
		layer.implementation.setSize(canvas,parseInt(this.getProperty('size')));
}

function PunctualRenderer_updateObject(renderable,layer) {
	if(this.hasThema('color')) {
		layer.implementation.setObjectColor(renderable.object,this.thematism.themas['color'].process(renderable.properties));
	}
	if(this.hasThema('size')) {
		layer.implementation.setObjectSize(renderable.object,this.thematism.themas['size'].process(renderable.properties));
	}
}

function PunctualRenderer_getSample(format,width,height) {
	if(format=='VML') {
		if(this.dynamic) {
			var dim=width;
			if(height<width)
				dim=height;
			dim=Math.floor(1/3*dim);
			var posx=Math.floor((width-dim-parseInt(this.getProperty('size')-1)*2)/2);
			var posx1=posx-width/4;
			var posx2=posx+width/4;
			var posy=Math.floor((height-dim-parseInt(this.getProperty('size')-1)*2)/2);
			var html='<v:oval style="position:absolute;left:'+posx1+'px;top:'+posy+'px;width:'+(5+parseInt(this.getProperty('size')))+'px;height:'+(5+parseInt(this.getProperty('size')))+'px"><v:fill color="red"/><v:stroke color="red" weight="1"/></v:oval>';
			html+='<v:oval style="position:absolute;left:'+posx2+'px;top:'+posy+'px;width:'+(5+parseInt(this.getProperty('size')))+'px;height:'+(5+parseInt(this.getProperty('size')))+'px"><v:fill color="blue"/><v:stroke color="blue" weight="1"/></v:oval>';
			return html;
		} else {
			var dim=width;
			if(height<width)
				dim=height;
			dim=Math.floor(1/3*dim);
			
			var posx=Math.floor((width-dim-parseInt(this.getProperty('size')-1)*2)/2);
			var posy=Math.floor((height-dim-parseInt(this.getProperty('size')-1)*2)/2);
			
			return '<v:oval style="position:absolute;left:'+posx+'px;top:'+posy+'px;width:'+(5+parseInt(this.getProperty('size')))+'px;height:'+(5+parseInt(this.getProperty('size')))+'px"><v:fill color="'+this.getProperty('color')+'"/><v:stroke color="'+this.getProperty('color')+'" weight="1"/></v:oval>';
		}
	}
}

function PunctualRenderer_setSelectable(value) {
	if(value) {
		this.setProperty('opacity',1);
		this.setProperty('size',2);
	}
}

function PunctualRenderer_clone() {
	var result=new PunctualRenderer();
	this.copyProperties(result);
	return result;
}

function PunctualRenderer_getPointerEvents() {
	return 'fill';
}

function PunctualRenderer() {
	this.initRenderer();
	this.manageableProperties['color']='color';
	this.manageableProperties['size']='number,1,4';
}

PunctualRenderer.prototype.setProperty=Renderer_setProperty;
PunctualRenderer.prototype.getProperty=Renderer_getProperty;
PunctualRenderer.prototype.setLayer=Renderer_setLayer;
PunctualRenderer.prototype.init=Renderer_init;
PunctualRenderer.prototype.hasChanged=Renderer_hasChanged;
PunctualRenderer.prototype.hasThema=Renderer_hasThema;
PunctualRenderer.prototype.initRenderer=Renderer_initRenderer;
PunctualRenderer.prototype.setThematism=Renderer_setThematism;
PunctualRenderer.prototype.getElementCount=Renderer_getElementCount;
PunctualRenderer.prototype.hasManageableProperty=Renderer_hasManageableProperty;
PunctualRenderer.prototype.draw=PunctualRenderer_draw;
PunctualRenderer.prototype.updateObject=PunctualRenderer_updateObject;
PunctualRenderer.prototype.getSample=PunctualRenderer_getSample;
PunctualRenderer.prototype.clone=PunctualRenderer_clone;
PunctualRenderer.prototype.copyProperties=Renderer_copyProperties;
PunctualRenderer.prototype.setSelectable=PunctualRenderer_setSelectable;
PunctualRenderer.prototype.getPointerEvents=PunctualRenderer_getPointerEvents;

function RasterRenderer_draw(layer,canvas) {
	// NOTHING TO DO
}

function RasterRenderer_updateObject(renderable,layer) {
	// NOTHING TO DO
}

function RasterRenderer_getSample(format,width,height) {
	if(format=='VML')
		return '<img src="images/raster.gif" width="'+width+'" height="'+height+'" style="position:absolute;left:1px;top:1px">';
}

function RasterRenderer_clone() {
	var result=new RasterRenderer();
	this.copyProperties(result);
	return result;
}

function RasterRenderer() {
	this.initRenderer();
}

RasterRenderer.prototype.setProperty=Renderer_setProperty;
RasterRenderer.prototype.getProperty=Renderer_getProperty;
RasterRenderer.prototype.setLayer=Renderer_setLayer;
RasterRenderer.prototype.init=Renderer_init;
RasterRenderer.prototype.hasChanged=Renderer_hasChanged;
RasterRenderer.prototype.hasThema=Renderer_hasThema;
RasterRenderer.prototype.initRenderer=Renderer_initRenderer;
RasterRenderer.prototype.setThematism=Renderer_setThematism;
RasterRenderer.prototype.hasManageableProperty=Renderer_hasManageableProperty;
RasterRenderer.prototype.getElementCount=Renderer_getElementCount;
RasterRenderer.prototype.draw=RasterRenderer_draw;
RasterRenderer.prototype.updateObject=RasterRenderer_updateObject;
RasterRenderer.prototype.getSample=RasterRenderer_getSample;
RasterRenderer.prototype.clone=RasterRenderer_clone;
RasterRenderer.prototype.copyProperties=Renderer_copyProperties;

function Renderable(object,properties) {
	this.object=object;
	this.properties=properties;
}

function ValuesThema_process(objectProperties) {
	return this.values[objectProperties[this.property]];
}

function ValuesThema_addValue(value,propertyValue) {
	this.values[value]=propertyValue;
}

function ValuesThema(property) {
	this.property=property;
	this.values=new Array();
}

ValuesThema.prototype.addValue=ValuesThema_addValue;
ValuesThema.prototype.process=ValuesThema_process;

function Thematism_addThema(property,thema) {
	this.themas[property]=thema;
}

function Thematism_addDescription(propertyComb,description) {
	this.propertiesOrder.push(propertyComb);
	this.descriptions[propertyComb]=description;
}

function Thematism_getDescription(propertyComb) {
	return this.descriptions[propertyComb];
}

function Thematism_getPropertyList() {
	return this.propertiesOrder;
}

function Thematism() {
	this.propertiesOrder=new Array();
	this.themas=new Array();
	this.descriptions=new Array();
}

Thematism.prototype.addThema=Thematism_addThema;
Thematism.prototype.addDescription=Thematism_addDescription;
Thematism.prototype.getDescription=Thematism_getDescription;
Thematism.prototype.getPropertyList=Thematism_getPropertyList;

//---------------------------------------------------------------------------------------------------------------------------
function RangeThema_process(objectProperties) {
	for(var i=0;i<this.ranges;i++)
	{
		if (this.dataProvider)
		{
			var value=null;
			var ar=this.dataProvider.getValues('THEMADATASET');
			for(v in ar)
			{
				var el=ar[v];
				var a=el.split('=');
			
				if (value==null)
					value=a[0];
						
				if (a[0]==objectProperties[this.property])
					value=a[1];
			}
			
			if (value>=this.rangeMin[i] && value<=this.rangeMax[i])
			{
				return this.values[i];
			}
		}
		else
		{
		if (objectProperties[this.property]>=this.rangeMin[i] && objectProperties[this.property]<=this.rangeMax[i])
		{
			return this.values[i];
		}
	}
}
}

function RangeThema_addValue(valueMin,valueMax,propertyValue) {
	this.rangeMin[this.ranges]=valueMin;
	this.rangeMax[this.ranges]=valueMax;
	this.values[this.ranges]=propertyValue;
	this.ranges++;
}

function RangeThema(property,dataProvider) {
	this.property=property;
	this.rangeMin=new Array();
	this.rangeMax=new Array();
	this.values=new Array();
	this.ranges=0;
	this.dataProvider=dataProvider;
}

RangeThema.prototype.addValue=RangeThema_addValue;
RangeThema.prototype.process=RangeThema_process;

//----------------------------------------------------------------------------------------------------------------------------
function DataProvider() {
	this.values=new Array();
	this.values['SINGLEDATASET']=new Array('A=10','B=30','C=50','D=5','E=5');
}

function DataProvider_getValues(id)
{
	if (this.values[id])
	{
		return this.values[id];
	}
	else
		return 0;
}
function DataProvider_setValues(id,array)
{
//	alert('SET: '+id+','+array.length);
	this.values[id]=array;
}
DataProvider.prototype.getValues=DataProvider_getValues;
DataProvider.prototype.setValues=DataProvider_setValues;

//----------------------------------------------------------------------------------------------------------------------------

function SequentialColorManager(colors) {
	this.colorPointer=0;
    this.colors=colors;
}

function SequentialColorManager_init() {
	this.colorPointer=0;
}

function SequentialColorManager_nextColor(renderable) {
	if (this.colorPointer<this.colors.length)
	{
		this.colorPointer++;
		
	}
	else
	{
		// temporary : circular buffer
		this.colorPointer=1;
	}
	return this.colors[this.colorPointer-1];
	
}

SequentialColorManager.prototype.init=SequentialColorManager_init;
SequentialColorManager.prototype.nextColor=SequentialColorManager_nextColor;
//--------------------------------------------------------------------------------------------------------------

function PieRenderer_draw(layer,canvas) {
	// nothing to do.
}

function PieRenderer_updateObject(renderable,layer) {
	var values=this.dataProvider.getValues('100');

	var node=renderable.object;
	var id=node.getAttribute('id');
	var values=this.dataProvider.getValues(id);
	alert(id,values.length);
	if(node.getNodeType()==1) {
		var bbox=layer.getBBox(id);
		if (bbox!=null)
			bbox=bbox[1];
		if (bbox!=null)
		{
			var cx=bbox.x+bbox.width/2;
			var cy=bbox.y+bbox.height/2;
			var SVGDoc=node.getOwnerDocument();
			var parent=node.getParentNode();
	

			parent.removeChild(node);

			var r=this.size/2;
			var total=0;
			for(var pos2 in values)
			total += parseFloat(values[pos2].substring(values[pos2].indexOf('=')+1));
			var startangle=0;
			var partialPerc=0;
			var partial=0;
							
			this.colorManager.init();

			for(var pos2 in values) {
				var cat=values[pos2].substring(0,values[pos2].indexOf('='));
				var val=parseFloat(values[pos2].substring(values[pos2].indexOf('=')+1));
				var perc=parseInt(parseFloat(val)/total*100);
				var value=parseInt(perc/100*360);

				if(pos2<values.length-1) {
					partialPerc+=perc;
					partial+=value;
				} else {
					perc=100-partialPerc;
					value=360-partial;
				}

				var a1=deg2rad(startangle);
				var a2=deg2rad(startangle+value);
				var fa=0;
				if(Math.abs(value)>180)
				fa=1;
				var fs=1;
				var x1=r*Math.cos(a1)+cx;
				var y1=r*Math.sin(a1)+cy;

				var x2=r*Math.cos(a2)+cx;
				var y2=r*Math.sin(a2)+cy;
				var arc;
				if(perc==100) {
					arc=SVGDoc.createElement('circle');
					arc.setAttribute("cx",cx);
					arc.setAttribute("cy",cy);
					arc.setAttribute("r",r);

				} else {
					arc=SVGDoc.createElement('path');
					arc.setAttribute("d","M "+cx+","+cy+" L "+x1+","+y1+" A "+r+","+r+" 0 "+fa+","+fs+" "+x2+","+y2+" z");
				}
				var color=this.colorManager.nextColor(renderable);
				arc.setAttribute("fill",color);
				arc.setAttribute("stroke",color);
				arc.setAttribute("stroke-width",0.1);
				arc.setAttribute('gmwmsvg:tt',cat+' - '+perc+'%');
				if(perc!=0)
				parent.appendChild(arc);
				startangle+=value;
			}
		}
	}
}


function PieRenderer_getSample(format,width,height) {
        if(format=='VML') {
                var html='<v:rect fillcolor="white" style="position:absolute;top:0px;left:0px;width:'+(width+1)+'px;height:'+(height+1)+'px"/>';

                html+='<v:arc style="position:absolute;left:0px;top:1px;width:'+width+'px;height:'+height+'px" startangle="0" endangle="180"><v:stroke color="red" weight="1"/><v:fill color="red"></v:fill></v:arc><v:arc style="position:absolute;left:0px;top:1px;width:'+width+'px;height:'+height+'px" startangle="180" endangle="360"><v:stroke color="yellow" weight="1"/><v:fill color="yellow"></v:fill></v:arc><v:arc style="position:absolute;left:0px;top:1px;width:'+width+'px;height:'+height+'px" startangle="45" endangle="225"><v:stroke color="blue" weight="1"/><v:fill color="blue"></v:fill></v:arc>';

                return html;
        }
        return '';
}




function PieRenderer_setSelectable(value) {
	// NOTHING TO DO
}

function PieRenderer_clone() {
	var result=new PieRenderer();
	this.copyProperties(result);
	return result;
}

function PieRenderer_getPointerEvents() {
	return 'fill';
}

function PieRenderer() {
	this.initRenderer();
	this.dynamic=true;
	this.dataProvider=null;
	this.colorManager=null;
	this.size=300;

////////////////// TEMPORANEO //////////////////
	/*this.dataProvider=new DataProvider();
	this.colorManager=new ColorManager();*/
////////////////// TEMPORANEO //////////////////
}

function PieRenderer_setSize(size) {
	this.size=size;
}

function PieRenderer_setColorManager(cm) {
	this.colorManager=cm;
}

function PieRenderer_setDataProvider(dp) {
	this.dataProvider=dp;
}

PieRenderer.prototype.setProperty=Renderer_setProperty;
PieRenderer.prototype.getProperty=Renderer_getProperty;
PieRenderer.prototype.setLayer=Renderer_setLayer;
PieRenderer.prototype.init=Renderer_init;
PieRenderer.prototype.hasChanged=Renderer_hasChanged;
PieRenderer.prototype.hasThema=Renderer_hasThema;
PieRenderer.prototype.initRenderer=Renderer_initRenderer;
PieRenderer.prototype.setThematism=Renderer_setThematism;
PieRenderer.prototype.getElementCount=Renderer_getElementCount;
PieRenderer.prototype.hasManageableProperty=Renderer_hasManageableProperty;
PieRenderer.prototype.draw=PieRenderer_draw;
PieRenderer.prototype.updateObject=PieRenderer_updateObject;
PieRenderer.prototype.getSample=PieRenderer_getSample;
PieRenderer.prototype.clone=PieRenderer_clone;
PieRenderer.prototype.copyProperties=Renderer_copyProperties;
PieRenderer.prototype.setSelectable=PieRenderer_setSelectable;
PieRenderer.prototype.getPointerEvents=PieRenderer_getPointerEvents;
PieRenderer.prototype.setDataProvider=PieRenderer_setDataProvider;
PieRenderer.prototype.setColorManager=PieRenderer_setColorManager;
PieRenderer.prototype.setSize=PieRenderer_setSize;


//--------------------------------------------------------------------------------------------------------------

function HistogramRenderer_draw(layer,canvas) {
}


function HistogramRenderer_updateObject(renderable,layer) {
	var values=this.dataProvider.getValues('100');

	var node=renderable.object;
	var id=node.getAttribute('id');
	var values=this.dataProvider.getValues(id);
	if(node.getNodeType()==1) {
		var bbox=layer.getBBox(id);
		if (bbox!=null)
			bbox=bbox[1];
		if (bbox!=null)
		{
			var cx=bbox.x+bbox.width/2;
			var cy=bbox.y+bbox.height/2;
			var SVGDoc=node.getOwnerDocument();
			var parent=node.getParentNode();
	

			parent.removeChild(node);

			var allWidth=300;

			var rectH=this.size; // 67;
			var allWidth=rectH*4; // 300;

/*			var max=0.0;
			for(var c in values)
				if (parseFloat(values[c].substring(values[c].indexOf('=')+1))>max)
					max=parseFloat(values[c].substring(values[c].indexOf('=')+1));

*/
			var rectW=allWidth/values.length;
			var startX=cx-(rectW*values.length/2.0);

			this.colorManager.init();

			for(var count in values) {
				var cat=values[count].substring(0,values[count].indexOf('='));
				var val=parseFloat(values[count].substring(values[count].indexOf('=')+1));
				
				var value=parseInt(val/100*rectH);
//				var value=parseInt(rectH*val/max);
				
				var rect=SVGDoc.createElement('rect');
				rect.setAttribute("x",startX+count*rectW);
				rect.setAttribute("y",cy-value);
				rect.setAttribute("width",rectW);
				rect.setAttribute("height",parseInt(value));
				rect.setAttribute("fill",this.colorManager.nextColor(renderable));
				rect.setAttribute("stroke-width",0.1);
				rect.setAttribute('gmwmsvg:tt',cat+' - '+val+'');
				parent.appendChild(rect);
			}
		}
	}
}

function HistogramRenderer_getSample(format,width,height) {
        if(format=='VML') {
                var html='<v:rect fillcolor="white" style="position:absolute;top:0px;left:0px;width:'+(width+1)+'px;height:'+(height+1)+'px"/>';

                html+='<v:rect fillcolor="red" style="position:absolute;top:'+((height)/2-(height-4)/4)+'px;left:2px;width:'+((width-4)/3)+'px;height:'+((height-4)/2)+'px"/><v:rect fillcolor="green" style="position:absolute;top:2px;left:'+((width-4)/3+2)+'px;width:'+((width-4)/3)+'px;height:'+(height-4)+'px"/><v:rect fillcolor="blue" style="position:absolute;top:'+((height)/2-(height-4)/8)+'px;left:'+(2*(width-4)/3+2)+'px;width:'+((width-4)/3)+'px;height:'+((height-4)/4)+'px"/>';

                return html;
        }
        return '';

} 

function HistogramRenderer_setSelectable(value) {
	// NOTHING TO DO
}

function HistogramRenderer_clone() {
	var result=new HistogramRenderer();
	this.copyProperties(result);
	return result;
}

function HistogramRenderer_getPointerEvents() {
	return 'fill';
}

function HistogramRenderer() {
	this.initRenderer();
	this.dynamic=true;
	this.dataProvider=null;
	this.colorManager=null;
	this.size=300;

////////////////// TEMPORANEO //////////////////
	/*this.dataProvider=new DataProvider();
	this.colorManager=new ColorManager();*/
////////////////// TEMPORANEO //////////////////
}

function HistogramRenderer_setColorManager(cm) {
	this.colorManager=cm;
}

function HistogramRenderer_setDataProvider(dp) {
	this.dataProvider=dp;
}

function HistogramRenderer_setSize(size) {
	this.size=size;
}

HistogramRenderer.prototype.setProperty=Renderer_setProperty;
HistogramRenderer.prototype.getProperty=Renderer_getProperty;
HistogramRenderer.prototype.setLayer=Renderer_setLayer;
HistogramRenderer.prototype.init=Renderer_init;
HistogramRenderer.prototype.hasChanged=Renderer_hasChanged;
HistogramRenderer.prototype.hasThema=Renderer_hasThema;
HistogramRenderer.prototype.initRenderer=Renderer_initRenderer;
HistogramRenderer.prototype.setThematism=Renderer_setThematism;
HistogramRenderer.prototype.getElementCount=Renderer_getElementCount;
HistogramRenderer.prototype.hasManageableProperty=Renderer_hasManageableProperty;
HistogramRenderer.prototype.draw=HistogramRenderer_draw;
HistogramRenderer.prototype.updateObject=HistogramRenderer_updateObject;
HistogramRenderer.prototype.getSample=HistogramRenderer_getSample;
HistogramRenderer.prototype.clone=HistogramRenderer_clone;
HistogramRenderer.prototype.copyProperties=Renderer_copyProperties;
HistogramRenderer.prototype.setSelectable=HistogramRenderer_setSelectable;
HistogramRenderer.prototype.getPointerEvents=HistogramRenderer_getPointerEvents;
HistogramRenderer.prototype.setDataProvider=HistogramRenderer_setDataProvider;
HistogramRenderer.prototype.setColorManager=HistogramRenderer_setColorManager;
HistogramRenderer.prototype.setSize=HistogramRenderer_setSize;


//--------------------------------------------------------------------------------------------------------------

function deg2rad(deg) {
	return deg/180.0*Math.PI;
}