Used to display a Ruler. More...

#include <Ruler.h>

Classes
struct	Fonts

class	Label
	An array of these created by the Ruler is used to determine what and where text annotations to the numbers on the Ruler get drawn. More...

Public Types
enum	RulerFormat { IntFormat, RealFormat, RealLogFormat, TimeFormat, LinearDBFormat }

Public Member Functions
	Ruler ()

	~Ruler ()

void	SetBounds (int left, int top, int right, int bottom)

void	SetOrientation (int orient)

void	SetRange (double min, double max)

void	SetRange (double min, double max, double hiddenMin, double hiddenMax)

void	SetTwoTone (bool twoTone)

void	SetFormat (RulerFormat format)

void	SetUnits (const wxString &units)

void	SetDbMirrorValue (const double d)

void	SetLog (bool log)

void	SetSpacing (int spacing)

void	SetLabelEdges (bool labelEdges)

void	SetFlip (bool flip)

void	SetMinor (bool value)

void	SetFonts (const wxFont &minorFont, const wxFont &majorFont, const wxFont &minorMinorFont)

Fonts	GetFonts () const

void	SetNumberScale (const NumberScale *pScale)

void	OfflimitsPixels (int start, int end)

void	GetMaxSize (wxCoord width, wxCoord height)

void	SetCustomMode (bool value)

void	SetCustomMajorLabels (wxArrayString *label, size_t numLabel, int start, int step)

void	SetCustomMinorLabels (wxArrayString *label, size_t numLabel, int start, int step)

void	SetUseZoomInfo (int leftOffset, const ZoomInfo *zoomInfo)

void	Draw (wxDC &dc)

void	Draw (wxDC &dc, const TimeTrack *timetrack)

void	DrawGrid (wxDC &dc, int length, bool minor=true, bool major=true, int xOffset=0, int yOffset=0)

void	SetTickColour (const wxColour &colour)

void	Invalidate ()

int	GetZeroPosition ()

Public Attributes
bool	mbTicksOnly

bool	mbTicksAtExtremes

wxRect	mRect

Private Member Functions
void	Update ()

void	Update (const TimeTrack *timetrack)

void	FindTickSizes ()

void	FindLinearTickSizes (double UPP)

wxString	LabelString (double d, bool major)

void	Tick (int pos, double d, bool major, bool minor)

void	TickCustom (int labelIdx, bool major, bool minor)

int	FindZero (Label *label, int len)

Private Attributes
wxColour	mTickColour

wxPen	mPen

int	mMaxWidth

int	mMaxHeight

int	mLeft

int	mTop

int	mRight

int	mBottom

int	mLead

int	mLength

int	mLengthOld

wxDC *	mDC

std::unique_ptr< wxFont >	mMinorFont

std::unique_ptr< wxFont >	mMajorFont

std::unique_ptr< wxFont >	mMinorMinorFont

bool	mUserFonts

double	mMin

double	mMax

double	mHiddenMin

double	mHiddenMax

double	mMajor

double	mMinor

int	mDigits

ArrayOf< int >	mUserBits

ArrayOf< int >	mBits

int	mUserBitLen

bool	mValid

int	mNumMajor

ArrayOf< Label >	mMajorLabels

int	mNumMinor

ArrayOf< Label >	mMinorLabels

int	mNumMinorMinor

ArrayOf< Label >	mMinorMinorLabels

int	mOrientation

int	mSpacing

double	mDbMirrorValue

bool	mHasSetSpacing

bool	mLabelEdges

RulerFormat	mFormat

bool	mLog

bool	mFlip

bool	mCustom

bool	mbMinor

bool	mMajorGrid

bool	mMinorGrid

int	mGridLineLength

wxString	mUnits

bool	mTwoTone

const ZoomInfo *	mUseZoomInfo

int	mLeftOffset

std::unique_ptr< NumberScale >	mpNumberScale

Detailed Description

Used to display a Ruler.

This is a generic class which can be used to display just about any kind of ruler.

At a minimum, the user must specify the dimensions of the ruler, its orientation (horizontal or vertical), and the values displayed at the two ends of the ruler (min and max). By default, this class will display tick marks at reasonable round numbers and fractions, for example, 100, 50, 10, 5, 1, 0.5, 0.1, etc.

The class is designed to display a small handful of labeled Major ticks, and a few Minor ticks between each of these. Minor ticks are labeled if there is enough space. Labels will never run into each other.

In addition to Real numbers, the Ruler currently supports two other formats for its display:

Integer - never shows tick marks for fractions of an integer

Time - Assumes values represent seconds, and labels the tick marks in "HH:MM:SS" format, e.g. 4000 seconds becomes "1:06:40", for example. Will display fractions of a second, and tick marks are all reasonable round numbers for time (i.e. 15 seconds, 30 seconds, etc.)

Definition at line 32 of file Ruler.h.

Member Enumeration Documentation

enum Ruler::RulerFormat

Enumerator
IntFormat
RealFormat
RealLogFormat
TimeFormat
LinearDBFormat

Definition at line 35 of file Ruler.h.

                     {
       IntFormat,
       RealFormat,
       RealLogFormat,
       TimeFormat,
       LinearDBFormat,
    };

Constructor & Destructor Documentation

Ruler::Ruler ( )

Definition at line 121 of file Ruler.cpp.

    : mpNumberScale{}
 {
    mMin = mHiddenMin = 0.0;
    mMax = mHiddenMax = 100.0;
    mOrientation = wxHORIZONTAL;
    mSpacing = 6;
    mHasSetSpacing = false;
    mFormat = RealFormat;
    mFlip = false;
    mLog = false;
    mLabelEdges = false;
    mUnits = wxT("");
 
    mLeft = -1;
    mTop = -1;
    mRight = -1;
    mBottom = -1;
    mbTicksOnly = true;
    mbTicksAtExtremes = false;
    mTickColour = wxColour( theTheme.Colour( clrTrackPanelText ));
    mPen.SetColour(mTickColour);
    mDbMirrorValue = 0.0;
 
    // Note: the font size is now adjusted automatically whenever
    // Invalidate is called on a horizontal Ruler, unless the user
    // calls SetFonts manually.  So the defaults here are not used
    // often.
 
    int fontSize = 10;
 #ifdef __WXMSW__
    fontSize = 8;
 #endif
 
    mMinorMinorFont = std::make_unique<wxFont>(fontSize - 1, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
    mMinorFont = std::make_unique<wxFont>(fontSize, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
    mMajorFont = std::make_unique<wxFont>(fontSize, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD);
 
    mUserFonts = false;
 
    mLengthOld = 0;
    mLength = 0;
    mUserBitLen = 0;
 
    mValid = false;
 
    mCustom = false;
    mbMinor = true;
 
    mGridLineLength = 0;
    mMajorGrid = false;
    mMinorGrid = false;
 
    mTwoTone = false;
 
    mUseZoomInfo = NULL;
 }

Ruler::~Ruler ( )

Definition at line 179 of file Ruler.cpp.

References Invalidate().

 {
    Invalidate();  // frees up our arrays
 }

Member Function Documentation

void Ruler::Draw ( wxDC & dc )

Definition at line 1330 of file Ruler.cpp.

Referenced by AdornedRulerPanel::DoDrawMarks(), EffectCompressorPanel::OnPaint(), MeterPanel::OnPaint(), and AudacityPrintout::OnPrintPage().

 {
    Draw( dc, NULL);
 }

void Ruler::Draw	(	wxDC &	dc,
		const TimeTrack *	timetrack
	)

Definition at line 1335 of file Ruler.cpp.

References mbMinor, mBottom, mbTicksAtExtremes, mbTicksOnly, mDC, mFlip, mLeft, mLength, mMajorFont, mMajorLabels, mMinorFont, mMinorLabels, mMinorMinorFont, mMinorMinorLabels, mNumMajor, mNumMinor, mNumMinorMinor, mOrientation, mPen, mRight, mTickColour, mTop, mTwoTone, mValid, and Update().

 {
    mDC = &dc;
    if( mLength <=0 )
       return;
 
    if (!mValid)
       Update(timetrack);
 
    mDC->SetTextForeground( mTickColour );
 #ifdef EXPERIMENTAL_THEMING
    mDC->SetPen(mPen);
 #else
    mDC->SetPen(*wxBLACK_PEN);
 #endif
 
    // Draws a long line the length of the ruler.
    if( !mbTicksOnly )
    {
       if (mOrientation == wxHORIZONTAL) {
          if (mFlip)
             mDC->DrawLine(mLeft, mTop, mRight+1, mTop);
          else
             mDC->DrawLine(mLeft, mBottom, mRight+1, mBottom);
       }
       else {
          if (mFlip)
             mDC->DrawLine(mLeft, mTop, mLeft, mBottom+1);
          else
          {
             // These calculations appear to be wrong, and to never have been used (so not tested) prior to MixerBoard.
             //    mDC->DrawLine(mRect.x-mRect.width, mTop, mRect.x-mRect.width, mBottom+1);
             const int nLineX = mRight - 1;
             mDC->DrawLine(nLineX, mTop, nLineX, mBottom+1);
          }
       }
    }
 
    int i;
 
    mDC->SetFont(*mMajorFont);
 
    // We may want to not show the ticks at the extremes,
    // though still showing the labels.
    // This gives a better look when the ruler is on a bevelled
    // button, since otherwise the tick is drawn on the bevel.
    int iMaxPos = (mOrientation==wxHORIZONTAL)? mRight : mBottom-5;
 
    for(i=0; i<mNumMajor; i++) {
       int pos = mMajorLabels[i].pos;
 
       if( mbTicksAtExtremes || ((pos!=0)&&(pos!=iMaxPos)))
       {
          if (mOrientation == wxHORIZONTAL) {
             if (mFlip)
                mDC->DrawLine(mLeft + pos, mTop,
                              mLeft + pos, mTop + 4);
             else
                mDC->DrawLine(mLeft + pos, mBottom - 4,
                              mLeft + pos, mBottom);
          }
          else {
             if (mFlip)
                mDC->DrawLine(mLeft, mTop + pos,
                              mLeft + 4, mTop + pos);
             else
                mDC->DrawLine(mRight - 4, mTop + pos,
                              mRight, mTop + pos);
          }
       }
 
       mMajorLabels[i].Draw(*mDC, mTwoTone, mTickColour);
    }
 
    if(mbMinor == true) {
       mDC->SetFont(*mMinorFont);
       for(i=0; i<mNumMinor; i++) {
          int pos = mMinorLabels[i].pos;
          if( mbTicksAtExtremes || ((pos!=0)&&(pos!=iMaxPos)))
          {
             if (mOrientation == wxHORIZONTAL)
             {
                if (mFlip)
                   mDC->DrawLine(mLeft + pos, mTop,
                                 mLeft + pos, mTop + 2);
                else
                   mDC->DrawLine(mLeft + pos, mBottom - 2,
                                 mLeft + pos, mBottom);
             }
             else
             {
                if (mFlip)
                   mDC->DrawLine(mLeft, mTop + pos,
                                 mLeft + 2, mTop + pos);
                else
                   mDC->DrawLine(mRight - 2, mTop + pos,
                                 mRight, mTop + pos);
             }
          }
          mMinorLabels[i].Draw(*mDC, mTwoTone, mTickColour);
       }
    }
 
    mDC->SetFont(*mMinorMinorFont);
 
    for(i=0; i<mNumMinorMinor; i++) {
       if (mMinorMinorLabels[i].text != wxT(""))
       {
          int pos = mMinorMinorLabels[i].pos;
 
          if( mbTicksAtExtremes || ((pos!=0)&&(pos!=iMaxPos)))
          {
             if (mOrientation == wxHORIZONTAL)
             {
                if (mFlip)
                   mDC->DrawLine(mLeft + pos, mTop,
                                 mLeft + pos, mTop + 2);
                else
                   mDC->DrawLine(mLeft + pos, mBottom - 2,
                                 mLeft + pos, mBottom);
             }
             else
             {
                if (mFlip)
                   mDC->DrawLine(mLeft, mTop + pos,
                                 mLeft + 2, mTop + pos);
                else
                   mDC->DrawLine(mRight - 2, mTop + pos,
                                 mRight, mTop + pos);
             }
          }
          mMinorMinorLabels[i].Draw(*mDC, mTwoTone, mTickColour);
       }
    }
 }

void Ruler::DrawGrid	(	wxDC &	dc,
		int	length,
		bool	minor = `true`,
		bool	major = `true`,
		int	xOffset = `0`,
		int	yOffset = `0`
	)

Definition at line 1472 of file Ruler.cpp.

References GetZeroPosition(), mbMinor, mDC, mGridLineLength, mMajorGrid, mMajorLabels, mMinorGrid, mMinorLabels, mNumMajor, mNumMinor, mOrientation, and Update().

Referenced by FreqWindow::DrawPlot(), EffectScienFilterPanel::OnPaint(), and EqualizationPanel::OnPaint().

 {
    mGridLineLength = length;
    mMajorGrid = major;
    mMinorGrid = minor;
    mDC = &dc;
 
    Update();
 
    int gridPos;
    wxPen gridPen;
 
    if(mbMinor && (mMinorGrid && (mGridLineLength != 0 ))) {
       gridPen.SetColour(178, 178, 178); // very light grey
       mDC->SetPen(gridPen);
       for(int i=0; i<mNumMinor; i++) {
          gridPos = mMinorLabels[i].pos;
          if(mOrientation == wxHORIZONTAL) {
             if((gridPos != 0) && (gridPos != mGridLineLength))
                mDC->DrawLine(gridPos+xOffset, yOffset, gridPos+xOffset, mGridLineLength+yOffset);
          }
          else {
             if((gridPos != 0) && (gridPos != mGridLineLength))
                mDC->DrawLine(xOffset, gridPos+yOffset, mGridLineLength+xOffset, gridPos+yOffset);
          }
       }
    }
 
    if(mMajorGrid && (mGridLineLength != 0 )) {
       gridPen.SetColour(127, 127, 127); // light grey
       mDC->SetPen(gridPen);
       for(int i=0; i<mNumMajor; i++) {
          gridPos = mMajorLabels[i].pos;
          if(mOrientation == wxHORIZONTAL) {
             if((gridPos != 0) && (gridPos != mGridLineLength))
                mDC->DrawLine(gridPos+xOffset, yOffset, gridPos+xOffset, mGridLineLength+yOffset);
          }
          else {
             if((gridPos != 0) && (gridPos != mGridLineLength))
                mDC->DrawLine(xOffset, gridPos+yOffset, mGridLineLength+xOffset, gridPos+yOffset);
          }
       }
 
       int zeroPosition = GetZeroPosition();
       if(zeroPosition > 0) {
          // Draw 'zero' grid line in black
          mDC->SetPen(*wxBLACK_PEN);
          if(mOrientation == wxHORIZONTAL) {
             if(zeroPosition != mGridLineLength)
                mDC->DrawLine(zeroPosition+xOffset, yOffset, zeroPosition+xOffset, mGridLineLength+yOffset);
          }
          else {
             if(zeroPosition != mGridLineLength)
                mDC->DrawLine(xOffset, zeroPosition+yOffset, mGridLineLength+xOffset, zeroPosition+yOffset);
          }
       }
    }
 }

void Ruler::FindLinearTickSizes ( double UPP )

private

Definition at line 388 of file Ruler.cpp.

References IntFormat, LinearDBFormat, mDigits, mFormat, mMajor, mMinor, mOrientation, RealFormat, RealLogFormat, and TimeFormat.

Referenced by Update().

 {
    // Given the dimensions of the ruler, the range of values it
    // has to display, and the format (i.e. Int, Real, Time),
    // figure out how many units are in one Minor tick, and
    // in one Major tick.
    //
    // The goal is to always put tick marks on nice round numbers
    // that are easy for humans to grok.  This is the most tricky
    // with time.
 
    double d;
 
    // As a heuristic, we want at least 22 pixels between each 
    // minor tick.  We want to show numbers like "-48"
    // in that space.
    // If vertical, we don't need as much space.
    double units = ((mOrientation == wxHORIZONTAL) ? 22 : 16) * fabs(UPP);
 
    mDigits = 0;
 
    switch(mFormat) {
    case LinearDBFormat:
       if (units < 0.001) {
          mMinor = 0.001;
          mMajor = 0.005;
          return;
       }
       if (units < 0.01) {
          mMinor = 0.01;
          mMajor = 0.05;
          return;
       }
       if (units < 0.1) {
          mMinor = 0.1;
          mMajor = 0.5;
          return;
       }
       if (units < 1.0) {
          mMinor = 1.0;
          mMajor = 6.0;
          return;
       }
       if (units < 3.0) {
          mMinor = 3.0;
          mMajor = 12.0;
          return;
       }
       if (units < 6.0) {
          mMinor = 6.0;
          mMajor = 24.0;
          return;
       }
       if (units < 12.0) {
          mMinor = 12.0;
          mMajor = 48.0;
          return;
       }
       if (units < 24.0) {
          mMinor = 24.0;
          mMajor = 96.0;
          return;
       }
       d = 20.0;
       for(;;) {
          if (units < d) {
             mMinor = d;
             mMajor = d*5.0;
             return;
          }
          d *= 5.0;
          if (units < d) {
             mMinor = d;
             mMajor = d*5.0;
             return;
          }
          d *= 2.0;
       }
       break;
 
    case IntFormat:
       d = 1.0;
       for(;;) {
          if (units < d) {
             mMinor = d;
             mMajor = d*5.0;
             return;
          }
          d *= 5.0;
          if (units < d) {
             mMinor = d;
             mMajor = d*2.0;
             return;
          }
          d *= 2.0;
       }
       break;
 
    case TimeFormat:
       if (units > 0.5) {
          if (units < 1.0) { // 1 sec
             mMinor = 1.0;
             mMajor = 5.0;
             return;
          }
          if (units < 5.0) { // 5 sec
             mMinor = 5.0;
             mMajor = 15.0;
             return;
          }
          if (units < 10.0) {
             mMinor = 10.0;
             mMajor = 30.0;
             return;
          }
          if (units < 15.0) {
             mMinor = 15.0;
             mMajor = 60.0;
             return;
          }
          if (units < 30.0) {
             mMinor = 30.0;
             mMajor = 60.0;
             return;
          }
          if (units < 60.0) { // 1 min
             mMinor = 60.0;
             mMajor = 300.0;
             return;
          }
          if (units < 300.0) { // 5 min
             mMinor = 300.0;
             mMajor = 900.0;
             return;
          }
          if (units < 600.0) { // 10 min
             mMinor = 600.0;
             mMajor = 1800.0;
             return;
          }
          if (units < 900.0) { // 15 min
             mMinor = 900.0;
             mMajor = 3600.0;
             return;
          }
          if (units < 1800.0) { // 30 min
             mMinor = 1800.0;
             mMajor = 3600.0;
             return;
          }
          if (units < 3600.0) { // 1 hr
             mMinor = 3600.0;
             mMajor = 6*3600.0;
             return;
          }
          if (units < 6*3600.0) { // 6 hrs
             mMinor = 6*3600.0;
             mMajor = 24*3600.0;
             return;
          }
          if (units < 24*3600.0) { // 1 day
             mMinor = 24*3600.0;
             mMajor = 7*24*3600.0;
             return;
          }
 
          mMinor = 24.0 * 7.0 * 3600.0; // 1 week
          mMajor = 24.0 * 7.0 * 3600.0;
       }
 
       // Otherwise fall through to RealFormat
       // (fractions of a second should be dealt with
       // the same way as for RealFormat)
 
    case RealFormat:
       d = 0.000001;
       // mDigits is number of digits after the decimal point.
       mDigits = 6;
       for(;;) {
          if (units < d) {
             mMinor = d;
             mMajor = d*5.0;
             return;
          }
          d *= 5.0;
          if (units < d) {
             mMinor = d;
             mMajor = d*2.0;
             return;
          }
          d *= 2.0;
          mDigits--;
          // More than 10 digit numbers?  Something is badly wrong.
          // Probably units is coming in with too high a value.
          wxASSERT( mDigits >= -10 );
          if( mDigits < -10 )
             break;
       }
       mMinor = d;
       mMajor = d * 2.0;
       break;
 
    case RealLogFormat:
       d = 0.000001;
       // mDigits is number of digits after the decimal point.
       mDigits = 6;
       for(;;) {
          if (units < d) {
             mMinor = d;
             mMajor = d*5.0;
             return;
          }
          d *= 5.0;
          if (units < d) {
             mMinor = d;
             mMajor = d*2.0;
             return;
          }
          d *= 2.0;
          mDigits--;
          // More than 10 digit numbers?  Something is badly wrong.
          // Probably units is coming in with too high a value.
          wxASSERT( mDigits >= -10 );
          if( mDigits < -10 )
             break;
       }
       mDigits++;
       mMinor = d;
       mMajor = d * 2.0;
       break;
    }
 }

void Ruler::FindTickSizes ( )

private

int Ruler::FindZero	(	Label *	label,
		int	len
	)

private

Definition at line 1531 of file Ruler.cpp.

References Ruler::Label::value.

Referenced by GetZeroPosition().

 {
    int i = 0;
    double d = 1.0;   // arbitrary
 
    do {
       d = label[i].value;
       i++;
    } while( (i < len) && (d != 0.0) );
 
    if(d == 0.0)
       return (label[i - 1].pos) ;
    else
       return -1;
 }

Fonts Ruler::GetFonts ( ) const

inline

Definition at line 107 of file Ruler.h.

108 { return { mMajorFont.get(), mMinorFont.get(), mMinorMinorFont.get() }; }

Ruler::mMinorMinorFont

std::unique_ptr< wxFont > mMinorMinorFont

Definition: Ruler.h:184

Ruler::mMinorFont

std::unique_ptr< wxFont > mMinorFont

Definition: Ruler.h:184

Ruler::mMajorFont

std::unique_ptr< wxFont > mMajorFont

Definition: Ruler.h:184

void Ruler::GetMaxSize	(	wxCoord *	width,
		wxCoord *	height
	)

Definition at line 1556 of file Ruler.cpp.

References mDC, mRect, mValid, and Update().

Referenced by FreqWindow::DrawPlot(), AdornedRulerPanel::GetMaxSize(), EffectCompressorPanel::OnPaint(), MeterPanel::SetActiveStyle(), EffectEqualization::TransferDataFromWindow(), and EffectScienFilter::TransferGraphLimitsFromWindow().

 {
    if (!mValid) {
       wxScreenDC sdc;
       mDC = &sdc;
       Update(NULL);
    }
 
    if (width)
       *width = mRect.GetWidth(); //mMaxWidth;
 
    if (height)
       *height = mRect.GetHeight(); //mMaxHeight;
 }

int Ruler::GetZeroPosition ( )

Definition at line 1547 of file Ruler.cpp.

References FindZero(), mMajorLabels, mMinorLabels, mNumMajor, and mNumMinor.

Referenced by DrawGrid().

 {
    int zero;
    if((zero = FindZero(mMajorLabels.get(), mNumMajor)) < 0)
       zero = FindZero(mMinorLabels.get(), mNumMinor);
    // PRL: don't consult minor minor??
    return zero;
 }

void Ruler::Invalidate ( )

Definition at line 372 of file Ruler.cpp.

References mBits, mBottom, mLeft, mLength, mOrientation, mRight, mTop, mUserBitLen, mUserBits, and mValid.

Referenced by AdornedRulerPanel::InvalidateRuler(), SetBounds(), SetFlip(), SetFonts(), SetFormat(), SetLabelEdges(), SetLog(), SetNumberScale(), SetOrientation(), SetSpacing(), SetUnits(), and ~Ruler().

 {
    mValid = false;
 
    if (mOrientation == wxHORIZONTAL)
       mLength = mRight-mLeft;
    else
       mLength = mBottom-mTop;
 
    mBits.reset();
    if (mUserBits && mLength+1 != mUserBitLen) {
       mUserBits.reset();
       mUserBitLen = 0;
    }
 }

wxString Ruler::LabelString	(	double	d,
		bool	major
	)

private

Definition at line 621 of file Ruler.cpp.

References format, IntFormat, LinearDBFormat, mDigits, mFormat, mMinor, mUnits, RealFormat, RealLogFormat, and TimeFormat.

Referenced by Tick().

 {
    // Given a value, turn it into a string according
    // to the current ruler format.  The number of digits of
    // accuracy depends on the resolution of the ruler,
    // i.e. how far zoomed in or out you are.
 
    wxString s;
 
    // Replace -0 with 0
    if (d < 0.0 && (d+mMinor > 0.0) && ( mFormat != RealLogFormat ))
       d = 0.0;
 
    switch(mFormat) {
    case IntFormat:
       s.Printf(wxT("%d"), (int)floor(d+0.5));
       break;
    case LinearDBFormat:
       if (mMinor >= 1.0)
          s.Printf(wxT("%d"), (int)floor(d+0.5));
       else {
          int precision = -log10(mMinor);
          s.Printf(wxT("%.*f"), precision, d);
       }
       break;
    case RealFormat:
       if (mMinor >= 1.0)
          s.Printf(wxT("%d"), (int)floor(d+0.5));
       else {
          s.Printf(wxString::Format(wxT("%%.%df"), mDigits), d);
       }
       break;
    case RealLogFormat:
       if (mMinor >= 1.0)
          s.Printf(wxT("%d"), (int)floor(d+0.5));
       else {
          s.Printf(wxString::Format(wxT("%%.%df"), mDigits), d);
       }
       break;
    case TimeFormat:
       if (major) {
          if (d < 0) {
             s = wxT("-");
             d = -d;
          }
 
          #if ALWAYS_HH_MM_SS
          int secs = (int)(d + 0.5);
          if (mMinor >= 1.0) {
             s.Printf(wxT("%d:%02d:%02d"), secs/3600, (secs/60)%60, secs%60);
          }
          else {
             wxString t1, t2, format;
             t1.Printf(wxT("%d:%02d:"), secs/3600, (secs/60)%60);
             format.Printf(wxT("%%0%d.%dlf"), mDigits+3, mDigits);
             t2.Printf(format, fmod(d, 60.0));
             s += t1 + t2;
          }
          break;
          #endif
 
          if (mMinor >= 3600.0) {
             int hrs = (int)(d / 3600.0 + 0.5);
             wxString h;
             h.Printf(wxT("%d:00:00"), hrs);
             s += h;
          }
          else if (mMinor >= 60.0) {
             int minutes = (int)(d / 60.0 + 0.5);
             wxString m;
             if (minutes >= 60)
                m.Printf(wxT("%d:%02d:00"), minutes/60, minutes%60);
             else
                m.Printf(wxT("%d:00"), minutes);
             s += m;
          }
          else if (mMinor >= 1.0) {
             int secs = (int)(d + 0.5);
             wxString t;
             if (secs >= 3600)
                t.Printf(wxT("%d:%02d:%02d"), secs/3600, (secs/60)%60, secs%60);
             else if (secs >= 60)
                t.Printf(wxT("%d:%02d"), secs/60, secs%60);
             else
                t.Printf(wxT("%d"), secs);
             s += t;
          }
          else {
 // Commented out old and incorrect code for avoiding the 40mins and 60 seconds problem
 // It was causing Bug 463 - Incorrect Timeline numbering (where at high zoom and long tracks,
 // numbers did not change.
 #if 0
             // The casting to float is working around an issue where 59 seconds
             // would show up as 60 when using g++ (Ubuntu 4.3.3-5ubuntu4) 4.3.3.
             int secs = (int)(float)(d);
             wxString t1, t2, format;
 
             if (secs >= 3600)
                t1.Printf(wxT("%d:%02d:"), secs/3600, (secs/60)%60);
             else if (secs >= 60)
                t1.Printf(wxT("%d:"), secs/60);
 
             if (secs >= 60)
                format.Printf(wxT("%%0%d.%dlf"), mDigits+3, mDigits);
             else
                format.Printf(wxT("%%%d.%dlf"), mDigits+3, mDigits);
             // The casting to float is working around an issue where 59 seconds
             // would show up as 60 when using g++ (Ubuntu 4.3.3-5ubuntu4) 4.3.3.
             t2.Printf(format, fmod((float)d, (float)60.0));
 #else
             // For d in the range of hours, d is just very slightly below the value it should 
             // have, because of using a double, which in turn yields values like 59:59:999999 
             // mins:secs:nanosecs when we want 1:00:00:000000
             // so adjust by less than a nano second per hour to get nicer number formatting.
             double dd = d * 1.000000000000001;
             int secs = (int)(dd);
             wxString t1, t2, format;
 
             if (secs >= 3600)
                t1.Printf(wxT("%d:%02d:"), secs/3600, (secs/60)%60);
             else if (secs >= 60)
                t1.Printf(wxT("%d:"), secs/60);
 
             if (secs >= 60)
                format.Printf(wxT("%%0%d.%dlf"), mDigits+3, mDigits);
             else
                format.Printf(wxT("%%%d.%dlf"), mDigits+3, mDigits);
             // dd will be reduced to just the seconds and fractional part.
             dd = dd - secs + (secs%60);
             // truncate to appropriate number of digits, so that the print formatting 
             // doesn't round up 59.9999999 to 60.
             double multiplier = pow( 10, mDigits);
             dd = ((int)(dd * multiplier))/multiplier;
             t2.Printf(format, dd);
 #endif
             s += t1 + t2;
          }
       }
       else {
       }
    }
 
    if (mUnits != wxT(""))
       s = (s + mUnits);
 
    return s;
 }

void Ruler::OfflimitsPixels	(	int	start,
		int	end
	)

Definition at line 334 of file Ruler.cpp.

References mBottom, mLeft, mLength, mOrientation, mRight, mTop, mUserBitLen, mUserBits, and ArrayOf< X >::reinit().

Referenced by MeterPanel::HandleLayout().

 {
    if (!mUserBits) {
       if (mOrientation == wxHORIZONTAL)
          mLength = mRight-mLeft;
       else
          mLength = mBottom-mTop;
       if( mLength < 0 )
          return;
       mUserBits.reinit(static_cast<size_t>(mLength+1), true);
       mUserBitLen  = mLength+1;
    }
 
    if (end < start)
       std::swap( start, end );
 
    if (start < 0)
       start = 0;
    if (end > mLength)
       end = mLength;
 
    for(int i = start; i <= end; i++)
       mUserBits[i] = 1;
 }

void Ruler::SetBounds	(	int	left,
		int	top,
		int	right,
		int	bottom
	)

Definition at line 359 of file Ruler.cpp.

References Invalidate(), mBottom, mLeft, mRight, and mTop.

Referenced by MeterPanel::HandleLayout(), EffectCompressorPanel::OnPaint(), AudacityPrintout::OnPrintPage(), MeterPanel::SetActiveStyle(), and AdornedRulerPanel::UpdateRects().

 {
    if (mLeft != left || mTop != top ||
        mRight != right || mBottom != bottom) {
       mLeft = left;
       mTop = top;
       mRight = right;
       mBottom = bottom;
 
       Invalidate();
    }
 }

void Ruler::SetCustomMajorLabels	(	wxArrayString *	label,
		size_t	numLabel,
		int	start,
		int	step
	)

Definition at line 1574 of file Ruler.cpp.

References mMajorLabels, and mNumMajor.

 {
    mNumMajor = numLabel;
    mMajorLabels.reinit(numLabel);
 
    for(size_t i = 0; i<numLabel; i++) {
       mMajorLabels[i].text = label->Item(i);
       mMajorLabels[i].pos  = start + i*step;
    }
    //Remember: DELETE majorlabels....
 }

void Ruler::SetCustomMinorLabels	(	wxArrayString *	label,
		size_t	numLabel,
		int	start,
		int	step
	)

Definition at line 1586 of file Ruler.cpp.

References mMinorLabels, and mNumMinor.

 {
    mNumMinor = numLabel;
    mMinorLabels.reinit(numLabel);
 
    for(size_t i = 0; i<numLabel; i++) {
       mMinorLabels[i].text = label->Item(i);
       mMinorLabels[i].pos  = start + i*step;
    }
    //Remember: DELETE majorlabels....
 }

void Ruler::SetCustomMode ( bool value )

Definition at line 1572 of file Ruler.cpp.

References mCustom.

1572 { mCustom = value; }

Ruler::mCustom

bool mCustom

Definition: Ruler.h:233

void Ruler::SetDbMirrorValue ( const double d )

inline

Definition at line 84 of file Ruler.h.

84 { mDbMirrorValue = d ; };

Ruler::mDbMirrorValue

double mDbMirrorValue

Definition: Ruler.h:227

void Ruler::SetFlip ( bool flip )

Definition at line 288 of file Ruler.cpp.

References Invalidate(), and mFlip.

Referenced by EffectCompressorPanel::OnPaint().

 {
    // If this is true, the orientation of the tick marks
    // is reversed from the default; eg. above the line
    // instead of below
 
    if (mFlip != flip) {
       mFlip = flip;
 
       Invalidate();
    }
 }

void Ruler::SetFonts	(	const wxFont &	minorFont,
		const wxFont &	majorFont,
		const wxFont &	minorMinorFont
	)

Definition at line 306 of file Ruler.cpp.

References Invalidate(), mMajorFont, mMinorFont, mMinorMinorFont, and mUserFonts.

 {
    *mMinorMinorFont = minorMinorFont;
    *mMinorFont = minorFont;
    *mMajorFont = majorFont;
 
    // Won't override these fonts
    mUserFonts = true;
 
    Invalidate();
 }

void Ruler::SetFormat ( RulerFormat format )

Definition at line 189 of file Ruler.cpp.

References format, Invalidate(), and mFormat.

Referenced by AdornedRulerPanel::AdornedRulerPanel(), FreqWindow::DrawPlot(), EffectCompressorPanel::OnPaint(), AudacityPrintout::OnPrintPage(), and MeterPanel::SetActiveStyle().

 {
    // IntFormat, RealFormat, RealLogFormat, TimeFormat, or LinearDBFormat
 
    if (mFormat != format) {
       mFormat = format;
 
       Invalidate();
    }
 }

void Ruler::SetLabelEdges ( bool labelEdges )

Definition at line 275 of file Ruler.cpp.

References Invalidate(), and mLabelEdges.

Referenced by AdornedRulerPanel::AdornedRulerPanel(), and AudacityPrintout::OnPrintPage().

 {
    // If this is true, the edges of the ruler will always
    // receive a label.  If not, the nearest round number is
    // labeled (which may or may not be the edge).
 
    if (mLabelEdges != labelEdges) {
       mLabelEdges = labelEdges;
 
       Invalidate();
    }
 }

void Ruler::SetLog ( bool log )

Definition at line 200 of file Ruler.cpp.

References Invalidate(), and mLog.

Referenced by FreqWindow::DrawPlot(), EffectEqualization::OnLinFreq(), EffectEqualization::UpdateDraw(), and EffectEqualization::UpdateGraphic().

 {
    // Logarithmic
 
    if (mLog != log) {
       mLog = log;
 
       Invalidate();
    }
 }

void Ruler::SetMinor ( bool value )

Definition at line 301 of file Ruler.cpp.

References mbMinor.

 {
    mbMinor = value;
 }

void Ruler::SetNumberScale ( const NumberScale * pScale )

Definition at line 318 of file Ruler.cpp.

References Invalidate(), and mpNumberScale.

 {
    if (!pScale) {
       if (mpNumberScale) {
          mpNumberScale.reset();
          Invalidate();
       }
    }
    else {
       if (!mpNumberScale || *mpNumberScale != *pScale) {
          mpNumberScale = std::make_unique<NumberScale>(*pScale);
          Invalidate();
       }
    }
 }

void Ruler::SetOrientation ( int orient )

Definition at line 223 of file Ruler.cpp.

References Invalidate(), mHasSetSpacing, mOrientation, and mSpacing.

Referenced by EffectCompressorPanel::OnPaint(), AudacityPrintout::OnPrintPage(), and MeterPanel::SetActiveStyle().

 {
    // wxHORIZONTAL || wxVERTICAL
 
    if (mOrientation != orient) {
       mOrientation = orient;
 
       if (mOrientation == wxVERTICAL && !mHasSetSpacing)
          mSpacing = 2;
 
       Invalidate();
    }
 }

void Ruler::SetRange	(	double	min,
		double	max
	)

Definition at line 237 of file Ruler.cpp.

Referenced by AdornedRulerPanel::DoDrawMarks(), FreqWindow::DrawPlot(), EffectEqualization::OnLinFreq(), EffectCompressorPanel::OnPaint(), AudacityPrintout::OnPrintPage(), MeterPanel::SetActiveStyle(), EffectEqualization::TransferDataFromWindow(), EffectScienFilter::TransferGraphLimitsFromWindow(), EffectEqualization::UpdateDraw(), and EffectEqualization::UpdateGraphic().

 {
    SetRange(min, max, min, max);
 }

void Ruler::SetRange	(	double	min,
		double	max,
		double	hiddenMin,
		double	hiddenMax
	)

Definition at line 243 of file Ruler.cpp.

References min().

 {
    // For a horizontal ruler,
    // min is the value in the center of pixel "left",
    // max is the value in the center of pixel "right".
 
    // In the special case of a time ruler,
    // hiddenMin and hiddenMax are values that would be shown with the fisheye
    // turned off.  In other cases they equal min and max respectively.
 
    if (mMin != min || mMax != max ||
       mHiddenMin != hiddenMin || mHiddenMax != hiddenMax) {
       mMin = min;
       mMax = max;
       mHiddenMin = hiddenMin;
       mHiddenMax = hiddenMax;
 
       Invalidate();
    }
 }

void Ruler::SetSpacing ( int spacing )

Definition at line 264 of file Ruler.cpp.

References Invalidate(), mHasSetSpacing, and mSpacing.

 {
    mHasSetSpacing = true;
 
    if (mSpacing != spacing) {
       mSpacing = spacing;
 
       Invalidate();
    }
 }

void Ruler::SetTickColour ( const wxColour & colour )

inline

Definition at line 151 of file Ruler.h.

Referenced by AdornedRulerPanel::DoDrawMarks(), EffectCompressorPanel::OnPaint(), and MeterPanel::OnPaint().

152 { mTickColour = colour; mPen.SetColour( colour );}

Ruler::mPen

wxPen mPen

Definition: Ruler.h:176

Ruler::mTickColour

wxColour mTickColour

Definition: Ruler.h:175

void Ruler::SetTwoTone ( bool twoTone )

Definition at line 184 of file Ruler.cpp.

References mTwoTone.

Referenced by AdornedRulerPanel::UpdatePrefs().

 {
    mTwoTone = twoTone;
 }

void Ruler::SetUnits ( const wxString & units )

Definition at line 211 of file Ruler.cpp.

References Invalidate(), and mUnits.

Referenced by FreqWindow::DrawPlot(), and EffectCompressorPanel::OnPaint().

 {
    // Specify the name of the units (like "dB") if you
    // want numbers like "1.6" formatted as "1.6 dB".
 
    if (mUnits != units) {
       mUnits = units;
 
       Invalidate();
    }
 }

void Ruler::SetUseZoomInfo	(	int	leftOffset,
		const ZoomInfo *	zoomInfo
	)

Definition at line 1613 of file Ruler.cpp.

References mLeftOffset, and mUseZoomInfo.

Referenced by AdornedRulerPanel::AdornedRulerPanel(), and AdornedRulerPanel::SetLeftOffset().

 {
    mLeftOffset = leftOffset;
    mUseZoomInfo = zoomInfo;
 }

void Ruler::Tick	(	int	pos,
		double	d,
		bool	major,
		bool	minor
	)

private

Definition at line 769 of file Ruler.cpp.

References label, LabelString(), Ruler::Label::lx, Ruler::Label::ly, mBits, mDbMirrorValue, mDC, mFlip, mLead, mLeft, mLength, mMajorFont, mMajorLabels, mMaxHeight, mMaxWidth, mMinorFont, mMinorLabels, mMinorMinorFont, mMinorMinorLabels, mNumMajor, mNumMinor, mNumMinorMinor, mOrientation, mRect, mSpacing, mTop, Ruler::Label::pos, Ruler::Label::text, and Ruler::Label::value.

Referenced by Update().

 {
    wxString l;
    wxCoord strW, strH, strD, strL;
    int strPos, strLen, strLeft, strTop;
 
    // FIXME: We don't draw a tick if off end of our label arrays
    // But we shouldn't have an array of labels.
    if( mNumMinorMinor >= mLength )
       return;
    if( mNumMinor >= mLength )
       return;
    if( mNumMajor >= mLength )
       return;
 
    Label *label;
    if (major)
       label = &mMajorLabels[mNumMajor++];
    else if (minor)
       label = &mMinorLabels[mNumMinor++];
    else
       label = &mMinorMinorLabels[mNumMinorMinor++];
 
    label->value = d;
    label->pos = pos;
    label->lx = mLeft - 1000; // don't display
    label->ly = mTop - 1000;  // don't display
    label->text = wxT("");
 
    mDC->SetFont(major? *mMajorFont: minor? *mMinorFont : *mMinorMinorFont);
    // Bug 521.  dB view for waveforms needs a 2-sided scale.
    if(( mDbMirrorValue > 1.0 ) && ( -d > mDbMirrorValue ))
       d = -2*mDbMirrorValue - d;
    l = LabelString(d, major);
    mDC->GetTextExtent(l, &strW, &strH, &strD, &strL);
 
    if (mOrientation == wxHORIZONTAL) {
       strLen = strW;
       strPos = pos - strW/2;
       if (strPos < 0)
          strPos = 0;
       if (strPos + strW >= mLength)
          strPos = mLength - strW;
       strLeft = mLeft + strPos;
       if (mFlip) {
          strTop = mTop + 4;
          mMaxHeight = max(mMaxHeight, strH + 4);
       }
       else {
          strTop =-strH-mLead;
          mMaxHeight = max(mMaxHeight, strH + 6);
       }
    }
    else {
       strLen = strH;
       strPos = pos - strH/2;
       if (strPos < 0)
          strPos = 0;
       if (strPos + strH >= mLength)
          strPos = mLength - strH;
       strTop = mTop + strPos;
       if (mFlip) {
          strLeft = mLeft + 5;
          mMaxWidth = max(mMaxWidth, strW + 5);
       }
       else
          strLeft =-strW-6;
    }
 
 
    // FIXME: we shouldn't even get here if strPos < 0.
    // Ruler code currently does  not handle very small or
    // negative sized windows (i.e. don't draw) properly.
    if( strPos < 0 )
       return;
 
    // See if any of the pixels we need to draw this
    // label is already covered
 
    int i;
    for(i=0; i<strLen; i++)
       if (mBits[strPos+i])
          return;
 
    // If not, position the label and give it text
 
    label->lx = strLeft;
    label->ly = strTop;
    label->text = l;
 
    // And mark these pixels, plus some surrounding
    // ones (the spacing between labels), as covered
    int leftMargin = mSpacing;
    if (strPos < leftMargin)
       leftMargin = strPos;
    strPos -= leftMargin;
    strLen += leftMargin;
 
    int rightMargin = mSpacing;
    if (strPos + strLen > mLength - mSpacing)
       rightMargin = mLength - strPos - strLen;
    strLen += rightMargin;
 
    for(i=0; i<strLen; i++)
       mBits[strPos+i] = 1;
 
    wxRect r(strLeft, strTop, strW, strH);
    mRect.Union(r);
 
 }

void Ruler::TickCustom	(	int	labelIdx,
		bool	major,
		bool	minor
	)

private

Definition at line 880 of file Ruler.cpp.

References label, Ruler::Label::lx, Ruler::Label::ly, mBits, mDC, mFlip, mLead, mLeft, mLength, mMajorFont, mMajorLabels, mMaxHeight, mMaxWidth, mMinorFont, mMinorLabels, mMinorMinorFont, mMinorMinorLabels, mNumMajor, mNumMinor, mOrientation, mRect, mSpacing, mTop, Ruler::Label::pos, Ruler::Label::text, and Ruler::Label::value.

Referenced by Update().

 {
    //This should only used in the mCustom case
    // Many code comes from 'Tick' method: this should
    // be optimized.
 
    int pos;
    wxString l;
    wxCoord strW, strH, strD, strL;
    int strPos, strLen, strLeft, strTop;
 
    // FIXME: We don't draw a tick if of end of our label arrays
    // But we shouldn't have an array of labels.
    if( mNumMinor >= mLength )
       return;
    if( mNumMajor >= mLength )
       return;
 
    Label *label;
    if (major)
       label = &mMajorLabels[labelIdx];
    else if (minor)
       label = &mMinorLabels[labelIdx];
    else
       label = &mMinorMinorLabels[labelIdx];
 
    label->value = 0.0;
    pos = label->pos;         // already stored in label class
    l   = label->text;
    label->lx = mLeft - 1000; // don't display
    label->ly = mTop - 1000;  // don't display
 
    mDC->SetFont(major? *mMajorFont: minor? *mMinorFont : *mMinorMinorFont);
 
    mDC->GetTextExtent(l, &strW, &strH, &strD, &strL);
 
    if (mOrientation == wxHORIZONTAL) {
       strLen = strW;
       strPos = pos - strW/2;
       if (strPos < 0)
          strPos = 0;
       if (strPos + strW >= mLength)
          strPos = mLength - strW;
       strLeft = mLeft + strPos;
       if (mFlip) {
          strTop = mTop + 4;
          mMaxHeight = max(mMaxHeight, strH + 4);
       }
       else {
 
          strTop = mTop- mLead+4;// More space was needed...
          mMaxHeight = max(mMaxHeight, strH + 6);
       }
    }
    else {
       strLen = strH;
       strPos = pos - strH/2;
       if (strPos < 0)
          strPos = 0;
       if (strPos + strH >= mLength)
          strPos = mLength - strH;
       strTop = mTop + strPos;
       if (mFlip) {
          strLeft = mLeft + 5;
          mMaxWidth = max(mMaxWidth, strW + 5);
       }
       else {
 
          strLeft =-strW-6;
        }
    }
 
 
    // FIXME: we shouldn't even get here if strPos < 0.
    // Ruler code currently does  not handle very small or
    // negative sized windows (i.e. don't draw) properly.
    if( strPos < 0 )
       return;
 
    // See if any of the pixels we need to draw this
    // label is already covered
 
    int i;
    for(i=0; i<strLen; i++)
       if (mBits[strPos+i])
          return;
 
    // If not, position the label
 
    label->lx = strLeft;
    label->ly = strTop;
 
    // And mark these pixels, plus some surrounding
    // ones (the spacing between labels), as covered
    int leftMargin = mSpacing;
    if (strPos < leftMargin)
       leftMargin = strPos;
    strPos -= leftMargin;
    strLen += leftMargin;
 
    int rightMargin = mSpacing;
    if (strPos + strLen > mLength - mSpacing)
       rightMargin = mLength - strPos - strLen;
    strLen += rightMargin;
 
    for(i=0; i<strLen; i++)
       mBits[strPos+i] = 1;
 
 
    wxRect r(strLeft, strTop, strW, strH);
    mRect.Union(r);
 
 }

void Ruler::Update ( )

private

Definition at line 994 of file Ruler.cpp.

Referenced by Draw(), DrawGrid(), and GetMaxSize().

 {
   Update(NULL);
 }

void Ruler::Update ( const TimeTrack * timetrack )

private

Definition at line 999 of file Ruler.cpp.

References TimeTrack::ComputeWarpedLength(), FindLinearTickSizes(), IntFormat, mBits, mBottom, mCustom, mDC, mDigits, mFlip, mFormat, mHiddenMax, mHiddenMin, min(), mLabelEdges, mLead, mLeft, mLeftOffset, mLength, mLengthOld, mLog, mMajor, mMajorFont, mMajorLabels, mMax, mMaxHeight, mMaxWidth, mMin, mMinor, mMinorFont, mMinorLabels, mMinorMinorFont, mMinorMinorLabels, mNumMajor, mNumMinor, mNumMinorMinor, mOrientation, mpNumberScale, mRect, mRight, mTop, mUserBits, mUserFonts, mUseZoomInfo, mValid, nstLogarithmic, ZoomInfo::PositionToTime(), ArrayOf< X >::reinit(), Tick(), TickCustom(), ZoomInfo::TimeToPosition(), and NumberScale::ValueToPosition().

 {
    const ZoomInfo *zoomInfo = NULL;
    if (!mLog && mOrientation == wxHORIZONTAL)
       zoomInfo = mUseZoomInfo;
 
    // This gets called when something has been changed
    // (i.e. we've been invalidated).  Recompute all
    // tick positions and font size.
 
    int i;
    int j;
 
    if (!mUserFonts) {
       int fontSize = 4;
       wxCoord strW, strH, strD, strL;
       wxString exampleText = wxT("0.9");   //ignored for height calcs on all platforms
       int desiredPixelHeight;
 
 
       static const int MinPixelHeight = 10; // 8;
       static const int MaxPixelHeight =
 #ifdef __WXMAC__
             10
 #else
             12
 #endif
       ;
 
       if (mOrientation == wxHORIZONTAL)
          desiredPixelHeight = mBottom - mTop - 5; // height less ticks and 1px gap
       else
          desiredPixelHeight = MaxPixelHeight;
 
       desiredPixelHeight =
          std::max(MinPixelHeight, std::min(MaxPixelHeight,
             desiredPixelHeight));
 
       // Keep making the font bigger until it's too big, then subtract one.
       mDC->SetFont(wxFont(fontSize, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD));
       mDC->GetTextExtent(exampleText, &strW, &strH, &strD, &strL);
       while ((strH - strD - strL) <= desiredPixelHeight && fontSize < 40) {
          fontSize++;
          mDC->SetFont(wxFont(fontSize, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD));
          mDC->GetTextExtent(exampleText, &strW, &strH, &strD, &strL);
       }
       fontSize--;
       mDC->SetFont(wxFont(fontSize, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL));
       mDC->GetTextExtent(exampleText, &strW, &strH, &strD, &strL);
       mLead = strL;
 
       mMajorFont = std::make_unique<wxFont>(fontSize, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_BOLD);
 
       mMinorFont = std::make_unique<wxFont>(fontSize, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
 
       mMinorMinorFont = std::make_unique<wxFont>(fontSize - 1, wxFONTFAMILY_SWISS, wxFONTSTYLE_NORMAL, wxFONTWEIGHT_NORMAL);
    }
 
    // If ruler is being resized, we could end up with it being too small.
    // Values of mLength of zero or below cause bad array allocations and
    // division by zero.  So...
    // IF too small THEN bail out and don't draw.
    if( mLength <= 0 )
       return;
 
    if (mOrientation == wxHORIZONTAL) {
       mMaxWidth = mLength;
       mMaxHeight = 0;
       mRect = wxRect(0,0, mLength,0);
    }
    else {
       mMaxWidth = 0;
       mMaxHeight = mLength;
       mRect = wxRect(0,0, 0,mLength);
    }
 
    // FIXME: Surely we do not need to allocate storage for the labels?
    // We can just recompute them as we need them?  Yes, but only if
    // mCustom is false!!!!
 
    auto size = static_cast<size_t>(mLength + 1);
    if(!mCustom) {
       mNumMajor = 0;
       mNumMinor = 0;
       mNumMinorMinor = 0;
       if (mLength!=mLengthOld) {
          mMajorLabels.reinit(size);
          mMinorLabels.reinit(size);
          mMinorMinorLabels.reinit(size);
          mLengthOld = mLength;
       }
    }
 
    mBits.reinit(size);
    if (mUserBits)
       for(i=0; i<=mLength; i++)
          mBits[i] = mUserBits[i];
    else
       for(i=0; i<=mLength; i++)
          mBits[i] = 0;
 
    // *************** Label calculation routine **************
    if(mCustom == true) {
 
       // SET PARAMETER IN MCUSTOM CASE
       // Works only with major labels
 
       int numLabel = mNumMajor;
 
       i = 0;
       while((i<numLabel) && (i<=mLength)) {
 
          TickCustom(i, true, false);
          i++;
       }
 
    } else if(mLog==false) {
 
       // Use the "hidden" min and max to determine the tick size.
       // That may make a difference with fisheye.
       // Otherwise you may see the tick size for the whole ruler change
       // when the fisheye approaches start or end.
       double UPP = (mHiddenMax-mHiddenMin)/mLength;  // Units per pixel
       FindLinearTickSizes(UPP);
 
       // Left and Right Edges
       if (mLabelEdges) {
          Tick(0, mMin, true, false);
          Tick(mLength, mMax, true, false);
       }
 
       // Zero (if it's in the middle somewhere)
       if (mMin * mMax < 0.0) {
          int mid;
          if (zoomInfo != NULL)
             mid = (int)(zoomInfo->TimeToPosition(0.0, mLeftOffset));
          else
             mid = (int)(mLength*(mMin / (mMin - mMax)) + 0.5);
          const int iMaxPos = (mOrientation == wxHORIZONTAL) ? mRight : mBottom - 5;
          if (mid >= 0 && mid < iMaxPos)
             Tick(mid, 0.0, true, false);
       }
 
       double sg = UPP > 0.0? 1.0: -1.0;
 
       int nDroppedMinorLabels=0;
       // Major and minor ticks
       for (int jj = 0; jj < 2; ++jj) {
          const double denom = jj == 0 ? mMajor : mMinor;
          i = -1; j = 0;
          double d, warpedD, nextD;
 
          double prevTime = 0.0, time = 0.0;
          if (zoomInfo != NULL) {
             j = zoomInfo->TimeToPosition(mMin);
             prevTime = zoomInfo->PositionToTime(--j);
             time = zoomInfo->PositionToTime(++j);
             d = (prevTime + time) / 2.0;
          }
          else
             d = mMin - UPP / 2;
          if (timetrack)
             warpedD = timetrack->ComputeWarpedLength(0.0, d);
          else
             warpedD = d;
          // using ints doesn't work, as
          // this will overflow and be negative at high zoom.
          double step = floor(sg * warpedD / denom);
          while (i <= mLength) {
             i++;
             if (zoomInfo)
             {
                prevTime = time;
                time = zoomInfo->PositionToTime(++j);
                nextD = (prevTime + time) / 2.0;
                // wxASSERT(time >= prevTime);
             }
             else
                nextD = d + UPP;
             if (timetrack)
                warpedD += timetrack->ComputeWarpedLength(d, nextD);
             else
                warpedD = nextD;
             d = nextD;
 
             if (floor(sg * warpedD / denom) > step) {
                step = floor(sg * warpedD / denom);
                bool major = jj == 0;
                Tick(i, sg * step * denom, major, !major);
                if( !major && mMinorLabels[mNumMinor-1].text.IsEmpty() ){
                   nDroppedMinorLabels++;
                }
             }
          }
       }
 
       // If we've dropped minor labels through overcrowding, then don't show
       // any of them.  We're allowed though to drop ones which correspond to the
       // major numbers.
       if( nDroppedMinorLabels > (mNumMajor+ (mLabelEdges ? 2:0)) ){
          // Old code dropped the labels AND their ticks, like so:
          //    mNumMinor = 0;
          // Nowadays we just drop the labels.
          for(i=0; i<mNumMinor; i++)
             mMinorLabels[i].text = "";
       }
 
       // Left and Right Edges
       if (mLabelEdges) {
          Tick(0, mMin, true, false);
          Tick(mLength, mMax, true, false);
       }
    }
    else {
       // log case
 
       NumberScale numberScale(mpNumberScale
          ? *mpNumberScale
          : NumberScale(nstLogarithmic, mMin, mMax)
       );
 
       mDigits=2; //TODO: implement dynamic digit computation
       double loLog = log10(mMin);
       double hiLog = log10(mMax);
       int loDecade = (int) floor(loLog);
 
       double val;
       double startDecade = pow(10., (double)loDecade);
 
       // Major ticks are the decades
       double decade = startDecade;
       double delta=hiLog-loLog, steps=fabs(delta);
       double step = delta>=0 ? 10 : 0.1;
       double rMin=std::min(mMin, mMax), rMax=std::max(mMin, mMax);
       for(i=0; i<=steps; i++)
       {  // if(i!=0)
          {  val = decade;
             if(val >= rMin && val < rMax) {
                const int pos(0.5 + mLength * numberScale.ValueToPosition(val));
                Tick(pos, val, true, false);
             }
          }
          decade *= step;
       }
 
       // Minor ticks are multiples of decades
       decade = startDecade;
       float start, end, mstep;
       if (delta > 0)
       {  start=2; end=10; mstep=1;
       }else
       {  start=9; end=1; mstep=-1;
       }
       steps++;
       for(i=0; i<=steps; i++) {
          for(j=start; j!=end; j+=mstep) {
             val = decade * j;
             if(val >= rMin && val < rMax) {
                const int pos(0.5 + mLength * numberScale.ValueToPosition(val));
                Tick(pos, val, false, true);
             }
          }
          decade *= step;
       }
 
       // MinorMinor ticks are multiples of decades
       decade = startDecade;
       if (delta > 0)
       {  start= 10; end=100; mstep= 1;
       }else
       {  start=100; end= 10; mstep=-1;
       }
       steps++;
       for (i = 0; i <= steps; i++) {
          // PRL:  Bug1038.  Don't label 1.6, rounded, as a duplicate tick for "2"
          if (!(mFormat == IntFormat && decade < 10.0)) {
             for (int f = start; f != (int)(end); f += mstep) {
                if ((int)(f / 10) != f / 10.0f) {
                   val = decade * f / 10;
                   if (val >= rMin && val < rMax) {
                      const int pos(0.5 + mLength * numberScale.ValueToPosition(val));
                      Tick(pos, val, false, false);
                   }
                }
             }
          }
          decade *= step;
       }
    }
 
    int displacementx=0, displacementy=0;
    if (!mFlip) {
       if (mOrientation==wxHORIZONTAL) {
          int d=mTop+mRect.GetHeight()+5;
          mRect.Offset(0,d);
          mRect.Inflate(0,5);
          displacementx=0;
          displacementy=d;
       }
       else {
          int d=mLeft-mRect.GetLeft()+5;
          mRect.Offset(d,0);
          mRect.Inflate(5,0);
          displacementx=d;
          displacementy=0;
       }
    }
    else {
       if (mOrientation==wxHORIZONTAL) {
          mRect.Inflate(0,5);
          displacementx=0;
          displacementy=0;
       }
    }
    for(i=0; i<mNumMajor; i++) {
       mMajorLabels[i].lx+= displacementx;
       mMajorLabels[i].ly+= displacementy;
    }
    for(i=0; i<mNumMinor; i++) {
       mMinorLabels[i].lx+= displacementx;
       mMinorLabels[i].ly+= displacementy;
    }
    for(i=0; i<mNumMinorMinor; i++) {
       mMinorMinorLabels[i].lx+= displacementx;
       mMinorMinorLabels[i].ly+= displacementy;
    }
    mMaxWidth = mRect.GetWidth ();
    mMaxHeight= mRect.GetHeight();
    mValid = true;
 }