Represents an entry containing metadata and notes. More...

#include <Entries.h>

Inheritance diagram for musx::dom::Entry:

Classes
struct	EntryLocation
	The location of this entry as calculated by calcLocations, which is called by the factory. More...

Public Member Functions
	Entry (const DocumentWeakPtr &document, Cmper partId, ShareMode shareMode, EntryNumber entnum, EntryNumber prev, EntryNumber next)
	Constructor function.

EntryNumber	getEntryNumber () const
	Gets the entry number for this entry.

MusxInstance< Entry >	getNext () const
	Gets the next entry in this list or nullptr if none.

MusxInstance< Entry >	getPrevious () const
	Gets the previous entry in this list or nullptr if none.

Duration	calcDurationInfo () const
	Calculates the NoteType and number of augmentation dots. (See calcDurationInfoFromEdu.)

util::Fraction	calcFraction () const
	Calculates the duration as a util::Fraction of a whole note.

bool	hasStem () const
	Returns true if the entry's duration has a stem.

bool	isPossibleFullMeasureRest () const
	Returns true if the entry could be a full-measure rest.

void	integrityCheck (const std::shared_ptr< Base > &ptrToThis) override
	Allows a class to determine if it has been properly contructed by the factory and fix issues that it can, such as creating default instances of contained classes.

Public Member Functions inherited from musx::dom::Base
virtual	~Base () noexcept(false)=default
	Virtual destructor for polymorphic behavior.

DocumentPtr	getDocument () const
	Gets a reference to the Document.

Cmper	getSourcePartId () const
	Gets the source partId for this instance. If an instance is fully shared with the score, the source is SCORE_PARTID. If an instance is partially shared or non shared, the source is the ID of the part that sourced it.

ShareMode	getShareMode () const
	Gets the sharing mode for this instance.

const SharedNodes &	getUnlinkedNodes () const
	Gets the unlinked nodes for this instance. (Only populated for `ShareMode::Partial`)

void	addUnlinkedNode (const std::string &nodeName)
	Adds a shared node for this instance.

virtual bool	requireAllFields () const
	Specifies if the parser should alert (print or throw) when an unknown xml tag is found for this class.

Static Public Member Functions
static void	calcLocations (const DocumentPtr &document)
	Calculates the locations for all entries in the document. This function is normally only called by the document factory.

static const xml::XmlElementArray< Entry > &	xmlMappingArray ()
	Required for musx::factory::FieldPopulator.

Public Attributes
Edu	duration {}
	Duration of the entry, not taking into account tuplets.

int	numNotes {}
	Number of notes in the entry. There is an error if this is not the same as notes.size().

Evpu	hOffsetScore {}
	Manual offset created with the Note Position Tool in the score. (xml node is `<posi>`.)

bool	isValid {}
	Should always be true but otherwise appears to be used internally by Finale.

bool	isNote {}
	If this value is false, the entry is a rest.

bool	v2Launch {}
	Indicates if this entry (which is voice1) launches a voice2 sequence. (xml node is `<controller>`)

bool	voice2 {}
	This is a V2 note. (xml node `<v2>`)

bool	createdByHP {}
	Indicates the entry was created by Finale's smart playback engine.

bool	playDisabledByHP {}
	Used by Finale's smart playback engine.

bool	graceNote {}
	Indicate the entry is a grace note.

bool	noteDetail {}
	Indicates there is a note detail or EntrySize record for the entry.

bool	articDetail {}
	Indicates there is an articulation on the entry.

bool	lyricDetail {}
	Indicates there is a lyric assignment on the entry.

bool	tupletStart {}
	Indicates that a tuplet start on the entry.

bool	splitRest {}
	Indicates that rests in different layers are not combined on this entry.

bool	performanceData {}
	Indicates there is performance data on the entry.

bool	floatRest {}
	Is floating rest. If false, the first note element gives the staff position of the rest.

bool	isHidden {}
	Indicates the entry is hidden, (xml node is `<ignore>`)

bool	beamExt {}
	Indicates that there is a beam extension on the entry.

bool	flipTie {}
	Indicates the existence of a flipped tie, either in Speedy Entry or Layer Attributes.

bool	dotTieAlt {}
	Indicates dot or tie alterations are present.

bool	beam {}
	Signifies the start of a beam or singleton entry. (That is, any beam breaks at this entry.)

bool	secBeam {}
	Signifies a secondary beam break occurs on the entry.

bool	freezeStemScore {}
	Freeze stem flag in the score. (upStemScore gives the direction.)

bool	stemDetail {}
	Indicates there are stem modifications.

bool	crossStaff {}
	Signifies that at least one note in the entry has been cross staffed.

bool	reverseUpStem {}
	Indicates that a stem normally up is reversed.

bool	reverseDownStem {}
	Indicates that a stem normally down is reversed.

bool	doubleStem {}
	Creates a double stem on the entry. (Appears to be exclusive with splitStem.)

bool	splitStem {}

bool	upStemScore {}
	Whether a stem is up or down as set in the score. (Only reliable when freezeStemScore is true.)

bool	checkAccis {}
	Used by Finale to convert pre-2014 `.mus` files. May never be saved in `.musx`.

bool	dummy {}

bool	smartShapeDetail {}
	Indicates this entry has a smart shape assignment.

bool	noLeger {}
	Hide ledger lines.

bool	sorted {}
	Sorted flag.

bool	slashGrace {}

bool	flatBeam {}
	Forces any beam that starts on this entry to be flat by default.

bool	noPlayback {}
	Indicates that the entry should not be played back.

bool	noSpacing {}
	Indicates that the entry should be ignored when calculating music spacing.

bool	freezeBeam {}
	Freeze beam flag (Derived from the presence of `<freezeBeam>` node.)

std::vector< std::shared_ptr< Note > >	notes
	Collection of notes that comprise the entry. These are in order from lowest to highest.

struct musx::dom::Entry::EntryLocation	location
	The location of this entry.

Static Public Attributes
static constexpr std::string_view	XmlNodeName = "entry"
	The XML node name for this type.

Additional Inherited Members
Public Types inherited from musx::dom::Base
enum class	ShareMode { All , Partial , None }
	Describes how this instance is shared between part and score. More...

using	SharedNodes = std::set< std::string >
	The container type for shared nodes.

Protected Member Functions inherited from musx::dom::Base
	Base (const DocumentWeakPtr &document, Cmper partId, ShareMode shareMode)
	Constructs the base class.

	Base (const Base &)=default
	explicit default copy constructor

	Base (Base &&) noexcept=default
	explicit default move constructor

Base &	operator= (const Base &)
	no-op copy assignment operator allows subclasses to copy their values.

Base &	operator= (Base &&) noexcept
	no-op move assignment operator allows subclasses to move their values.

Detailed Description

Represents an entry containing metadata and notes.

This class is identified by the XML node name "entry".

Constructor & Destructor Documentation

◆ Entry()

musx::dom::Entry::Entry	(	const DocumentWeakPtr &	document,
		Cmper	partId,
		ShareMode	shareMode,
		EntryNumber	entnum,
		EntryNumber	prev,
		EntryNumber	next
	)

inlineexplicit

Constructor function.

The partId and shareMode values should always be 0 and ShareMode::All, but they are required by the factory function.

Member Function Documentation

◆ calcLocations()

void musx::dom::Entry::calcLocations ( const DocumentPtr & document )

static

Calculates the locations for all entries in the document. This function is normally only called by the document factory.

Parameters

document The document to search.

◆ getNext()

MusxInstance< Entry > musx::dom::Entry::getNext ( ) const

Gets the next entry in this list or nullptr if none.

Note that the entry list may contain entries that aren't in any frame. These should be ignored.

◆ getPrevious()

MusxInstance< Entry > musx::dom::Entry::getPrevious ( ) const

Gets the previous entry in this list or nullptr if none.

Note that the entry list may contain entries that aren't in any frame. These should be ignored.

◆ hasStem()

bool musx::dom::Entry::hasStem ( ) const

inline

Returns true if the entry's duration has a stem.

Returns: True if the entry's duration is less than a whole note, irrespective of whether it is a rest or a note.

◆ integrityCheck()

void musx::dom::Entry::integrityCheck ( const std::shared_ptr< Base > & ptrToThis )

inlineoverridevirtual

Allows a class to determine if it has been properly contructed by the factory and fix issues that it can, such as creating default instances of contained classes.

The default implementation should always be called inside an overridden implementation.

Parameters

ptrToThis This instance in a shared_ptr. (Avoids need for shared_from_this.)

Exceptions

musx::dom::integrity_error if there is a problem.

Reimplemented from musx::dom::Base.

◆ isPossibleFullMeasureRest()

bool musx::dom::Entry::isPossibleFullMeasureRest ( ) const

inline

Returns true if the entry could be a full-measure rest.

Note: Finale recognizes only whole rests as possible full-measure rests. Any other rest types (specifically breve rests in 4/2 and larger time signatures) are implemented by users as workarounds. These workarouds typically involve suppressing Finale's full-measure rest display and replacing them with a text expression.

Member Data Documentation

◆ dummy

bool musx::dom::Entry::dummy {}

An entry (usually a rest) inserted for alignment. It may not be meaningful outside the Finale runtime environment and is probably safe to ignore.

◆ duration

Edu musx::dom::Entry::duration {}

Duration of the entry, not taking into account tuplets.

This is effectively the type of note (quarter, eight, whole etc.) plus the augmentation dots, if any. The most significant bit determines the note type and each set bit to the right is an augmentation dot.

(xml node is <dura>)

◆ slashGrace

bool musx::dom::Entry::slashGrace {}

Indicates that a non-beamed grace note with flags (8th note or smaller) should have a slash on the stem. If options::GraceNoteOptions::slashFlaggedGraceNotes is true, this options has no effect. The stem always has a slash in that case.

◆ splitStem

bool musx::dom::Entry::splitStem {}

Indicates the presence of a note with Note::upSplitStem set. If no note has a split stem, it shows as a double stem. (Appears to be exclusive with doubleStem.)

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Additional Inherited Members