rgraph-rails 5.00 → 6.14

data/vendor/assets/javascripts/RGraph.gantt.js

@@ -1,83 +1,1647 @@
+'version:2023-09-16 (6.14)';
+//
+    // o--------------------------------------------------------------------------------o
+    // | This file is part of the RGraph package - you can learn more at:               |
+    // |                                                                                |
+    // |                         https://www.rgraph.net                                 |
+    // |                                                                                |
+    // | RGraph is licensed under the Open Source MIT license. That means that it's     |
+    // | totally free to use and there are no restrictions on what you can do with it!  |
+    // o--------------------------------------------------------------------------------o
 
-RGraph=window.RGraph||{isRGraph:true};RGraph.Gantt=function(conf)
-{if(typeof conf==='object'&&typeof conf.data==='object'&&typeof conf.id==='string'){var id=conf.id
-var canvas=document.getElementById(id);var data=conf.data;var parseConfObjectForOptions=true;}else{var id=conf;var canvas=document.getElementById(id);var data=arguments[1];}
-this.id=id;this.canvas=canvas;this.context=this.canvas.getContext?this.canvas.getContext("2d",{alpha:(typeof id==='object'&&id.alpha===false)?false:true}):null;this.canvas.__object__=this;this.type='gantt';this.isRGraph=true;this.uid=RGraph.CreateUID();this.canvas.uid=this.canvas.uid?this.canvas.uid:RGraph.CreateUID();this.data=data;this.colorsParsed=false;this.coordsText=[];this.original_colors=[];this.firstDraw=true;this.propertyNameAliases={};this.properties={'chart.background.bars.count':null,'chart.background.bars.color1':'rgba(0,0,0,0)','chart.background.bars.color2':'rgba(0,0,0,0)','chart.background.grid':true,'chart.background.grid.linewidth':1,'chart.background.grid.color':'#ddd','chart.background.grid.hsize':20,'chart.background.grid.vsize':20,'chart.background.grid.hlines':true,'chart.background.grid.vlines':true,'chart.background.grid.border':true,'chart.background.grid.align':true,'chart.background.grid.autofit':true,'chart.background.grid.autofit.align':true,'chart.background.grid.hlines.count':null,'chart.background.grid.vlines.count':null,'chart.background.vbars':[],'chart.background.hbars':[],'chart.text.size':12,'chart.text.font':'Arial, Verdana, sans-serif','chart.text.color':'black','chart.text.bold':false,'chart.text.italic':false,'chart.text.accessible':true,'chart.text.accessible.overflow':'visible','chart.text.accessible.pointerevents':false,'chart.margin.left':75,'chart.margin.right':25,'chart.margin.top':35,'chart.margin.bottom':25,'chart.labels.inbar':null,'chart.labels.inbar.bgcolor':null,'chart.labels.inbar.align':'left','chart.labels.inbar.size':null,'chart.labels.inbar.font':null,'chart.labels.inbar.color':null,'chart.labels.inbar.bold':null,'chart.labels.inbar.italic':null,'chart.labels.inbar.above':false,'chart.labels.complete':true,'chart.labels.complete.font':null,'chart.labels.complete.size':null,'chart.labels.complete.color':null,'chart.labels.complete.bold':null,'chart.labels.complete.italic':null,'chart.vmargin':2,'chart.title':'','chart.title.background':null,'chart.title.x':null,'chart.title.y':null,'chart.title.bold':null,'chart.title.italic':null,'chart.title.font':null,'chart.title.size':null,'chart.title.color':null,'chart.title.halign':null,'chart.title.valign':null,'chart.yaxis.labels.font':null,'chart.yaxis.labels.size':null,'chart.yaxis.labels.color':null,'chart.yaxis.labels.bold':null,'chart.yaxis.labels.italic':null,'chart.yaxis.title':'','chart.yaxis.title.bold':null,'chart.yaxis.title.italic':null,'chart.yaxis.title.font':null,'chart.yaxis.title.size':null,'chart.yaxis.title.color':null,'chart.yaxis.title.pos':null,'chart.yaxis.title.position':'right','chart.yaxis.title.x':null,'chart.yaxis.title.y':null,'chart.xaxis.labels':[],'chart.xaxis.labels.font':null,'chart.xaxis.labels.size':null,'chart.xaxis.labels.color':null,'chart.xaxis.labels.bold':null,'chart.xaxis.labels.italic':null,'chart.xaxis.labels.align':'bottom','chart.xaxis.title':'','chart.xaxis.title.x':null,'chart.xaxis.title.y':null,'chart.xaxis.title.bold':null,'chart.xaxis.title.color':null,'chart.xaxis.title.font':null,'chart.xaxis.title.size':null,'chart.xaxis.title.italic':null,'chart.xaxis.scale.min':0,'chart.xaxis.scale.max':0,'chart.colors.default':'white','chart.borders':true,'chart.coords':[],'chart.tooltips':null,'chart.tooltips.effect':'fade','chart.tooltips.css.class':'RGraph_tooltip','chart.tooltips.highlight':true,'chart.tooltips.event':'onclick','chart.highlight.stroke':'rgba(0,0,0,0)','chart.highlight.fill':'rgba(255,255,255,0.7)','chart.contextmenu':null,'chart.annotatable':false,'chart.annotatable.color':'black','chart.resizable':false,'chart.resizable.handle.adjust':[0,0],'chart.resizable.handle.background':null,'chart.adjustable':false,'chart.adjustable.only':null,'chart.events.click':null,'chart.events.mousemove':null,'chart.clearto':'rgba(0,0,0,0)'}
-if(!data){alert('[GANTT] The Gantt chart event data is now supplied as the second argument to the constructor - please update your code');}else{for(var i=0,idx=0;i<data.length;++i){if(typeof data[i].start==='string')data[i].start=parseFloat(data[i].start);if(typeof data[i].duration==='string')data[i].duration=parseFloat(data[i].duration);if(typeof data[i].complete==='string')data[i].complete=parseFloat(data[i].complete);if(typeof data[i].linewidth==='string')data[i].linewidth=parseFloat(data[i].linewidth);}}
-for(var i=0,idx=0;i<data.length;++i){if(RGraph.isArray(this.data[i][0])){for(var j=0;j<this.data[i].length;++j){this['$'+(idx++)]={};}}else{this['$'+(idx++)]={};}}
-if(!this.canvas.__rgraph_aa_translated__){this.context.translate(0.5,0.5);this.canvas.__rgraph_aa_translated__=true;}
-var RG=RGraph,ca=this.canvas,co=ca.getContext('2d'),prop=this.properties,pa2=RG.path2,win=window,doc=document,ma=Math
-if(RG.Effects&&typeof RG.Effects.decorate==='function'){RG.Effects.decorate(this);}
-this.set=this.Set=function(name)
-{var value=typeof arguments[1]==='undefined'?null:arguments[1];if(arguments.length===1&&typeof name==='object'){RG.parseObjectStyleConfig(this,name);return this;}
-if(name.substr(0,6)!='chart.'){name='chart.'+name;}
-while(name.match(/([A-Z])/)){name=name.replace(/([A-Z])/,'.'+RegExp.$1.toLowerCase());}
-if(name=='chart.margin'){name='chart.vmargin'}
-if(name=='chart.events'){alert('[GANTT] The chart.events property is deprecated - supply the events data as an argument to the constructor instead');this.data=value;}
-prop[name]=value;return this;};this.get=this.Get=function(name)
-{if(name.substr(0,6)!='chart.'){name='chart.'+name;}
-while(name.match(/([A-Z])/)){name=name.replace(/([A-Z])/,'.'+RegExp.$1.toLowerCase());}
-if(name=='chart.margin'){name='chart.vmargin'}
-return prop[name.toLowerCase()];};this.draw=this.Draw=function()
-{RG.fireCustomEvent(this,'onbeforedraw');this.marginLeft=prop['chart.margin.left'];this.marginRight=prop['chart.margin.right'];this.marginTop=prop['chart.margin.top'];this.marginBottom=prop['chart.margin.bottom'];this.coordsText=[];if(!this.colorsParsed){this.parseColors();this.colorsParsed=true;}
-this.graphArea=ca.width-this.marginLeft-this.marginRight;this.graphHeight=ca.height-this.marginTop-this.marginBottom;this.numEvents=this.data.length
-this.barHeight=this.graphHeight/this.numEvents;this.halfBarHeight=this.barHeight/2;if(RG.isNull(prop['chart.background.grid.hlines.count'])){this.set('chart.background.grid.hlines.count',this.data.length);}
-RG.Background.draw(this);this.drawLabels();this.drawEvents();if(prop['chart.contextmenu']){RG.showContext(this);}
-if(prop['chart.resizable']){RG.allowResizing(this);}
-RG.installEventListeners(this);if(this.firstDraw){this.firstDraw=false;RG.fireCustomEvent(this,'onfirstdraw');this.firstDrawFunc();}
-RG.fireCustomEvent(this,'ondraw');return this;};this.exec=function(func)
-{func(this);return this;};this.drawLabels=this.DrawLabels=function()
-{var labels=prop['chart.xaxis.labels'],labelsColor=prop['chart.xaxis.labels.color']||prop['chart.text.color'],labelSpace=(this.graphArea)/labels.length,x=this.marginLeft+(labelSpace/2),y=this.marginTop-(prop['chart.text.size']/2)-5,font=prop['chart.text.font'],size=prop['chart.text.size'];co.beginPath();co.fillStyle=prop['chart.text.color'];co.strokeStyle='black'
-if(prop['chart.xaxis.labels.align']=='bottom'){y=ca.height-this.marginBottom+size+2;}
-var textConf=RG.getTextConf({object:this,prefix:'chart.xaxis.labels'});for(i=0;i<labels.length;++i){RG.text2(this,{font:textConf.font,size:textConf.size,color:textConf.color,bold:textConf.bold,italic:textConf.italic,x:x+(i*labelSpace),y:y,text:String(labels[i]),halign:'center',valign:'center',tag:'labels.horizontal'});}
-for(var i=0,len=this.data.length;i<len;++i){var ev=this.data[i],x=this.marginLeft,y=this.marginTop+this.halfBarHeight+(i*this.barHeight);co.fillStyle=labelsColor||prop['chart.text.color'];var label=RG.isArray(ev)?String(ev[0].label):String(ev.label);var textConf=RG.getTextConf({object:this,prefix:'chart.yaxis.labels'});if(label){RG.text2(this,{font:textConf.font,size:textConf.size,color:textConf.color,bold:textConf.bold,italic:textConf.italic,x:x-5,y:y,text:label,halign:'right',valign:'center',tag:'labels.vertical'});}}};this.drawEvents=this.DrawEvents=function()
-{var events=this.data;this.coords=[];if(prop['chart.background.vbars']){for(i=0,len=prop['chart.background.vbars'].length;i<len;++i){if(prop['chart.background.vbars'][i][0]+prop['chart.background.vbars'][i][1]>prop['chart.xaxis.scale.max']){prop['chart.background.vbars'][i][1]=364-prop['chart.background.vbars'][i][0];}
-var barX=this.marginLeft+(((prop['chart.background.vbars'][i][0]-prop['chart.xaxis.scale.min'])/(prop['chart.xaxis.scale.max']-prop['chart.xaxis.scale.min']))*this.graphArea),barY=this.marginTop,width=(this.graphArea/(prop['chart.xaxis.scale.max']-prop['chart.xaxis.scale.min']))*prop['chart.background.vbars'][i][1],height=ca.height-this.marginTop-this.marginBottom;if((barX+width)>(ca.width-this.marginRight)){width=ca.width-this.marginRight-barX;}
-co.fillStyle=prop['chart.background.vbars'][i][2];co.fillRect(barX,barY,width,height);}}
-if(prop['chart.background.hbars']){for(i=0,len=prop['chart.background.hbars'].length;i<len;++i){if(prop['chart.background.hbars'][i]){var barX=this.marginLeft,barY=((ca.height-this.marginTop-this.marginBottom)/this.data.length)*i+this.marginTop,width=this.graphArea,height=this.barHeight
-co.fillStyle=prop['chart.background.hbars'][i];co.fillRect(barX,barY,width,height);}}}
-var sequentialIndex=0;for(i=0;i<events.length;++i){if(typeof events[i].start==='number'){this.DrawSingleEvent(events[i],i,sequentialIndex++);}else{for(var j=0;j<events[i].length;++j){var subindex=j;this.DrawSingleEvent(events[i][j],i,sequentialIndex++,subindex);}}}};this.getShape=this.getBar=function(e)
-{e=RG.fixEventObject(e);var mouseXY=RG.getMouseXY(e),mouseX=mouseXY[0],mouseY=mouseXY[1];for(var i=0,len=this.coords.length;i<len;i++){var left=this.coords[i][0],top=this.coords[i][1],width=this.coords[i][2],height=this.coords[i][3];if(mouseX>=left&&mouseX<=(left+width)&&mouseY>=top&&mouseY<=(top+height)){var tooltip=RG.parseTooltipText(prop['chart.tooltips'],i);var ret={0:this,object:this,1:left,x:left,2:top,y:top,3:width,width:width,4:height,height:height,5:i,index:this.coords[i][4].index,subindex:(this.coords[i][4]&&typeof this.coords[i][4].subindex==='number'?this.coords[i][4].subindex:null),sequentialIndex:this.coords[i][5],tooltip:tooltip};return ret;}}};this.drawSingleEvent=this.DrawSingleEvent=function(ev,index,sequentialIndex)
-{ev.index=index;if(typeof arguments[3]==='number'){ev.subindex=arguments[3]}
-var min=prop['chart.xaxis.scale.min'];co.beginPath();co.strokeStyle='black';co.fillStyle=ev.color?ev.color:prop['chart.colors.default'];var barStartX=this.marginLeft+(((ev.start-min)/(prop['chart.xaxis.scale.max']-min))*this.graphArea),barStartY=this.marginTop+(index*this.barHeight),barWidth=(ev.duration/(prop['chart.xaxis.scale.max']-min))*this.graphArea;if((barStartX+barWidth)>(ca.width-this.marginRight)){barWidth=ca.width-this.marginRight-barStartX;}
-this.coords.push([barStartX,barStartY+prop['chart.vmargin'],barWidth,this.barHeight-(2*prop['chart.vmargin']),ev,sequentialIndex,]);if(prop['chart.borders']||typeof ev.border==='number'){co.strokeStyle=typeof(ev.border)==='string'?ev.border:'black';co.lineWidth=(typeof(ev.linewidth)==='number'?ev.linewidth:1);if(ev.linewidth!==0){co.strokeRect(barStartX,barStartY+prop['chart.vmargin'],barWidth,this.barHeight-(2*prop['chart.vmargin']));}}
-if(RG.isNull(ev.complete)){co.fillStyle=ev.color?ev.color:prop['chart.colors.default'];}else{co.fillStyle=ev.background?ev.background:prop['chart.colors.default'];}
-co.fillRect(barStartX,barStartY+prop['chart.vmargin'],barWidth,this.barHeight-(2*prop['chart.vmargin']));var complete=(ev.complete/100)*barWidth;if(typeof(ev.complete)==='number'){co.fillStyle=ev.color?ev.color:'#0c0';co.fillRect(barStartX,barStartY+prop['chart.vmargin'],(ev.complete/100)*barWidth,this.barHeight-(2*prop['chart.vmargin']));if(prop['chart.labels.complete']){co.beginPath();var textConf=RG.getTextConf({object:this,prefix:'chart.labels.complete'});RG.text2(this,{font:textConf.font,size:textConf.size,color:textConf.color,bold:textConf.bold,italic:textConf.italic,x:barStartX+barWidth+5,y:barStartY+this.halfBarHeight,text:String(ev.complete)+'%',valign:'center',tag:'labels.complete'});}}
-if(prop['chart.labels.inbar']&&prop['chart.labels.inbar'][sequentialIndex]){var label=String(prop['chart.labels.inbar'][sequentialIndex]),halign=prop['chart.labels.inbar.align']=='left'?'left':'center';halign=prop['chart.labels.inbar.align']=='right'?'right':halign;if(halign=='right'){var x=(barStartX+barWidth)-5;}else if(halign=='center'){var x=barStartX+(barWidth/2);}else{var x=barStartX+5;}
-if(prop['chart.labels.inbar.above']){x=barStartX+barWidth+5;halign='left';}
-var textConf=RG.getTextConf({object:this,prefix:'chart.labels.inbar'});co.fillStyle=prop['chart.labels.inbar.color'];RG.text2(this,{font:textConf.font,size:textConf.size,color:textConf.color,bold:textConf.bold,italic:textConf.italic,x:x,y:barStartY+this.halfBarHeight,text:label,valign:'center',halign:halign,bounding:typeof(prop['chart.labels.inbar.bgcolor'])=='string',boundingFill:typeof(prop['chart.labels.inbar.bgcolor'])==='string'?prop['chart.labels.inbar.bgcolor']:null,tag:'labels.inbar'});}};this.highlight=this.Highlight=function(shape)
-{if(typeof prop['chart.highlight.style']==='function'){(prop['chart.highlight.style'])(shape);}else{RG.Highlight.Rect(this,shape);}};this.getObjectByXY=function(e)
-{var mouseXY=RG.getMouseXY(e);if(mouseXY[0]>this.marginLeft&&mouseXY[0]<(ca.width-this.marginRight)&&mouseXY[1]>this.marginTop&&mouseXY[1]<(ca.height-this.marginBottom)){return this;}};this.adjusting_mousemove=this.Adjusting_mousemove=function(e)
-{if(prop['chart.adjustable']&&RG.Registry.get('chart.adjusting')&&RG.Registry.Get('chart.adjusting').uid==this.uid){var bar=RG.Registry.get('chart.adjusting.gantt');if(bar){var mouseXY=RG.getMouseXY(e),obj=RG.Registry.get('chart.adjusting.gantt')['object'],index=bar['index'],subindex=bar['subindex'],diff=((mouseXY[0]-RG.Registry.get('chart.adjusting.gantt')['mousex'])/(ca.width-obj.marginLeft-obj.marginRight))*prop['chart.xaxis.scale.max'],eventStart=RG.Registry.get('chart.adjusting.gantt')['event_start'],duration=RG.Registry.get('chart.adjusting.gantt')['event_duration'],event=typeof subindex==='number'?obj.data[index][subindex]:obj.data[index]
-if(bar['mode']==='move'){diff=ma.round(diff);if(RG.isNull(subindex)){event.start=eventStart+diff;if(eventStart+diff<0){obj.data[index].start=0;}else if((eventStart+diff+obj.data[index].duration)>prop['chart.xaxis.scale.max']){obj.data[index].start=prop['chart.xaxis.scale.max']-obj.data[index].duration;}}else{var index=RG.Registry.get('chart.adjusting.gantt').index,subindex=RG.Registry.get('chart.adjusting.gantt').subindex,event=this.data[index][subindex];event.start=eventStart+diff;if((eventStart+diff)<0){event.start=0;}else if((eventStart+diff+event.duration)>prop['chart.xaxis.scale.max']){event.start=prop['chart.xaxis.scale.max']-event.duration;}}}else if(bar['mode']=='resize'){if(mouseXY[0]>(ca.width-obj.marginRight)){mouseXY[0]=ca.width-obj.marginRight;}
-var diff=((mouseXY[0]-RG.Registry.get('chart.adjusting.gantt')['mousex'])/(ca.width-obj.marginLeft-obj.marginRight))*prop['chart.xaxis.scale.max'];diff=ma.round(diff);if(RG.isNull(subindex)){obj.data[index].duration=duration+diff;if(obj.data[index].duration<0){obj.data[index].duration=1;}}else{obj.data[index][subindex].duration=duration+diff;if(obj.data[index][subindex].duration<0){obj.data[index][subindex].duration=1;}}}
-RG.resetColorsToOriginalValues(this);RG.redrawCanvas(ca);RG.fireCustomEvent(obj,'onadjust');}}};this.getXCoord=function(value)
-{var min=prop['chart.xaxis.scale.min'],max=prop['chart.xaxis.scale.max'],graphArea=ca.width-this.marginLeft-this.marginRight;if(value>max||value<min){return null;}
-var x=(((value-min)/(max-min))*graphArea)+this.marginLeft;return x;};this.getValue=function(arg)
-{if(arg.length==2){var mouseXY=arg;}else{var mouseXY=RGraph.getMouseXY(arg);}
-var mouseX=mouseXY[0],mouseY=mouseXY[1];var value=(mouseX-this.marginLeft)/(ca.width-this.marginLeft-this.marginRight);value*=(prop['chart.xaxis.scale.max']-prop['chart.xaxis.scale.min']);if(value<prop['chart.xaxis.scale.min']||value>prop['chart.xaxis.scale.max']){value=null;}
-return value;};this.parseColors=function()
-{if(this.original_colors.length===0){this.original_colors['data']=RG.arrayClone(this.data);this.original_colors['chart.background.bars.color1']=RG.arrayClone(prop['chart.background.bars.color1']);this.original_colors['chart.background.bars.color2']=RG.arrayClone(prop['chart.background.bars.color2']);this.original_colors['chart.background.grid.color']=RG.arrayClone(prop['chart.background.grid.color']);this.original_colors['chart.colors.default']=RG.arrayClone(prop['chart.colors.default']);this.original_colors['chart.highlight.stroke']=RG.arrayClone(prop['chart.highlight.stroke']);this.original_colors['chart.highlight.fill']=RG.arrayClone(prop['chart.highlight.fill']);}
-for(var i=0,sequentialIndex=0;i<this.data.length;++i){if(RG.isArray(this.data[i])&&typeof this.data[i][0]==='object'&&typeof this.data[i][0].start==='number'){for(var j=0,len=this.data[i].length;j<len;j+=1,sequentialIndex+=1){this.data[i][j].background=this.parseSingleColorForGradient(this.data[i][j].background,{start:this.data[i][j].start,duration:this.data[i][j].duration});this.data[i][j].color=this.parseSingleColorForGradient(this.data[i][j].color,{start:this.data[i][j].start,duration:this.data[i][j].duration});}}else{if(typeof this.data[i].background==='string'){this.data[i].background=this.parseSingleColorForGradient(this.data[i].background,{start:this.data[i].start,duration:this.data[i].duration});}
-if(typeof this.data[i].color==='string'){this.data[i].color=this.parseSingleColorForGradient(this.data[i].color,{start:this.data[i].start,duration:this.data[i].duration});}
-++sequentialIndex;}}
-prop['chart.background.bars.color1']=this.parseSingleColorForGradient(prop['chart.background.bars.color1']);prop['chart.background.bars.color2']=this.parseSingleColorForGradient(prop['chart.background.bars.color2']);prop['chart.background.grid.color']=this.parseSingleColorForGradient(prop['chart.background.grid.color']);prop['chart.background.color']=this.parseSingleColorForGradient(prop['chart.background.color']);prop['chart.colors.default']=this.parseSingleColorForGradient(prop['chart.colors.default']);prop['chart.highlight.stroke']=this.parseSingleColorForGradient(prop['chart.highlight.stroke']);prop['chart.highlight.fill']=this.parseSingleColorForGradient(prop['chart.highlight.fill']);};this.reset=function()
-{};this.parseSingleColorForGradient=function(color)
-{var opts=arguments[1]||{};if(!color||typeof(color)!='string'){return color;}
-if(color.match(/^gradient\((.*)\)$/i)){if(color.match(/^gradient\(({.*})\)$/i)){return RGraph.parseJSONGradient({object:this,def:RegExp.$1});}
-var parts=RegExp.$1.split(':'),value=(opts.start+opts.duration)>prop['chart.xaxis.scale.max']?prop['chart.xaxis.scale.max']:(opts.start+opts.duration);var grad=co.createLinearGradient(typeof opts.start==='number'?this.getXCoord(opts.start):this.marginLeft,0,typeof opts.start==='number'?this.getXCoord(value):ca.width-this.marginRight,0);var diff=1/(parts.length-1);grad.addColorStop(0,RG.trim(parts[0]));for(var j=1;j<parts.length;++j){grad.addColorStop(j*diff,RG.trim(parts[j]));}}
-return grad?grad:color;};this.on=function(type,func)
-{if(type.substr(0,2)!=='on'){type='on'+type;}
-if(typeof this[type]!=='function'){this[type]=func;}else{RG.addCustomEventListener(this,type,func);}
-return this;};this.firstDrawFunc=function()
-{};this.grow=function()
-{var obj=this,opt=arguments[0]||{},callback=arguments[1]?arguments[1]:function(){},canvas=obj.canvas,context=obj.context,numFrames=opt.frames||30,frame=0;original_events=RG.arrayClone(obj.data);function iterator()
-{RG.clear(obj.canvas);RG.redrawCanvas(obj.canvas);if(frame<=numFrames){for(var i=0,len=obj.data.length;i<len;++i){if(typeof obj.data[i]==='object'&&obj.data[i][0]&&typeof obj.data[i][0]==='object'){for(var j=0;j<obj.data[i].length;++j){obj.data[i][j].duration=(frame/numFrames)*original_events[i][j].duration;}}else{obj.data[i].duration=(frame/numFrames)*original_events[i].duration;}}
-obj.reset();frame++;RGraph.Effects.updateCanvas(iterator);}else{callback(obj);}}
-iterator();return this;};this.resetColorsToOriginalValues=function()
-{for(var i=0;i<this.original_colors['data'].length;++i){if(this.original_colors['data'][i].background){this.data[i].background=RG.arrayClone(this.original_colors['data'][i].background);}
-if(this.original_colors['data'][i].color){this.data[i].color=RG.arrayClone(this.original_colors['data'][i].color);}
-if(typeof this.original_colors['data'][i][0]==='object'&&typeof this.original_colors['data'][i][0].start==='number'){for(var j=0,len2=this.original_colors['data'][i].length;j<len2;++j){this.data[i][j].background=RG.arrayClone(this.original_colors['data'][i][j].background);this.data[i][j].color=RG.arrayClone(this.original_colors['data'][i][j].color);}}}};this.reset=function()
-{this.resetColorsToOriginalValues();this.colorsParsed=false;this.coordsText=[];this.original_colors=[];this.firstDraw=true;this.coords=[];};this.sequentialIndex2Grouped=function(){alert('[RGRAPH] Something went badly wrong - contact support');};this.isAdjustable=function(shape)
-{if(RG.isNull(prop['chart.adjustable.only'])){return true;}else if(RG.isArray(prop['chart.adjustable.only'])&&prop['chart.adjustable.only'][shape.sequentialIndex]){return true;}
-return false;};RG.Register(this);if(parseConfObjectForOptions){RG.parseObjectStyleConfig(this,conf.options);}};
+    RGraph = window.RGraph || {isrgraph:true,isRGraph:true,rgraph:true};
+
+    //
+    // The gantt chart constructor
+    //
+    RGraph.Gantt = function (conf)
+    {
+        var id     = conf.id
+        var canvas = document.getElementById(id);
+        var data   = conf.data;
+
+        this.id                     = id;
+        this.canvas                 = canvas;
+        this.context                = this.canvas.getContext ? this.canvas.getContext("2d", {alpha: (typeof id === 'object' && id.alpha === false) ? false : true}) : null;
+        this.canvas.__object__      = this;
+        this.type                   = 'gantt';
+        this.isRGraph               = true;
+        this.isrgraph               = true;
+        this.rgraph                 = true;
+        this.uid                    = RGraph.createUID();
+        this.canvas.uid             = this.canvas.uid ? this.canvas.uid : RGraph.createUID();
+        this.data                   = data;
+        this.original_data          = RGraph.arrayClone(data);
+        this.colorsParsed           = false;
+        this.coordsText             = [];
+        this.original_colors        = [];
+        this.firstDraw              = true; // After the first draw this will be false
+        this.stopAnimationRequested = false;// Used to control the animations
+
+        
+        // Set some defaults
+        this.properties =
+        {
+            backgroundBarsCount:    null,
+            backgroundBarsColor1:   'rgba(0,0,0,0)',
+            backgroundBarsColor2:   'rgba(0,0,0,0)',
+            backgroundGrid:        true,
+            backgroundGridLinewidth:  1,
+            backgroundGridColor:  '#ddd',
+            backgroundGridHsize:  20,
+            backgroundGridVsize:  20,
+            backgroundGridHlines: true,
+            backgroundGridVlines: true,
+            backgroundGridBorder: true,
+            backgroundGridAlign:  true,
+            backgroundGridAutofit:true,
+            backgroundGridAutofitAlign:true,
+            backgroundGridHlinesCount: null,
+            backgroundGridVlinesCount: null,
+            backgroundVbars:           [],
+            backgroundHbars:           [],
+
+            textSize:              12,
+            textFont:              'Arial, Verdana, sans-serif',
+            textColor:             'black',
+            textBold:              false,
+            textItalic:            false,
+            textAccessible:               false,
+            textAccessibleOverflow:      'visible',
+            textAccessiblePointerevents: false,
+            text:                        null,
+
+            marginLeft:            75,
+            marginRight:           35,
+            marginTop:             35,
+            marginBottom:          35,
+            marginInner:           2,
+
+            labelsInbar:            null,
+            labelsInbarBgcolor:     null,
+            labelsInbarAlign:       'left',
+            labelsInbarSize:        null,
+            labelsInbarFont:        null,
+            labelsInbarColor:       null,
+            labelsInbarBold:        null,
+            labelsInbarItalic:      null,
+            labelsInbarAbove:       false,
+            labelsInbarOffsetx:     0,
+            labelsInbarOffsety:     0,
+            labelsComplete:         true,
+            labelsCompleteFont:     null,
+            labelsCompleteSize:     null,
+            labelsCompleteColor:    null,
+            labelsCompleteBold:     null,
+            labelsCompleteItalic:   null,
+            labelsCompleteOffsetx:  0,
+            labelsCompleteOffsety:  0,
+
+            title:                  '',
+            titleX:                null,
+            titleY:                null,
+            titleBold:             null,
+            titleItalic:           null,
+            titleFont:             null,
+            titleSize:             null,
+            titleColor:            null,
+            titleHalign:           null,
+            titleValign:           null,
+            titleOffsetx:          0,
+            titleOffsety:          0,
+            titleSubtitle:        '',
+            titleSubtitleSize:    null,
+            titleSubtitleColor:   '#aaa',
+            titleSubtitleFont:    null,
+            titleSubtitleBold:    null,
+            titleSubtitleItalic:  null,
+            titleSubtitleOffsetx: 0,
+            titleSubtitleOffsety: 0,
+
+            xaxis:                      false,
+            xaxisLinewidth:             1,
+            xaxisColor:                 'black',
+            xaxisTickmarks:             true,
+            xaxisTickmarksLength:       3,
+            xaxisTickmarksLastLeft:     null,
+            xaxisTickmarksLastRight:    null,
+            xaxisTickmarksCount:        null,
+            xaxisLabels:                null,
+            xaxisLabelsSize:            null,
+            xaxisLabelsFont:            null,
+            xaxisLabelsItalic:          null,
+            xaxisLabelsBold:            null,
+            xaxisLabelsColor:           null,
+            xaxisLabelsOffsetx:         0,
+            xaxisLabelsOffsety:         0,
+            xaxisLabelsHalign:          null,
+            xaxisLabelsValign:          null,
+            xaxisLabelsPosition:        'section',
+            xaxisPosition:              'bottom',
+            xaxisLabelsAngle:           0,
+            xaxisTitle:                 null,
+            xaxisTitleBold:             null,
+            xaxisTitleSize:             null,
+            xaxisTitleFont:             null,
+            xaxisTitleColor:            null,
+            xaxisTitleItalic:           null,
+            xaxisTitlePos:              null,
+            xaxisTitleOffsetx:          0,
+            xaxisTitleOffsety:          0,
+            xaxisTitleX:                null,
+            xaxisTitleY:                null,
+            xaxisTitleHalign:           null,
+            xaxisTitleValign:           null,
+            xaxisScaleMin:              0,
+            xaxisScaleMax:              0,
+
+            yaxis:                    false,
+            yaxisColor:               'black',
+            yaxisLinewidth:           1,
+            yaxisTickmarks:           false,
+            yaxisTickmarksLength:     null,
+            yaxisTickmarksCount:      null,
+            yaxisTickmarksLastTop:    null,
+            yaxisTickmarksLastBottom: null,
+            yaxisScale:              false,
+            yaxisLabelsPosition:     'section',
+            yaxisLabels:          null, // This is populated when the chart is first drawn
+            yaxisLabelsFont:      null,
+            yaxisLabelsSize:      null,
+            yaxisLabelsColor:     null,
+            yaxisLabelsBold:      null,
+            yaxisLabelsItalic:    null,
+            yaxisLabelsOffsety:   0,
+            yaxisLabelsOffsetx:   0,
+            yaxisLabelsValign:    'center',
+            yaxisLabelsHalign:    'right',
+            yaxisTitle:            '',
+            yaxisTitleBold:       null,
+            yaxisTitleItalic:     null,
+            yaxisTitleFont:       null,
+            yaxisTitleSize:       null,
+            yaxisTitleColor:      null,
+            yaxisTitlePos:        null,
+            yaxisTitleOffsetx:    null,
+            yaxisTitleOffsety:    null,
+            yaxisTitleX:          null,
+            yaxisTitleY:          null,
+            yaxisTitleHalign:     null,
+            yaxisTitleValign:     null,
+            yaxisTitleAccessible: null,
+
+            colorsDefault:        'white',
+
+            borders:              true,
+
+            coords:                [],
+
+            tooltips:                   null,
+            tooltipsEffect:             'slide',
+            tooltipsCssClass:           'RGraph_tooltip',
+            tooltipsCss:                null,
+            tooltipsHighlight:          true,
+            tooltipsEvent:              'click',
+            tooltipsFormattedThousand:  ',',
+            tooltipsFormattedPoint:     '.',
+            tooltipsFormattedDecimals:  0,
+            tooltipsFormattedUnitsPre:  '',
+            tooltipsFormattedUnitsPost: '',
+            tooltipsFormattedTableHeaders: null,
+            tooltipsFormattedTableData: null,
+            tooltipsPointer:            true,
+            tooltipsPointerOffsetx:     0,
+            tooltipsPointerOffsety:     0,
+            tooltipsPositionStatic:     true,
+            tooltipsHotspotIgnore:      null,
+
+            highlightStroke:       'rgba(0,0,0,0)',
+            highlightFill:         'rgba(255,255,255,0.7)',
+
+            contextmenu:            null,
+            
+            annotatable:              false,
+            annotatableColor:         'black',
+            annotatableLinewidth:     1,
+            
+            adjustable:               false,
+            adjustableOnly:           null,
+            
+            clearto:                  'rgba(0,0,0,0)'
+        }
+
+
+        //
+        // Create the dollar objects so that functions can be added to them
+        //
+        if (!data) {
+            alert('[GANTT] The Gantt chart event data is now supplied as the second argument to the constructor - please update your code');
+        } else {
+            // Go through the data converting relevant args to numbers
+            for (var i=0,idx=0; i<data.length; ++i) {
+                if (typeof data[i].start     === 'string') data[i].start     = parseFloat(data[i].start);
+                if (typeof data[i].duration  === 'string') data[i].duration  = parseFloat(data[i].duration);
+                if (typeof data[i].complete  === 'string') data[i].complete  = parseFloat(data[i].complete);
+                if (typeof data[i].linewidth === 'string') data[i].linewidth = parseFloat(data[i].linewidth);
+            }
+        }
+        
+        // Linearize the data (DON'T use RGraph.arrayLinearize() here)
+        
+        // Initialise this
+        this.properties.yaxisLabels = [];
+
+        for (var i=0,idx=0; i<data.length; ++i) {
+            if (RGraph.isArray(this.data[i])) {
+                for (var j=0; j<this.data[i].length; ++j) {
+                    this.data[i][j].index   = j;
+                    this.data[i][j].dataset = i;
+                    this['$' + (idx++)] = this.data[i][j];
+                
+                    // Populate the label property
+                    if (this.data[i][j].label) {
+                        this.properties.yaxisLabels[i] = this.data[i][j].label;
+                    }
+                }
+            } else {
+
+                this.data[i].index   = 0;
+                this.data[i].dataset = i;
+                this['$' + (idx++)] = this.data[i];
+                
+                // Populate the label property
+                this.properties.yaxisLabels[i] = this.data[i].label;
+            }
+        }
+
+
+
+
+        // Easy access to  properties and the path function
+        var properties = this.properties;
+        this.path      = RGraph.pathObjectFunction;
+        
+        
+        
+        //
+        // "Decorate" the object with the generic effects if the effects library has been included
+        //
+        if (RGraph.Effects && typeof RGraph.Effects.decorate === 'function') {
+            RGraph.Effects.decorate(this);
+        }
+        
+        
+        
+        // Add the responsive method. This method resides in the common file.
+        this.responsive = RGraph.responsive;
+
+
+
+
+
+
+
+
+        //
+        // A setter
+        //
+        this.set = function (name)
+        {
+            var value = typeof arguments[1] === 'undefined' ? null : arguments[1];
+
+            // the number of arguments is only one and it's an
+            // object - parse it for configuration data and return.
+            if (arguments.length === 1 && typeof arguments[0] === 'object') {
+                for (i in arguments[0]) {
+                    if (typeof i === 'string') {
+                        this.set(i, arguments[0][i]);
+                    }
+                }
+
+                return this;
+            }
+
+            properties[name] = value;
+
+            return this;
+        };
+
+
+
+
+
+
+
+
+        //
+        // A peudo getter
+        // 
+        // @param name  string The name of the property to get
+        //
+        this.get = function (name)
+        {
+            return properties[name];
+        };
+
+
+
+
+
+
+
+
+        //
+        // Draws the chart
+        //
+        this.draw = function ()
+        {
+            //
+            // Fire the onbeforedraw event
+            //
+            RGraph.fireCustomEvent(this, 'onbeforedraw');
+
+
+
+            // Translate half a pixel for antialiasing purposes - but only if it hasn't been
+            // done already
+            //
+            // MUST be the first thing done!
+            //
+            if (!this.canvas.__rgraph_aa_translated__) {
+                this.context.translate(0.5,0.5);
+            
+                this.canvas.__rgraph_aa_translated__ = true;
+            }
+
+            //
+            // Make the margins easy ro access
+            //            
+            this.marginLeft   = properties.marginLeft;
+            this.marginRight  = properties.marginRight;
+            this.marginTop    = properties.marginTop;
+            this.marginBottom = properties.marginBottom;
+            
+            //
+            // Stop this growing uncntrollably
+            //
+            this.coordsText = [];
+    
+    
+            //
+            // Parse the colors. This allows for simple gradient syntax
+            //
+            if (!this.colorsParsed) {
+
+                this.parseColors();
+                
+                // Don't want to do this again
+                this.colorsParsed = true;
+            }
+
+            //
+            // Work out the graphArea
+            //
+            this.graphArea     = this.canvas.width - this.marginLeft - this.marginRight;
+            this.graphHeight   = this.canvas.height - this.marginTop - this.marginBottom;
+            this.numEvents     = this.data.length
+            this.barHeight     = this.graphHeight / this.numEvents;
+            this.halfBarHeight = this.barHeight / 2;
+
+            // Set the number of horizontal grid lines to the same as that of the
+            // data items that we have.
+            if (RGraph.isNull(properties.backgroundGridHlinesCount)) {
+                this.set('backgroundGridHlinesCount', this.data.length);
+            }
+            
+            
+            //
+            // Populate the yaxisLabels property from the data. But only do this once
+            //
+            properties.yaxisLabelsSpecific = [];
+            for (var i=0; i<this.data.length; ++i) {
+                if (typeof this.data[i] === 'object' && typeof this.data[i][0] === 'object') {
+                    properties.yaxisLabelsSpecific.push(this.data[i][0].label);
+                } else {
+                    properties.yaxisLabelsSpecific.push(this.data[i].label);
+                }
+            }
+            properties.yaxisLabels = properties.yaxisLabelsSpecific;
+    
+    
+    
+            //
+            // Draw the background
+            //
+            RGraph.Background.draw(this);
+    
+    
+    
+            //
+            // Draw the labels at the top
+            //
+            this.drawLabels();
+    
+    
+    
+            //
+            // Draw the events
+            //
+            this.drawEvents();
+    
+    
+    
+            //
+            // Setup the context menu if required
+            //
+            if (properties.contextmenu) {
+                RGraph.showContext(this);
+            }
+
+
+
+
+            //
+            // Add custom text thats specified
+            //
+            RGraph.addCustomText(this);
+
+
+
+
+    
+    
+    
+    
+            //
+            // This installs the event listeners
+            //
+            RGraph.installEventListeners(this);
+    
+
+            //
+            // Fire the onfirstdraw event
+            //
+            if (this.firstDraw) {
+                this.firstDraw = false;
+                RGraph.fireCustomEvent(this, 'onfirstdraw');
+                this.firstDrawFunc();
+            }
+
+
+
+
+            //
+            // Fire the RGraph draw event
+            //
+            RGraph.fireCustomEvent(this, 'ondraw');
+
+
+
+
+
+
+
+
+
+
+            //
+            // Install any inline responsive configuration. This
+            // should be last in the draw function - even after
+            // the draw events.
+            //
+            RGraph.installInlineResponsive(this);
+
+
+
+
+
+
+
+
+            
+
+
+            return this;
+        };
+
+
+
+
+
+
+
+
+        //
+        // Used in chaining. Runs a function there and then - not waiting for
+        // the events to fire (eg the onbeforedraw event)
+        // 
+        // @param function func The function to execute
+        //
+        this.exec = function (func)
+        {
+            func(this);
+            
+            return this;
+        };
+
+
+
+
+
+
+
+
+        //
+        // Draws the labels at the top and the left of the chart
+        //
+        this.drawLabels = function ()
+        {
+            // Use the RGraph.drawXAxis() function to draw the X axis labels
+            RGraph.drawXAxis(this);
+
+            // Use the RGraph.drawYAxis() function to draw the Y axis labels
+            RGraph.drawYAxis(this);
+        };
+
+
+
+
+
+
+
+
+        //
+        // Draws the events to the canvas
+        //
+        this.drawEvents = function ()
+        {
+            var events = this.data;
+    
+            //
+            // Reset the coords array to prevent it growing
+            //
+            this.coords = [];
+
+
+
+
+            //
+            // First draw the vertical bars that have been added
+            //
+            if (properties.backgroundVbars) {
+
+                for (i=0,len=properties.backgroundVbars.length; i<len; ++i) {
+
+                    // Boundary checking
+                    if (properties.backgroundVbars[i][0] + properties.backgroundVbars[i][1] > properties.xaxisScaleMax) {
+                        properties.backgroundVbars[i][1] = 364 - properties.backgroundVbars[i][0];
+                    }
+        
+                    var barX   = this.marginLeft + (( (properties.backgroundVbars[i][0] - properties.xaxisScaleMin) / (properties.xaxisScaleMax - properties.xaxisScaleMin) ) * this.graphArea),
+                        barY   = this.marginTop,
+                        width  = (this.graphArea / (properties.xaxisScaleMax - properties.xaxisScaleMin) ) * properties.backgroundVbars[i][1],
+                        height = this.canvas.height - this.marginTop - this.marginBottom;
+                    
+                    // Right hand bounds checking
+                    if ( (barX + width) > (this.canvas.width - this.marginRight) ) {
+                        width = this.canvas.width - this.marginRight - barX;
+                    }
+        
+                    this.context.fillStyle = properties.backgroundVbars[i][2];
+                    this.context.fillRect(barX, barY, width, height);
+                }
+            }
+
+
+
+            // Now draw the horizontal bars
+            if (properties.backgroundHbars) {
+
+                for (i=0,len=properties.backgroundHbars.length; i<len; ++i) {
+
+                    if (properties.backgroundHbars[i]) {
+                        
+                        var barX   = this.marginLeft,
+                            barY   = ((this.canvas.height - this.marginTop - this.marginBottom) / this.data.length) * i + this.marginTop,
+                            width  = this.graphArea,
+                            height = this.barHeight
+
+                        this.context.fillStyle = properties.backgroundHbars[i];
+                        this.context.fillRect(barX, barY, width, height);
+                    }
+                }
+            }
+
+
+
+
+            // Draw the events
+            var sequentialIndex = 0;
+
+            for (i=0; i<events.length; ++i) {
+                if (typeof events[i].start === 'number') {
+
+                    this.drawSingleEvent(
+                        events[i],
+                        i,
+                        sequentialIndex++
+                    );
+                } else {
+                    for (var j=0; j<events[i].length; ++j) {
+
+                        var index = j;
+
+                        this.drawSingleEvent(
+                            events[i][j],
+                            i,
+                            sequentialIndex++,
+                            index
+                        );
+
+                    }
+                }
+    
+            }
+        };
+
+
+
+
+
+
+
+
+        //
+        // Retrieves the bar (if any) that has been click on or is hovered over
+        // 
+        // @param object e The event object
+        //
+        this.getShape = function (e)
+        {
+            var mouseXY = RGraph.getMouseXY(e),
+                mouseX  = mouseXY[0],
+                mouseY  = mouseXY[1];
+    
+            //
+            // Loop through the bars determining if the mouse is over a bar
+            //
+            for (var i=0,len=this.coords.length; i<len; i++) {
+
+                if (RGraph.tooltipsHotspotIgnore(this, i)) {
+                    continue;
+                }
+
+                var left   = this.coords[i][0],
+                    top    = this.coords[i][1],
+                    width  = this.coords[i][2],
+                    height = this.coords[i][3];
+    
+                if (   mouseX >= left
+                    && mouseX <= (left + width)
+                    && mouseY >= top
+                    && mouseY <= (top + height)
+                   ) {
+
+                    if (RGraph.parseTooltipText && properties.tooltips) {
+                        var tooltip = RGraph.parseTooltipText(properties.tooltips, i);
+                    }
+
+                    var dataset = this.coords[i][4].dataset;
+                    var index   = (this.coords[i][4] && typeof this.coords[i][4].index === 'number' ? this.coords[i][4].index : 0);
+                    var label   = this.coords[i][4].label;
+
+                    var ret = {
+                       object: this,
+                            x: left,
+                            y: top,
+                        width: width,
+                       height: height,
+                      dataset: dataset,
+                        index: index,
+              sequentialIndex: this.coords[i][5],
+                        label: label,
+                      tooltip: typeof tooltip === 'string' ? tooltip : null
+                    };
+
+                    return ret;
+                }
+            }
+        };
+
+
+
+
+
+
+
+
+        // Draws a single event
+        this.drawSingleEvent = function (ev, dataset, sequentialIndex)
+        {
+            // Store the indexes on the original data
+            ev.dataset = dataset;
+            if (typeof arguments[3] === 'number') {
+                ev.index = arguments[3]
+            }
+
+            var min = properties.xaxisScaleMin;
+
+            this.context.beginPath();
+            this.context.strokeStyle = 'black';
+            this.context.fillStyle = ev.color ? ev.color : properties.colorsDefault;
+
+            var barStartX  = this.marginLeft + (((ev.start - min) / (properties.xaxisScaleMax - min)) * this.graphArea),
+                barStartY  = this.marginTop + (dataset * this.barHeight),
+                barWidth   = (ev.duration / (properties.xaxisScaleMax - min) ) * this.graphArea;
+
+            // If the width is greater than the graph atrea, curtail it
+            if ( (barStartX + barWidth) > (this.canvas.width - this.marginRight) ) {
+                barWidth = this.canvas.width - this.marginRight - barStartX;
+            }
+
+            //  Draw the bar storing the coordinates
+            this.coords.push([
+                barStartX,
+                barStartY + properties.marginInner,
+                barWidth,
+                this.barHeight - (2 * properties.marginInner),
+                ev,
+                sequentialIndex,
+            ]);
+
+
+
+
+
+            // draw the border around the bar
+            if (properties.borders || typeof ev.border === 'number') {
+
+                this.context.strokeStyle = typeof ev.border === 'string' ? ev.border : 'black';
+                this.context.lineWidth = (typeof ev.linewidth === 'number' ? ev.linewidth : 1);
+
+                if (ev.linewidth !== 0) {
+                    this.context.strokeRect(
+                        barStartX,
+                        barStartY + properties.marginInner,
+                        barWidth,
+                        this.barHeight - (2 * properties.marginInner)
+                    );
+                }
+            }
+            
+            // Not entirely sure what this does...
+            if (RGraph.isNull(ev.complete)) {
+                this.context.fillStyle = ev.color ? ev.color : properties.colorsDefault;
+            } else {
+                this.context.fillStyle = ev.background ? ev.background : properties.colorsDefault;
+            }
+
+            this.context.fillRect(
+                barStartX,
+                barStartY + properties.marginInner,
+                barWidth,
+                this.barHeight - (2 * properties.marginInner)
+            );
+    
+            // Work out the completeage indicator
+            var complete = (ev.complete / 100) * barWidth;
+    
+            // Draw the % complete indicator. If it's greater than 0
+            if (typeof ev.complete === 'number') {
+
+                this.context.fillStyle = ev.color ? ev.color : '#0c0';
+
+                // Draw the percent complete bar if the complete option is given
+                this.context.fillRect(
+                    barStartX,
+                    barStartY + properties.marginInner,
+                    (ev.complete / 100) * barWidth,
+                    this.barHeight - (2 * properties.marginInner)
+                );
+                
+                // Don't necessarily have to draw the label
+                if (properties.labelsComplete) {
+                    
+                    this.context.beginPath();
+
+                    // Get the text configuration
+                    var textConf = RGraph.getTextConf({
+                        object: this,
+                        prefix: 'labelsComplete'
+                    });
+
+                    RGraph.text({
+                    
+                        object: this,
+
+                        font:   textConf.font,
+                        size:   textConf.size,
+                        color:  textConf.color,
+                        bold:   textConf.bold,
+                        italic: textConf.italic,
+
+                        x:      barStartX + barWidth + 5 + properties.labelsCompleteOffsetx,
+                        y:      barStartY + this.halfBarHeight + properties.labelsCompleteOffsety,
+
+                        text:   String(ev.complete) + '%',
+                        
+                        valign: 'center',
+                        tag:    'labels.complete'
+                    });
+                }
+            }
+
+
+            //
+            // Draw the inbar label if it's defined
+            //
+            if (properties.labelsInbar && properties.labelsInbar[sequentialIndex]) {
+                
+                var label = String(properties.labelsInbar[sequentialIndex]),
+                    halign = properties.labelsInbarAlign == 'left' ? 'left' : 'center';
+
+                halign = properties.labelsInbarAlign == 'right' ? 'right' : halign;
+                
+                // Work out the position of the text
+                if (halign == 'right') {
+                    var x = (barStartX + barWidth) - 5;
+                } else if (halign == 'center') {
+                    var x = barStartX + (barWidth / 2);
+                } else {
+                    var x = barStartX + 5;
+                }
+    
+    
+                // Draw the labels "above" the bar
+                if (properties.labelsInbarAbove) {
+                    x = barStartX + barWidth + 5;
+                    halign = 'left';
+                }
+
+                // Get the text configuration
+                var textConf = RGraph.getTextConf({
+                    object: this,
+                    prefix: 'labelsInbar'
+                });
+
+                // Set the color
+                this.context.fillStyle = properties.labelsInbarColor;
+                RGraph.text({
+                
+                    object: this,
+
+                    font:   textConf.font,
+                    size:   textConf.size,
+                    color:  textConf.color,
+                    bold:   textConf.bold,
+                    italic: textConf.italic,
+
+                    x:            x + properties.labelsInbarOffsetx,
+                    y:            barStartY + this.halfBarHeight + properties.labelsInbarOffsety,
+                    text:         label,
+                    valign:       'center',
+                    halign:       halign,
+                    bounding:     typeof properties.labelsInbarBgcolor == 'string',
+                    boundingFill: typeof properties.labelsInbarBgcolor === 'string' ? properties.labelsInbarBgcolor : null,
+                    tag:          'labels.inbar'
+                });
+            }
+        };
+
+
+
+
+
+
+
+
+        //
+        // Each object type has its own Highlight() function which highlights the appropriate shape
+        // 
+        // @param object shape The shape to highlight
+        //
+        this.highlight = function (shape)
+        {
+            // First check for inverted highlighting
+            if (typeof properties.highlightStyle === 'string' && properties.highlightStyle === 'invert') {
+                for (var i=0; i<this.coords.length; ++i) {
+                    if (i !== shape.sequentialIndex) {
+                        this.path(
+                            'b r % % % % s % f %',
+                            this.coords[i][0] - 0.5,this.coords[i][1] - 0.5,this.coords[i][2] + 1, this.coords[i][3] + 1,
+                            properties.highlightStroke,
+                            properties.highlightFill
+                        );
+                    }
+                }
+                
+                return;
+            }
+
+            if (typeof properties.highlightStyle === 'function') {
+                (properties.highlightStyle)(shape);
+            } else {
+                RGraph.Highlight.rect(this, shape);
+            }
+        };
+
+
+
+
+
+
+
+
+        //
+        // The getObjectByXY() worker method. Don't call this call:
+        // 
+        // RGraph.ObjectRegistry.getObjectByXY(e)
+        // 
+        // @param object e The event object
+        //
+        this.getObjectByXY = function (e)
+        {
+            var mouseXY = RGraph.getMouseXY(e);
+    
+            if (
+                   mouseXY[0] > this.marginLeft
+                && mouseXY[0] < (this.canvas.width - this.marginRight)
+                && mouseXY[1] > this.marginTop
+                && mouseXY[1] < (this.canvas.height - this.marginBottom)
+                ) {
+    
+                return this;
+            }
+        };
+
+
+
+
+
+
+
+
+        //
+        // This method handles the adjusting calculation for when the mouse is moved
+        // 
+        // @param object e The event object
+        //
+        this.adjusting_mousemove = function (e)
+        {
+            // Handle adjusting for the Bar
+            if (properties.adjustable && RGraph.Registry.get('adjusting') && RGraph.Registry.get('adjusting').uid == this.uid) {
+
+                var bar = RGraph.Registry.get('adjusting.gantt');
+
+                if (bar) {
+                    var mouseXY    = RGraph.getMouseXY(e),
+                        obj        = bar.object,
+                        dataset    = bar.dataset,
+                        index      = bar.index,
+                        diff       = ((mouseXY[0] - bar.mousex) / (obj.canvas.width - obj.marginLeft - obj.marginRight)) * properties.xaxisScaleMax,
+                        eventStart = bar.event_start || 0,
+                        duration   = bar.event_duration,
+                        event      = typeof obj.data[dataset][index] === 'object' ? obj.data[dataset][index] : obj.data[dataset]
+
+                    if (bar['mode'] === 'move') {
+
+                        diff = Math.round(diff);
+
+
+                        // Single event
+                        if (!RGraph.isArray(obj.data[dataset])) {
+
+                            event.start = eventStart + diff;
+                            
+                            if (eventStart + diff < 0) {
+                                obj.data[dataset].start = 0;
+
+                            } else if ((eventStart + diff + obj.data[dataset].duration) > properties.xaxisScaleMax) {
+                                obj.data[dataset].start = properties.xaxisScaleMax - obj.data[dataset].duration;
+                            }
+
+
+                        // Multiple events
+                        } else {
+
+                            var dataset = bar.dataset,
+                                index   = typeof bar.index === 'number'  ? bar.index : 0,
+                                event   = obj.data[dataset][index];
+
+                            event.start = eventStart + diff;
+                            
+                            if ( (eventStart + diff) < 0) {
+                                event.start = 0;
+                            } else if ( (eventStart + diff + event.duration) > properties.xaxisScaleMax ) {
+                                event.start = properties.xaxisScaleMax - event.duration;
+                            }
+                        }
+
+
+
+
+
+
+
+
+
+
+
+
+                    } else if (bar.mode == 'resize') {
+        
+                        //
+                        // Account for the right hand gutter. Appears to be a FF bug
+                        //
+                        if (mouseXY[0] > (obj.canvas.width - obj.marginRight)) {
+                            mouseXY[0] = obj.canvas.width - obj.marginRight;
+                        }
+                        
+                        var diff = ((mouseXY[0] - RGraph.Registry.get('adjusting.gantt')['mousex']) / (obj.canvas.width - obj.marginLeft - obj.marginRight)) * properties.xaxisScaleMax;
+                            diff = Math.round(diff);
+
+
+
+
+
+
+                        // Single event
+                        if (!RGraph.isArray(obj.data[dataset])) {
+                            obj.data[dataset].duration = duration + diff;
+                            
+                            if (obj.data[dataset].duration < 0) {
+                                obj.data[dataset].duration = 1;
+                            }
+
+                        // Multiple events
+                        } else {
+
+                            obj.data[dataset][index].duration = duration + diff;
+                            
+                            if (obj.data[dataset][index].duration <= 0) {
+                                obj.data[dataset][index].duration = 1;
+                            }
+
+                        }
+                    }
+                    
+                    RGraph.resetColorsToOriginalValues(obj);
+        
+                    //RGraph.clear(obj.canvas);
+                    RGraph.redrawCanvas(obj.canvas);
+                    
+                    RGraph.fireCustomEvent(obj, 'onadjust');
+                }
+            }
+        };
+
+
+
+
+
+
+
+
+        //
+        // Returns the X coordinate for the given value
+        // 
+        // @param number value The desired value (eg minute/hour/day etc)
+        //
+        this.getXCoord = function (value)
+        {
+            var min       = properties.xaxisScaleMin,
+                max       = properties.xaxisScaleMax,
+                graphArea = this.canvas.width - this.marginLeft - this.marginRight;
+
+            if (value > max || value < min) {
+                return null;
+            }
+
+            var x = (((value - min) / (max - min)) * graphArea) + this.marginLeft;
+            
+            return x;
+        };
+
+
+
+
+
+
+
+
+        //
+        // Returns the value given EITHER the event object OR a two element array containing the X/Y coords
+        //
+        this.getValue = function (arg)
+        {
+            if (arg.length == 2) {
+                var mouseXY = arg; // Two coords given
+            } else {
+                var mouseXY = RGraph.getMouseXY(arg); // event given
+            }
+            
+            var mouseX = mouseXY[0],
+                mouseY = mouseXY[1];
+            
+            var value  = (mouseX - this.marginLeft) / (this.canvas.width - this.marginLeft - this.marginRight);
+                value *= (properties.xaxisScaleMax - properties.xaxisScaleMin);
+            
+            // Bounds checking
+            if (value < properties.xaxisScaleMin || value > properties.xaxisScaleMax) {
+                value = null;
+            }
+            
+            return value;
+        };
+
+
+
+
+
+
+
+
+        //
+        // This allows for easy specification of gradients. Could optimise this not to repeatedly call parseSingleColors()
+        //
+        this.parseColors = function ()
+        {
+            // Save the original colors so that they can be restored when the canvas is reset
+            if (this.original_colors.length === 0) {
+                
+                this.original_colors.data                 = RGraph.arrayClone(this.data);
+                this.original_colors.backgroundBarsColor1 = RGraph.arrayClone(properties.backgroundBarsColor1);
+                this.original_colors.backgroundBarsColor2 = RGraph.arrayClone(properties.backgroundBarsColor2);
+                this.original_colors.backgroundGridColor  = RGraph.arrayClone(properties.backgroundGridColor);
+                this.original_colors.colorsDefault        = RGraph.arrayClone(properties.colorsDefault);
+                this.original_colors.highlightStroke      = RGraph.arrayClone(properties.highlightStroke);
+                this.original_colors.highlightFill        = RGraph.arrayClone(properties.highlightFill);
+            }
+
+
+
+
+            //
+            // this.coords can be used here as gradients are only parsed on the SECOND draw - not the first.
+            // A .redraw() is downe at the end of the first draw.
+            //
+            for (var i=0,sequentialIndex=0; i<this.data.length; ++i) {
+
+                // Multiple events
+                if (   RGraph.isArray(this.data[i])
+                    && typeof this.data[i][0] === 'object'
+                    && typeof this.data[i][0].start === 'number'
+                   ) {
+
+                    for (var j=0,len=this.data[i].length; j<len; j+=1,sequentialIndex+=1) {
+                        this.data[i][j].background = this.parseSingleColorForGradient(
+                            this.data[i][j].background,
+                            {start: this.data[i][j].start, duration: this.data[i][j].duration}
+                        );
+
+                        this.data[i][j].color = this.parseSingleColorForGradient(
+                            this.data[i][j].color, 
+                            {start: this.data[i][j].start, duration: this.data[i][j].duration}
+                        );
+                    }
+                
+                // Single event
+                } else {
+                
+                    if (typeof this.data[i].background === 'string') {
+                        this.data[i].background = this.parseSingleColorForGradient(
+                            this.data[i].background,
+                            {start: this.data[i].start, duration: this.data[i].duration}
+                        );
+                    }
+
+                    if (typeof this.data[i].color === 'string') {
+                        this.data[i].color = this.parseSingleColorForGradient(
+                            this.data[i].color,
+                            {start: this.data[i].start, duration: this.data[i].duration}
+                        );
+                    }
+
+                    ++sequentialIndex;
+                }
+            }
+
+            properties.backgroundBarsColor1 = this.parseSingleColorForGradient(properties.backgroundBarsColor1);
+            properties.backgroundBarsColor2 = this.parseSingleColorForGradient(properties.backgroundBarsColor2);
+            properties.backgroundGridColor  = this.parseSingleColorForGradient(properties.backgroundGridColor);
+            properties.backgroundColor      = this.parseSingleColorForGradient(properties.backgroundColor);
+            properties.colorsDefault        = this.parseSingleColorForGradient(properties.colorsDefault);
+            properties.highlightStroke      = this.parseSingleColorForGradient(properties.highlightStroke);
+            properties.highlightFill        = this.parseSingleColorForGradient(properties.highlightFill);
+        };
+
+
+
+
+
+
+
+
+        //
+        // Use this function to reset the object to the post-constructor state. Eg reset colors if
+        // need be etc
+        //
+        this.reset = function ()
+        {
+        };
+
+
+
+
+
+
+
+
+        //
+        // This parses a single color value
+        // 
+        // @param string color The color to parse
+        //
+        this.parseSingleColorForGradient = function (color)
+        {
+            var opts = arguments[1] || {};
+
+            if (!color || typeof color != 'string') {
+                return color;
+            }
+
+
+            if (color.match(/^gradient\((.*)\)$/i)) {
+
+                // Allow for JSON gradients
+                if (color.match(/^gradient\(({.*})\)$/i)) {
+                    return RGraph.parseJSONGradient({object: this, def: RegExp.$1});
+                }
+
+                var parts = RegExp.$1.split(':'),
+                    value = (opts.start + opts.duration) > properties.xaxisScaleMax ? properties.xaxisScaleMax : (opts.start + opts.duration);
+
+                // Create the gradient
+                var grad = this.context.createLinearGradient(
+                    typeof opts.start === 'number' ? this.getXCoord(opts.start) : this.marginLeft,
+                    0,
+                    typeof opts.start === 'number' ? this.getXCoord(value) : this.canvas.width - this.marginRight,
+                    0
+                );
+    
+                var diff = 1 / (parts.length - 1);
+
+                grad.addColorStop(0, RGraph.trim(parts[0]));
+                for (var j=1; j<parts.length; ++j) {
+                    grad.addColorStop(j * diff, RGraph.trim(parts[j]));
+                }
+            }
+
+            return grad ? grad : color;
+        };
+
+
+
+
+
+
+
+
+        //
+        // Using a function to add events makes it easier to facilitate method chaining
+        // 
+        // @param string   type The type of even to add
+        // @param function func 
+        //
+        this.on = function (type, func)
+        {
+            if (type.substr(0,2) !== 'on') {
+                type = 'on' + type;
+            }
+            
+            if (typeof this[type] !== 'function') {
+                this[type] = func;
+            } else {
+                RGraph.addCustomEventListener(this, type, func);
+            }
+    
+            return this;
+        };
+
+
+
+
+
+
+
+
+        //
+        // This function runs once only
+        // (put at the end of the file (before any effects))
+        //
+        this.firstDrawFunc = function ()
+        {
+        };
+
+
+
+
+
+
+
+
+        //
+        // Gantt chart Grow effect
+        // 
+        // @param object   obj Options for the grow effect
+        // @param function     Optional callback (a function)
+        //
+        this.grow = function ()
+        {
+            // Cancel any stop request if one is pending
+            this.cancelStopAnimation();
+            
+            // Reset the data to the original
+            this.data = RGraph.arrayClone(this.original_data);
+
+            var obj             = this,
+                opt             = arguments[0] || {},
+                callback        = arguments[1] ? arguments[1] : function () {},
+                canvas          = obj.canvas,
+                context         = obj.context,
+                numFrames       = opt.frames || 30,
+                frame           = 0;
+                original_events = RGraph.arrayClone(obj.data);
+
+            function iterator ()
+            {
+                if (obj.stopAnimationRequested) {
+    
+                    // Reset the flag
+                    obj.stopAnimationRequested = false;
+    
+                    return;
+                }
+
+                RGraph.clear(obj.canvas);
+                RGraph.redrawCanvas(obj.canvas);
+
+
+                if (frame <= numFrames) {
+                    // Update the events
+                    for (var i=0,len=obj.data.length; i<len; ++i) {
+                        if (typeof obj.data[i] === 'object' && obj.data[i][0] && typeof obj.data[i][0] === 'object') {
+                            for (var j=0; j<obj.data[i].length; ++j) {
+                                obj.data[i][j].duration = (frame / numFrames) * original_events[i][j].duration;
+                            }
+                        } else {
+                            obj.data[i].duration = (frame / numFrames) * original_events[i].duration;
+                        }
+                    }
+
+                    obj.reset();
+
+
+                    
+                    frame++;
+
+                    RGraph.Effects.updateCanvas(iterator);
+    
+                } else {
+                    callback(obj);
+                }
+            }
+            
+            iterator();
+            
+            return this;
+        };
+
+
+
+
+
+
+
+
+        //
+        // Couple of functions that allow you to control the
+        // animation effect
+        //
+        this.stopAnimation = function ()
+        {
+            this.stopAnimationRequested = true;
+        };
+
+        this.cancelStopAnimation = function ()
+        {
+            this.stopAnimationRequested = false;
+        };
+
+
+
+
+
+
+
+
+        //
+        // This helps the Gantt reset colors when the reset function is called.
+        // It handles going through the data and resetting the colors.
+        //
+        this.resetColorsToOriginalValues = function ()
+        {
+            //
+            // Copy the original colors over for single-event-per-line data
+            //
+            for (var i=0; i<this.original_colors.data.length; ++i) {
+                if (this.original_colors.data[i].background) {
+                    this.data[i].background = RGraph.arrayClone(this.original_colors.data[i].background);
+                }
+
+                if (this.original_colors.data[i].color) {
+                    this.data[i].color = RGraph.arrayClone(this.original_colors.data[i].color);
+                }
+                
+                if (typeof this.original_colors.data[i][0] === 'object' && typeof this.original_colors.data[i][0].start === 'number') {
+                    for (var j=0,len2=this.original_colors.data[i].length; j<len2; ++j) {
+                        this.data[i][j].background = RGraph.arrayClone(this.original_colors.data[i][j].background);
+                        this.data[i][j].color      = RGraph.arrayClone(this.original_colors.data[i][j].color);
+                    }
+                }
+            }
+        };
+
+
+
+
+
+
+
+
+        //
+        // This function resets the object - clearing it of any previously gathered info
+        //
+        this.reset = function ()
+        {
+            this.resetColorsToOriginalValues();
+        
+            this.colorsParsed    = false;
+            this.coordsText      = [];
+            this.original_colors = [];
+            this.firstDraw       = true;
+            this.coords          = [];
+        };
+
+
+
+
+
+
+
+
+        // An unused function
+        this.sequentialIndex2Grouped=function(){alert('[RGRAPH] Something went badly wrong - contact support');};
+
+
+
+
+
+
+
+
+        // Determines whether the Gant is adjustable or not
+        this.isAdjustable = function (shape)
+        {
+            if (RGraph.isNull(properties.adjustableOnly)) {
+                return true;
+            
+            } else if (RGraph.isArray(properties.adjustableOnly) && shape && properties.adjustableOnly[shape.sequentialIndex]) {
+                return true;
+            }
+
+            return false;
+        };
+
+
+
+
+
+
+
+
+        //
+        // A worker function that handles Bar chart specific tooltip substitutions
+        //
+        this.tooltipSubstitutions = function (opt)
+        {
+            var event = this['$' + opt.index];
+
+            var value = {
+                start:    event.start,
+                duration: event.duration,
+                complete: event.complete
+            };
+
+
+            //
+            // Return the values to the user
+            //
+            return {
+                  index: event.index,
+                dataset: event.dataset,
+        sequentialIndex: opt.index,
+                  value: value
+            };
+        };
+
+
+
+
+
+
+
+
+        //
+        // A worker function that returns the correct color/label/value
+        //
+        // @param object specific The indexes that are applicable
+        // @param number index    The appropriate index
+        //
+        this.tooltipsFormattedCustom = function (specific, index)
+        {
+            return {
+                //label:,
+                //color:,
+                //value:
+            };
+        };
+
+
+
+
+
+
+
+
+        //
+        // This allows for static tooltip positioning
+        //
+        this.positionTooltipStatic = function (args)
+        {
+            var obj      = args.object,
+                e        = args.event,
+                tooltip  = args.tooltip,
+                index    = args.index,
+                canvasXY = RGraph.getCanvasXY(obj.canvas)
+                coords   = this.coords[args.index];
+
+            // Position the tooltip in the X direction
+            args.tooltip.style.left = (
+                canvasXY[0]                      // The X coordinate of the canvas
+                + coords[0]                      // The X coordinate of the point on the chart
+                + (coords[2] / 2)                // Add half of the width of the bar
+                - (tooltip.offsetWidth / 2)      // Subtract half of the tooltip width
+                + obj.properties.tooltipsOffsetx // Add any user defined offset
+            ) + 'px';
+
+            args.tooltip.style.top  = (
+                  canvasXY[1]                    // The Y coordinate of the canvas
+                + coords[1]                      // The Y coordinate of the bar on the chart
+                - tooltip.offsetHeight           // The height of the tooltip
+                - 10                             // An arbitrary amount
+                + obj.properties.tooltipsOffsety // Add any user defined offset
+            ) + 'px';
+            
+            // If the top of the tooltip is off the top of the page
+            // then move the tooltip down
+            if(parseFloat(args.tooltip.style.top) < 0) {
+                args.tooltip.style.top = parseFloat(args.tooltip.style.top) + (coords[3] / 2) + 5 + 'px';
+            }
+        };
+
+
+
+
+
+
+
+
+        //
+        // Register the object
+        //
+        RGraph.register(this);
+
+
+
+
+
+
+
+
+        //
+        // This is the 'end' of the constructor so if the first argument
+        // contains configuration data - handle that.
+        //
+        RGraph.parseObjectStyleConfig(this, conf.options);
+    };