Free cookie consent management tool by TermsFeed Policy Generator

source: branches/HiveStatistics/sources/HeuristicLab.Services.Hive.Statistics/3.3/Scripts/jqPlot/plugins/jqplot.pyramidAxisRenderer.js @ 9617

Last change on this file since 9617 was 9617, checked in by pfleck, 11 years ago

#2063:
Started integrating Hive statistics into statistics web project.
Added jqPlot library for charting.

File size: 29.1 KB
Line 
1/**
2 * jqPlot
3 * Pure JavaScript plotting plugin using jQuery
4 *
5 * Version: 1.0.0b2_r1012
6 *
7 * Copyright (c) 2009-2011 Chris Leonello
8 * jqPlot is currently available for use in all personal or commercial projects
9 * under both the MIT (http://www.opensource.org/licenses/mit-license.php) and GPL
10 * version 2.0 (http://www.gnu.org/licenses/gpl-2.0.html) licenses. This means that you can
11 * choose the license that best suits your project and use it accordingly.
12 *
13 * Although not required, the author would appreciate an email letting him
14 * know of any substantial use of jqPlot.  You can reach the author at:
15 * chris at jqplot dot com or see http://www.jqplot.com/info.php .
16 *
17 * If you are feeling kind and generous, consider supporting the project by
18 * making a donation at: http://www.jqplot.com/donate.php .
19 *
20 * sprintf functions contained in jqplot.sprintf.js by Ash Searle:
21 *
22 *     version 2007.04.27
23 *     author Ash Searle
24 *     http://hexmen.com/blog/2007/03/printf-sprintf/
25 *     http://hexmen.com/js/sprintf.js
26 *     The author (Ash Searle) has placed this code in the public domain:
27 *     "This code is unrestricted: you are free to use it however you like."
28 *
29 */
30(function($) {
31    $.jqplot.PyramidAxisRenderer = function() {
32        $.jqplot.LinearAxisRenderer.call(this);
33    };
34   
35    $.jqplot.PyramidAxisRenderer.prototype = new $.jqplot.LinearAxisRenderer();
36    $.jqplot.PyramidAxisRenderer.prototype.constructor = $.jqplot.PyramidAxisRenderer;
37       
38    // called with scope of axis
39    $.jqplot.PyramidAxisRenderer.prototype.init = function(options){
40        // Group: Properties
41        //
42        // prop: position
43        // Position of axis.  Values are: top, bottom , left, center, right.
44        // By default, x and x2 axes are bottom, y axis is center.
45        this.position = null;
46        // prop: drawBaseline
47        // True to draw the axis baseline.
48        this.drawBaseline = true;
49        // prop: baselineWidth
50        // width of the baseline in pixels.
51        this.baselineWidth = null;
52        // prop: baselineColor
53        // CSS color spec for the baseline.
54        this.baselineColor = null;
55        this.tickSpacingFactor = 25;
56        this._type = 'pyramid';
57        this._splitAxis = false;
58        this._splitLength = null;
59        this.category = false;
60        this._autoFormatString = '';
61        this._overrideFormatString = false;
62       
63        $.extend(true, this, options);
64        this.renderer.options = options;
65
66        this.resetDataBounds = this.renderer.resetDataBounds;
67        this.resetDataBounds();
68
69    };
70
71    $.jqplot.PyramidAxisRenderer.prototype.resetDataBounds = function() {
72        // Go through all the series attached to this axis and find
73        // the min/max bounds for this axis.
74        var db = this._dataBounds;
75        db.min = null;
76        db.max = null;
77        var temp;
78        for (var i=0; i<this._series.length; i++) {
79            var s = this._series[i];
80            var d = s._plotData;
81           
82            for (var j=0, l=d.length; j<l; j++) {
83                if (this.name.charAt(0) === 'x') {
84                    temp = d[j][1];
85                    if ((temp !== null && temp < db.min) || db.min === null) {
86                        db.min = temp;
87                    }
88                    if ((temp !== null && temp > db.max) || db.max === null) {
89                        db.max = temp;
90                    }
91                }             
92                else {
93                    temp = d[j][0];
94                    if ((temp !== null && temp < db.min) || db.min === null) {
95                        db.min = temp;
96                    }
97                    if ((temp !== null && temp > db.max) || db.max === null) {
98                        db.max = temp;
99                    }
100                }             
101            }
102        }
103    };
104   
105    // called with scope of axis
106    $.jqplot.PyramidAxisRenderer.prototype.draw = function(ctx, plot) {
107        if (this.show) {
108            // populate the axis label and value properties.
109            // createTicks is a method on the renderer, but
110            // call it within the scope of the axis.
111            this.renderer.createTicks.call(this, plot);
112            // fill a div with axes labels in the right direction.
113            // Need to pregenerate each axis to get it's bounds and
114            // position it and the labels correctly on the plot.
115            var dim=0;
116            var temp;
117            // Added for theming.
118            if (this._elem) {
119                // Memory Leaks patch
120                //this._elem.empty();
121                this._elem.emptyForce();
122                this._elem = null;
123            }
124           
125            this._elem = $(document.createElement('div'));
126            this._elem.addClass('jqplot-axis jqplot-'+this.name);
127            this._elem.css('position', 'absolute');
128
129           
130            if (this.name == 'xaxis' || this.name == 'x2axis') {
131                this._elem.width(this._plotDimensions.width);
132            }
133            else {
134                this._elem.height(this._plotDimensions.height);
135            }
136           
137            // create a _label object.
138            this.labelOptions.axis = this.name;
139            this._label = new this.labelRenderer(this.labelOptions);
140            if (this._label.show) {
141                var elem = this._label.draw(ctx, plot);
142                elem.appendTo(this._elem);
143                elem = null;
144            }
145   
146            var t = this._ticks;
147            var tick;
148            for (var i=0; i<t.length; i++) {
149                tick = t[i];
150                if (tick.show && tick.showLabel && (!tick.isMinorTick)) {
151                    this._elem.append(tick.draw(ctx, plot));
152                }
153            }
154            tick = null;
155            t = null;
156        }
157        return this._elem;
158    };   
159
160    // Note, primes can be found on http://primes.utm.edu/
161    var _primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997];
162
163
164    var _primesHash = {};
165
166    for (var i =0, l = _primes.length; i < l; i++) {
167        _primesHash[_primes[i]] = _primes[i];
168    }
169
170    // called with scope of axis
171    $.jqplot.PyramidAxisRenderer.prototype.createTicks = function(plot) {
172        // we're are operating on an axis here
173        var userTicks = this.ticks;
174        // databounds were set on axis initialization.
175        var db = this._dataBounds;
176        var dim;
177        var interval;
178        var min;
179        var max;
180        var range;
181        var pos1;
182        var pos2;
183        var tt;
184        var i;
185        var l;
186        var s;
187        // get a copy of user's settings for min/max.
188        var userMin = this.min;
189        var userMax = this.max;
190        var ut;
191        var t;
192        var threshold;
193        var tdim;
194        var scalefact;
195        var ret;
196        var tumin;
197        var tumax;
198        var maxVisibleTicks;
199        var val;
200        var skip = null;
201        var temp;
202       
203        // if we already have ticks, use them.
204        // ticks must be in order of increasing value.
205
206        if (userTicks.length) {
207            // ticks could be 1D or 2D array of [val, val, ,,,] or [[val, label], [val, label], ...] or mixed
208            for (i=0, l=userTicks.length; i<l; i++){
209                ut = userTicks[i];
210                t = new this.tickRenderer(this.tickOptions);
211                if ($.isArray(ut)) {
212                    t.value = ut[0];
213                    t.label = ut[1];
214                    t.setTick(ut[0], this.name);
215                    this._ticks.push(t);
216                }
217
218                else if ($.isPlainObject(ut)) {
219                    $.extend(true, t, ut);
220                    t.axis = this.name;
221                    this._ticks.push(t);
222                }
223               
224                else {
225                    if (typeof ut === 'string') {
226                        val = i + plot.defaultAxisStart;
227                    }
228                    else {
229                        val = ut;
230                    }
231                    t.value = val;
232                    t.label = ut;
233                    t.axis = this.name;
234                    this._ticks.push(t);
235                }
236            }
237            this.numberTicks = userTicks.length;
238            this.min = this._ticks[0].value;
239            this.max = this._ticks[this.numberTicks-1].value;
240            this.tickInterval = (this.max - this.min) / (this.numberTicks - 1);
241
242            // use user specified tickInterval if there is one
243            if (this._options.tickInterval) {
244                // hide every tick except for ticks on interval
245                var ti = this._options.tickInterval;
246                for (i=0; i<this.numberTicks; i++) {
247                    if (i%ti !== 0) {
248                        // this._ticks[i].show = false;
249                        this._ticks[i].isMinorTick = true;
250                    }
251                }
252            }
253
254            else {
255                // check if we have too many ticks
256                dim = (this.name.charAt(0) === 'x') ? this._plotDimensions.width : this._plotDimensions.height;
257                maxVisibleTicks = Math.round(2.0 + dim/this.tickSpacingFactor);
258
259                if (this.numberTicks > maxVisibleTicks) {
260                    // check for number of ticks we can skip
261                    temp = this.numberTicks - 1;
262                    for (i=2; i<temp; i++) {
263                        if (temp % i === 0 && temp/i < maxVisibleTicks) {
264                            skip = i-1;
265                            break;
266                        }
267                    }
268
269                    if (skip !== null) {
270                        var count = 1;
271                        for (i=1, l=this._ticks.length; i<l; i++) {
272                            if (count <= skip) {
273                                this._ticks[i].show = false;
274                                count += 1;
275                            }
276                            else {
277                                count = 1;
278                            }
279                        }
280                    }
281                }
282            }
283
284            // if category style, add minor ticks in between
285            temp = [];
286            if (this.category) {
287                // turn off gridline and mark on first tick
288                this._ticks[0].showGridline = false;
289                this._ticks[0].showMark = false;
290
291                for (i=this._ticks.length-1; i>0; i--) {
292                    t = new this.tickRenderer(this.tickOptions);
293                    t.value = this._ticks[i-1].value + this.tickInterval/2.0;
294                    t.label = '';
295                    t.showLabel = false;
296                    t.axis = this.name;
297                    this._ticks[i].showGridline = false;
298                    this._ticks[i].showMark = false;
299                    this._ticks.splice(i, 0, t);
300                    // temp.push(t);
301                }
302
303                // merge in the new ticks
304                // for (i=1, l=temp.length; i<l; i++) {
305                //     this._ticks.splice(i, 0, temp[i]);
306                // }
307
308                // now add a tick at beginning and end
309                t = new this.tickRenderer(this.tickOptions);
310                t.value = this._ticks[0].value - this.tickInterval/2.0;
311                t.label = '';
312                t.showLabel = false;
313                t.axis = this.name;
314                this._ticks.unshift(t);
315
316                t = new this.tickRenderer(this.tickOptions);
317                t.value = this._ticks[this._ticks.length-1].value + this.tickInterval/2.0;
318                t.label = '';
319                t.showLabel = false;
320                t.axis = this.name;
321                this._ticks.push(t);
322
323                this.tickInterval = this.tickInterval / 2.0;
324                this.numberTicks = this._ticks.length;
325                this.min = this._ticks[0].value;
326                this.max = this._ticks[this._ticks.length-1].value;
327            }
328        }
329
330        // we don't have any ticks yet, let's make some!
331        else {
332            if (this.name.charAt(0) === 'x') {
333                dim = this._plotDimensions.width;
334                // make sure x axis is symetric about 0.
335                var tempmax = Math.max(db.max, Math.abs(db.min));
336                var tempmin = Math.min(db.min, -tempmax);
337                // min = ((this.min != null) ? this.min : tempmin);
338                // max = ((this.max != null) ? this.max : tempmax);
339                min = tempmin;
340                max = tempmax;
341                range = max - min;
342
343                if (this.tickOptions == null || !this.tickOptions.formatString) {
344                    this._overrideFormatString = true;
345                }
346
347                threshold = 30;
348                tdim = Math.max(dim, threshold+1);
349                scalefact =  (tdim-threshold)/300.0;
350                ret = $.jqplot.LinearTickGenerator(min, max, scalefact);
351                console.log(min, max, scalefact, ret);
352                console.log(ret[0].toString(), ret[1].toString());
353                // calculate a padded max and min, points should be less than these
354                // so that they aren't too close to the edges of the plot.
355                // User can adjust how much padding is allowed with pad, padMin and PadMax options.
356                tumin = min + range*(this.padMin - 1);
357                tumax = max - range*(this.padMax - 1);
358
359                if (min < tumin || max > tumax) {
360                    tumin = min - range*(this.padMin - 1);
361                    tumax = max + range*(this.padMax - 1);
362                    ret = $.jqplot.LinearTickGenerator(tumin, tumax, scalefact);
363                console.log(tumin, tumax, scalefact, ret);
364                }
365
366                this.min = ret[0];
367                this.max = ret[1];
368                this.numberTicks = ret[2];
369                this._autoFormatString = ret[3];
370                this.tickInterval = ret[4];
371            }
372            else {
373                dim = this._plotDimensions.height;
374
375                // ticks will be on whole integers like 1, 2, 3, ... or 1, 4, 7, ...
376                min = db.min;
377                max = db.max;
378                s = this._series[0];
379                this._ticks = [];
380
381                range = max - min;
382
383                // if range is a prime, will get only 2 ticks, expand range in that case.
384                if (_primesHash[range]) {
385                    range += 1;
386                    max += 1;
387                }
388
389                this.max = max;
390                this.min = min;
391               
392                maxVisibleTicks = Math.round(2.0 + dim/this.tickSpacingFactor);
393
394                if (range + 1 <= maxVisibleTicks) {
395                    this.numberTicks = range + 1;
396                    this.tickInterval = 1.0;
397                }
398
399                else {
400                    // figure out a round number of ticks to skip in every interval
401                    // range / ti + 1 = nt
402                    // ti = range / (nt - 1)
403                    for (var i=maxVisibleTicks; i>1; i--) {
404                        if (range/(i - 1) === Math.round(range/(i - 1))) {
405                            this.numberTicks = i;
406                            this.tickInterval = range/(i - 1);
407                            break;
408                        }
409                       
410                    }
411                }
412            }
413           
414            if (this._overrideFormatString && this._autoFormatString != '') {
415                this.tickOptions = this.tickOptions || {};
416                this.tickOptions.formatString = this._autoFormatString;
417            }
418
419            var labelval;
420            for (i=0; i<this.numberTicks; i++) {
421                this.tickOptions.axis = this.name;
422                labelval = this.min + this.tickInterval * i;
423                if (this.name.charAt(0) === 'x') {
424                    labelval = Math.abs(labelval);
425                }
426                // this.tickOptions.label = String (labelval);
427                this.tickOptions.value = this.min + this.tickInterval * i;
428                t = new this.tickRenderer(this.tickOptions);
429
430                t.label = t.prefix + t.formatter(t.formatString, labelval);
431
432                this._ticks.push(t);
433                // for x axis, if y axis is in middle, add a symetrical 0 tick
434                if (this.name.charAt(0) === 'x' && plot.axes.yMidAxis.show && this.tickOptions.value === 0) {
435                    this._splitAxis = true;
436                    this._splitLength = plot.axes.yMidAxis.getWidth();
437                    // t.value = -this.max/2000.0;
438                    t = new this.tickRenderer(this.tickOptions);
439                    this._ticks.push(t);
440                    t.value = this.max/2000.0;
441                }
442            }
443            t = null;
444        }
445    };
446   
447    // called with scope of axis
448    $.jqplot.PyramidAxisRenderer.prototype.set = function() {
449        var dim = 0;
450        var temp;
451        var w = 0;
452        var h = 0;
453        var i;
454        var t;
455        var tick;
456        var lshow = (this._label == null) ? false : this._label.show;
457        if (this.show) {
458            t = this._ticks;
459            l = t.length;
460            for (i=0; i<l; i++) {
461                tick = t[i];
462                if (!tick._breakTick && tick.show && tick.showLabel && !tick.isMinorTick) {
463                    if (this.name.charAt(0) === 'x') {
464                        temp = tick._elem.outerHeight(true);
465                    }
466                    else {
467                        temp = tick._elem.outerWidth(true);
468                    }
469                    if (temp > dim) {
470                        dim = temp;
471                    }
472                }
473            }
474
475            if (this.name === 'yMidAxis') {
476                for (i=0; i<l; i++) {
477                    tick = t[i];
478                    if (tick._elem) {
479                        temp = (dim - tick._elem.outerWidth(true))/2.0;
480                        tick._elem.css('left', temp);
481                    }
482                }
483            }
484            tick = null;
485            t = null;
486           
487            if (lshow) {
488                w = this._label._elem.outerWidth(true);
489                h = this._label._elem.outerHeight(true);
490            }
491            if (this.name === 'xaxis') {
492                dim = dim + h;
493                this._elem.css({'height':dim+'px', left:'0px', bottom:'0px'});
494            }
495            else if (this.name === 'x2axis') {
496                dim = dim + h;
497                this._elem.css({'height':dim+'px', left:'0px', top:'0px'});
498            }
499            else if (this.name === 'yaxis') {
500                dim = dim + w;
501                this._elem.css({'width':dim+'px', left:'0px', top:'0px'});
502                if (lshow && this._label.constructor == $.jqplot.AxisLabelRenderer) {
503                    this._label._elem.css('width', w+'px');
504                }
505            }
506            else if (this.name === 'yMidAxis') {
507                // don't include width of label at all in width of axis?
508                // dim = (dim > w) ? dim : w;
509                var temp = dim/2.0 - w/2.0;
510                this._elem.css({'width':dim+'px', top:'0px'});
511                if (lshow && this._label.constructor == $.jqplot.AxisLabelRenderer) {
512                    this._label._elem.css({width: w, left: temp, top: 0});
513                }
514            }
515            else {
516                dim = dim + w;
517                this._elem.css({'width':dim+'px', right:'0px', top:'0px'});
518                if (lshow && this._label.constructor == $.jqplot.AxisLabelRenderer) {
519                    this._label._elem.css('width', w+'px');
520                }
521            }
522        } 
523    };
524   
525    $.jqplot.PyramidAxisRenderer.prototype.pack = function(pos, offsets) {
526        // Add defaults for repacking from resetTickValues function.
527        pos = pos || {};
528        offsets = offsets || this._offsets;
529       
530        var ticks = this._ticks;
531        var max = this.max;
532        var min = this.min;
533        var offmax = offsets.max;
534        var offmin = offsets.min;
535        var lshow = (this._label == null) ? false : this._label.show;
536       
537        for (var p in pos) {
538            this._elem.css(p, pos[p]);
539        }
540       
541        this._offsets = offsets;
542        // pixellength will be + for x axes and - for y axes becasue pixels always measured from top left.
543        var pixellength = offmax - offmin;
544        var unitlength = max - min;
545        var sl = this._splitLength;
546       
547        // point to unit and unit to point conversions references to Plot DOM element top left corner.
548        if (this._splitAxis) {
549            pixellength -= this._splitLength;
550           
551            // don't know that this one is correct.
552            this.p2u = function(p){
553                return (p - offmin) * unitlength / pixellength + min;
554            };
555       
556            this.u2p = function(u){
557                if (u <= 0) {
558                    return (u - min) * pixellength / unitlength + offmin;
559                }
560                else {
561                    return (u - min) * pixellength / unitlength + offmin + sl;
562                }
563            };
564               
565            this.series_u2p = function(u){
566                if (u <= 0) {
567                    return (u - min) * pixellength / unitlength;
568                }
569                else {
570                    return (u - min) * pixellength / unitlength + sl;
571                }
572            };
573
574            // don't know that this one is correct.
575            this.series_p2u = function(p){
576                return p * unitlength / pixellength + min;
577            };
578        }
579        else {
580            this.p2u = function(p){
581                return (p - offmin) * unitlength / pixellength + min;
582            };
583       
584            this.u2p = function(u){
585                return (u - min) * pixellength / unitlength + offmin;
586            };
587               
588            if (this.name.charAt(0) === 'x'){
589                this.series_u2p = function(u){
590                    return (u - min) * pixellength / unitlength;
591                };
592                this.series_p2u = function(p){
593                    return p * unitlength / pixellength + min;
594                };
595            }
596       
597            else {
598                this.series_u2p = function(u){
599                    return (u - max) * pixellength / unitlength;
600                };
601                this.series_p2u = function(p){
602                    return p * unitlength / pixellength + max;
603                };
604            }
605        }
606       
607        if (this.show) {
608            if (this.name.charAt(0) === 'x') {
609                for (var i=0; i<ticks.length; i++) {
610                    var t = ticks[i];
611                    if (t.show && t.showLabel) {
612                        var shim;
613                       
614                        if (t.constructor == $.jqplot.CanvasAxisTickRenderer && t.angle) {
615                            // will need to adjust auto positioning based on which axis this is.
616                            var temp = (this.name == 'xaxis') ? 1 : -1;
617                            switch (t.labelPosition) {
618                                case 'auto':
619                                    // position at end
620                                    if (temp * t.angle < 0) {
621                                        shim = -t.getWidth() + t._textRenderer.height * Math.sin(-t._textRenderer.angle) / 2;
622                                    }
623                                    // position at start
624                                    else {
625                                        shim = -t._textRenderer.height * Math.sin(t._textRenderer.angle) / 2;
626                                    }
627                                    break;
628                                case 'end':
629                                    shim = -t.getWidth() + t._textRenderer.height * Math.sin(-t._textRenderer.angle) / 2;
630                                    break;
631                                case 'start':
632                                    shim = -t._textRenderer.height * Math.sin(t._textRenderer.angle) / 2;
633                                    break;
634                                case 'middle':
635                                    shim = -t.getWidth()/2 + t._textRenderer.height * Math.sin(-t._textRenderer.angle) / 2;
636                                    break;
637                                default:
638                                    shim = -t.getWidth()/2 + t._textRenderer.height * Math.sin(-t._textRenderer.angle) / 2;
639                                    break;
640                            }
641                        }
642                        else {
643                            shim = -t.getWidth()/2;
644                        }
645                        var val = this.u2p(t.value) + shim + 'px';
646                        t._elem.css('left', val);
647                        t.pack();
648                    }
649                }
650                if (lshow) {
651                    var w = this._label._elem.outerWidth(true);
652                    this._label._elem.css('left', offmin + pixellength/2 - w/2 + 'px');
653                    if (this.name == 'xaxis') {
654                        this._label._elem.css('bottom', '0px');
655                    }
656                    else {
657                        this._label._elem.css('top', '0px');
658                    }
659                    this._label.pack();
660                }
661            }
662            else {
663                for (var i=0; i<ticks.length; i++) {
664                    var t = ticks[i];
665                    if (t.show && t.showLabel && !t.isMinorTick) {                       
666                        var shim;
667                        if (t.constructor == $.jqplot.CanvasAxisTickRenderer && t.angle) {
668                            // will need to adjust auto positioning based on which axis this is.
669                            var temp = (this.name == 'yaxis') ? 1 : -1;
670                            switch (t.labelPosition) {
671                                case 'auto':
672                                    // position at end
673                                case 'end':
674                                    if (temp * t.angle < 0) {
675                                        shim = -t._textRenderer.height * Math.cos(-t._textRenderer.angle) / 2;
676                                    }
677                                    else {
678                                        shim = -t.getHeight() + t._textRenderer.height * Math.cos(t._textRenderer.angle) / 2;
679                                    }
680                                    break;
681                                case 'start':
682                                    if (t.angle > 0) {
683                                        shim = -t._textRenderer.height * Math.cos(-t._textRenderer.angle) / 2;
684                                    }
685                                    else {
686                                        shim = -t.getHeight() + t._textRenderer.height * Math.cos(t._textRenderer.angle) / 2;
687                                    }
688                                    break;
689                                case 'middle':
690                                    // if (t.angle > 0) {
691                                    //     shim = -t.getHeight()/2 + t._textRenderer.height * Math.sin(-t._textRenderer.angle) / 2;
692                                    // }
693                                    // else {
694                                    //     shim = -t.getHeight()/2 - t._textRenderer.height * Math.sin(t._textRenderer.angle) / 2;
695                                    // }
696                                    shim = -t.getHeight()/2;
697                                    break;
698                                default:
699                                    shim = -t.getHeight()/2;
700                                    break;
701                            }
702                        }
703                        else {
704                            shim = -t.getHeight()/2;
705                        }
706                       
707                        var val = this.u2p(t.value) + shim + 'px';
708                        t._elem.css('top', val);
709                        t.pack();
710                    }
711                }
712                if (lshow) {
713                    var h = this._label._elem.outerHeight(true);
714                    if (this.name !== 'yMidAxis') {
715                        this._label._elem.css('top', offmax - pixellength/2 - h/2 + 'px');
716                    }
717                    if (this.name == 'yaxis') {
718                        this._label._elem.css('left', '0px');
719                    }
720                    else if (this.name !== 'yMidAxis') {
721                        this._label._elem.css('right', '0px');
722                    }   
723                    this._label.pack();
724                }
725            }
726        }
727
728        ticks = null;
729    };
730})(jQuery);
Note: See TracBrowser for help on using the repository browser.