A Track that is used for Midi notes. (Somewhat old code). More...

#include <NoteTrack.h>

Inheritance diagram for NoteTrack:

Collaboration diagram for NoteTrack:

Public Types
using	Holder = std::shared_ptr< NoteTrack >

Public Types inherited from Track
enum class	LinkType : int { None = 0 , Group = 2 , Aligned }
	For two tracks describes the type of the linkage. More...

using	ChannelGroupAttachments = ClientData::Site< ChannelGroupData, ClientData::Cloneable<>, ClientData::DeepCopying >
	Hosting of objects attached by higher level code. More...

using	AttachedObjects = ::AttachedTrackObjects
	Alias for my base type. More...

using	IntervalData = TrackIntervalData

using	Interval = TrackInterval

using	Intervals = std::vector< Interval >

using	ConstInterval = ConstTrackInterval

using	ConstIntervals = std::vector< ConstInterval >

using	Holder = std::shared_ptr< Track >

template<typename R = void>
using	Continuation = std::function< R() >
	Type of arguments passed as optional second parameter to TypeSwitch() cases. More...

using	Fallthrough = Continuation<>
	Type of arguments passed as optional second parameter to TypeSwitch<void>() cases. More...

Public Types inherited from ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >
using	DataType = ClientData

using	DataPointer = Pointer< ClientData >

using	DataFactory = std::function< DataPointer(Host &) >
	Type of function from which RegisteredFactory is constructed; it builds attachments. More...

Public Member Functions
	NoteTrack ()

	NoteTrack (const NoteTrack &orig, ProtectedCreationArg &&)=delete
	Copy construction hasn't been necessary yet. More...

virtual	~NoteTrack ()

double	GetOffset () const override

double	GetStartTime () const override

double	GetEndTime () const override

Alg_seq &	GetSeq () const

void	WarpAndTransposeNotes (double t0, double t1, const TimeWarper &warper, double semitones)

int	FindChannel (const wxRect &rect, int mx, int my)

bool	LabelClick (const wxRect &rect, int x, int y, bool right)

void	SetSequence (std::unique_ptr< Alg_seq > &&seq)

void	PrintSequence ()

Alg_seq *	MakeExportableSeq (std::unique_ptr< Alg_seq > &cleanup) const

bool	ExportMIDI (const wxString &f) const

bool	ExportAllegro (const wxString &f) const

Track::Holder	Cut (double t0, double t1) override

Track::Holder	Copy (double t0, double t1, bool forClipboard=true) const override

bool	Trim (double t0, double t1)

void	Clear (double t0, double t1) override

void	Paste (double t, const Track *src) override

void	Silence (double t0, double t1) override

void	InsertSilence (double t, double len) override

bool	Shift (double t)

QuantizedTimeAndBeat	NearestBeatTime (double time) const

bool	StretchRegion (QuantizedTimeAndBeat t0, QuantizedTimeAndBeat t1, double newDur)

int	GetBottomNote () const
	Gets the current bottom note (a pitch) More...

int	GetTopNote () const
	Gets the current top note (a pitch) More...

void	SetBottomNote (int note)
	Sets the bottom note (a pitch), making sure that it is never greater than the top note. More...

void	SetTopNote (int note)
	Sets the top note (a pitch), making sure that it is never less than the bottom note. More...

void	SetNoteRange (int note1, int note2)
	Sets the top and bottom note (both pitches) automatically, swapping them if needed. More...

void	ZoomAllNotes ()
	Zooms so that all notes are visible. More...

void	ZoomMaxExtent ()
	Zooms so that the entire track is visible. More...

void	ShiftNoteRange (int offset)
	Shifts all notes vertically by the given pitch. More...

void	ZoomOut (const wxRect &rect, int y)
	Zooms out a constant factor (subject to zoom limits) More...

void	ZoomIn (const wxRect &rect, int y)
	Zooms in a constant factor (subject to zoom limits) More...

void	Zoom (const wxRect &rect, int y, float multiplier, bool center)

void	ZoomTo (const wxRect &rect, int start, int end)

bool	HandleXMLTag (const std::string_view &tag, const AttributesList &attrs) override

XMLTagHandler *	HandleXMLChild (const std::string_view &tag) override

void	WriteXML (XMLWriter &xmlFile) const override

unsigned	GetVisibleChannels () const

void	SetVisibleChannels (unsigned value)

bool	IsVisibleChan (int c) const

void	SetVisibleChan (int c)

void	ClearVisibleChan (int c)

void	ToggleVisibleChan (int c)

void	SoloVisibleChan (int c)

const TypeInfo &	GetTypeInfo () const override

Track::Holder	PasteInto (AudacityProject &) const override
	Find or create the destination track for a paste, maybe in a different project. More...

ConstIntervals	GetIntervals () const override
	Report times on the track where important intervals begin and end, for UI to snap to. More...

Intervals	GetIntervals () override

Public Member Functions inherited from AudioTrack
	AudioTrack ()

	AudioTrack (const Track &orig, ProtectedCreationArg &&a)

void	WriteXMLAttributes (XMLWriter &WXUNUSED(xmlFile)) const

bool	HandleXMLAttribute (const std::string_view &, const XMLAttributeValueView &)

Public Member Functions inherited from Track
TrackId	GetId () const

template<typename Subclass = Track>
std::shared_ptr< Subclass >	SharedPointer ()

template<typename Subclass = const Track>
auto	SharedPointer () const -> std::enable_if_t< std::is_const_v< Subclass >, std::shared_ptr< Subclass > >

std::shared_ptr< Track >	SubstitutePendingChangedTrack ()

std::shared_ptr< const Track >	SubstitutePendingChangedTrack () const

std::shared_ptr< const Track >	SubstituteOriginalTrack () const

virtual const TypeInfo &	GetTypeInfo () const =0

virtual const TypeNames &	GetTypeNames () const

virtual bool	SupportsBasicEditing () const
	Whether this track type implements cut-copy-paste; by default, true. More...

virtual Holder	PasteInto (AudacityProject &) const =0
	Find or create the destination track for a paste, maybe in a different project. More...

virtual ConstIntervals	GetIntervals () const
	Report times on the track where important intervals begin and end, for UI to snap to. More...

virtual Intervals	GetIntervals ()

virtual bool	LinkConsistencyFix (bool doFix=true, bool completeList=true)
	Check consistency of channel groups, and maybe fix it. More...

bool	LinkConsistencyCheck (bool completeList)
	Do the non-mutating part of consistency fix only and return status. More...

bool	HasOwner () const

std::shared_ptr< TrackList >	GetOwner () const

LinkType	GetLinkType () const noexcept

bool	IsAlignedWithLeader () const
	Returns true if the leader track has link type LinkType::Aligned. More...

ChannelGroupData &	GetGroupData ()

const ChannelGroupData &	GetGroupData () const

	Track ()

	Track (const Track &orig, ProtectedCreationArg &&)

Track &	operator= (const Track &orig)=delete

virtual	~Track ()

void	Init (const Track &orig)

virtual Holder	Duplicate () const

const wxString &	GetName () const
	Name is always the same for all channels of a group. More...

void	SetName (const wxString &n)

bool	GetSelected () const
	Selectedness is always the same for all channels of a group. More...

virtual void	SetSelected (bool s)

void	EnsureVisible (bool modifyState=false)

virtual double	GetOffset () const =0

void	Offset (double t)

virtual void	SetOffset (double o)

virtual Holder	Cut (double WXUNUSED(t0), double WXUNUSED(t1))=0

virtual Holder	Copy (double WXUNUSED(t0), double WXUNUSED(t1), bool forClipboard=true) const =0

virtual void	Clear (double WXUNUSED(t0), double WXUNUSED(t1))=0

virtual void	Paste (double WXUNUSED(t), const Track *WXUNUSED(src))=0

virtual void	SyncLockAdjust (double oldT1, double newT1)

virtual void	Silence (double WXUNUSED(t0), double WXUNUSED(t1))=0

virtual void	InsertSilence (double WXUNUSED(t), double WXUNUSED(len))=0

bool	SameKindAs (const Track &track) const

template<typename R = void, typename ... Functions>
R	TypeSwitch (const Functions &...functions)
	Use this function rather than testing track type explicitly and making down-casts. More...

template<typename R = void, typename ... Functions>
R	TypeSwitch (const Functions &...functions) const
	Use this function rather than testing track type explicitly and making down-casts. More...

virtual void	WriteXML (XMLWriter &xmlFile) const =0

virtual bool	GetErrorOpening ()

virtual double	GetStartTime () const =0

virtual double	GetEndTime () const =0

void	Notify (bool allChannels, int code=-1)

bool	Any () const

bool	IsSelected () const

bool	IsLeader () const

bool	IsSelectedLeader () const

void	AdjustPositions ()

void	WriteCommonXMLAttributes (XMLWriter &xmlFile, bool includeNameAndSelected=true) const

bool	HandleCommonXMLAttribute (const std::string_view &attr, const XMLAttributeValueView &valueView)

Public Member Functions inherited from XMLTagHandler
	XMLTagHandler ()

virtual	~XMLTagHandler ()

virtual bool	HandleXMLTag (const std::string_view &tag, const AttributesList &attrs)=0

virtual void	HandleXMLEndTag (const std::string_view &WXUNUSED(tag))

virtual void	HandleXMLContent (const std::string_view &WXUNUSED(content))

virtual XMLTagHandler *	HandleXMLChild (const std::string_view &tag)=0

void	ReadXMLEndTag (const char *tag)

void	ReadXMLContent (const char *s, int len)

XMLTagHandler *	ReadXMLChild (const char *tag)

Public Member Functions inherited from ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >
	~Site ()

	Site ()

	Site (const Site &other)

Site &	operator= (const Site &other)

	Site (Site &&other)

Site &	operator= (Site &&other)

size_t	size () const
	How many attachment pointers are in the Site. More...

template<typename Subclass = ClientData>
Subclass &	Get (const RegisteredFactory &key)
	Get reference to an attachment, creating on demand if not present, down-cast it to Subclass. More...

template<typename Subclass = const ClientData>
auto	Get (const RegisteredFactory &key) const -> std::enable_if_t< std::is_const< Subclass >::value, Subclass & >
	Get reference to an attachment, creating on demand if not present, down-cast it to Subclass. More...

template<typename Subclass = ClientData>
Subclass *	Find (const RegisteredFactory &key)
	Get a (bare) pointer to an attachment, or null, down-cast it to Subclass *; will not create on demand. More...

template<typename Subclass = const ClientData>
auto	Find (const RegisteredFactory &key) const -> std::enable_if_t< std::is_const< Subclass >::value, Subclass * >
	Get a (bare) pointer to an attachment, or null, down-cast it to Subclass *; will not create on demand. More...

template<typename ReplacementPointer >
void	Assign (const RegisteredFactory &key, ReplacementPointer &&replacement)
	Reassign Site's pointer to ClientData. More...

Static Public Member Functions
static NoteTrack *	New (AudacityProject &project)

static void	DrawLabelControls (const NoteTrack *pTrack, wxDC &dc, const wxRect &rect, int highlightedChannel=-1)

static const TypeInfo &	ClassTypeInfo ()

Static Public Member Functions inherited from AudioTrack
static const TypeInfo &	ClassTypeInfo ()

Static Public Member Functions inherited from Track
template<typename Subclass = Track>
static std::shared_ptr< Subclass >	SharedPointer (Track *pTrack)

template<typename Subclass = const Track>
static std::shared_ptr< Subclass >	SharedPointer (const Track *pTrack)

static const TypeInfo &	ClassTypeInfo ()

static void	FinishCopy (const Track n, Track dest)

template<typename TrackType >
static void	checkTrackType ()

template<typename R , typename TrackType , typename... Functions>
static R	CallExecutor (R , std::tuple<> , TrackType &, const Functions &...)

template<typename R , typename TrackType , typename... Functions, typename Executor , typename... Executors>
static R	CallExecutor (R , std::tuple< Executor, Executors... > , TrackType &track, const Functions &...functions)

template<typename ... Executors>
static constexpr unsigned	UsedCases (std::tuple< Executors... > *)

template<typename Tag , bool IsConst, typename R , typename ... TrackTypes, typename ... Functions>
static R	DoTypeSwitch (std::conditional_t< IsConst, const Track, Track > &track, TypeList::List< TrackTypes... >, const Functions &...functions)
	Deduce two packs from arguments. More...

Static Public Member Functions inherited from ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >
static size_t	slots ()
	How many static factories have been registered with this specialization of Site. More...

Private Types
enum	{ MinPitch = 0 , MaxPitch = 127 }

Private Member Functions
Track::Holder	Clone () const override

void	AddToDuration (double delta)

Private Attributes
std::unique_ptr< Alg_seq >	mSeq

std::unique_ptr< char[]>	mSerializationBuffer

long	mSerializationLength

int	mBottomNote

int	mTopNote

float	mPitchHeight

std::atomic< unsigned >	mVisibleChannels { ALL_CHANNELS }
	A bit set; atomic because it may be read by worker threads in playback. More...

std::weak_ptr< StretchHandle >	mStretchHandle

Static Private Attributes
static const float	ZoomStep = powf( 2.0f, 0.25f )

Additional Inherited Members
Public Attributes inherited from Track
std::pair< int, int >	vrulerSize

Protected Member Functions inherited from Track
void	SetLinkType (LinkType linkType, bool completeList=true)

Protected Member Functions inherited from ClientData::Site< Host, ClientData, ObjectCopyingPolicy, Pointer, ObjectLockingPolicy, RegistryLockingPolicy >
template<typename Function >
void	ForEach (const Function &function)
	Invoke function on each ClientData object that has been created in `this`. More...

template<typename Function >
void	ForEach (const Function &function) const
	Invoke function on each ClientData object that has been created in `this`. More...

template<typename Function >
ClientData *	FindIf (const Function &function)
	Return pointer to first attachment in `this` that is not null and satisfies a predicate, or nullptr. More...

template<typename Function >
const ClientData *	FindIf (const Function &function) const
	Return pointer to first attachment in `this` that is not null and satisfies a predicate, or nullptr. More...

void	BuildAll ()
	For each RegisteredFactory, if the corresponding attachment is absent in `this`, build and store it. More...

Protected Attributes inherited from Track
std::weak_ptr< TrackList >	mList

TrackNodePointer	mNode {}
	Holds iterator to self, so that TrackList::Find can be constant-time. More...

int	mIndex
	0-based position of this track in its TrackList More...

double	mOffset

Detailed Description

A Track that is used for Midi notes. (Somewhat old code).

Definition at line 61 of file NoteTrack.h.

Member Typedef Documentation

◆ Holder

using NoteTrack::Holder = std::shared_ptr<NoteTrack>

Definition at line 73 of file NoteTrack.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

Enumerator
MinPitch
MaxPitch

Definition at line 240 of file NoteTrack.h.

240{ MinPitch = 0, MaxPitch = 127 };

NoteTrack::MinPitch

@ MinPitch

Definition: NoteTrack.h:240

NoteTrack::MaxPitch

@ MaxPitch

Definition: NoteTrack.h:240

Constructor & Destructor Documentation

◆ NoteTrack() [1/2]

NoteTrack::NoteTrack ( )

Definition at line 122 of file NoteTrack.cpp.

   : NoteTrackBase()
{
   SetName(_("Note Track"));
 
   mSeq = NULL;
   mSerializationLength = 0;
 
   mBottomNote = MinPitch;
   mTopNote = MaxPitch;
}

References _, MaxPitch, mBottomNote, MinPitch, mSeq, mSerializationLength, mTopNote, and Track::SetName().

Here is the call graph for this function:

◆ NoteTrack() [2/2]

NoteTrack::NoteTrack	(	const NoteTrack &	orig,
		ProtectedCreationArg &&
	)

delete

Copy construction hasn't been necessary yet.

◆ ~NoteTrack()

NoteTrack::~NoteTrack ( )

virtual

Definition at line 134 of file NoteTrack.cpp.

135{

136}

Member Function Documentation

◆ AddToDuration()

void NoteTrack::AddToDuration ( double delta )

private

Definition at line 726 of file NoteTrack.cpp.

{
   auto &seq = GetSeq();
#if 0
   // PRL:  Would this be better ?
   seq.set_real_dur( seq.get_real_dur() + delta );
#else
   seq.convert_to_seconds();
   seq.set_dur( seq.get_dur() + delta );
#endif
}

References GetSeq().

Referenced by Paste(), and StretchRegion().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClassTypeInfo()

auto NoteTrack::ClassTypeInfo ( )

static

Definition at line 699 of file NoteTrack.cpp.

{
   return typeInfo();
}

References typeInfo().

Here is the call graph for this function:

◆ Clear()

void NoteTrack::Clear	(	double	t0,
		double	t1
	)

override

Definition at line 520 of file NoteTrack.cpp.

{
   if (t1 < t0)
      THROW_INCONSISTENCY_EXCEPTION;
 
   double len = t1-t0;
 
   auto &seq = GetSeq();
 
   auto offset = GetOffset();
   auto start = t0 - offset;
   if (start < 0.0) {
      // AlgSeq::clear will shift the cleared interval, not changing len, if
      // start is negative.  That's not what we want to happen.
      if (len > -start) {
         seq.clear(0, len + start, false);
         SetOffset(t0);
      }
      else
         SetOffset(offset - len);
   }
   else {
      //auto delta = -(
      //( std::min( t1, GetEndTime() ) ) - ( std::max( t0, GetStartTime() ) )
      //);
      seq.clear(start, len, false);
 
      // Not needed
      // Alg_seq::clear seems to handle this
      // AddToDuration( delta );
   }
}

References GetOffset(), GetSeq(), Track::SetOffset(), and THROW_INCONSISTENCY_EXCEPTION.

Referenced by anonymous_namespace{EditMenus.cpp}::OnCut().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ClearVisibleChan()

void NoteTrack::ClearVisibleChan ( int c )

inline

Definition at line 187 of file NoteTrack.h.

187 {

188 mVisibleChannels.fetch_and(~CHANNEL_BIT(c), std::memory_order_relaxed); }

CHANNEL_BIT

#define CHANNEL_BIT(c)

Definition: NoteTrack.h:175

NoteTrack::mVisibleChannels

std::atomic< unsigned > mVisibleChannels

A bit set; atomic because it may be read by worker threads in playback.

Definition: NoteTrack.h:244

References CHANNEL_BIT.

◆ Clone()

Track::Holder NoteTrack::Clone ( ) const

overrideprivatevirtual

Implements Track.

Definition at line 160 of file NoteTrack.cpp.

{
   auto duplicate = std::make_shared<NoteTrack>();
   duplicate->Init(*this);
   // The duplicate begins life in serialized state.  Often the duplicate is
   // pushed on the Undo stack.  Then we want to un-serialize it (or a further
   // copy) only on demand after an Undo.
   if (mSeq) {
      SonifyBeginSerialize();
      wxASSERT(!mSerializationBuffer);
      // serialize from this to duplicate's mSerializationBuffer
      void *buffer;
      mSeq->serialize(&buffer,
                      &duplicate->mSerializationLength);
      duplicate->mSerializationBuffer.reset( (char*)buffer );
      SonifyEndSerialize();
   }
   else if (mSerializationBuffer) {
      // Copy already serialized data.
      wxASSERT(!mSeq);
      duplicate->mSerializationLength = this->mSerializationLength;
      duplicate->mSerializationBuffer.reset
         ( safenew char[ this->mSerializationLength ] );
      memcpy( duplicate->mSerializationBuffer.get(),
              this->mSerializationBuffer.get(), this->mSerializationLength );
   }
   else {
      // We are duplicating a default-constructed NoteTrack, and that's okay
   }
   // copy some other fields here
   duplicate->SetBottomNote(mBottomNote);
   duplicate->SetTopNote(mTopNote);
   duplicate->SetVisibleChannels(GetVisibleChannels());
   duplicate->SetOffset(GetOffset());
#ifdef EXPERIMENTAL_MIDI_OUT
   duplicate->SetVelocity(GetVelocity());
#endif
   return duplicate;
}

References GetOffset(), GetVisibleChannels(), mBottomNote, mSeq, mSerializationBuffer, mSerializationLength, mTopNote, safenew, SonifyBeginSerialize, and SonifyEndSerialize.

Here is the call graph for this function:

◆ Copy()

Track::Holder NoteTrack::Copy	(	double	t0,
		double	t1,
		bool	forClipboard = `true`
	)		const

override

Definition at line 473 of file NoteTrack.cpp.

{
   if (t1 < t0)
      THROW_INCONSISTENCY_EXCEPTION;
 
   double len = t1-t0;
 
   auto newTrack = std::make_shared<NoteTrack>();
 
   newTrack->Init(*this);
 
   auto &seq = GetSeq();
   seq.convert_to_seconds();
   newTrack->mSeq.reset(seq.copy(t0 - GetOffset(), len, false));
   newTrack->SetOffset(0);
 
   // What should be done with the rest of newTrack's members?
   // (mBottomNote, mSerializationBuffer,
   // mSerializationLength, mVisibleChannels)
 
   return newTrack;
}

References GetOffset(), GetSeq(), and THROW_INCONSISTENCY_EXCEPTION.

Referenced by anonymous_namespace{EditMenus.cpp}::OnCut().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Cut()

Track::Holder NoteTrack::Cut	(	double	t0,
		double	t1
	)

override

Definition at line 443 of file NoteTrack.cpp.

{
   if (t1 < t0)
      THROW_INCONSISTENCY_EXCEPTION;
 
   double len = t1-t0;
   //auto delta = -(
      //( std::min( t1, GetEndTime() ) ) - ( std::max( t0, GetStartTime() ) )
   //);
 
   auto newTrack = std::make_shared<NoteTrack>();
 
   newTrack->Init(*this);
 
   auto &seq = GetSeq();
   seq.convert_to_seconds();
   newTrack->mSeq.reset(seq.cut(t0 - GetOffset(), len, false));
   newTrack->SetOffset(0);
 
   // Not needed
   // Alg_seq::cut seems to handle this
   //AddToDuration( delta );
 
   // What should be done with the rest of newTrack's members?
   //(mBottomNote,
   // mSerializationBuffer, mSerializationLength, mVisibleChannels)
 
   return newTrack;
}

References GetOffset(), GetSeq(), and THROW_INCONSISTENCY_EXCEPTION.

Referenced by anonymous_namespace{EditMenus.cpp}::OnCut().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DrawLabelControls()

void NoteTrack::DrawLabelControls	(	const NoteTrack *	pTrack,
		wxDC &	dc,
		const wxRect &	rect,
		int	highlightedChannel = `-1`
	)

static

Definition at line 254 of file NoteTrack.cpp.

{
   dc.SetTextForeground(theTheme.Colour(clrLabelTrackText));
   wxASSERT_MSG(rect.width % 4 == 0, "Midi channel control rect width must be divisible by 4");
   wxASSERT_MSG(rect.height % 4 == 0, "Midi channel control rect height must be divisible by 4");
 
   auto cellWidth = rect.width / 4;
   auto cellHeight = rect.height / 4;
 
   wxRect box;
   for (int row = 0; row < 4; row++) {
      for (int col = 0; col < 4; col++) {
         // chanName is the "external" channel number (1-16)
         // used by AColor and button labels
         int chanName = row * 4 + col + 1;
 
         box.x = rect.x + col * cellWidth;
         box.y = rect.y + row * cellHeight;
         box.width = cellWidth;
         box.height = cellHeight;
 
         bool visible = pTrack ? pTrack->IsVisibleChan(chanName - 1) : true;
         if (visible) {
            // highlightedChannel counts 0 based
            if ( chanName == highlightedChannel + 1 )
               AColor::LightMIDIChannel(&dc, chanName);
            else
               AColor::MIDIChannel(&dc, chanName);
            dc.DrawRectangle(box);
// two choices: channel is enabled (to see and play) when button is in
// "up" position (original Audacity style) or in "down" position
//
#define CHANNEL_ON_IS_DOWN 1
#if CHANNEL_ON_IS_DOWN
            AColor::DarkMIDIChannel(&dc, chanName);
#else
            AColor::LightMIDIChannel(&dc, chanName);
#endif
            AColor::Line(dc, box.x, box.y, box.x + box.width - 1, box.y);
            AColor::Line(dc, box.x, box.y, box.x, box.y + box.height - 1);
 
#if CHANNEL_ON_IS_DOWN
            AColor::LightMIDIChannel(&dc, chanName);
#else
            AColor::DarkMIDIChannel(&dc, chanName);
#endif
            AColor::Line(dc,
                         box.x + box.width - 1, box.y,
                         box.x + box.width - 1, box.y + box.height - 1);
            AColor::Line(dc,
                         box.x, box.y + box.height - 1,
                         box.x + box.width - 1, box.y + box.height - 1);
         } else {
            if ( chanName == highlightedChannel + 1 )
               AColor::LightMIDIChannel(&dc, chanName);
            else
               AColor::MIDIChannel(&dc, 0);
            dc.DrawRectangle(box);
#if CHANNEL_ON_IS_DOWN
            AColor::LightMIDIChannel(&dc, 0);
#else
            AColor::DarkMIDIChannel(&dc, 0);
#endif
            AColor::Line(dc, box.x, box.y, box.x + box.width - 1, box.y);
            AColor::Line(dc, box.x, box.y, box.x, box.y + box.height - 1);
 
#if CHANNEL_ON_IS_DOWN
            AColor::DarkMIDIChannel(&dc, 0);
#else
            AColor::LightMIDIChannel(&dc, 0);
#endif
            AColor::Line(dc,
                         box.x + box.width - 1, box.y,
                         box.x + box.width - 1, box.y + box.height - 1);
            AColor::Line(dc,
                         box.x, box.y + box.height - 1,
                         box.x + box.width - 1, box.y + box.height - 1);
 
         }
 
         wxString text;
         wxCoord w;
         wxCoord h;
 
         text.Printf(wxT("%d"), chanName);
         dc.GetTextExtent(text, &w, &h);
 
         dc.DrawText(text, box.x + (box.width - w) / 2, box.y + (box.height - h) / 2);
      }
   }
   dc.SetTextForeground(theTheme.Colour(clrTrackPanelText));
   AColor::MIDIChannel(&dc, 0); // always return with gray color selected
}

References ThemeBase::Colour(), AColor::DarkMIDIChannel(), IsVisibleChan(), AColor::LightMIDIChannel(), AColor::Line(), AColor::MIDIChannel(), theTheme, and wxT().

Referenced by anonymous_namespace{NoteTrackControls.cpp}::MidiControlsDrawFunction().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExportAllegro()

bool NoteTrack::ExportAllegro ( const wxString & f ) const

Definition at line 891 of file NoteTrack.cpp.

{
   double offset = GetOffset();
   auto in_seconds = ImportExportPrefs::AllegroStyleSetting.ReadEnum();
   auto &seq = GetSeq();
   if (in_seconds) {
       seq.convert_to_seconds();
   } else {
       seq.convert_to_beats();
   }
   return seq.write(f.mb_str(), offset);
}

References ImportExportPrefs::AllegroStyleSetting, GetOffset(), GetSeq(), and EnumSetting< Enum >::ReadEnum().

Here is the call graph for this function:

◆ ExportMIDI()

bool NoteTrack::ExportMIDI ( const wxString & f ) const

Definition at line 883 of file NoteTrack.cpp.

{
   std::unique_ptr<Alg_seq> cleanup;
   auto seq = MakeExportableSeq(cleanup);
   bool rslt = seq->smf_write(f.mb_str());
   return rslt;
}

References MakeExportableSeq().

Here is the call graph for this function:

◆ FindChannel()

int NoteTrack::FindChannel	(	const wxRect &	rect,
		int	mx,
		int	my
	)

Definition at line 349 of file NoteTrack.cpp.

{
   wxASSERT_MSG(rect.width % 4 == 0, "Midi channel control rect width must be divisible by 4");
   wxASSERT_MSG(rect.height % 4 == 0, "Midi channel control rect height must be divisible by 4");
 
   auto cellWidth = rect.width / 4;
   auto cellHeight = rect.height / 4;
 
   int col = (mx - rect.x) / cellWidth;
   int row = (my - rect.y) / cellHeight;
 
   return row * 4 + col;
}

Referenced by LabelClick().

Here is the caller graph for this function:

◆ GetBottomNote()

int NoteTrack::GetBottomNote ( ) const

inline

Gets the current bottom note (a pitch)

Definition at line 122 of file NoteTrack.h.

122{ return mBottomNote; }

Referenced by NoteTrackDisplayData::NoteTrackDisplayData().

Here is the caller graph for this function:

◆ GetEndTime()

double NoteTrack::GetEndTime ( ) const

overridevirtual

Implements Track.

Definition at line 211 of file NoteTrack.cpp.

{
   return GetStartTime() + GetSeq().get_real_dur();
}

References GetSeq(), and GetStartTime().

Referenced by GetIntervals(), and Paste().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetIntervals() [1/2]

auto NoteTrack::GetIntervals ( ) const

overridevirtual

Report times on the track where important intervals begin and end, for UI to snap to.

Some intervals may be empty, and no ordering of the intervals is assumed.

Reimplemented from Track.

Definition at line 712 of file NoteTrack.cpp.

{
   ConstIntervals results;
   results.emplace_back( GetStartTime(), GetEndTime() );
   return results;
}

References GetEndTime(), and GetStartTime().

Here is the call graph for this function:

◆ GetIntervals() [2/2]

auto NoteTrack::GetIntervals ( )

overridevirtual

This overload exposes the extra data of the intervals as non-const This overload exposes the extra data of the intervals as non-const

Reimplemented from Track.

Definition at line 719 of file NoteTrack.cpp.

{
   Intervals results;
   results.emplace_back( GetStartTime(), GetEndTime() );
   return results;
}

◆ GetOffset()

double NoteTrack::GetOffset ( ) const

overridevirtual

Implements Track.

Definition at line 201 of file NoteTrack.cpp.

{
   return mOffset;
}

References Track::mOffset.

Referenced by Clear(), Clone(), Copy(), Cut(), anonymous_namespace{NoteTrackView.cpp}::DrawNoteBackground(), anonymous_namespace{NoteTrackView.cpp}::DrawNoteTrack(), ExportAllegro(), GetStartTime(), InsertSilence(), MakeExportableSeq(), NearestBeatTime(), Paste(), Silence(), Trim(), WarpAndTransposeNotes(), and WriteXML().

Here is the caller graph for this function:

◆ GetSeq()

Alg_seq & NoteTrack::GetSeq ( ) const

Definition at line 138 of file NoteTrack.cpp.

{
   if (!mSeq) {
      if (!mSerializationBuffer)
         mSeq = std::make_unique<Alg_seq>();
      else {
         std::unique_ptr<Alg_track> alg_track
         { Alg_seq::unserialize
            ( mSerializationBuffer.get(), mSerializationLength ) };
         wxASSERT(alg_track->get_type() == 's');
         mSeq.reset( static_cast<Alg_seq*>(alg_track.release()) );
 
         // Preserve the invariant that at most one of the representations is
         // valid
         mSerializationBuffer.reset();
         mSerializationLength = 0;
      }
   }
   wxASSERT(mSeq);
   return *mSeq;
}

References mSeq, mSerializationBuffer, and mSerializationLength.

Referenced by AddToDuration(), Clear(), Copy(), Cut(), anonymous_namespace{NoteTrackView.cpp}::DrawNoteBackground(), anonymous_namespace{NoteTrackView.cpp}::DrawNoteTrack(), ExportAllegro(), GetEndTime(), InsertSilence(), MakeExportableSeq(), NearestBeatTime(), Paste(), Shift(), Silence(), StretchRegion(), Trim(), WarpAndTransposeNotes(), WriteXML(), and ZoomAllNotes().

Here is the caller graph for this function:

◆ GetStartTime()

double NoteTrack::GetStartTime ( ) const

overridevirtual

Implements Track.

Definition at line 206 of file NoteTrack.cpp.

{
   return GetOffset();
}

References GetOffset().

Referenced by GetEndTime(), and GetIntervals().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetTopNote()

int NoteTrack::GetTopNote ( ) const

inline

Gets the current top note (a pitch)

Definition at line 124 of file NoteTrack.h.

124{ return mTopNote; }

Referenced by NoteTrackDisplayData::NoteTrackDisplayData().

Here is the caller graph for this function:

◆ GetTypeInfo()

auto NoteTrack::GetTypeInfo ( ) const

overridevirtual

Implements Track.

Definition at line 694 of file NoteTrack.cpp.

{
   return typeInfo();
}

References typeInfo().

Here is the call graph for this function:

◆ GetVisibleChannels()

unsigned NoteTrack::GetVisibleChannels ( ) const

inline

Definition at line 176 of file NoteTrack.h.

                                       {
      return mVisibleChannels.load(std::memory_order_relaxed);
   }

Referenced by Clone(), and WriteXML().

Here is the caller graph for this function:

◆ HandleXMLChild()

XMLTagHandler * NoteTrack::HandleXMLChild ( const std::string_view & tag )

overridevirtual

Implements XMLTagHandler.

Definition at line 953 of file NoteTrack.cpp.

{
   return NULL;
}

◆ HandleXMLTag()

bool NoteTrack::HandleXMLTag	(	const std::string_view &	tag,
		const AttributesList &	attrs
	)

overridevirtual

Implements XMLTagHandler.

Definition at line 912 of file NoteTrack.cpp.

{
   if (tag == "notetrack") {
      for (auto pair : attrs)
      {
         auto attr = pair.first;
         auto value = pair.second;
 
         long nValue;
         double dblValue;
         if (this->Track::HandleCommonXMLAttribute(attr, value))
            ;
         else if (this->NoteTrackBase::HandleXMLAttribute(attr, value))
         {}
         else if (attr == "offset" && value.TryGet(dblValue))
            SetOffset(dblValue);
         else if (attr == "visiblechannels") {
             if (!value.TryGet(nValue) ||
                 !IsValidVisibleChannels(nValue))
                 return false;
             SetVisibleChannels(nValue);
         }
#ifdef EXPERIMENTAL_MIDI_OUT
         else if (attr == "velocity" && value.TryGet(dblValue))
            DoSetVelocity(static_cast<float>(dblValue));
#endif
         else if (attr == "bottomnote" && value.TryGet(nValue))
            SetBottomNote(nValue);
         else if (attr == "topnote" && value.TryGet(nValue))
            SetTopNote(nValue);
         else if (attr == "data") {
             std::string s(value.ToWString());
             std::istringstream data(s);
             mSeq = std::make_unique<Alg_seq>(data, false);
         }
      } // while
      return true;
   }
   return false;
}

References Track::HandleCommonXMLAttribute(), AudioTrack::HandleXMLAttribute(), anonymous_namespace{NoteTrack.cpp}::IsValidVisibleChannels(), mSeq, SetBottomNote(), Track::SetOffset(), SetTopNote(), and SetVisibleChannels().

Here is the call graph for this function:

◆ InsertSilence()

void NoteTrack::InsertSilence	(	double	t,
		double	len
	)

override

Definition at line 618 of file NoteTrack.cpp.

{
   if (len < 0)
      THROW_INCONSISTENCY_EXCEPTION;
 
   auto &seq = GetSeq();
   seq.convert_to_seconds();
   seq.insert_silence(t - GetOffset(), len);
 
   // is this needed?
   // AddToDuration( len );
}

References GetOffset(), GetSeq(), and THROW_INCONSISTENCY_EXCEPTION.

Referenced by Paste().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsVisibleChan()

bool NoteTrack::IsVisibleChan ( int c ) const

inline

Definition at line 182 of file NoteTrack.h.

                                   {
      return (GetVisibleChannels() & CHANNEL_BIT(c)) != 0;
   }

References CHANNEL_BIT.

Referenced by DrawLabelControls(), anonymous_namespace{NoteTrackView.cpp}::DrawNoteTrack(), and anonymous_namespace{MIDIPlay.h}::Iterator::Unmuted().

Here is the caller graph for this function:

◆ LabelClick()

bool NoteTrack::LabelClick	(	const wxRect &	rect,
		int	x,
		int	y,
		bool	right
	)

Definition at line 368 of file NoteTrack.cpp.

{
   auto channel = FindChannel(rect, mx, my);
   if (right)
      SoloVisibleChan(channel);
   else
      ToggleVisibleChan(channel);
 
   return true;
}

References FindChannel(), SoloVisibleChan(), and ToggleVisibleChan().

Here is the call graph for this function:

◆ MakeExportableSeq()

Alg_seq * NoteTrack::MakeExportableSeq ( std::unique_ptr< Alg_seq > & cleanup ) const

Definition at line 760 of file NoteTrack.cpp.

{
   cleanup.reset();
   double offset = GetOffset();
   if (offset == 0)
      return &GetSeq();
   // make a copy, deleting events that are shifted before time 0
   double start = -offset;
   if (start < 0) start = 0;
   // notes that begin before "start" are not included even if they
   // extend past "start" (because "all" parameter is set to false)
   cleanup.reset( GetSeq().copy(start, GetSeq().get_dur() - start, false) );
   auto seq = cleanup.get();
   if (offset > 0) {
      {
         // swap cleanup and mSeq so that Shift operates on the NEW copy
         swap( this->mSeq, cleanup );
         auto cleanup2 = finally( [&] { swap( this->mSeq, cleanup ); } );
 
         const_cast< NoteTrack *>( this )->Shift(offset);
      }
#ifdef OLD_CODE
      // now shift events by offset. This must be done with an integer
      // number of measures, so first, find the beats-per-measure
      double beats_per_measure = 4.0;
      Alg_time_sig_ptr tsp = NULL;
      if (seq->time_sig.length() > 0 && seq->time_sig[0].beat < ALG_EPS) {
         // there is an initial time signature
         tsp = &(seq->time_sig[0]);
         beats_per_measure = (tsp->num * 4) / tsp->den;
      }
      // also need the initial tempo
      double bps = ALG_DEFAULT_BPM / 60;
      Alg_time_map_ptr map = seq->get_time_map();
      Alg_beat_ptr bp = &(map->beats[0]);
      if (bp->time < ALG_EPS) { // tempo change at time 0
         if (map->beats.len > 1) { // compute slope to get tempo
            bps = (map->beats[1].beat - map->beats[0].beat) /
                  (map->beats[1].time - map->beats[0].time);
         } else if (seq->get_time_map()->last_tempo_flag) {
            bps = seq->get_time_map()->last_tempo;
         }
      }
      // find closest number of measures to fit in the gap
      // number of measures is offset / measure_time
      double measure_time = beats_per_measure / bps; // seconds per measure
      int n = ROUND(offset / measure_time);
      if (n == 0) n = 1;
      // we will insert n measures. Compute the desired duration of each.
      measure_time = offset / n;
      bps = beats_per_measure / measure_time;
      // insert integer multiple of measures at beginning
      seq->convert_to_beats();
      seq->insert_silence(0, beats_per_measure * n);
      // make sure time signature at 0 is correct
      if (tsp) {
         seq->set_time_sig(0, tsp->num, tsp->den);
      }
      // adjust tempo to match offset
      seq->set_tempo(bps * 60.0, 0, beats_per_measure * n);
#endif
   } else {
      auto &mySeq = GetSeq();
      // if offset is negative, it might not be a multiple of beats, but
      // we want to preserve the relative positions of measures. I.e. we
      // should shift barlines and time signatures as well as notes.
      // Insert a time signature at the first bar-line if necessary.
 
      // Translate start from seconds to beats and call it beat:
      double beat = mySeq.get_time_map()->time_to_beat(start);
      // Find the time signature in mySeq in effect at start (beat):
      int i = mySeq.time_sig.find_beat(beat);
      // i is where you would insert a NEW time sig at beat,
      // Case 1: beat coincides with a time sig at i. Time signature
      // at beat means that there is a barline at beat, so when beat
      // is shifted to 0, the relative barline positions are preserved
      if (mySeq.time_sig.length() > 0 &&
          within(beat, mySeq.time_sig[i].beat, ALG_EPS)) {
         // beat coincides with time signature change, so offset must
         // be a multiple of beats
         /* do nothing */ ;
      // Case 2: there is no time signature before beat.
      } else if (i == 0 && (mySeq.time_sig.length() == 0 ||
                            mySeq.time_sig[i].beat > beat)) {
         // If beat does not fall on an implied barline, we need to
         // insert a time signature.
         double measures = beat / 4.0;
         double imeasures = ROUND(measures);
         if (!within(measures, imeasures, ALG_EPS)) {
            double bar_offset = ((int)(measures) + 1) * 4.0 - beat;
            seq->set_time_sig(bar_offset, 4, 4);
         }
      // This case should never be true because if i == 0, either there
      // are no time signatures before beat (Case 2),
      // or there is one time signature at beat (Case 1)
      } else if (i == 0) {
         /* do nothing (might be good to assert(false)) */ ;
      // Case 3: i-1 must be the effective time sig position
      } else {
         i -= 1; // index the time signature in effect at beat
         Alg_time_sig_ptr tsp = &(mySeq.time_sig[i]);
         double beats_per_measure = (tsp->num * 4) / tsp->den;
         double measures = (beat - tsp->beat) / beats_per_measure;
         int imeasures = ROUND(measures);
         if (!within(measures, imeasures, ALG_EPS)) {
            // beat is not on a measure, so we need to insert a time sig
            // to force a bar line at the first measure location after
            // beat
            double bar = tsp->beat + beats_per_measure * ((int)(measures) + 1);
            double bar_offset = bar - beat;
            // insert NEW time signature at bar_offset in NEW sequence
            // It will have the same time signature, but the position will
            // force a barline to match the barlines in mSeq
            seq->set_time_sig(bar_offset, tsp->num, tsp->den);
         }
         // else beat coincides with a barline, so no need for an extra
         // time signature to force barline alignment
      }
   }
   return seq;
}

References staffpad::vo::copy(), GetOffset(), GetSeq(), mSeq, ROUND, Shift(), anonymous_namespace{NoteTrack.cpp}::swap(), and within().

Referenced by ExportMIDI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NearestBeatTime()

QuantizedTimeAndBeat NoteTrack::NearestBeatTime ( double time ) const

Definition at line 675 of file NoteTrack.cpp.

{
   // Alg_seq knows nothing about offset, so remove offset time
   double seq_time = time - GetOffset();
   double beat;
   auto &seq = GetSeq();
   seq_time = seq.nearest_beat_time(seq_time, &beat);
   // add the offset back in to get "actual" audacity track time
   return { seq_time + GetOffset(), beat };
}

References GetOffset(), and GetSeq().

Here is the call graph for this function:

◆ New()

NoteTrack * NoteTrack::New ( AudacityProject & project )

static

Definition at line 114 of file NoteTrack.cpp.

{
   auto &tracks = TrackList::Get( project );
   auto result = tracks.Add( std::make_shared<NoteTrack>());
   result->AttachedTrackObjects::BuildAll();
   return result;
}

References TrackList::Get().

Here is the call graph for this function:

◆ Paste()

void NoteTrack::Paste	(	double	t,
		const Track *	src
	)

override

Definition at line 553 of file NoteTrack.cpp.

{
   // Paste inserts src at time t. If src has a positive offset,
   // the offset is treated as silence which is also inserted. If
   // the offset is negative, the offset is ignored and the ENTIRE
   // src is inserted (otherwise, we would either lose data from
   // src by not inserting things at negative times, or inserting
   // things at negative times could overlap things already in
   // the destination track).
 
   //Check that src is a non-NULL NoteTrack
   bool bOk = src && src->TypeSwitch< bool >( [&](const NoteTrack *other) {
 
      auto myOffset = this->GetOffset();
      if (t < myOffset) {
         // workaround strange behavior described at
         // http://bugzilla.audacityteam.org/show_bug.cgi?id=1735#c3
         SetOffset(t);
         InsertSilence(t, myOffset - t);
      }
 
      double delta = 0.0;
      auto &seq = GetSeq();
      auto offset = other->GetOffset();
      if ( offset > 0 ) {
         seq.convert_to_seconds();
         seq.insert_silence( t - GetOffset(), offset );
         t += offset;
         // Is this needed or does Alg_seq::insert_silence take care of it?
         //delta += offset;
      }
 
      // This seems to be needed:
      delta += std::max( 0.0, t - GetEndTime() );
 
      // This, not:
      //delta += other->GetSeq().get_real_dur();
 
      seq.paste(t - GetOffset(), &other->GetSeq());
 
      AddToDuration( delta );
 
      return true;
   });
 
   if ( !bOk )
      // THROW_INCONSISTENCY_EXCEPTION; // ?
      (void)0;// intentionally do nothing
}

References AddToDuration(), GetEndTime(), GetOffset(), GetSeq(), InsertSilence(), Track::SetOffset(), and Track::TypeSwitch().

Here is the call graph for this function:

◆ PasteInto()

Track::Holder NoteTrack::PasteInto ( AudacityProject & ) const

overridevirtual

Find or create the destination track for a paste, maybe in a different project.

Returns: A smart pointer to the track; its use_count() can tell whether it is new

Implements Track.

Definition at line 704 of file NoteTrack.cpp.

{
   auto pNewTrack = std::make_shared<NoteTrack>();
   pNewTrack->Init(*this);
   pNewTrack->Paste(0.0, this);
   return pNewTrack;
}

◆ PrintSequence()

void NoteTrack::PrintSequence ( )

Definition at line 384 of file NoteTrack.cpp.

{
   FILE *debugOutput;
 
   debugOutput = fopen("debugOutput.txt", "wt");
   wxFprintf(debugOutput, "Importing MIDI...\n");
 
   // This is called for debugging purposes.  Do not compute mSeq on demand
   // with GetSeq()
   if (mSeq) {
      int i = 0;
 
      while(i < mSeq->length()) {
         wxFprintf(debugOutput, "--\n");
         wxFprintf(debugOutput, "type: %c\n",
            ((Alg_event_ptr)mSeq->track_list.tracks[i])->get_type());
         wxFprintf(debugOutput, "time: %f\n",
            ((Alg_event_ptr)mSeq->track_list.tracks[i])->time);
         wxFprintf(debugOutput, "channel: %li\n",
            ((Alg_event_ptr)mSeq->track_list.tracks[i])->chan);
 
         if(((Alg_event_ptr)mSeq->track_list.tracks[i])->get_type() == wxT('n'))
         {
            wxFprintf(debugOutput, "pitch: %f\n",
               ((Alg_note_ptr)mSeq->track_list.tracks[i])->pitch);
            wxFprintf(debugOutput, "duration: %f\n",
               ((Alg_note_ptr)mSeq->track_list.tracks[i])->dur);
            wxFprintf(debugOutput, "velocity: %f\n",
               ((Alg_note_ptr)mSeq->track_list.tracks[i])->loud);
         }
         else if(((Alg_event_ptr)mSeq->track_list.tracks[i])->get_type() == wxT('n'))
         {
            wxFprintf(debugOutput, "key: %li\n", ((Alg_update_ptr)mSeq->track_list.tracks[i])->get_identifier());
            wxFprintf(debugOutput, "attribute type: %c\n", ((Alg_update_ptr)mSeq->track_list.tracks[i])->parameter.attr_type());
            wxFprintf(debugOutput, "attribute: %s\n", ((Alg_update_ptr)mSeq->track_list.tracks[i])->parameter.attr_name());
 
            if(((Alg_update_ptr)mSeq->track_list.tracks[i])->parameter.attr_type() == wxT('r'))
            {
               wxFprintf(debugOutput, "value: %f\n", ((Alg_update_ptr)mSeq->track_list.tracks[i])->parameter.r);
            }
            else if(((Alg_update_ptr)mSeq->track_list.tracks[i])->parameter.attr_type() == wxT('i')) {
               wxFprintf(debugOutput, "value: %li\n", ((Alg_update_ptr)mSeq->track_list.tracks[i])->parameter.i);
            }
            else if(((Alg_update_ptr)mSeq->track_list.tracks[i])->parameter.attr_type() == wxT('s')) {
               wxFprintf(debugOutput, "value: %s\n", ((Alg_update_ptr)mSeq->track_list.tracks[i])->parameter.s);
            }
            else {}
         }
 
         i++;
      }
   }
   else {
      wxFprintf(debugOutput, "No sequence defined!\n");
   }
 
   fclose(debugOutput);
}

References mSeq, and wxT().

Here is the call graph for this function:

◆ SetBottomNote()

void NoteTrack::SetBottomNote ( int note )

Sets the bottom note (a pitch), making sure that it is never greater than the top note.

Definition at line 988 of file NoteTrack.cpp.

{
   if (note < MinPitch)
      note = MinPitch;
   else if (note > 96)
      note = 96;
 
   wxCHECK(note <= mTopNote, );
 
   mBottomNote = note;
}

References mBottomNote, MinPitch, and mTopNote.

Referenced by HandleXMLTag().

Here is the caller graph for this function:

◆ SetNoteRange()

void NoteTrack::SetNoteRange	(	int	note1,
		int	note2
	)

Sets the top and bottom note (both pitches) automatically, swapping them if needed.

Definition at line 1010 of file NoteTrack.cpp.

{
   // Bounds check
   if (note1 > MaxPitch)
      note1 = MaxPitch;
   else if (note1 < MinPitch)
      note1 = MinPitch;
   if (note2 > MaxPitch)
      note2 = MaxPitch;
   else if (note2 < MinPitch)
      note2 = MinPitch;
   // Swap to ensure ordering
   if (note2 < note1) { auto tmp = note1; note1 = note2; note2 = tmp; }
 
   mBottomNote = note1;
   mTopNote = note2;
}

References MaxPitch, mBottomNote, MinPitch, and mTopNote.

Referenced by Zoom(), ZoomAllNotes(), and ZoomTo().

Here is the caller graph for this function:

◆ SetSequence()

void NoteTrack::SetSequence ( std::unique_ptr< Alg_seq > && seq )

Definition at line 379 of file NoteTrack.cpp.

{
   mSeq = std::move(seq);
}

References mSeq.

Referenced by ImportMIDI().

Here is the caller graph for this function:

◆ SetTopNote()

void NoteTrack::SetTopNote ( int note )

Sets the top note (a pitch), making sure that it is never less than the bottom note.

Definition at line 1000 of file NoteTrack.cpp.

{
   if (note > MaxPitch)
      note = MaxPitch;
 
   wxCHECK(note >= mBottomNote, );
 
   mTopNote = note;
}

References MaxPitch, mBottomNote, and mTopNote.

Referenced by HandleXMLTag().

Here is the caller graph for this function:

◆ SetVisibleChan()

void NoteTrack::SetVisibleChan ( int c )

inline

Definition at line 185 of file NoteTrack.h.

185 {

186 mVisibleChannels.fetch_or(CHANNEL_BIT(c), std::memory_order_relaxed); }

References CHANNEL_BIT.

◆ SetVisibleChannels()

void NoteTrack::SetVisibleChannels ( unsigned value )

inline

Definition at line 179 of file NoteTrack.h.

                                           {
      mVisibleChannels.store(value, std::memory_order_relaxed);
   }

Referenced by HandleXMLTag().

Here is the caller graph for this function:

◆ Shift()

bool NoteTrack::Shift ( double t )

Definition at line 648 of file NoteTrack.cpp.

{
   if (t > 0) {
      auto &seq = GetSeq();
      // insert an even number of measures
      seq.convert_to_beats();
      // get initial tempo
      double tempo = seq.get_tempo(0.0);
      double beats_per_measure = seq.get_bar_len(0.0);
      int m = ROUND(t * tempo / beats_per_measure);
      // need at least 1 measure, so if we rounded down to zero, fix it
      if (m == 0) m = 1;
      // compute NEW tempo so that m measures at NEW tempo take t seconds
      tempo = beats_per_measure * m / t; // in beats per second
      seq.insert_silence(0.0, beats_per_measure * m);
      seq.set_tempo(tempo * 60.0 /* bpm */, 0.0, beats_per_measure * m);
      seq.write("afterShift.gro");
   } else if (t < 0) {
      auto &seq = GetSeq();
      seq.convert_to_seconds();
      seq.clear(0, t, true);
   } else { // offset is zero, no modifications
      return false;
   }
   return true;
}

References GetSeq(), and ROUND.

Referenced by MakeExportableSeq().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ShiftNoteRange()

void NoteTrack::ShiftNoteRange ( int offset )

Shifts all notes vertically by the given pitch.

Definition at line 1028 of file NoteTrack.cpp.

{
   // Ensure everything stays in bounds
   if (mBottomNote + offset < MinPitch || mTopNote + offset > MaxPitch)
       return;
 
   mBottomNote += offset;
   mTopNote += offset;
}

References MaxPitch, mBottomNote, and mTopNote.

Referenced by NoteTrackMenuTable::OnChangeOctave().

Here is the caller graph for this function:

◆ Silence()

void NoteTrack::Silence	(	double	t0,
		double	t1
	)

override

Definition at line 603 of file NoteTrack.cpp.

{
   if (t1 < t0)
      THROW_INCONSISTENCY_EXCEPTION;
 
   auto len = t1 - t0;
 
   auto &seq = GetSeq();
   seq.convert_to_seconds();
   // XXX: do we want to set the all param?
   // If it's set, then it seems like notes are silenced if they start or end in the range,
   // otherwise only if they start in the range. --Poke
   seq.silence(t0 - GetOffset(), len, false);
}

References GetOffset(), GetSeq(), and THROW_INCONSISTENCY_EXCEPTION.

Here is the call graph for this function:

◆ SoloVisibleChan()

void NoteTrack::SoloVisibleChan ( int c )

inline

Definition at line 193 of file NoteTrack.h.

                               {
      auto visibleChannels = 0u;
      if (GetVisibleChannels() == CHANNEL_BIT(c))
         visibleChannels = ALL_CHANNELS;
      else
         visibleChannels = CHANNEL_BIT(c);
      mVisibleChannels.store(visibleChannels, std::memory_order_relaxed);
   }

References ALL_CHANNELS, and CHANNEL_BIT.

Referenced by LabelClick().

Here is the caller graph for this function:

◆ StretchRegion()

bool NoteTrack::StretchRegion	(	QuantizedTimeAndBeat	t0,
		QuantizedTimeAndBeat	t1,
		double	newDur
	)

Definition at line 738 of file NoteTrack.cpp.

{
   auto &seq = GetSeq();
   bool result = seq.stretch_region( t0.second, t1.second, newDur );
   if (result) {
      const auto oldDur = t1.first - t0.first;
      AddToDuration( newDur - oldDur );
   }
   return result;
}

References AddToDuration(), and GetSeq().

Referenced by StretchHandle::Stretch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ToggleVisibleChan()

void NoteTrack::ToggleVisibleChan ( int c )

inline

Definition at line 189 of file NoteTrack.h.

189 {

190 mVisibleChannels.fetch_xor(CHANNEL_BIT(c), std::memory_order_relaxed); }

References CHANNEL_BIT.

Referenced by LabelClick().

Here is the caller graph for this function:

◆ Trim()

bool NoteTrack::Trim	(	double	t0,
		double	t1
	)

Definition at line 496 of file NoteTrack.cpp.

{
   if (t1 < t0)
      return false;
   auto &seq = GetSeq();
   //auto delta = -(
      //( GetEndTime() - std::min( GetEndTime(), t1 ) ) +
      //( std::max(t0, GetStartTime()) - GetStartTime() )
   //);
   seq.convert_to_seconds();
   // DELETE way beyond duration just in case something is out there:
   seq.clear(t1 - GetOffset(), seq.get_dur() + 10000.0, false);
   // Now that stuff beyond selection is cleared, clear before selection:
   seq.clear(0.0, t0 - GetOffset(), false);
   // want starting time to be t0
   SetOffset(t0);
 
   // Not needed
   // Alg_seq::clear seems to handle this
   //AddToDuration( delta );
 
   return true;
}

References GetOffset(), GetSeq(), and Track::SetOffset().

Here is the call graph for this function:

◆ WarpAndTransposeNotes()

void NoteTrack::WarpAndTransposeNotes	(	double	t0,
		double	t1,
		const TimeWarper &	warper,
		double	semitones
	)

Definition at line 216 of file NoteTrack.cpp.

{
   double offset = this->GetOffset(); // track is shifted this amount
   auto &seq = GetSeq();
   seq.convert_to_seconds(); // make sure time units are right
   t1 -= offset; // adjust time range to compensate for track offset
   t0 -= offset;
   if (t1 > seq.get_dur()) { // make sure t0, t1 are within sequence
      t1 = seq.get_dur();
      if (t0 >= t1) return;
   }
   Alg_iterator iter(mSeq.get(), false);
   iter.begin();
   Alg_event_ptr event;
   while (0 != (event = iter.next()) && event->time < t1) {
      if (event->is_note() && event->time >= t0) {
         event->set_pitch(event->get_pitch() + semitones);
      }
   }
   iter.end();
   // now, use warper to warp the tempo map
   seq.convert_to_beats(); // beats remain the same
   Alg_time_map_ptr map = seq.get_time_map();
   map->insert_beat(t0, map->time_to_beat(t0));
   map->insert_beat(t1, map->time_to_beat(t1));
   int i, len = map->length();
   for (i = 0; i < len; i++) {
      Alg_beat &beat = map->beats[i];
      beat.time = warper.Warp(beat.time + offset) - offset;
   }
   // about to redisplay, so might as well convert back to time now
   seq.convert_to_seconds();
}

References GetOffset(), GetSeq(), mSeq, and TimeWarper::Warp().

Here is the call graph for this function:

◆ WriteXML()

void NoteTrack::WriteXML ( XMLWriter & xmlFile ) const

overridevirtual

Implements Track.

Definition at line 958 of file NoteTrack.cpp.

{
   std::ostringstream data;
   Track::Holder holder;
   const NoteTrack *saveme = this;
   if (!mSeq) {
      // replace saveme with an (unserialized) duplicate, which is
      // destroyed at end of function.
      holder = Clone();
      saveme = static_cast<NoteTrack*>(holder.get());
   }
   saveme->GetSeq().write(data, true);
   xmlFile.StartTag(wxT("notetrack"));
   saveme->Track::WriteCommonXMLAttributes( xmlFile );
   this->NoteTrackBase::WriteXMLAttributes(xmlFile);
   xmlFile.WriteAttr(wxT("offset"), saveme->GetOffset());
   xmlFile.WriteAttr(wxT("visiblechannels"),
      static_cast<int>(saveme->GetVisibleChannels()));
 
#ifdef EXPERIMENTAL_MIDI_OUT
   xmlFile.WriteAttr(wxT("velocity"),
      static_cast<double>(saveme->GetVelocity()));
#endif
   xmlFile.WriteAttr(wxT("bottomnote"), saveme->mBottomNote);
   xmlFile.WriteAttr(wxT("topnote"), saveme->mTopNote);
   xmlFile.WriteAttr(wxT("data"), wxString(data.str().c_str(), wxConvUTF8));
   xmlFile.EndTag(wxT("notetrack"));
}

References GetOffset(), GetSeq(), GetVisibleChannels(), mBottomNote, mTopNote, AudioTrack::WriteXMLAttributes(), and wxT().

Here is the call graph for this function:

◆ Zoom()

void NoteTrack::Zoom	(	const wxRect &	rect,
		int	y,
		float	multiplier,
		bool	center
	)

Zoom the note track around y. If center is true, the result will be centered at y.

Definition at line 1052 of file NoteTrack.cpp.

{
   NoteTrackDisplayData data = NoteTrackDisplayData(this, rect);
   int clickedPitch = data.YToIPitch(y);
   int extent = mTopNote - mBottomNote + 1;
   int newExtent = (int) (extent / multiplier);
   float position;
   if (center) {
      // center the pitch that the user clicked on
      position = .5;
   } else {
      // align to keep the pitch that the user clicked on in the same place
      position = extent / (clickedPitch - mBottomNote);
   }
   int newBottomNote = clickedPitch - (newExtent * position);
   int newTopNote = clickedPitch + (newExtent * (1 - position));
   SetNoteRange(newBottomNote, newTopNote);
}

References mBottomNote, mTopNote, SetNoteRange(), and NoteTrackDisplayData::YToIPitch().

Referenced by ZoomTo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ZoomAllNotes()

void NoteTrack::ZoomAllNotes ( )

Zooms so that all notes are visible.

Definition at line 1087 of file NoteTrack.cpp.

{
   Alg_iterator iterator( &GetSeq(), false );
   iterator.begin();
   Alg_event_ptr evt;
 
   // Go through all of the notes, finding the minimum and maximum value pitches.
   bool hasNotes = false;
   int minPitch = MaxPitch;
   int maxPitch = MinPitch;
 
   while (NULL != (evt = iterator.next())) {
      if (evt->is_note()) {
         int pitch = (int) evt->get_pitch();
         hasNotes = true;
         if (pitch < minPitch)
            minPitch = pitch;
         if (pitch > maxPitch)
            maxPitch = pitch;
      }
   }
 
   if (!hasNotes) {
      // Semi-arbitrary default values:
      minPitch = 48;
      maxPitch = 72;
   }
 
   SetNoteRange(minPitch, maxPitch);
}

References GetSeq(), MaxPitch, MinPitch, and SetNoteRange().

Referenced by ImportMIDI().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ZoomIn()

void NoteTrack::ZoomIn	(	const wxRect &	rect,
		int	y
	)

inline

Zooms in a constant factor (subject to zoom limits)

Definition at line 142 of file NoteTrack.h.

142{ Zoom(rect, y, ZoomStep, true); }

NoteTrack::Zoom

void Zoom(const wxRect &rect, int y, float multiplier, bool center)

Definition: NoteTrack.cpp:1052

NoteTrack::ZoomStep

static const float ZoomStep

Definition: NoteTrack.h:241

Referenced by NoteTrackVRulerControls::HandleWheelRotation().

Here is the caller graph for this function:

◆ ZoomMaxExtent()

void NoteTrack::ZoomMaxExtent ( )

inline

Zooms so that the entire track is visible.

Definition at line 135 of file NoteTrack.h.

135{ SetNoteRange(MinPitch, MaxPitch); }

◆ ZoomOut()

void NoteTrack::ZoomOut	(	const wxRect &	rect,
		int	y
	)

inline

Zooms out a constant factor (subject to zoom limits)

Definition at line 140 of file NoteTrack.h.

140{ Zoom(rect, y, 1.0f / ZoomStep, true); }

◆ ZoomTo()

void NoteTrack::ZoomTo	(	const wxRect &	rect,
		int	start,
		int	end
	)

Definition at line 1072 of file NoteTrack.cpp.

{
   wxRect trackRect(0, rect.GetY(), 1, rect.GetHeight());
   NoteTrackDisplayData data = NoteTrackDisplayData(this, trackRect);
   int pitch1 = data.YToIPitch(start);
   int pitch2 = data.YToIPitch(end);
   if (pitch1 == pitch2) {
      // Just zoom in instead of zooming to show only one note
      Zoom(rect, start, 1, true);
      return;
   }
   // It's fine for this to be in either order
   SetNoteRange(pitch1, pitch2);
}

References PackedArray::end(), SetNoteRange(), NoteTrackDisplayData::YToIPitch(), and Zoom().

Here is the call graph for this function:

Member Data Documentation

◆ mBottomNote

int NoteTrack::mBottomNote

private

Definition at line 230 of file NoteTrack.h.

Referenced by Clone(), NoteTrack(), SetBottomNote(), SetNoteRange(), SetTopNote(), ShiftNoteRange(), WriteXML(), and Zoom().

◆ mPitchHeight

float NoteTrack::mPitchHeight

private

Definition at line 238 of file NoteTrack.h.

◆ mSeq

std::unique_ptr<Alg_seq> NoteTrack::mSeq

mutableprivate

Definition at line 221 of file NoteTrack.h.

Referenced by Clone(), GetSeq(), HandleXMLTag(), MakeExportableSeq(), NoteTrack(), PrintSequence(), SetSequence(), and WarpAndTransposeNotes().

◆ mSerializationBuffer

std::unique_ptr<char[]> NoteTrack::mSerializationBuffer

mutableprivate

Definition at line 222 of file NoteTrack.h.

Referenced by Clone(), and GetSeq().

◆ mSerializationLength

long NoteTrack::mSerializationLength

mutableprivate

Definition at line 223 of file NoteTrack.h.

Referenced by Clone(), GetSeq(), and NoteTrack().

◆ mStretchHandle

std::weak_ptr<StretchHandle> NoteTrack::mStretchHandle

private

Definition at line 246 of file NoteTrack.h.

◆ mTopNote

int NoteTrack::mTopNote

private

Definition at line 230 of file NoteTrack.h.

Referenced by Clone(), NoteTrack(), SetBottomNote(), SetNoteRange(), SetTopNote(), ShiftNoteRange(), WriteXML(), and Zoom().

◆ mVisibleChannels

std::atomic<unsigned> NoteTrack::mVisibleChannels { ALL_CHANNELS }

private

A bit set; atomic because it may be read by worker threads in playback.

Definition at line 244 of file NoteTrack.h.

◆ ZoomStep

const float NoteTrack::ZoomStep = powf( 2.0f, 0.25f )

staticprivate

Definition at line 241 of file NoteTrack.h.

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

Public Types

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Holder

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ NoteTrack() [1/2]

◆ NoteTrack() [2/2]

◆ ~NoteTrack()

Member Function Documentation

◆ AddToDuration()

◆ ClassTypeInfo()

◆ Clear()

◆ ClearVisibleChan()

◆ Clone()

◆ Copy()

◆ Cut()

◆ DrawLabelControls()

◆ ExportAllegro()

◆ ExportMIDI()

◆ FindChannel()

◆ GetBottomNote()

◆ GetEndTime()

◆ GetIntervals() [1/2]

◆ GetIntervals() [2/2]

◆ GetOffset()

◆ GetSeq()

◆ GetStartTime()

◆ GetTopNote()

◆ GetTypeInfo()

◆ GetVisibleChannels()

◆ HandleXMLChild()

◆ HandleXMLTag()

◆ InsertSilence()

◆ IsVisibleChan()

◆ LabelClick()

◆ MakeExportableSeq()

◆ NearestBeatTime()

◆ New()

◆ Paste()

◆ PasteInto()

◆ PrintSequence()

◆ SetBottomNote()

◆ SetNoteRange()

◆ SetSequence()

◆ SetTopNote()

◆ SetVisibleChan()

◆ SetVisibleChannels()

◆ Shift()

◆ ShiftNoteRange()

◆ Silence()

◆ SoloVisibleChan()

◆ StretchRegion()

◆ ToggleVisibleChan()

◆ Trim()

◆ WarpAndTransposeNotes()

◆ WriteXML()

◆ Zoom()

◆ ZoomAllNotes()

◆ ZoomIn()

◆ ZoomMaxExtent()

◆ ZoomOut()

◆ ZoomTo()

Member Data Documentation

◆ mBottomNote

◆ mPitchHeight

◆ mSeq

◆ mSerializationBuffer

◆ mSerializationLength

◆ mStretchHandle

◆ mTopNote

◆ mVisibleChannels