dojox/charting/scaler/linear.js

• Provides:

  • dojox.charting.scaler.linear

• Requires:

  • dojox.charting.scaler.common in common

• dc

  • summary

• findString

  • summary

• getLabel

  • summary

• dojox.charting.scaler.linear.buildScaler

  • type

    Function

  • parameters:
    • min: (typeof Number)
    • max: (typeof Number)
    • span: (typeof Number)
    • kwArgs: (typeof Object)
  • source: [view]
       var h = {fixUpper: "none", fixLower: "none", natural: false};
       if(kwArgs){
        if("fixUpper" in kwArgs){ h.fixUpper = String(kwArgs.fixUpper); }
        if("fixLower" in kwArgs){ h.fixLower = String(kwArgs.fixLower); }
        if("natural" in kwArgs){ h.natural = Boolean(kwArgs.natural); }
       }
    
       
       // update bounds
       if("min" in kwArgs){ min = kwArgs.min; }
       if("max" in kwArgs){ max = kwArgs.max; }
       if(kwArgs.includeZero){
        if(min > 0){ min = 0; }
        if(max < 0){ max = 0; }
       }
       h.min = min;
       h.useMin = true;
       h.max = max;
       h.useMax = true;
    
       
       if("from" in kwArgs){
        min = kwArgs.from;
        h.useMin = false;
       }
       if("to" in kwArgs){
        max = kwArgs.to;
        h.useMax = false;
       }
    
       
       // check for erroneous condition
       if(max <= min){
        return calcTicks(min, max, h, 0, 0, 0, span); // Object
       }
    
       
       var mag = Math.floor(Math.log(max - min) / Math.LN10),
        major = kwArgs && ("majorTickStep" in kwArgs) ? kwArgs.majorTickStep : Math.pow(10, mag),
        minor = 0, micro = 0, ticks;
    
        
       // calculate minor ticks
       if(kwArgs && ("minorTickStep" in kwArgs)){
        minor = kwArgs.minorTickStep;
       }else{
        do{
         minor = major / 10;
         if(!h.natural || minor > 0.9){
          ticks = calcTicks(min, max, h, major, minor, 0, span);
          if(ticks.bounds.scale * ticks.minor.tick > deltaLimit){ break; }
         }
         minor = major / 5;
         if(!h.natural || minor > 0.9){
          ticks = calcTicks(min, max, h, major, minor, 0, span);
          if(ticks.bounds.scale * ticks.minor.tick > deltaLimit){ break; }
         }
         minor = major / 2;
         if(!h.natural || minor > 0.9){
          ticks = calcTicks(min, max, h, major, minor, 0, span);
          if(ticks.bounds.scale * ticks.minor.tick > deltaLimit){ break; }
         }
         return calcTicks(min, max, h, major, 0, 0, span); // Object
        }while(false);
       }
    
     
       // calculate micro ticks
       if(kwArgs && ("microTickStep" in kwArgs)){
        micro = kwArgs.microTickStep;
        ticks = calcTicks(min, max, h, major, minor, micro, span);
       }else{
        do{
         micro = minor / 10;
         if(!h.natural || micro > 0.9){
          ticks = calcTicks(min, max, h, major, minor, micro, span);
          if(ticks.bounds.scale * ticks.micro.tick > deltaLimit){ break; }
         }
         micro = minor / 5;
         if(!h.natural || micro > 0.9){
          ticks = calcTicks(min, max, h, major, minor, micro, span);
          if(ticks.bounds.scale * ticks.micro.tick > deltaLimit){ break; }
         }
         micro = minor / 2;
         if(!h.natural || micro > 0.9){
          ticks = calcTicks(min, max, h, major, minor, micro, span);
          if(ticks.bounds.scale * ticks.micro.tick > deltaLimit){ break; }
         }
         micro = 0;
        }while(false);
       }
    
     
       return micro ? ticks : calcTicks(min, max, h, major, minor, 0, span); // Object
  • returns

    Object

  • summary

• dojox.charting.scaler.linear.buildTicks

  • type

    Function

  • parameters:
    • scaler: (typeof Object)
    • kwArgs: (typeof Object)
  • source: [view]
       var step, next, tick,
        nextMajor = scaler.major.start,
        nextMinor = scaler.minor.start,
        nextMicro = scaler.micro.start;
       if(kwArgs.microTicks && scaler.micro.tick){
        step = scaler.micro.tick, next = nextMicro;
       }else if(kwArgs.minorTicks && scaler.minor.tick){
        step = scaler.minor.tick, next = nextMinor;
       }else if(scaler.major.tick){
        step = scaler.major.tick, next = nextMajor;
       }else{
        // no ticks
        return null;
       }
       // make sure that we have finite bounds
       var revScale = 1 / scaler.bounds.scale;
       if(scaler.bounds.to <= scaler.bounds.from || isNaN(revScale) || !isFinite(revScale) ||
         step <= 0 || isNaN(step) || !isFinite(step)){
        // no ticks
        return null;
       }
       // loop over all ticks
       var majorTicks = [], minorTicks = [], microTicks = [];
       while(next <= scaler.bounds.to + revScale){
        if(Math.abs(nextMajor - next) < step / 2){
         // major tick
         tick = {value: nextMajor};
         if(kwArgs.majorLabels){
          tick.label = getLabel(nextMajor, scaler.major.prec, kwArgs);
         }
         majorTicks.push(tick);
         nextMajor += scaler.major.tick;
         nextMinor += scaler.minor.tick;
         nextMicro += scaler.micro.tick;
        }else if(Math.abs(nextMinor - next) < step / 2){
         // minor tick
         if(kwArgs.minorTicks){
          tick = {value: nextMinor};
          if(kwArgs.minorLabels && (scaler.minMinorStep <= scaler.minor.tick * scaler.bounds.scale)){
           tick.label = getLabel(nextMinor, scaler.minor.prec, kwArgs);
          }
          minorTicks.push(tick);
         }
         nextMinor += scaler.minor.tick;
         nextMicro += scaler.micro.tick;
        }else{
         // micro tick
         if(kwArgs.microTicks){
          microTicks.push({value: nextMicro});
         }
         nextMicro += scaler.micro.tick;
        }
        next += step;
       }
       return {major: majorTicks, minor: minorTicks, micro: microTicks}; // Object
  • returns

    Object

  • summary

• dojox.charting.scaler.linear.getTransformerFromModel

  • type

    Function

  • parameters:
    • scaler: (typeof Object)
  • source: [view]
       var offset = scaler.bounds.from, scale = scaler.bounds.scale;
       return function(x){ return (x - offset) * scale; }; // Function
  • returns

    Function

  • summary

• dojox.charting.scaler.linear.getTransformerFromPlot

  • type

    Function

  • parameters:
    • scaler: (typeof Object)
  • source: [view]
       var offset = scaler.bounds.from, scale = scaler.bounds.scale;
       return function(x){ return x / scale + offset; }; // Function
  • returns

    Function

  • summary

• dojox.charting.scaler.linear

  • type

    Object

  • summary

• dojox.charting.scaler

  • type

    Object

  • summary

• dojox.charting

  • type

    Object

  • summary

• dojox

  • type

    Object

  • summary