BeatsFormat Class Reference

#include <BeatsFormat.h>

Inheritance diagram for BeatsFormat:

Collaboration diagram for BeatsFormat:

Classes
struct	Tick
struct	Ticks

Public Member Functions
	BeatsFormat (const ProjectTimeSignature &timeSignature)
	BeatsFormat ()=delete
	~BeatsFormat () override
void	SetTickSizes (double units, double &major, double &minor, double &minorMinor, int &mDigits) const override
void	SetLabelString (wxString &s, double d, double units, double minor, int mDigits, TickType tickType) const override
void	SetData (double bpm, int timeSigUpper, int timeSigLower)
void	UpdateSubdivision (double units)
const Ticks &	GetSubdivision () const
	RulerFormat ()
Public Member Functions inherited from RulerFormat
	RulerFormat ()
virtual	~RulerFormat ()
virtual void	SetTickSizes (double units, double &major, double &minor, double &minorMinor, int &mDigits) const =0
virtual void	SetLabelString (wxString &s, double d, double units, double minor, int mDigits, TickType tickType) const =0

Private Attributes
double	mBpm { 60.0 }
int	mTimeSigUpper { 4 }
int	mTimeSigLower { 4 }
Ticks	mTicks

Additional Inherited Members
Public Types inherited from RulerFormat
enum	TickType { t_major , t_minor , t_minorMinor }

Detailed Description

Definition at line 18 of file BeatsFormat.h.

Constructor & Destructor Documentation

BeatsFormat() [1/2]

BeatsFormat::BeatsFormat

(

const ProjectTimeSignature &

timeSignature

)

Definition at line 182 of file BeatsFormat.cpp.

{
   SetData(
      sig.GetTempo(), sig.GetUpperTimeSignature(), sig.GetLowerTimeSignature());
}

References ProjectTimeSignature::GetLowerTimeSignature(), ProjectTimeSignature::GetTempo(), ProjectTimeSignature::GetUpperTimeSignature(), and SetData().

Here is the call graph for this function:

BeatsFormat() [2/2]

BeatsFormat::BeatsFormat ( )

delete

~BeatsFormat()

BeatsFormat::~BeatsFormat ( )

overridedefault

Member Function Documentation

GetSubdivision()

const BeatsFormat::Ticks & BeatsFormat::GetSubdivision

(

)

const

Definition at line 177 of file BeatsFormat.cpp.

{
   return mTicks;
}

References mTicks.

Referenced by anonymous_namespace{TrackArt.cpp}::BeatsGridlinePainter::GetMinorTick().

Here is the caller graph for this function:

RulerFormat()

RulerFormat::RulerFormat ( )

inlineexplicit

Definition at line 22 of file RulerFormat.h.

{}

SetData()

void BeatsFormat::SetData	(	double	bpm,
		int	timeSigUpper,
		int	timeSigLower
	)

Precondition

bpm > 0

timeSigUpper > 0

timeSigLower > 1

(timeSigLower & (timeSigLower - 1)) == 0

Definition at line 70 of file BeatsFormat.cpp.

{
   // Check preconditions
   assert(bpm > 0);
   assert(timeSigUpper > 0);
   assert(timeSigLower > 1);
   assert((timeSigLower & (timeSigLower - 1)) == 0);
 
   if (!(mBpm > 0 && mTimeSigUpper > 1 && mTimeSigLower > 1))
      return;
 
   if (mTimeSigLower & (mTimeSigLower - 1))
      return;
 
   mBpm = bpm;
   mTimeSigUpper = timeSigUpper;
   mTimeSigLower = timeSigLower;
}

References mBpm, mTimeSigLower, and mTimeSigUpper.

Referenced by BeatsFormat(), and ProjectTimeRuler::Impl::Impl().

Here is the caller graph for this function:

SetLabelString()

void BeatsFormat::SetLabelString ( wxString &  s, double  d, double  units, double  minor, int  mDigits, TickType  tickType  ) const

overridevirtual

Implements RulerFormat.

Definition at line 30 of file BeatsFormat.cpp.

{
   if (d < 0) {
      return;
   }
 
   const auto lower = static_cast<double>(mTimeSigLower);
   double val = (mBpm * (lower / 4) * d) / (60 * mTimeSigUpper);
   double beatApprox = (val - floor(val)) * mTimeSigUpper + 1;
   int beat = round(beatApprox);
 
   // Don't add decimal if it's a major tick or is on the beat
   // Segment by distance with units
   if (units < .4 * (60 / mBpm)* (4 / lower))
   {
      if (tickType == RulerFormat::t_major) {
         s.Printf(wxT("%d"), (int)round(val + 1));
      }
      else if (tickType == RulerFormat::t_minor && abs(beat - beatApprox) < 1.0e-5f) {
         s.Printf(wxT("%d.%d"), (int)floor(val + 1), (int)beat);
      }
   }
   else if (units < .8 * (60 / mBpm) * (4 / lower))
   {
      if (tickType == RulerFormat::t_major) {
         s.Printf(wxT("%d"), (int)round(val + 1));
      }
      else if (tickType == RulerFormat::t_minor && beat != 1) {
         s.Printf(wxT("%d.%d"), (int)floor(val + 1), (int)beat);
      }
   }
   else {
      if (tickType == RulerFormat::t_major) {
         s.Printf(wxT("%d"), (int)round(val + 1));
      }
   }
}

References mBpm, mTimeSigLower, mTimeSigUpper, fast_float::round(), RulerFormat::t_major, RulerFormat::t_minor, and wxT().

Here is the call graph for this function:

SetTickSizes()

void BeatsFormat::SetTickSizes ( double  units, double &  major, double &  minor, double &  minorMinor, int &  mDigits  ) const

overridevirtual

Implements RulerFormat.

Definition at line 16 of file BeatsFormat.cpp.

{
   const_cast<BeatsFormat*>(this)->UpdateSubdivision(units);
 
   major = mTicks.major.duration;
   minor = mTicks.minor.duration;
   minorMinor = mTicks.minorMinor.duration;
 
   mDigits = 0;
}

References BeatsFormat::Tick::duration, BeatsFormat::Ticks::major, BeatsFormat::Ticks::minor, BeatsFormat::Ticks::minorMinor, mTicks, and UpdateSubdivision().

Here is the call graph for this function:

UpdateSubdivision()

void BeatsFormat::UpdateSubdivision

(

double

units

)

Definition at line 89 of file BeatsFormat.cpp.

{
   Ticks ticks;
 
   const auto lower = static_cast<double>(mTimeSigLower);
   if (units < .025 * (60 / mBpm) * (4 / lower))
   {
      // measures
      ticks.major = { mTimeSigUpper, mTimeSigLower,
                      (60 * mTimeSigUpper) / (mBpm * (lower / 4)) };
      // thirtysecondth notes (label every quarter note)
      ticks.minor = { 1, 32, 60 / (mBpm * (lower * 2)) };
      // hundredtwentyeighth notes
      ticks.minorMinor = { 1, 128, 60 / (mBpm * (lower * 8)) };
   }
   else if (units < .05 * (60 / mBpm) * (4 / lower))
   {
      // measures
      ticks.major = { mTimeSigUpper, mTimeSigLower,
                      (60 * mTimeSigUpper) / (mBpm * (lower / 4)) };
      // sixteenth notes (label every quarter note)
      ticks.minor = { 1, 16, 60 / (mBpm * (lower)) };
      // sixtyfourth notes
      ticks.minorMinor = { 1, 64, 60 / (mBpm * (lower * 4)) };
   }
   else if (units < .1 * (60 / mBpm) * (4 / lower))
   {
      // measures
      ticks.major = { mTimeSigUpper, mTimeSigLower,
                      (60 * mTimeSigUpper) / (mBpm * (lower / 4)) };
      // eigth notes (label every quarter note)
      ticks.minor = { 1, 8, 60 / (mBpm * (lower / 2)) };
      // thirtysecondth notes
      ticks.minorMinor = { 1, 32, 60 / (mBpm * (lower * 2)) };
   }
   else if (units < .4 * (60 / mBpm) * (4 / lower))
   {
      // measures
      ticks.major = { mTimeSigUpper, mTimeSigLower,
                      (60 * mTimeSigUpper) / (mBpm * (lower / 4)) };
      // eigth notes (label every quarter note)
      ticks.minor = { 1, 8, 60 / (mBpm * (lower / 2)) };
      // sixteenth notes
      ticks.minorMinor = { 1, 16, 60 / (mBpm * (lower)) };
   }
   else if (units < .8 * (60 / mBpm) * (4 / lower))
   {
      // measures
      ticks.major = { mTimeSigUpper, mTimeSigLower,
                      (60 * mTimeSigUpper) / (mBpm * (lower / 4)) };
      // quarter notes
      ticks.minor = { 1, 4, 60 / (mBpm * (lower / 4)) };
      // sixteenth notes
      ticks.minorMinor = { 1, 16, 60 / (mBpm * (lower)) };
   }
   else if (units < 4 * (60 / mBpm) * (4 / lower))
   {
      // measures
      ticks.major = { mTimeSigUpper, mTimeSigLower,
                      (60 * mTimeSigUpper) / (mBpm * (lower / 4)) };
      // quarter notes
      ticks.minorMinor = { 1, 4, 60 / (mBpm * (lower / 4)) };
   }
   else if (units < 8 * (60 / mBpm) * (4 / lower))
   {
      // four-measures
      ticks.major = { 4 * mTimeSigUpper, mTimeSigLower,
                      (60 * mTimeSigUpper) / (mBpm * (lower / 16)) };
      // measures
      ticks.minor = { 4, mTimeSigLower, 60 / (mBpm * (lower / 16)) };
      // half measures
      ticks.minorMinor = { 2, mTimeSigLower, 60 / (mBpm * (lower / 8)) };
   }
   else
   {
      int factor = pow(
         2, std::floor(
               log2(std::ceil(units) * (mBpm / 60) * (mTimeSigLower / 4))) -
               2);
      ticks.major = { factor * 4 * mTimeSigUpper, mTimeSigLower,
                (60 * mTimeSigUpper) / (mBpm * (lower / (16 * factor))) };
      ticks.minorMinor = { factor * 2, mTimeSigLower,
                           60 / (mBpm * (lower / (8 * factor))) };
   }
 
   mTicks = ticks;
}

References BeatsFormat::Ticks::major, mBpm, BeatsFormat::Ticks::minor, BeatsFormat::Ticks::minorMinor, mTicks, mTimeSigLower, and mTimeSigUpper.

Referenced by SetTickSizes().

Here is the caller graph for this function:

Member Data Documentation

mBpm

double BeatsFormat::mBpm { 60.0 }

private

Definition at line 63 of file BeatsFormat.h.

Referenced by SetData(), SetLabelString(), and UpdateSubdivision().

mTicks

Ticks BeatsFormat::mTicks

private

Definition at line 67 of file BeatsFormat.h.

Referenced by GetSubdivision(), SetTickSizes(), and UpdateSubdivision().

mTimeSigLower

int BeatsFormat::mTimeSigLower { 4 }

private

Definition at line 65 of file BeatsFormat.h.

Referenced by SetData(), SetLabelString(), and UpdateSubdivision().

mTimeSigUpper

int BeatsFormat::mTimeSigUpper { 4 }

private

Definition at line 64 of file BeatsFormat.h.

Referenced by SetData(), SetLabelString(), and UpdateSubdivision().

---

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

• BeatsFormat.h
• BeatsFormat.cpp