git.pond.sub.org Git - eow/blob - static/dojo-release-1.1.1/dojox/charting/scaler.js

   1 if(!dojo._hasResource["dojox.charting.scaler"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
   2 dojo._hasResource["dojox.charting.scaler"] = true;
   3 dojo.provide("dojox.charting.scaler");
   4
   5 (function(){
   6         var deltaLimit = 3;     // pixels
   7
   8         var isText = function(val, text){
   9                 val = val.toLowerCase();
  10                 for(var i = 0; i < text.length; ++i){
  11                         if(val == text[i]){ return true; }
  12                 }
  13                 return false;
  14         };
  15
  16         var calcTicks = function(min, max, kwArgs, majorTick, minorTick, microTick, span){
  17                 kwArgs = dojo.clone(kwArgs);
  18                 if(!majorTick){
  19                         if(kwArgs.fixUpper == "major"){ kwArgs.fixUpper = "minor"; }
  20                         if(kwArgs.fixLower == "major"){ kwArgs.fixLower = "minor"; }
  21                 }
  22                 if(!minorTick){
  23                         if(kwArgs.fixUpper == "minor"){ kwArgs.fixUpper = "micro"; }
  24                         if(kwArgs.fixLower == "minor"){ kwArgs.fixLower = "micro"; }
  25                 }
  26                 if(!microTick){
  27                         if(kwArgs.fixUpper == "micro"){ kwArgs.fixUpper = "none"; }
  28                         if(kwArgs.fixLower == "micro"){ kwArgs.fixLower = "none"; }
  29                 }
  30                 var lowerBound = isText(kwArgs.fixLower, ["major"]) ?
  31                                 Math.floor(min / majorTick) * majorTick :
  32                                         isText(kwArgs.fixLower, ["minor"]) ?
  33                                                 Math.floor(min / minorTick) * minorTick :
  34                                                         isText(kwArgs.fixLower, ["micro"]) ?
  35                                                                 Math.floor(min / microTick) * unit : min,
  36                         upperBound = isText(kwArgs.fixUpper, ["major"]) ?
  37                                 Math.ceil(max / majorTick) * majorTick :
  38                                         isText(kwArgs.fixUpper, ["minor"]) ?
  39                                                 Math.ceil(max / minorTick) * minorTick :
  40                                                         isText(kwArgs.fixUpper, ["unit"]) ?
  41                                                                 Math.ceil(max / unit) * unit : max,
  42                         majorStart = (isText(kwArgs.fixLower, ["major"]) || !majorTick) ?
  43                                 lowerBound : Math.ceil(lowerBound / majorTick) * majorTick,
  44                         minorStart = (isText(kwArgs.fixLower, ["major", "minor"]) || !minorTick) ?
  45                                 lowerBound : Math.ceil(lowerBound / minorTick) * minorTick,
  46                         microStart = (isText(kwArgs.fixLower, ["major", "minor", "micro"]) || ! microTick) ?
  47                                 lowerBound : Math.ceil(lowerBound / microTick) * microTick,
  48                         majorCount = !majorTick ? 0 : (isText(kwArgs.fixUpper, ["major"]) ?
  49                                 Math.round((upperBound - majorStart) / majorTick) :
  50                                 Math.floor((upperBound - majorStart) / majorTick)) + 1,
  51                         minorCount = !minorTick ? 0 : (isText(kwArgs.fixUpper, ["major", "minor"]) ?
  52                                 Math.round((upperBound - minorStart) / minorTick) :
  53                                 Math.floor((upperBound - minorStart) / minorTick)) + 1,
  54                         microCount = !microTick ? 0 : (isText(kwArgs.fixUpper, ["major", "minor", "micro"]) ?
  55                                 Math.round((upperBound - microStart) / microTick) :
  56                                 Math.floor((upperBound - microStart) / microTick)) + 1,
  57                         minorPerMajor  = minorTick ? Math.round(majorTick / minorTick) : 0,
  58                         microPerMinor  = microTick ? Math.round(minorTick / microTick) : 0,
  59                         majorPrecision = majorTick ? Math.floor(Math.log(majorTick) / Math.LN10) : 0,
  60                         minorPrecision = minorTick ? Math.floor(Math.log(minorTick) / Math.LN10) : 0,
  61                         scale = span / (upperBound - lowerBound);
  62                 if(!isFinite(scale)){ scale = 1; }
  63                 return {
  64                         bounds: {
  65                                 lower:  lowerBound,
  66                                 upper:  upperBound
  67                         },
  68                         major: {
  69                                 tick:   majorTick,
  70                                 start:  majorStart,
  71                                 count:  majorCount,
  72                                 prec:   majorPrecision
  73                         },
  74                         minor: {
  75                                 tick:   minorTick,
  76                                 start:  minorStart,
  77                                 count:  minorCount,
  78                                 prec:   minorPrecision
  79                         },
  80                         micro: {
  81                                 tick:   microTick,
  82                                 start:  microStart,
  83                                 count:  microCount,
  84                                 prec:   0
  85                         },
  86                         minorPerMajor:  minorPerMajor,
  87                         microPerMinor:  microPerMinor,
  88                         scale:                  scale
  89                 };
  90         };
  91
  92         dojox.charting.scaler = function(min, max, span, kwArgs){
  93                 var h = {fixUpper: "none", fixLower: "none", natural: false};
  94                 if(kwArgs){
  95                         if("fixUpper" in kwArgs){ h.fixUpper = String(kwArgs.fixUpper); }
  96                         if("fixLower" in kwArgs){ h.fixLower = String(kwArgs.fixLower); }
  97                         if("natural"  in kwArgs){ h.natural  = Boolean(kwArgs.natural); }
  98                 }
  99
 100                 if(max <= min){
 101                         return calcTicks(min, max, h, 0, 0, 0, span);   // Object
 102                 }
 103
 104                 var mag = Math.floor(Math.log(max - min) / Math.LN10),
 105                         major = kwArgs && ("majorTick" in kwArgs) ? kwArgs.majorTick : Math.pow(10, mag),
 106                         minor = 0, micro = 0, ticks;
 107
 108                 // calculate minor ticks
 109                 if(kwArgs && ("minorTick" in kwArgs)){
 110                         minor = kwArgs.minorTick;
 111                 }else{
 112                         do{
 113                                 minor = major / 10;
 114                                 if(!h.natural || minor > 0.9){
 115                                         ticks = calcTicks(min, max, h, major, minor, 0, span);
 116                                         if(ticks.scale * ticks.minor.tick > deltaLimit){ break; }
 117                                 }
 118                                 minor = major / 5;
 119                                 if(!h.natural || minor > 0.9){
 120                                         ticks = calcTicks(min, max, h, major, minor, 0, span);
 121                                         if(ticks.scale * ticks.minor.tick > deltaLimit){ break; }
 122                                 }
 123                                 minor = major / 2;
 124                                 if(!h.natural || minor > 0.9){
 125                                         ticks = calcTicks(min, max, h, major, minor, 0, span);
 126                                         if(ticks.scale * ticks.minor.tick > deltaLimit){ break; }
 127                                 }
 128                                 return calcTicks(min, max, h, major, 0, 0, span);       // Object
 129                         }while(false);
 130                 }
 131
 132                 // calculate micro ticks
 133                 if(kwArgs && ("microTick" in kwArgs)){
 134                         micro = kwArgs.microTick;
 135                         ticks = calcTicks(min, max, h, major, minor, micro, span);
 136                 }else{
 137                         do{
 138                                 micro = minor / 10;
 139                                 if(!h.natural || micro > 0.9){
 140                                         ticks = calcTicks(min, max, h, major, minor, micro, span);
 141                                         if(ticks.scale * ticks.micro.tick > deltaLimit){ break; }
 142                                 }
 143                                 micro = minor / 5;
 144                                 if(!h.natural || micro > 0.9){
 145                                         ticks = calcTicks(min, max, h, major, minor, micro, span);
 146                                         if(ticks.scale * ticks.micro.tick > deltaLimit){ break; }
 147                                 }
 148                                 micro = minor / 2;
 149                                 if(!h.natural || micro > 0.9){
 150                                         ticks = calcTicks(min, max, h, major, minor, micro, span);
 151                                         if(ticks.scale * ticks.micro.tick > deltaLimit){ break; }
 152                                 }
 153                                 micro = 0;
 154                         }while(false);
 155                 }
 156
 157                 return micro ? ticks : calcTicks(min, max, h, major, minor, 0, span);   // Object
 158         };
 159 })();
 160
 161 }