Struct KeySignature 

pub struct KeySignature { /* private fields */ }

A key signature represented by the number of sharps.

Flats are represented as negative sharps, so B-flat major has -2. A non-traditional signature, E- and G# together, is flagged as one and lists its pitches; it keeps a count as well, as music21’s does since 14acfa0f2.

Implementations

impl KeySignature

pub fn new(sharps: IntegerType) -> Self

Creates a key signature from a sharp count.

pub fn color(&self) -> Option<&str>

The colour the signature is drawn in, if one was said.

pub fn set_color(&mut self, color: Option<String>)

Sets the colour the signature is drawn in.

pub fn from_altered_pitches(pitches: Vec<Pitch>) -> Self

Creates a non-traditional key signature from the pitches it alters: E- and G# together, say, which no count of sharps can express. Its count is nought.

pub fn sharps(&self) -> IntegerType

Returns the number of sharps, with flats as negative values.

pub fn set_sharps(&mut self, sharps: IntegerType)

Replaces the sharp count, leaving the flag and any pitches written over it as they are, as music21’s sharps setter does.

pub fn set_altered_pitches(&mut self, pitches: Vec<Pitch>)

Writes pitches over the ones the count implies, as music21’s alteredPitches setter does. It does not make the signature non-traditional; Self::set_non_traditional does that.

pub fn is_non_traditional(&self) -> bool

Whether the signature is a list of altered pitches rather than a count of sharps or flats: music21’s isNonTraditional.

pub fn set_non_traditional(&mut self, non_traditional: bool)

Flags the signature non-traditional or traditional, its count and pitches left as they are.

pub fn accidentals_apply_only_to_octave(&self) -> bool

Whether the altered pitches of a non-traditional signature carry octaves that limit where they apply, as F#4 altering only that octave. music21 records the flag; applying it is a stream’s job.

pub fn set_accidentals_apply_only_to_octave(&mut self, value: bool)

Sets whether the altered pitches apply only in their own octave.

pub fn description(&self) -> String

The description music21 prints after of: 3 sharps, 1 flat, no sharps or flats, or pitches: [E-, G#].

pub fn altered_pitches(&self) -> Result<Vec<Pitch>>

Returns the pitches this signature alters, in circle-of-fifths order and without octaves: F# C# G# for three sharps, B- E- A- for three flats; a non-traditional signature answers the pitches it was given.

pub fn accidental_by_step(&self, step: char) -> Result<Option<Accidental>>

Returns the accidental this signature puts on a step letter, if any.

pub fn transpose(&self, interval: &Interval) -> Result<Self>

Returns the signature of the major key this one’s major tonic moves to by the interval, drawn in the colour this one is.

pub fn transpose_pitch_from_c(&self, pitch: &Pitch) -> Result<Pitch>

Transposes a pitch spelled in C into this key signature the way music21’s transposePitchFromC does: up a fifth per sharp, or up a fourth per flat, keeping the pitch’s own octave, so E4 in two sharps is F#4 and in three flats G4.

pub fn scale(&self, mode: &str) -> Result<Scale>

Returns the major or minor scale this signature implies.

pub fn as_key(&self, mode: &str) -> Key

Converts this signature to a key in the given mode.

pub fn try_as_key(&self, mode: Option<&str>, tonic: Option<&str>) -> Result<Key>

Converts this signature to a key, optionally inferring mode from tonic.

Trait Implementations

impl Clone for KeySignature

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KeySignature

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for KeySignature

Available on crate feature serde only.

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for KeySignature

fn fmt(&self, f: &mut Formatter<'_>) -> Result

KeySignature of 3 sharps, KeySignature of pitches: [E-, G#].

impl From<KeySignature> for StreamElement

fn from(value: KeySignature) -> Self

Converts to this type from the input type.

impl PartialEq for KeySignature

fn eq(&self, other: &Self) -> bool

music21’s equalityAttributes: the count and the flag.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for KeySignature

Available on crate feature serde only.

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.