summaryrefslogtreecommitdiff
path: root/js/dojo/dojox/charting/plot2d/Candlesticks.js
diff options
context:
space:
mode:
Diffstat (limited to 'js/dojo/dojox/charting/plot2d/Candlesticks.js')
-rw-r--r--js/dojo/dojox/charting/plot2d/Candlesticks.js229
1 files changed, 229 insertions, 0 deletions
diff --git a/js/dojo/dojox/charting/plot2d/Candlesticks.js b/js/dojo/dojox/charting/plot2d/Candlesticks.js
new file mode 100644
index 0000000..a30d39b
--- /dev/null
+++ b/js/dojo/dojox/charting/plot2d/Candlesticks.js
@@ -0,0 +1,229 @@
+//>>built
+define("dojox/charting/plot2d/Candlesticks", ["dojo/_base/lang", "dojo/_base/declare", "dojo/_base/array", "./Base", "./common",
+ "dojox/lang/functional", "dojox/lang/functional/reversed", "dojox/lang/utils", "dojox/gfx/fx"],
+ function(lang, declare, arr, Base, dc, df, dfr, du, fx){
+/*=====
+var Base = dojox.charting.plot2d.Base;
+=====*/
+
+ var purgeGroup = dfr.lambda("item.purgeGroup()");
+
+ // Candlesticks are based on the Bars plot type; we expect the following passed
+ // as values in a series:
+ // { x?, open, close, high, low, mid? }
+ // if x is not provided, the array index is used.
+ // failing to provide the OHLC values will throw an error.
+ return declare("dojox.charting.plot2d.Candlesticks", Base, {
+ // summary:
+ // A plot that represents typical candlesticks (financial reporting, primarily).
+ // Unlike most charts, the Candlestick expects data points to be represented by
+ // an object of the form { x?, open, close, high, low, mid? }, where both
+ // x and mid are optional parameters. If x is not provided, the index of the
+ // data array is used.
+ defaultParams: {
+ hAxis: "x", // use a horizontal axis named "x"
+ vAxis: "y", // use a vertical axis named "y"
+ gap: 2, // gap between columns in pixels
+ animate: null // animate bars into place
+ },
+ optionalParams: {
+ minBarSize: 1, // minimal candle width in pixels
+ maxBarSize: 1, // maximal candle width in pixels
+ // theme component
+ stroke: {},
+ outline: {},
+ shadow: {},
+ fill: {},
+ font: "",
+ fontColor: ""
+ },
+
+ constructor: function(chart, kwArgs){
+ // summary:
+ // The constructor for a candlestick chart.
+ // chart: dojox.charting.Chart
+ // The chart this plot belongs to.
+ // kwArgs: dojox.charting.plot2d.__BarCtorArgs?
+ // An optional keyword arguments object to help define the plot.
+ this.opt = lang.clone(this.defaultParams);
+ du.updateWithObject(this.opt, kwArgs);
+ du.updateWithPattern(this.opt, kwArgs, this.optionalParams);
+ this.series = [];
+ this.hAxis = this.opt.hAxis;
+ this.vAxis = this.opt.vAxis;
+ this.animate = this.opt.animate;
+ },
+
+ collectStats: function(series){
+ // summary:
+ // Collect all statistics for drawing this chart. Since the common
+ // functionality only assumes x and y, Candlesticks must create it's own
+ // stats (since data has no y value, but open/close/high/low instead).
+ // series: dojox.charting.Series[]
+ // The data series array to be drawn on this plot.
+ // returns: Object
+ // Returns an object in the form of { hmin, hmax, vmin, vmax }.
+
+ // we have to roll our own, since we need to use all four passed
+ // values to figure out our stats, and common only assumes x and y.
+ var stats = lang.delegate(dc.defaultStats);
+ for(var i=0; i<series.length; i++){
+ var run = series[i];
+ if(!run.data.length){ continue; }
+ var old_vmin = stats.vmin, old_vmax = stats.vmax;
+ if(!("ymin" in run) || !("ymax" in run)){
+ arr.forEach(run.data, function(val, idx){
+ if(val !== null){
+ var x = val.x || idx + 1;
+ stats.hmin = Math.min(stats.hmin, x);
+ stats.hmax = Math.max(stats.hmax, x);
+ stats.vmin = Math.min(stats.vmin, val.open, val.close, val.high, val.low);
+ stats.vmax = Math.max(stats.vmax, val.open, val.close, val.high, val.low);
+ }
+ });
+ }
+ if("ymin" in run){ stats.vmin = Math.min(old_vmin, run.ymin); }
+ if("ymax" in run){ stats.vmax = Math.max(old_vmax, run.ymax); }
+ }
+ return stats; // Object
+ },
+
+ getSeriesStats: function(){
+ // summary:
+ // Calculate the min/max on all attached series in both directions.
+ // returns: Object
+ // {hmin, hmax, vmin, vmax} min/max in both directions.
+ var stats = this.collectStats(this.series);
+ stats.hmin -= 0.5;
+ stats.hmax += 0.5;
+ return stats;
+ },
+
+ render: function(dim, offsets){
+ // summary:
+ // Run the calculations for any axes for this plot.
+ // dim: Object
+ // An object in the form of { width, height }
+ // offsets: Object
+ // An object of the form { l, r, t, b}.
+ // returns: dojox.charting.plot2d.Candlesticks
+ // A reference to this plot for functional chaining.
+ if(this.zoom && !this.isDataDirty()){
+ return this.performZoom(dim, offsets);
+ }
+ this.resetEvents();
+ this.dirty = this.isDirty();
+ if(this.dirty){
+ arr.forEach(this.series, purgeGroup);
+ this._eventSeries = {};
+ this.cleanGroup();
+ var s = this.group;
+ df.forEachRev(this.series, function(item){ item.cleanGroup(s); });
+ }
+ var t = this.chart.theme, f, gap, width,
+ ht = this._hScaler.scaler.getTransformerFromModel(this._hScaler),
+ vt = this._vScaler.scaler.getTransformerFromModel(this._vScaler),
+ baseline = Math.max(0, this._vScaler.bounds.lower),
+ baselineHeight = vt(baseline),
+ events = this.events();
+ f = dc.calculateBarSize(this._hScaler.bounds.scale, this.opt);
+ gap = f.gap;
+ width = f.size;
+ for(var i = this.series.length - 1; i >= 0; --i){
+ var run = this.series[i];
+ if(!this.dirty && !run.dirty){
+ t.skip();
+ this._reconnectEvents(run.name);
+ continue;
+ }
+ run.cleanGroup();
+ var theme = t.next("candlestick", [this.opt, run]), s = run.group,
+ eventSeries = new Array(run.data.length);
+ for(var j = 0; j < run.data.length; ++j){
+ var v = run.data[j];
+ if(v !== null){
+ var finalTheme = t.addMixin(theme, "candlestick", v, true);
+
+ // calculate the points we need for OHLC
+ var x = ht(v.x || (j+0.5)) + offsets.l + gap,
+ y = dim.height - offsets.b,
+ open = vt(v.open),
+ close = vt(v.close),
+ high = vt(v.high),
+ low = vt(v.low);
+ if("mid" in v){
+ var mid = vt(v.mid);
+ }
+ if(low > high){
+ var tmp = high;
+ high = low;
+ low = tmp;
+ }
+
+ if(width >= 1){
+ // draw the line and rect, set up as a group and pass that to the events.
+ var doFill = open > close;
+ var line = { x1: width/2, x2: width/2, y1: y - high, y2: y - low },
+ rect = {
+ x: 0, y: y-Math.max(open, close),
+ width: width, height: Math.max(doFill ? open-close : close-open, 1)
+ };
+ var shape = s.createGroup();
+ shape.setTransform({dx: x, dy: 0 });
+ var inner = shape.createGroup();
+ inner.createLine(line).setStroke(finalTheme.series.stroke);
+ inner.createRect(rect).setStroke(finalTheme.series.stroke).
+ setFill(doFill ? finalTheme.series.fill : "white");
+ if("mid" in v){
+ // add the mid line.
+ inner.createLine({
+ x1: (finalTheme.series.stroke.width||1), x2: width - (finalTheme.series.stroke.width || 1),
+ y1: y - mid, y2: y - mid
+ }).setStroke(doFill ? "white" : finalTheme.series.stroke);
+ }
+
+ // TODO: double check this.
+ run.dyn.fill = finalTheme.series.fill;
+ run.dyn.stroke = finalTheme.series.stroke;
+ if(events){
+ var o = {
+ element: "candlestick",
+ index: j,
+ run: run,
+ shape: inner,
+ x: x,
+ y: y-Math.max(open, close),
+ cx: width/2,
+ cy: (y-Math.max(open, close)) + (Math.max(doFill ? open-close : close-open, 1)/2),
+ width: width,
+ height: Math.max(doFill ? open-close : close-open, 1),
+ data: v
+ };
+ this._connectEvents(o);
+ eventSeries[j] = o;
+ }
+ }
+ if(this.animate){
+ this._animateCandlesticks(shape, y - low, high - low);
+ }
+ }
+ }
+ this._eventSeries[run.name] = eventSeries;
+ run.dirty = false;
+ }
+ this.dirty = false;
+ return this; // dojox.charting.plot2d.Candlesticks
+ },
+ _animateCandlesticks: function(shape, voffset, vsize){
+ fx.animateTransform(lang.delegate({
+ shape: shape,
+ duration: 1200,
+ transform: [
+ {name: "translate", start: [0, voffset - (voffset/vsize)], end: [0, 0]},
+ {name: "scale", start: [1, 1/vsize], end: [1, 1]},
+ {name: "original"}
+ ]
+ }, this.animate)).play();
+ }
+ });
+});
generated by cgit v1.0-28-g1787 at 2026-01-10 09:19:24 +0000