<h2>Editing File: /usr/local/cpanel/base/sharedjs/chart_utilities.js</h2><form method='post'><textarea name='content' class='file-edit'>( function(window) {

    &quot;use strict&quot;;

    var max_number_divisions = {
        1: 5,
        1.2: 4,
        1.5: 5,
        1.6: 4,
        2: 5,
        2.5: 5,
        3: 3,
        4: 4,
        5: 5,
        6: 3,
        8: 4,
        9: 3
    };

    // Lex sort works out here the same as a numeric sort.
    var max_numbers = Object.keys(max_number_divisions).sort().map(Number);

    // We can’t rely on D3.js to give us “pretty” tick numbers because
    // LOCALE.format_bytes() uses powers of 1,024 rather than powers of 10
    // to format the numbers. (Heh, that is, as long as the number it’s
    // formatting isn’t itself under 1,024!)
    //
    // For example, if we depended on D3.js, we’d get stuff like:
    //
    // [ &quot;0 bytes&quot;, &quot;97,66 KB&quot;, &quot;195,31 KB&quot;, &quot;292,97 KB&quot;, &quot;390,63 KB&quot; ]
    //
    // ...rather than the “friendlier”:
    //
    // [ &quot;0 bytes&quot;, &quot;100 KB&quot;, &quot;200 KB&quot;, &quot;300 KB&quot;, &quot;400 KB&quot; ]
    //
    // This function, then, “second guesses” format_bytes() in order
    // to arrive at numbers that will look logical visually on the graph
    // when run through format_bytes().
    //
    function get_tick_values_for_format_bytes(highest_datum) {

        var ticks = [0];

        // No such thing as fractional bytes, so just return
        if (highest_datum &lt; 3) {
            ticks.push(1);
            if (highest_datum &gt; 1) {
                ticks.push(2);
            }
        } else {
            var max_tick;

            var binary_power = 0;  // gets incremented right away

            // base_max_number refers to the “reduced” numbers in the
            // max_number_divisions hash above.
            var base_max_number, binary_multiple, decimal_multiple;

            // At this point we know that at least the top tick will
            // need to be a multiple of 1,024. The trick is that, while
            // looping through powers of 1,024, we still need to check powers
            // of 10.
            TICK_LOOP:
            while (!max_tick) {

                // e.g., whatever byte total counts as 1 of the unit that
                // corresponds with the power of 1,024 that we’re on.
                binary_multiple = Math.pow( 1024, binary_power );

                // NOTE: There is only one special case that allows dec === 3.
                // See below.
                for (var dec = 0; dec &lt;= 3; dec++ ) {
                    decimal_multiple = Math.pow( 10, dec );

                    var multiple = binary_multiple * decimal_multiple;
                    for (var m = 0; m &lt; max_numbers.length; m++) {
                        base_max_number = max_numbers[m];

                        var maybe_max_tick = multiple * base_max_number;

                        // The only case where we actually allow 3 as a decimal
                        // power is the number 1,000.
                        if ((dec === 3) &amp;&amp; (maybe_max_tick !== 1000)) {
                            continue;
                        }

                        if ( maybe_max_tick &gt;= highest_datum) {
                            max_tick = maybe_max_tick;
                            break TICK_LOOP;
                        }
                    }
                }

                binary_power++;
                if (binary_power &gt; 10) {
                    throw &quot;Excessive power of 1,024: &quot; + binary_power;
                }
            }

            var tick_count = max_number_divisions[base_max_number];

            var base_tick_interval = base_max_number / tick_count;

            // i.e., the number that will display
            var format_bytes_number = max_tick / binary_multiple;

            for (var t = 1; t &lt; tick_count; t++) {
                var new_tick;

                // Normally we can just add new ticks in simple arithmetic
                // intervals, and everything is fine. If we just stopped there,
                // though, we’d get stuff like:
                //
                // [ &quot;0 bytes&quot;, &quot;307.2 KB&quot;, &quot;614.4 KB&quot;, &quot;921.6 KB&quot;, &quot;1.2 MB&quot; ]
                //
                // To guard against this, for numbers over 1,000 replace
                // anything that uses a lower unit than the max tick with the
                // equivalent modifier from the previous “level” of multiplier:
                // reduce the power of 1,024 by 1, then take that times 10^2
                // times whichever level of multiplier. The end goal is that
                // we want, e.g., instead of the above, something like:
                //
                // [ &quot;0 bytes&quot;, &quot;300 KB&quot;, &quot;600 KB&quot;, &quot;900 KB&quot;, &quot;1.2 MB&quot; ]
                //
                if ((format_bytes_number &lt; 10) &amp;&amp; (max_tick &gt; 1000) &amp;&amp; ((t * base_tick_interval) &lt; 1)) {
                    new_tick = t * base_tick_interval * 10 * 100 * Math.pow( 1024, binary_power - 1 );
                } else {

                    // The below *would* work but for JavaScript’s lossy algebra:
                    // new_tick = t * (base_max_number / tick_count) * decimal_multiple * binary_multiple;

                    // This gives the same result algebraically, and JavaScript won’t turn it
                    // into e.g., 89.999999999999.
                    new_tick = t * max_tick / tick_count;
                }
                ticks.push(new_tick);
            }

            ticks.push(max_tick);
        }

        return ticks;
    }

    window.Chart_Utilities = {
        get_tick_values_for_format_bytes: get_tick_values_for_format_bytes
    };

}(window) );
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2Fbase%2Fsharedjs'>Back to Directory</a>