RulerCalculations Class Reference

#include <ruler.hh>

Collaboration diagram for RulerCalculations:

Static Public Member Functions
static int	calculateInterval (double lower, double upper, double allocatedSize)
static int	intervalPixelSpacing (double interval, double lower, double upper, double allocatedSize)
static int	firstTick (double lower, int interval)
static double	scaleToRange (double x, double src_lower, double src_upper, double dest_lower, double dest_upper)

Static Public Attributes
static constexpr int	MIN_SPACE_MAJORTICKS {80}

Static Private Attributes
static constexpr std::array< int, 4 >	VALID_INTERVALS {1, 5, 10, 25}

Detailed Description

This class contains the functions a Ruler uses to calculate the interval between major ticks.

Member Function Documentation

calculateInterval()

int RulerCalculations::calculateInterval ( double  lower, double  upper, double  allocatedSize  )

static

Calculates an appropriate interval between major ticks on a ruler.

Parameters

lower	Lower limit of the ruler range. Must be strictly less than upper.
upper	Upper limit of the ruler range. Must be strictly greater than lower.
allocatedSize	The allocated width/height in pixels for the ruler.

Returns

The interval between ticks, or -1 if the given range is invalid.

{
  // We need to calculate the distance between the largest ticks on the ruler
  // We will try each interval x * 10^n for x in VALID_INTERVALS and integer n >= 0
  // from smallest to largest until we find an interval which will produce a
  // spacing of a large enough width/height when drawn
 
  require(upper > lower);
  require(upper - lower >= 1);
  require(allocatedSize > 0);
 
  // Index in the ruler's VALID_INTERVALS array
  int intervalIndex = 0;
  // Each interval is multiplied by 10 raised to a power n
  const int INTERVAL_BASE = 10;
  int intervalN = 0;
 
  // The interval to be returned
  int interval = 1;
 
  while(true)
  {
    interval = floor(VALID_INTERVALS.at(intervalIndex) * pow(INTERVAL_BASE, intervalN));
 
    // Calculate the drawn size for this interval by mapping from the ruler range
    // to the ruler size on the screen
    const double spacing = intervalPixelSpacing(interval, lower, upper, allocatedSize);
    if(spacing < 0)
    {
      return -1;
    }
    // If we've found a segment of appropriate size, we can stop
    if(spacing >= MIN_SPACE_MAJORTICKS)
    {
      break;
    }
 
    // Otherwise, try the next interval
    intervalIndex++;
    if(static_cast<unsigned int>(intervalIndex) == VALID_INTERVALS.size())
    {
      // We tried all intervals for the current n, increment n
      intervalIndex = 0;
      intervalN++;
    }
  }
 
  return interval;
}

Referenced by testCorrectIntervalForMinWidth(), and Ruler::updateMajorTickInterval().

Here is the call graph for this function:

Here is the caller graph for this function:

firstTick()

int RulerCalculations::firstTick ( double  lower, int  interval  )

static

Returns the position in the ruler range to start drawing from.

Parameters

lower	The lower limit of the ruler range.
interval	The interval between major ticks that the ruler will be drawn with.

Returns

The position of in the ruler to start drawing from.

{ return static_cast<int>(floor(lower / interval)) * interval; }

Referenced by Ruler::draw().

Here is the caller graph for this function:

intervalPixelSpacing()

int RulerCalculations::intervalPixelSpacing ( double  interval, double  lower, double  upper, double  allocatedSize  )

static

Calculates the spacing in pixels between tick marks for a given interval.

Parameters

interval	The interval to calculate the spacing for.
lower	Lower limit of the ruler range. Must be strictly less than upper.
upper	Upper limit of the ruler range. Must be strictly greater than lower.
allocatedSize	The allocated width/height in pixels for the ruler. Must be greater than 0.

Returns

The spacing in pixels between tick marks for a given interval, or -1 if the given range is invalid.

{
  require(upper > lower);
  require(allocatedSize > 0);
 
  const double RANGE_SIZE = upper - lower;
  return floor((allocatedSize / RANGE_SIZE) * interval);
}

Referenced by calculateInterval(), and Ruler::updateMajorTickInterval().

Here is the caller graph for this function:

scaleToRange()

double RulerCalculations::scaleToRange ( double  x, double  src_lower, double  src_upper, double  dest_lower, double  dest_upper  )

static

Scales a number x in the range [src_lower, src_upper] to the range [dest_lower, dest_upper]. Used to scale from the ruler range to the drawing space.

Parameters

x	The number to scale.
src_lower	The lower limit of the source range. Inclusive.
src_upper	The upper limit of the source range. Inclusive.
dest_lower	The lower limit of the destination range. Inclusive.
dest_upper	The upper limit of the destination range. Inclusive.

Returns

The result of x scaled from range source to dest.

{
  const double src_size = src_upper - src_lower;
  const double dest_size = dest_upper - dest_lower;
  const double scale = dest_size / src_size;
 
  return dest_lower + round(scale * (x - src_lower));
}

Referenced by Ruler::drawTicks().

Here is the caller graph for this function:

Member Data Documentation

MIN_SPACE_MAJORTICKS

constexpr int RulerCalculations::MIN_SPACE_MAJORTICKS {80}

staticconstexpr

The minimum space between major ticks.

{80};

Referenced by calculateInterval(), and testCorrectIntervalForMinWidth().

VALID_INTERVALS

constexpr std::array<int, 4> RulerCalculations::VALID_INTERVALS {1, 5, 10, 25}

staticconstexprprivate

Valid intervals between major ticks.

{1, 5, 10, 25};

Referenced by calculateInterval().

---

The documentation for this class was generated from the following files:

• gui/ruler/inc/ruler.hh
• gui/ruler/src/ruler.cc