Safe Haskell	None
Language	Haskell2010

Fadno.MusicXml.MusicXml20

Synopsis

Documentation

newtype ID Source #

xs:ID (simple)

Constructors

ID
Fields iD :: NCName

Instances

Eq ID Source #
Methods (==) :: ID -> ID -> Bool # (/=) :: ID -> ID -> Bool #
Ord ID Source #
Methods compare :: ID -> ID -> Ordering # (<) :: ID -> ID -> Bool # (<=) :: ID -> ID -> Bool # (>) :: ID -> ID -> Bool # (>=) :: ID -> ID -> Bool # max :: ID -> ID -> ID # min :: ID -> ID -> ID #
Read ID Source #
Methods readsPrec :: Int -> ReadS ID # readList :: ReadS [ID] # readPrec :: ReadPrec ID # readListPrec :: ReadPrec [ID] #
Show ID Source #
Methods showsPrec :: Int -> ID -> ShowS # show :: ID -> String # showList :: [ID] -> ShowS #
IsString ID Source #
Methods fromString :: String -> ID #
Generic ID Source #
Associated Types type Rep ID :: * -> * # Methods from :: ID -> Rep ID x # to :: Rep ID x -> ID #
EmitXml ID Source #
Methods emitXml :: ID -> XmlRep Source #
type Rep ID Source #
type Rep ID = D1 * (MetaData "ID" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "ID" PrefixI True) (S1 * (MetaSel (Just Symbol "iD") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NCName)))

parseID :: String -> XParse ID Source #

newtype IDREF Source #

xs:IDREF (simple)

Constructors

IDREF
Fields iDREF :: NCName

Instances

Eq IDREF Source #
Methods (==) :: IDREF -> IDREF -> Bool # (/=) :: IDREF -> IDREF -> Bool #
Ord IDREF Source #
Methods compare :: IDREF -> IDREF -> Ordering # (<) :: IDREF -> IDREF -> Bool # (<=) :: IDREF -> IDREF -> Bool # (>) :: IDREF -> IDREF -> Bool # (>=) :: IDREF -> IDREF -> Bool # max :: IDREF -> IDREF -> IDREF # min :: IDREF -> IDREF -> IDREF #
Read IDREF Source #
Methods readsPrec :: Int -> ReadS IDREF # readList :: ReadS [IDREF] # readPrec :: ReadPrec IDREF # readListPrec :: ReadPrec [IDREF] #
Show IDREF Source #
Methods showsPrec :: Int -> IDREF -> ShowS # show :: IDREF -> String # showList :: [IDREF] -> ShowS #
IsString IDREF Source #
Methods fromString :: String -> IDREF #
Generic IDREF Source #
Associated Types type Rep IDREF :: * -> * # Methods from :: IDREF -> Rep IDREF x # to :: Rep IDREF x -> IDREF #
EmitXml IDREF Source #
Methods emitXml :: IDREF -> XmlRep Source #
type Rep IDREF Source #
type Rep IDREF = D1 * (MetaData "IDREF" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "IDREF" PrefixI True) (S1 * (MetaSel (Just Symbol "iDREF") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NCName)))

parseIDREF :: String -> XParse IDREF Source #

newtype NCName Source #

xs:NCName (simple)

Constructors

NCName
Fields nCName :: Name

Instances

Eq NCName Source #
Methods (==) :: NCName -> NCName -> Bool # (/=) :: NCName -> NCName -> Bool #
Ord NCName Source #
Methods compare :: NCName -> NCName -> Ordering # (<) :: NCName -> NCName -> Bool # (<=) :: NCName -> NCName -> Bool # (>) :: NCName -> NCName -> Bool # (>=) :: NCName -> NCName -> Bool # max :: NCName -> NCName -> NCName # min :: NCName -> NCName -> NCName #
Read NCName Source #
Methods readsPrec :: Int -> ReadS NCName # readList :: ReadS [NCName] # readPrec :: ReadPrec NCName # readListPrec :: ReadPrec [NCName] #
Show NCName Source #
Methods showsPrec :: Int -> NCName -> ShowS # show :: NCName -> String # showList :: [NCName] -> ShowS #
IsString NCName Source #
Methods fromString :: String -> NCName #
Generic NCName Source #
Associated Types type Rep NCName :: * -> * # Methods from :: NCName -> Rep NCName x # to :: Rep NCName x -> NCName #
EmitXml NCName Source #
Methods emitXml :: NCName -> XmlRep Source #
type Rep NCName Source #
type Rep NCName = D1 * (MetaData "NCName" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "NCName" PrefixI True) (S1 * (MetaSel (Just Symbol "nCName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Name)))

parseNCName :: String -> XParse NCName Source #

newtype NMTOKEN Source #

xs:NMTOKEN (simple)

Constructors

NMTOKEN
Fields nMTOKEN :: Token

Instances

Eq NMTOKEN Source #
Methods (==) :: NMTOKEN -> NMTOKEN -> Bool # (/=) :: NMTOKEN -> NMTOKEN -> Bool #
Ord NMTOKEN Source #
Methods compare :: NMTOKEN -> NMTOKEN -> Ordering # (<) :: NMTOKEN -> NMTOKEN -> Bool # (<=) :: NMTOKEN -> NMTOKEN -> Bool # (>) :: NMTOKEN -> NMTOKEN -> Bool # (>=) :: NMTOKEN -> NMTOKEN -> Bool # max :: NMTOKEN -> NMTOKEN -> NMTOKEN # min :: NMTOKEN -> NMTOKEN -> NMTOKEN #
Read NMTOKEN Source #
Methods readsPrec :: Int -> ReadS NMTOKEN # readList :: ReadS [NMTOKEN] # readPrec :: ReadPrec NMTOKEN # readListPrec :: ReadPrec [NMTOKEN] #
Show NMTOKEN Source #
Methods showsPrec :: Int -> NMTOKEN -> ShowS # show :: NMTOKEN -> String # showList :: [NMTOKEN] -> ShowS #
IsString NMTOKEN Source #
Methods fromString :: String -> NMTOKEN #
Generic NMTOKEN Source #
Associated Types type Rep NMTOKEN :: * -> * # Methods from :: NMTOKEN -> Rep NMTOKEN x # to :: Rep NMTOKEN x -> NMTOKEN #
EmitXml NMTOKEN Source #
Methods emitXml :: NMTOKEN -> XmlRep Source #
type Rep NMTOKEN Source #
type Rep NMTOKEN = D1 * (MetaData "NMTOKEN" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "NMTOKEN" PrefixI True) (S1 * (MetaSel (Just Symbol "nMTOKEN") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Token)))

parseNMTOKEN :: String -> XParse NMTOKEN Source #

newtype Name Source #

xs:Name (simple)

Constructors

Name
Fields name :: Token

Instances

Eq Name Source #
Methods (==) :: Name -> Name -> Bool # (/=) :: Name -> Name -> Bool #
Ord Name Source #
Methods compare :: Name -> Name -> Ordering # (<) :: Name -> Name -> Bool # (<=) :: Name -> Name -> Bool # (>) :: Name -> Name -> Bool # (>=) :: Name -> Name -> Bool # max :: Name -> Name -> Name # min :: Name -> Name -> Name #
Read Name Source #
Methods readsPrec :: Int -> ReadS Name # readList :: ReadS [Name] # readPrec :: ReadPrec Name # readListPrec :: ReadPrec [Name] #
Show Name Source #
Methods showsPrec :: Int -> Name -> ShowS # show :: Name -> String # showList :: [Name] -> ShowS #
IsString Name Source #
Methods fromString :: String -> Name #
Generic Name Source #
Associated Types type Rep Name :: * -> * # Methods from :: Name -> Rep Name x # to :: Rep Name x -> Name #
EmitXml Name Source #
Methods emitXml :: Name -> XmlRep Source #
type Rep Name Source #
type Rep Name = D1 * (MetaData "Name" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "Name" PrefixI True) (S1 * (MetaSel (Just Symbol "name") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Token)))

parseName :: String -> XParse Name Source #

data AboveBelow Source #

above-below (simple)

The above-below type is used to indicate whether one element appears above or below another element.

Constructors

AboveBelowAbove	above
AboveBelowBelow	below

Instances

Bounded AboveBelow Source #
Methods minBound :: AboveBelow # maxBound :: AboveBelow #
Enum AboveBelow Source #
Methods succ :: AboveBelow -> AboveBelow # pred :: AboveBelow -> AboveBelow # toEnum :: Int -> AboveBelow # fromEnum :: AboveBelow -> Int # enumFrom :: AboveBelow -> [AboveBelow] # enumFromThen :: AboveBelow -> AboveBelow -> [AboveBelow] # enumFromTo :: AboveBelow -> AboveBelow -> [AboveBelow] # enumFromThenTo :: AboveBelow -> AboveBelow -> AboveBelow -> [AboveBelow] #
Eq AboveBelow Source #
Methods (==) :: AboveBelow -> AboveBelow -> Bool # (/=) :: AboveBelow -> AboveBelow -> Bool #
Ord AboveBelow Source #
Methods compare :: AboveBelow -> AboveBelow -> Ordering # (<) :: AboveBelow -> AboveBelow -> Bool # (<=) :: AboveBelow -> AboveBelow -> Bool # (>) :: AboveBelow -> AboveBelow -> Bool # (>=) :: AboveBelow -> AboveBelow -> Bool # max :: AboveBelow -> AboveBelow -> AboveBelow # min :: AboveBelow -> AboveBelow -> AboveBelow #
Show AboveBelow Source #
Methods showsPrec :: Int -> AboveBelow -> ShowS # show :: AboveBelow -> String # showList :: [AboveBelow] -> ShowS #
Generic AboveBelow Source #
Associated Types type Rep AboveBelow :: * -> * # Methods from :: AboveBelow -> Rep AboveBelow x # to :: Rep AboveBelow x -> AboveBelow #
EmitXml AboveBelow Source #
Methods emitXml :: AboveBelow -> XmlRep Source #
type Rep AboveBelow Source #
type Rep AboveBelow = D1 * (MetaData "AboveBelow" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "AboveBelowAbove" PrefixI False) (U1 )) (C1 (MetaCons "AboveBelowBelow" PrefixI False) (U1 *)))

parseAboveBelow :: String -> XParse AboveBelow Source #

data AccidentalValue Source #

accidental-value (simple)

The accidental-value type represents notated accidentals supported by MusicXML. In the MusicXML 2.0 DTD this was a string with values that could be included. The XSD strengthens the data typing to an enumerated list.

Constructors

AccidentalValueSharp	sharp
AccidentalValueNatural	natural
AccidentalValueFlat	flat
AccidentalValueDoubleSharp	double-sharp
AccidentalValueSharpSharp	sharp-sharp
AccidentalValueFlatFlat	flat-flat
AccidentalValueNaturalSharp	natural-sharp
AccidentalValueNaturalFlat	natural-flat
AccidentalValueQuarterFlat	quarter-flat
AccidentalValueQuarterSharp	quarter-sharp
AccidentalValueThreeQuartersFlat	three-quarters-flat
AccidentalValueThreeQuartersSharp	three-quarters-sharp

Instances

Bounded AccidentalValue Source #
Methods minBound :: AccidentalValue # maxBound :: AccidentalValue #
Enum AccidentalValue Source #
Methods succ :: AccidentalValue -> AccidentalValue # pred :: AccidentalValue -> AccidentalValue # toEnum :: Int -> AccidentalValue # fromEnum :: AccidentalValue -> Int # enumFrom :: AccidentalValue -> [AccidentalValue] # enumFromThen :: AccidentalValue -> AccidentalValue -> [AccidentalValue] # enumFromTo :: AccidentalValue -> AccidentalValue -> [AccidentalValue] # enumFromThenTo :: AccidentalValue -> AccidentalValue -> AccidentalValue -> [AccidentalValue] #
Eq AccidentalValue Source #
Methods (==) :: AccidentalValue -> AccidentalValue -> Bool # (/=) :: AccidentalValue -> AccidentalValue -> Bool #
Ord AccidentalValue Source #
Methods compare :: AccidentalValue -> AccidentalValue -> Ordering # (<) :: AccidentalValue -> AccidentalValue -> Bool # (<=) :: AccidentalValue -> AccidentalValue -> Bool # (>) :: AccidentalValue -> AccidentalValue -> Bool # (>=) :: AccidentalValue -> AccidentalValue -> Bool # max :: AccidentalValue -> AccidentalValue -> AccidentalValue # min :: AccidentalValue -> AccidentalValue -> AccidentalValue #
Show AccidentalValue Source #
Methods showsPrec :: Int -> AccidentalValue -> ShowS # show :: AccidentalValue -> String # showList :: [AccidentalValue] -> ShowS #
Generic AccidentalValue Source #
Associated Types type Rep AccidentalValue :: * -> * # Methods from :: AccidentalValue -> Rep AccidentalValue x # to :: Rep AccidentalValue x -> AccidentalValue #
EmitXml AccidentalValue Source #
Methods emitXml :: AccidentalValue -> XmlRep Source #
type Rep AccidentalValue Source #
type Rep AccidentalValue = D1 * (MetaData "AccidentalValue" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "AccidentalValueSharp" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "AccidentalValueNatural" PrefixI False) (U1 )) (C1 (MetaCons "AccidentalValueFlat" PrefixI False) (U1 )))) ((:+:) (C1 * (MetaCons "AccidentalValueDoubleSharp" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "AccidentalValueSharpSharp" PrefixI False) (U1 )) (C1 (MetaCons "AccidentalValueFlatFlat" PrefixI False) (U1 ))))) ((:+:) ((:+:) * (C1 * (MetaCons "AccidentalValueNaturalSharp" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "AccidentalValueNaturalFlat" PrefixI False) (U1 )) (C1 (MetaCons "AccidentalValueQuarterFlat" PrefixI False) (U1 )))) ((:+:) (C1 * (MetaCons "AccidentalValueQuarterSharp" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "AccidentalValueThreeQuartersFlat" PrefixI False) (U1 )) (C1 (MetaCons "AccidentalValueThreeQuartersSharp" PrefixI False) (U1 *))))))

parseAccidentalValue :: String -> XParse AccidentalValue Source #

newtype AccordionMiddle Source #

accordion-middle (simple)

The accordion-middle type may have values of 1, 2, or 3, corresponding to having 1 to 3 dots in the middle section of the accordion registration symbol.

Constructors

AccordionMiddle
Fields accordionMiddle :: PositiveInteger

Instances

Bounded AccordionMiddle Source #
Methods minBound :: AccordionMiddle # maxBound :: AccordionMiddle #
Enum AccordionMiddle Source #
Methods succ :: AccordionMiddle -> AccordionMiddle # pred :: AccordionMiddle -> AccordionMiddle # toEnum :: Int -> AccordionMiddle # fromEnum :: AccordionMiddle -> Int # enumFrom :: AccordionMiddle -> [AccordionMiddle] # enumFromThen :: AccordionMiddle -> AccordionMiddle -> [AccordionMiddle] # enumFromTo :: AccordionMiddle -> AccordionMiddle -> [AccordionMiddle] # enumFromThenTo :: AccordionMiddle -> AccordionMiddle -> AccordionMiddle -> [AccordionMiddle] #
Eq AccordionMiddle Source #
Methods (==) :: AccordionMiddle -> AccordionMiddle -> Bool # (/=) :: AccordionMiddle -> AccordionMiddle -> Bool #
Integral AccordionMiddle Source #
Methods quot :: AccordionMiddle -> AccordionMiddle -> AccordionMiddle # rem :: AccordionMiddle -> AccordionMiddle -> AccordionMiddle # div :: AccordionMiddle -> AccordionMiddle -> AccordionMiddle # mod :: AccordionMiddle -> AccordionMiddle -> AccordionMiddle # quotRem :: AccordionMiddle -> AccordionMiddle -> (AccordionMiddle, AccordionMiddle) # divMod :: AccordionMiddle -> AccordionMiddle -> (AccordionMiddle, AccordionMiddle) # toInteger :: AccordionMiddle -> Integer #
Num AccordionMiddle Source #
Methods (+) :: AccordionMiddle -> AccordionMiddle -> AccordionMiddle # (-) :: AccordionMiddle -> AccordionMiddle -> AccordionMiddle # (*) :: AccordionMiddle -> AccordionMiddle -> AccordionMiddle # negate :: AccordionMiddle -> AccordionMiddle # abs :: AccordionMiddle -> AccordionMiddle # signum :: AccordionMiddle -> AccordionMiddle # fromInteger :: Integer -> AccordionMiddle #
Ord AccordionMiddle Source #
Methods compare :: AccordionMiddle -> AccordionMiddle -> Ordering # (<) :: AccordionMiddle -> AccordionMiddle -> Bool # (<=) :: AccordionMiddle -> AccordionMiddle -> Bool # (>) :: AccordionMiddle -> AccordionMiddle -> Bool # (>=) :: AccordionMiddle -> AccordionMiddle -> Bool # max :: AccordionMiddle -> AccordionMiddle -> AccordionMiddle # min :: AccordionMiddle -> AccordionMiddle -> AccordionMiddle #
Read AccordionMiddle Source #
Methods readsPrec :: Int -> ReadS AccordionMiddle # readList :: ReadS [AccordionMiddle] # readPrec :: ReadPrec AccordionMiddle # readListPrec :: ReadPrec [AccordionMiddle] #
Real AccordionMiddle Source #
Methods toRational :: AccordionMiddle -> Rational #
Show AccordionMiddle Source #
Methods showsPrec :: Int -> AccordionMiddle -> ShowS # show :: AccordionMiddle -> String # showList :: [AccordionMiddle] -> ShowS #
Generic AccordionMiddle Source #
Associated Types type Rep AccordionMiddle :: * -> * # Methods from :: AccordionMiddle -> Rep AccordionMiddle x # to :: Rep AccordionMiddle x -> AccordionMiddle #
EmitXml AccordionMiddle Source #
Methods emitXml :: AccordionMiddle -> XmlRep Source #
type Rep AccordionMiddle Source #
type Rep AccordionMiddle = D1 * (MetaData "AccordionMiddle" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "AccordionMiddle" PrefixI True) (S1 * (MetaSel (Just Symbol "accordionMiddle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveInteger)))

parseAccordionMiddle :: String -> XParse AccordionMiddle Source #

data Actuate Source #

xlink:actuate (simple)

Constructors

ActuateOnRequest	onRequest
ActuateOnLoad	onLoad
ActuateOther	other
ActuateNone	none

Instances

Bounded Actuate Source #
Methods minBound :: Actuate # maxBound :: Actuate #
Enum Actuate Source #
Methods succ :: Actuate -> Actuate # pred :: Actuate -> Actuate # toEnum :: Int -> Actuate # fromEnum :: Actuate -> Int # enumFrom :: Actuate -> [Actuate] # enumFromThen :: Actuate -> Actuate -> [Actuate] # enumFromTo :: Actuate -> Actuate -> [Actuate] # enumFromThenTo :: Actuate -> Actuate -> Actuate -> [Actuate] #
Eq Actuate Source #
Methods (==) :: Actuate -> Actuate -> Bool # (/=) :: Actuate -> Actuate -> Bool #
Ord Actuate Source #
Methods compare :: Actuate -> Actuate -> Ordering # (<) :: Actuate -> Actuate -> Bool # (<=) :: Actuate -> Actuate -> Bool # (>) :: Actuate -> Actuate -> Bool # (>=) :: Actuate -> Actuate -> Bool # max :: Actuate -> Actuate -> Actuate # min :: Actuate -> Actuate -> Actuate #
Show Actuate Source #
Methods showsPrec :: Int -> Actuate -> ShowS # show :: Actuate -> String # showList :: [Actuate] -> ShowS #
Generic Actuate Source #
Associated Types type Rep Actuate :: * -> * # Methods from :: Actuate -> Rep Actuate x # to :: Rep Actuate x -> Actuate #
EmitXml Actuate Source #
Methods emitXml :: Actuate -> XmlRep Source #
type Rep Actuate Source #
type Rep Actuate = D1 * (MetaData "Actuate" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "ActuateOnRequest" PrefixI False) (U1 )) (C1 (MetaCons "ActuateOnLoad" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "ActuateOther" PrefixI False) (U1 )) (C1 (MetaCons "ActuateNone" PrefixI False) (U1 *))))

parseActuate :: String -> XParse Actuate Source #

data BackwardForward Source #

backward-forward (simple)

The backward-forward type is used to specify repeat directions. The start of the repeat has a forward direction while the end of the repeat has a backward direction.

Constructors

BackwardForwardBackward	backward
BackwardForwardForward	forward

Instances

Bounded BackwardForward Source #
Methods minBound :: BackwardForward # maxBound :: BackwardForward #
Enum BackwardForward Source #
Methods succ :: BackwardForward -> BackwardForward # pred :: BackwardForward -> BackwardForward # toEnum :: Int -> BackwardForward # fromEnum :: BackwardForward -> Int # enumFrom :: BackwardForward -> [BackwardForward] # enumFromThen :: BackwardForward -> BackwardForward -> [BackwardForward] # enumFromTo :: BackwardForward -> BackwardForward -> [BackwardForward] # enumFromThenTo :: BackwardForward -> BackwardForward -> BackwardForward -> [BackwardForward] #
Eq BackwardForward Source #
Methods (==) :: BackwardForward -> BackwardForward -> Bool # (/=) :: BackwardForward -> BackwardForward -> Bool #
Ord BackwardForward Source #
Methods compare :: BackwardForward -> BackwardForward -> Ordering # (<) :: BackwardForward -> BackwardForward -> Bool # (<=) :: BackwardForward -> BackwardForward -> Bool # (>) :: BackwardForward -> BackwardForward -> Bool # (>=) :: BackwardForward -> BackwardForward -> Bool # max :: BackwardForward -> BackwardForward -> BackwardForward # min :: BackwardForward -> BackwardForward -> BackwardForward #
Show BackwardForward Source #
Methods showsPrec :: Int -> BackwardForward -> ShowS # show :: BackwardForward -> String # showList :: [BackwardForward] -> ShowS #
Generic BackwardForward Source #
Associated Types type Rep BackwardForward :: * -> * # Methods from :: BackwardForward -> Rep BackwardForward x # to :: Rep BackwardForward x -> BackwardForward #
EmitXml BackwardForward Source #
Methods emitXml :: BackwardForward -> XmlRep Source #
type Rep BackwardForward Source #
type Rep BackwardForward = D1 * (MetaData "BackwardForward" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "BackwardForwardBackward" PrefixI False) (U1 )) (C1 (MetaCons "BackwardForwardForward" PrefixI False) (U1 *)))

parseBackwardForward :: String -> XParse BackwardForward Source #

data BarStyle Source #

bar-style (simple)

The bar-style type represents barline style information. Choices are regular, dotted, dashed, heavy, light-light, light-heavy, heavy-light, heavy-heavy, tick (a short stroke through the top line), short (a partial barline between the 2nd and 4th lines), and none.

Constructors

BarStyleRegular	regular
BarStyleDotted	dotted
BarStyleDashed	dashed
BarStyleHeavy	heavy
BarStyleLightLight	light-light
BarStyleLightHeavy	light-heavy
BarStyleHeavyLight	heavy-light
BarStyleHeavyHeavy	heavy-heavy
BarStyleTick	tick
BarStyleShort	short
BarStyleNone	none

Instances

Bounded BarStyle Source #
Methods minBound :: BarStyle # maxBound :: BarStyle #
Enum BarStyle Source #
Methods succ :: BarStyle -> BarStyle # pred :: BarStyle -> BarStyle # toEnum :: Int -> BarStyle # fromEnum :: BarStyle -> Int # enumFrom :: BarStyle -> [BarStyle] # enumFromThen :: BarStyle -> BarStyle -> [BarStyle] # enumFromTo :: BarStyle -> BarStyle -> [BarStyle] # enumFromThenTo :: BarStyle -> BarStyle -> BarStyle -> [BarStyle] #
Eq BarStyle Source #
Methods (==) :: BarStyle -> BarStyle -> Bool # (/=) :: BarStyle -> BarStyle -> Bool #
Ord BarStyle Source #
Methods compare :: BarStyle -> BarStyle -> Ordering # (<) :: BarStyle -> BarStyle -> Bool # (<=) :: BarStyle -> BarStyle -> Bool # (>) :: BarStyle -> BarStyle -> Bool # (>=) :: BarStyle -> BarStyle -> Bool # max :: BarStyle -> BarStyle -> BarStyle # min :: BarStyle -> BarStyle -> BarStyle #
Show BarStyle Source #
Methods showsPrec :: Int -> BarStyle -> ShowS # show :: BarStyle -> String # showList :: [BarStyle] -> ShowS #
Generic BarStyle Source #
Associated Types type Rep BarStyle :: * -> * # Methods from :: BarStyle -> Rep BarStyle x # to :: Rep BarStyle x -> BarStyle #
EmitXml BarStyle Source #
Methods emitXml :: BarStyle -> XmlRep Source #
type Rep BarStyle Source #
type Rep BarStyle = D1 * (MetaData "BarStyle" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "BarStyleRegular" PrefixI False) (U1 )) (C1 (MetaCons "BarStyleDotted" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "BarStyleDashed" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "BarStyleHeavy" PrefixI False) (U1 )) (C1 (MetaCons "BarStyleLightLight" PrefixI False) (U1 ))))) ((:+:) ((:+:) * (C1 * (MetaCons "BarStyleLightHeavy" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "BarStyleHeavyLight" PrefixI False) (U1 )) (C1 (MetaCons "BarStyleHeavyHeavy" PrefixI False) (U1 )))) ((:+:) (C1 * (MetaCons "BarStyleTick" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "BarStyleShort" PrefixI False) (U1 )) (C1 (MetaCons "BarStyleNone" PrefixI False) (U1 *))))))

parseBarStyle :: String -> XParse BarStyle Source #

newtype BeamLevel Source #

beam-level (simple)

The MusicXML format supports six levels of beaming, up to 256th notes. Unlike the number-level type, the beam-level type identifies concurrent beams in a beam group. It does not distinguish overlapping beams such as grace notes within regular notes, or beams used in different voices.

Constructors

BeamLevel
Fields beamLevel :: PositiveInteger

Instances

Bounded BeamLevel Source #
Methods minBound :: BeamLevel # maxBound :: BeamLevel #
Enum BeamLevel Source #
Methods succ :: BeamLevel -> BeamLevel # pred :: BeamLevel -> BeamLevel # toEnum :: Int -> BeamLevel # fromEnum :: BeamLevel -> Int # enumFrom :: BeamLevel -> [BeamLevel] # enumFromThen :: BeamLevel -> BeamLevel -> [BeamLevel] # enumFromTo :: BeamLevel -> BeamLevel -> [BeamLevel] # enumFromThenTo :: BeamLevel -> BeamLevel -> BeamLevel -> [BeamLevel] #
Eq BeamLevel Source #
Methods (==) :: BeamLevel -> BeamLevel -> Bool # (/=) :: BeamLevel -> BeamLevel -> Bool #
Integral BeamLevel Source #
Methods quot :: BeamLevel -> BeamLevel -> BeamLevel # rem :: BeamLevel -> BeamLevel -> BeamLevel # div :: BeamLevel -> BeamLevel -> BeamLevel # mod :: BeamLevel -> BeamLevel -> BeamLevel # quotRem :: BeamLevel -> BeamLevel -> (BeamLevel, BeamLevel) # divMod :: BeamLevel -> BeamLevel -> (BeamLevel, BeamLevel) # toInteger :: BeamLevel -> Integer #
Num BeamLevel Source #
Methods (+) :: BeamLevel -> BeamLevel -> BeamLevel # (-) :: BeamLevel -> BeamLevel -> BeamLevel # (*) :: BeamLevel -> BeamLevel -> BeamLevel # negate :: BeamLevel -> BeamLevel # abs :: BeamLevel -> BeamLevel # signum :: BeamLevel -> BeamLevel # fromInteger :: Integer -> BeamLevel #
Ord BeamLevel Source #
Methods compare :: BeamLevel -> BeamLevel -> Ordering # (<) :: BeamLevel -> BeamLevel -> Bool # (<=) :: BeamLevel -> BeamLevel -> Bool # (>) :: BeamLevel -> BeamLevel -> Bool # (>=) :: BeamLevel -> BeamLevel -> Bool # max :: BeamLevel -> BeamLevel -> BeamLevel # min :: BeamLevel -> BeamLevel -> BeamLevel #
Read BeamLevel Source #
Methods readsPrec :: Int -> ReadS BeamLevel # readList :: ReadS [BeamLevel] # readPrec :: ReadPrec BeamLevel # readListPrec :: ReadPrec [BeamLevel] #
Real BeamLevel Source #
Methods toRational :: BeamLevel -> Rational #
Show BeamLevel Source #
Methods showsPrec :: Int -> BeamLevel -> ShowS # show :: BeamLevel -> String # showList :: [BeamLevel] -> ShowS #
Generic BeamLevel Source #
Associated Types type Rep BeamLevel :: * -> * # Methods from :: BeamLevel -> Rep BeamLevel x # to :: Rep BeamLevel x -> BeamLevel #
EmitXml BeamLevel Source #
Methods emitXml :: BeamLevel -> XmlRep Source #
type Rep BeamLevel Source #
type Rep BeamLevel = D1 * (MetaData "BeamLevel" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "BeamLevel" PrefixI True) (S1 * (MetaSel (Just Symbol "beamLevel") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveInteger)))

parseBeamLevel :: String -> XParse BeamLevel Source #

data BeamValue Source #

beam-value (simple)

The beam-value type represents the type of beam associated with each of 6 beam levels (up to 256th notes) available for each note.

Constructors

BeamValueBegin	begin
BeamValueContinue	continue
BeamValueEnd	end
BeamValueForwardHook	forward hook
BeamValueBackwardHook	backward hook

Instances

Bounded BeamValue Source #
Methods minBound :: BeamValue # maxBound :: BeamValue #
Enum BeamValue Source #
Methods succ :: BeamValue -> BeamValue # pred :: BeamValue -> BeamValue # toEnum :: Int -> BeamValue # fromEnum :: BeamValue -> Int # enumFrom :: BeamValue -> [BeamValue] # enumFromThen :: BeamValue -> BeamValue -> [BeamValue] # enumFromTo :: BeamValue -> BeamValue -> [BeamValue] # enumFromThenTo :: BeamValue -> BeamValue -> BeamValue -> [BeamValue] #
Eq BeamValue Source #
Methods (==) :: BeamValue -> BeamValue -> Bool # (/=) :: BeamValue -> BeamValue -> Bool #
Ord BeamValue Source #
Methods compare :: BeamValue -> BeamValue -> Ordering # (<) :: BeamValue -> BeamValue -> Bool # (<=) :: BeamValue -> BeamValue -> Bool # (>) :: BeamValue -> BeamValue -> Bool # (>=) :: BeamValue -> BeamValue -> Bool # max :: BeamValue -> BeamValue -> BeamValue # min :: BeamValue -> BeamValue -> BeamValue #
Show BeamValue Source #
Methods showsPrec :: Int -> BeamValue -> ShowS # show :: BeamValue -> String # showList :: [BeamValue] -> ShowS #
Generic BeamValue Source #
Associated Types type Rep BeamValue :: * -> * # Methods from :: BeamValue -> Rep BeamValue x # to :: Rep BeamValue x -> BeamValue #
EmitXml BeamValue Source #
Methods emitXml :: BeamValue -> XmlRep Source #
type Rep BeamValue Source #
type Rep BeamValue = D1 * (MetaData "BeamValue" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "BeamValueBegin" PrefixI False) (U1 )) (C1 (MetaCons "BeamValueContinue" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "BeamValueEnd" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "BeamValueForwardHook" PrefixI False) (U1 )) (C1 (MetaCons "BeamValueBackwardHook" PrefixI False) (U1 *)))))

parseBeamValue :: String -> XParse BeamValue Source #

data ClefSign Source #

clef-sign (simple)

The clef-sign element represents the different clef symbols.

Constructors

ClefSignG	G
ClefSignF	F
ClefSignC	C
ClefSignPercussion	percussion
ClefSignTAB	TAB
ClefSignNone	none

Instances

Bounded ClefSign Source #
Methods minBound :: ClefSign # maxBound :: ClefSign #
Enum ClefSign Source #
Methods succ :: ClefSign -> ClefSign # pred :: ClefSign -> ClefSign # toEnum :: Int -> ClefSign # fromEnum :: ClefSign -> Int # enumFrom :: ClefSign -> [ClefSign] # enumFromThen :: ClefSign -> ClefSign -> [ClefSign] # enumFromTo :: ClefSign -> ClefSign -> [ClefSign] # enumFromThenTo :: ClefSign -> ClefSign -> ClefSign -> [ClefSign] #
Eq ClefSign Source #
Methods (==) :: ClefSign -> ClefSign -> Bool # (/=) :: ClefSign -> ClefSign -> Bool #
Ord ClefSign Source #
Methods compare :: ClefSign -> ClefSign -> Ordering # (<) :: ClefSign -> ClefSign -> Bool # (<=) :: ClefSign -> ClefSign -> Bool # (>) :: ClefSign -> ClefSign -> Bool # (>=) :: ClefSign -> ClefSign -> Bool # max :: ClefSign -> ClefSign -> ClefSign # min :: ClefSign -> ClefSign -> ClefSign #
Show ClefSign Source #
Methods showsPrec :: Int -> ClefSign -> ShowS # show :: ClefSign -> String # showList :: [ClefSign] -> ShowS #
Generic ClefSign Source #
Associated Types type Rep ClefSign :: * -> * # Methods from :: ClefSign -> Rep ClefSign x # to :: Rep ClefSign x -> ClefSign #
EmitXml ClefSign Source #
Methods emitXml :: ClefSign -> XmlRep Source #
type Rep ClefSign Source #
type Rep ClefSign = D1 * (MetaData "ClefSign" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "ClefSignG" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "ClefSignF" PrefixI False) (U1 )) (C1 (MetaCons "ClefSignC" PrefixI False) (U1 )))) ((:+:) (C1 * (MetaCons "ClefSignPercussion" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "ClefSignTAB" PrefixI False) (U1 )) (C1 (MetaCons "ClefSignNone" PrefixI False) (U1 *)))))

parseClefSign :: String -> XParse ClefSign Source #

newtype Color Source #

color (simple)

The color type indicates the color of an element. Color may be represented as hexadecimal RGB triples, as in HTML, or as hexadecimal ARGB tuples, with the A indicating alpha of transparency. An alpha value of 00 is totally transparent; FF is totally opaque. If RGB is used, the A value is assumed to be FF.

For instance, the RGB value "40800080" would be a transparent purple.

As in SVG 1.1, colors are defined in terms of the sRGB color space (IEC 61966).

Constructors

Color
Fields color :: Token

Instances

Eq Color Source #
Methods (==) :: Color -> Color -> Bool # (/=) :: Color -> Color -> Bool #
Ord Color Source #
Methods compare :: Color -> Color -> Ordering # (<) :: Color -> Color -> Bool # (<=) :: Color -> Color -> Bool # (>) :: Color -> Color -> Bool # (>=) :: Color -> Color -> Bool # max :: Color -> Color -> Color # min :: Color -> Color -> Color #
Read Color Source #
Methods readsPrec :: Int -> ReadS Color # readList :: ReadS [Color] # readPrec :: ReadPrec Color # readListPrec :: ReadPrec [Color] #
Show Color Source #
Methods showsPrec :: Int -> Color -> ShowS # show :: Color -> String # showList :: [Color] -> ShowS #
IsString Color Source #
Methods fromString :: String -> Color #
Generic Color Source #
Associated Types type Rep Color :: * -> * # Methods from :: Color -> Rep Color x # to :: Rep Color x -> Color #
EmitXml Color Source #
Methods emitXml :: Color -> XmlRep Source #
type Rep Color Source #
type Rep Color = D1 * (MetaData "Color" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "Color" PrefixI True) (S1 * (MetaSel (Just Symbol "color") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Token)))

parseColor :: String -> XParse Color Source #

newtype CommaSeparatedText Source #

comma-separated-text (simple)

The comma-separated-text type is used to specify a comma-separated list of text elements, as is used by the font-family attribute.

Constructors

CommaSeparatedText
Fields commaSeparatedText :: Token

Instances

Eq CommaSeparatedText Source #
Methods (==) :: CommaSeparatedText -> CommaSeparatedText -> Bool # (/=) :: CommaSeparatedText -> CommaSeparatedText -> Bool #
Ord CommaSeparatedText Source #
Methods compare :: CommaSeparatedText -> CommaSeparatedText -> Ordering # (<) :: CommaSeparatedText -> CommaSeparatedText -> Bool # (<=) :: CommaSeparatedText -> CommaSeparatedText -> Bool # (>) :: CommaSeparatedText -> CommaSeparatedText -> Bool # (>=) :: CommaSeparatedText -> CommaSeparatedText -> Bool # max :: CommaSeparatedText -> CommaSeparatedText -> CommaSeparatedText # min :: CommaSeparatedText -> CommaSeparatedText -> CommaSeparatedText #
Read CommaSeparatedText Source #
Methods readsPrec :: Int -> ReadS CommaSeparatedText # readList :: ReadS [CommaSeparatedText] # readPrec :: ReadPrec CommaSeparatedText # readListPrec :: ReadPrec [CommaSeparatedText] #
Show CommaSeparatedText Source #
Methods showsPrec :: Int -> CommaSeparatedText -> ShowS # show :: CommaSeparatedText -> String # showList :: [CommaSeparatedText] -> ShowS #
IsString CommaSeparatedText Source #
Methods fromString :: String -> CommaSeparatedText #
Generic CommaSeparatedText Source #
Associated Types type Rep CommaSeparatedText :: * -> * # Methods from :: CommaSeparatedText -> Rep CommaSeparatedText x # to :: Rep CommaSeparatedText x -> CommaSeparatedText #
EmitXml CommaSeparatedText Source #
Methods emitXml :: CommaSeparatedText -> XmlRep Source #
type Rep CommaSeparatedText Source #
type Rep CommaSeparatedText = D1 * (MetaData "CommaSeparatedText" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "CommaSeparatedText" PrefixI True) (S1 * (MetaSel (Just Symbol "commaSeparatedText") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Token)))

parseCommaSeparatedText :: String -> XParse CommaSeparatedText Source #

data CssFontSize Source #

css-font-size (simple)

The css-font-size type includes the CSS font sizes used as an alternative to a numeric point size.

Constructors

CssFontSizeXxSmall	xx-small
CssFontSizeXSmall	x-small
CssFontSizeSmall	small
CssFontSizeMedium	medium
CssFontSizeLarge	large
CssFontSizeXLarge	x-large
CssFontSizeXxLarge	xx-large

Instances

Bounded CssFontSize Source #
Methods minBound :: CssFontSize # maxBound :: CssFontSize #
Enum CssFontSize Source #
Methods succ :: CssFontSize -> CssFontSize # pred :: CssFontSize -> CssFontSize # toEnum :: Int -> CssFontSize # fromEnum :: CssFontSize -> Int # enumFrom :: CssFontSize -> [CssFontSize] # enumFromThen :: CssFontSize -> CssFontSize -> [CssFontSize] # enumFromTo :: CssFontSize -> CssFontSize -> [CssFontSize] # enumFromThenTo :: CssFontSize -> CssFontSize -> CssFontSize -> [CssFontSize] #
Eq CssFontSize Source #
Methods (==) :: CssFontSize -> CssFontSize -> Bool # (/=) :: CssFontSize -> CssFontSize -> Bool #
Ord CssFontSize Source #
Methods compare :: CssFontSize -> CssFontSize -> Ordering # (<) :: CssFontSize -> CssFontSize -> Bool # (<=) :: CssFontSize -> CssFontSize -> Bool # (>) :: CssFontSize -> CssFontSize -> Bool # (>=) :: CssFontSize -> CssFontSize -> Bool # max :: CssFontSize -> CssFontSize -> CssFontSize # min :: CssFontSize -> CssFontSize -> CssFontSize #
Show CssFontSize Source #
Methods showsPrec :: Int -> CssFontSize -> ShowS # show :: CssFontSize -> String # showList :: [CssFontSize] -> ShowS #
Generic CssFontSize Source #
Associated Types type Rep CssFontSize :: * -> * # Methods from :: CssFontSize -> Rep CssFontSize x # to :: Rep CssFontSize x -> CssFontSize #
EmitXml CssFontSize Source #
Methods emitXml :: CssFontSize -> XmlRep Source #
type Rep CssFontSize Source #
type Rep CssFontSize = D1 * (MetaData "CssFontSize" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "CssFontSizeXxSmall" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "CssFontSizeXSmall" PrefixI False) (U1 )) (C1 (MetaCons "CssFontSizeSmall" PrefixI False) (U1 )))) ((:+:) ((:+:) * (C1 * (MetaCons "CssFontSizeMedium" PrefixI False) (U1 )) (C1 (MetaCons "CssFontSizeLarge" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "CssFontSizeXLarge" PrefixI False) (U1 )) (C1 (MetaCons "CssFontSizeXxLarge" PrefixI False) (U1 *)))))

parseCssFontSize :: String -> XParse CssFontSize Source #

data DegreeTypeValue Source #

degree-type-value (simple)

The degree-type-value type indicates whether the current degree element is an addition, alteration, or subtraction to the kind of the current chord in the harmony element.

Constructors

DegreeTypeValueAdd	add
DegreeTypeValueAlter	alter
DegreeTypeValueSubtract	subtract

Instances

Bounded DegreeTypeValue Source #
Methods minBound :: DegreeTypeValue # maxBound :: DegreeTypeValue #
Enum DegreeTypeValue Source #
Methods succ :: DegreeTypeValue -> DegreeTypeValue # pred :: DegreeTypeValue -> DegreeTypeValue # toEnum :: Int -> DegreeTypeValue # fromEnum :: DegreeTypeValue -> Int # enumFrom :: DegreeTypeValue -> [DegreeTypeValue] # enumFromThen :: DegreeTypeValue -> DegreeTypeValue -> [DegreeTypeValue] # enumFromTo :: DegreeTypeValue -> DegreeTypeValue -> [DegreeTypeValue] # enumFromThenTo :: DegreeTypeValue -> DegreeTypeValue -> DegreeTypeValue -> [DegreeTypeValue] #
Eq DegreeTypeValue Source #
Methods (==) :: DegreeTypeValue -> DegreeTypeValue -> Bool # (/=) :: DegreeTypeValue -> DegreeTypeValue -> Bool #
Ord DegreeTypeValue Source #
Methods compare :: DegreeTypeValue -> DegreeTypeValue -> Ordering # (<) :: DegreeTypeValue -> DegreeTypeValue -> Bool # (<=) :: DegreeTypeValue -> DegreeTypeValue -> Bool # (>) :: DegreeTypeValue -> DegreeTypeValue -> Bool # (>=) :: DegreeTypeValue -> DegreeTypeValue -> Bool # max :: DegreeTypeValue -> DegreeTypeValue -> DegreeTypeValue # min :: DegreeTypeValue -> DegreeTypeValue -> DegreeTypeValue #
Show DegreeTypeValue Source #
Methods showsPrec :: Int -> DegreeTypeValue -> ShowS # show :: DegreeTypeValue -> String # showList :: [DegreeTypeValue] -> ShowS #
Generic DegreeTypeValue Source #
Associated Types type Rep DegreeTypeValue :: * -> * # Methods from :: DegreeTypeValue -> Rep DegreeTypeValue x # to :: Rep DegreeTypeValue x -> DegreeTypeValue #
EmitXml DegreeTypeValue Source #
Methods emitXml :: DegreeTypeValue -> XmlRep Source #
type Rep DegreeTypeValue Source #
type Rep DegreeTypeValue = D1 * (MetaData "DegreeTypeValue" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "DegreeTypeValueAdd" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "DegreeTypeValueAlter" PrefixI False) (U1 )) (C1 (MetaCons "DegreeTypeValueSubtract" PrefixI False) (U1 *))))

parseDegreeTypeValue :: String -> XParse DegreeTypeValue Source #

newtype Divisions Source #

divisions (simple)

The divisions type is used to express values in terms of the musical divisions defined by the divisions element. It is preferred that these be integer values both for MIDI interoperability and to avoid roundoff errors.

Constructors

Divisions
Fields divisions :: Decimal

Instances

Eq Divisions Source #
Methods (==) :: Divisions -> Divisions -> Bool # (/=) :: Divisions -> Divisions -> Bool #
Fractional Divisions Source #
Methods (/) :: Divisions -> Divisions -> Divisions # recip :: Divisions -> Divisions # fromRational :: Rational -> Divisions #
Num Divisions Source #
Methods (+) :: Divisions -> Divisions -> Divisions # (-) :: Divisions -> Divisions -> Divisions # (*) :: Divisions -> Divisions -> Divisions # negate :: Divisions -> Divisions # abs :: Divisions -> Divisions # signum :: Divisions -> Divisions # fromInteger :: Integer -> Divisions #
Ord Divisions Source #
Methods compare :: Divisions -> Divisions -> Ordering # (<) :: Divisions -> Divisions -> Bool # (<=) :: Divisions -> Divisions -> Bool # (>) :: Divisions -> Divisions -> Bool # (>=) :: Divisions -> Divisions -> Bool # max :: Divisions -> Divisions -> Divisions # min :: Divisions -> Divisions -> Divisions #
Read Divisions Source #
Methods readsPrec :: Int -> ReadS Divisions # readList :: ReadS [Divisions] # readPrec :: ReadPrec Divisions # readListPrec :: ReadPrec [Divisions] #
Real Divisions Source #
Methods toRational :: Divisions -> Rational #
RealFrac Divisions Source #
Methods properFraction :: Integral b => Divisions -> (b, Divisions) # truncate :: Integral b => Divisions -> b # round :: Integral b => Divisions -> b # ceiling :: Integral b => Divisions -> b # floor :: Integral b => Divisions -> b #
Show Divisions Source #
Methods showsPrec :: Int -> Divisions -> ShowS # show :: Divisions -> String # showList :: [Divisions] -> ShowS #
Generic Divisions Source #
Associated Types type Rep Divisions :: * -> * # Methods from :: Divisions -> Rep Divisions x # to :: Rep Divisions x -> Divisions #
EmitXml Divisions Source #
Methods emitXml :: Divisions -> XmlRep Source #
type Rep Divisions Source #
type Rep Divisions = D1 * (MetaData "Divisions" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "Divisions" PrefixI True) (S1 * (MetaSel (Just Symbol "divisions") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Decimal)))

parseDivisions :: String -> XParse Divisions Source #

data Enclosure Source #

enclosure (simple)

The enclosure type describes the shape and presence / absence of an enclosure around text.

Constructors

EnclosureRectangle	rectangle
EnclosureOval	oval
EnclosureNone	none

Instances

Bounded Enclosure Source #
Methods minBound :: Enclosure # maxBound :: Enclosure #
Enum Enclosure Source #
Methods succ :: Enclosure -> Enclosure # pred :: Enclosure -> Enclosure # toEnum :: Int -> Enclosure # fromEnum :: Enclosure -> Int # enumFrom :: Enclosure -> [Enclosure] # enumFromThen :: Enclosure -> Enclosure -> [Enclosure] # enumFromTo :: Enclosure -> Enclosure -> [Enclosure] # enumFromThenTo :: Enclosure -> Enclosure -> Enclosure -> [Enclosure] #
Eq Enclosure Source #
Methods (==) :: Enclosure -> Enclosure -> Bool # (/=) :: Enclosure -> Enclosure -> Bool #
Ord Enclosure Source #
Methods compare :: Enclosure -> Enclosure -> Ordering # (<) :: Enclosure -> Enclosure -> Bool # (<=) :: Enclosure -> Enclosure -> Bool # (>) :: Enclosure -> Enclosure -> Bool # (>=) :: Enclosure -> Enclosure -> Bool # max :: Enclosure -> Enclosure -> Enclosure # min :: Enclosure -> Enclosure -> Enclosure #
Show Enclosure Source #
Methods showsPrec :: Int -> Enclosure -> ShowS # show :: Enclosure -> String # showList :: [Enclosure] -> ShowS #
Generic Enclosure Source #
Associated Types type Rep Enclosure :: * -> * # Methods from :: Enclosure -> Rep Enclosure x # to :: Rep Enclosure x -> Enclosure #
EmitXml Enclosure Source #
Methods emitXml :: Enclosure -> XmlRep Source #
type Rep Enclosure Source #
type Rep Enclosure = D1 * (MetaData "Enclosure" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "EnclosureRectangle" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "EnclosureOval" PrefixI False) (U1 )) (C1 (MetaCons "EnclosureNone" PrefixI False) (U1 *))))

parseEnclosure :: String -> XParse Enclosure Source #

newtype EndingNumber Source #

ending-number (simple)

The ending-number type is used to specify either a comma-separated list of positive integers without leading zeros, or a string of zero or more spaces. It is used for the number attribute of the ending element. The zero or more spaces version is used when software knows that an ending is present, but cannot determine the type of the ending.

Constructors

EndingNumber
Fields endingNumber :: Token

Instances

Eq EndingNumber Source #
Methods (==) :: EndingNumber -> EndingNumber -> Bool # (/=) :: EndingNumber -> EndingNumber -> Bool #
Ord EndingNumber Source #
Methods compare :: EndingNumber -> EndingNumber -> Ordering # (<) :: EndingNumber -> EndingNumber -> Bool # (<=) :: EndingNumber -> EndingNumber -> Bool # (>) :: EndingNumber -> EndingNumber -> Bool # (>=) :: EndingNumber -> EndingNumber -> Bool # max :: EndingNumber -> EndingNumber -> EndingNumber # min :: EndingNumber -> EndingNumber -> EndingNumber #
Read EndingNumber Source #
Methods readsPrec :: Int -> ReadS EndingNumber # readList :: ReadS [EndingNumber] # readPrec :: ReadPrec EndingNumber # readListPrec :: ReadPrec [EndingNumber] #
Show EndingNumber Source #
Methods showsPrec :: Int -> EndingNumber -> ShowS # show :: EndingNumber -> String # showList :: [EndingNumber] -> ShowS #
IsString EndingNumber Source #
Methods fromString :: String -> EndingNumber #
Generic EndingNumber Source #
Associated Types type Rep EndingNumber :: * -> * # Methods from :: EndingNumber -> Rep EndingNumber x # to :: Rep EndingNumber x -> EndingNumber #
EmitXml EndingNumber Source #
Methods emitXml :: EndingNumber -> XmlRep Source #
type Rep EndingNumber Source #
type Rep EndingNumber = D1 * (MetaData "EndingNumber" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "EndingNumber" PrefixI True) (S1 * (MetaSel (Just Symbol "endingNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Token)))

parseEndingNumber :: String -> XParse EndingNumber Source #

data Fan Source #

fan (simple)

The fan type represents the type of beam fanning present on a note, used to represent accelerandos and ritardandos.

Constructors

FanAccel	accel
FanRit	rit
FanNone	none

Instances

Bounded Fan Source #
Methods minBound :: Fan # maxBound :: Fan #
Enum Fan Source #
Methods succ :: Fan -> Fan # pred :: Fan -> Fan # toEnum :: Int -> Fan # fromEnum :: Fan -> Int # enumFrom :: Fan -> [Fan] # enumFromThen :: Fan -> Fan -> [Fan] # enumFromTo :: Fan -> Fan -> [Fan] # enumFromThenTo :: Fan -> Fan -> Fan -> [Fan] #
Eq Fan Source #
Methods (==) :: Fan -> Fan -> Bool # (/=) :: Fan -> Fan -> Bool #
Ord Fan Source #
Methods compare :: Fan -> Fan -> Ordering # (<) :: Fan -> Fan -> Bool # (<=) :: Fan -> Fan -> Bool # (>) :: Fan -> Fan -> Bool # (>=) :: Fan -> Fan -> Bool # max :: Fan -> Fan -> Fan # min :: Fan -> Fan -> Fan #
Show Fan Source #
Methods showsPrec :: Int -> Fan -> ShowS # show :: Fan -> String # showList :: [Fan] -> ShowS #
Generic Fan Source #
Associated Types type Rep Fan :: * -> * # Methods from :: Fan -> Rep Fan x # to :: Rep Fan x -> Fan #
EmitXml Fan Source #
Methods emitXml :: Fan -> XmlRep Source #
type Rep Fan Source #
type Rep Fan = D1 * (MetaData "Fan" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "FanAccel" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "FanRit" PrefixI False) (U1 )) (C1 (MetaCons "FanNone" PrefixI False) (U1 *))))

parseFan :: String -> XParse Fan Source #

data FermataShape Source #

fermata-shape (simple)

The fermata-shape type represents the shape of the fermata sign. The empty value is equivalent to the normal value.

Constructors

FermataShapeNormal	normal
FermataShapeAngled	angled
FermataShapeSquare	square
FermataShape	//

Instances

Bounded FermataShape Source #
Methods minBound :: FermataShape # maxBound :: FermataShape #
Enum FermataShape Source #
Methods succ :: FermataShape -> FermataShape # pred :: FermataShape -> FermataShape # toEnum :: Int -> FermataShape # fromEnum :: FermataShape -> Int # enumFrom :: FermataShape -> [FermataShape] # enumFromThen :: FermataShape -> FermataShape -> [FermataShape] # enumFromTo :: FermataShape -> FermataShape -> [FermataShape] # enumFromThenTo :: FermataShape -> FermataShape -> FermataShape -> [FermataShape] #
Eq FermataShape Source #
Methods (==) :: FermataShape -> FermataShape -> Bool # (/=) :: FermataShape -> FermataShape -> Bool #
Ord FermataShape Source #
Methods compare :: FermataShape -> FermataShape -> Ordering # (<) :: FermataShape -> FermataShape -> Bool # (<=) :: FermataShape -> FermataShape -> Bool # (>) :: FermataShape -> FermataShape -> Bool # (>=) :: FermataShape -> FermataShape -> Bool # max :: FermataShape -> FermataShape -> FermataShape # min :: FermataShape -> FermataShape -> FermataShape #
Show FermataShape Source #
Methods showsPrec :: Int -> FermataShape -> ShowS # show :: FermataShape -> String # showList :: [FermataShape] -> ShowS #
Generic FermataShape Source #
Associated Types type Rep FermataShape :: * -> * # Methods from :: FermataShape -> Rep FermataShape x # to :: Rep FermataShape x -> FermataShape #
EmitXml FermataShape Source #
Methods emitXml :: FermataShape -> XmlRep Source #
type Rep FermataShape Source #
type Rep FermataShape = D1 * (MetaData "FermataShape" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "FermataShapeNormal" PrefixI False) (U1 )) (C1 (MetaCons "FermataShapeAngled" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "FermataShapeSquare" PrefixI False) (U1 )) (C1 (MetaCons "FermataShape" PrefixI False) (U1 *))))

parseFermataShape :: String -> XParse FermataShape Source #

newtype Fifths Source #

fifths (simple)

The fifths type represents the number of flats or sharps in a traditional key signature. Negative numbers are used for flats and positive numbers for sharps, reflecting the key's placement within the circle of fifths (hence the type name).

Constructors

Fifths
Fields fifths :: Int

Instances

Bounded Fifths Source #
Methods minBound :: Fifths # maxBound :: Fifths #
Enum Fifths Source #
Methods succ :: Fifths -> Fifths # pred :: Fifths -> Fifths # toEnum :: Int -> Fifths # fromEnum :: Fifths -> Int # enumFrom :: Fifths -> [Fifths] # enumFromThen :: Fifths -> Fifths -> [Fifths] # enumFromTo :: Fifths -> Fifths -> [Fifths] # enumFromThenTo :: Fifths -> Fifths -> Fifths -> [Fifths] #
Eq Fifths Source #
Methods (==) :: Fifths -> Fifths -> Bool # (/=) :: Fifths -> Fifths -> Bool #
Integral Fifths Source #
Methods quot :: Fifths -> Fifths -> Fifths # rem :: Fifths -> Fifths -> Fifths # div :: Fifths -> Fifths -> Fifths # mod :: Fifths -> Fifths -> Fifths # quotRem :: Fifths -> Fifths -> (Fifths, Fifths) # divMod :: Fifths -> Fifths -> (Fifths, Fifths) # toInteger :: Fifths -> Integer #
Num Fifths Source #
Methods (+) :: Fifths -> Fifths -> Fifths # (-) :: Fifths -> Fifths -> Fifths # (*) :: Fifths -> Fifths -> Fifths # negate :: Fifths -> Fifths # abs :: Fifths -> Fifths # signum :: Fifths -> Fifths # fromInteger :: Integer -> Fifths #
Ord Fifths Source #
Methods compare :: Fifths -> Fifths -> Ordering # (<) :: Fifths -> Fifths -> Bool # (<=) :: Fifths -> Fifths -> Bool # (>) :: Fifths -> Fifths -> Bool # (>=) :: Fifths -> Fifths -> Bool # max :: Fifths -> Fifths -> Fifths # min :: Fifths -> Fifths -> Fifths #
Read Fifths Source #
Methods readsPrec :: Int -> ReadS Fifths # readList :: ReadS [Fifths] # readPrec :: ReadPrec Fifths # readListPrec :: ReadPrec [Fifths] #
Real Fifths Source #
Methods toRational :: Fifths -> Rational #
Show Fifths Source #
Methods showsPrec :: Int -> Fifths -> ShowS # show :: Fifths -> String # showList :: [Fifths] -> ShowS #
Generic Fifths Source #
Associated Types type Rep Fifths :: * -> * # Methods from :: Fifths -> Rep Fifths x # to :: Rep Fifths x -> Fifths #
EmitXml Fifths Source #
Methods emitXml :: Fifths -> XmlRep Source #
type Rep Fifths Source #
type Rep Fifths = D1 * (MetaData "Fifths" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "Fifths" PrefixI True) (S1 * (MetaSel (Just Symbol "fifths") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Int)))

parseFifths :: String -> XParse Fifths Source #

data FontSize Source #

font-size (simple)

The font-size can be one of the CSS font sizes or a numeric point size.

Constructors

FontSizeDecimal
Fields fontSize1 :: Decimal
FontSizeCssFontSize
Fields fontSize2 :: CssFontSize

Instances

Eq FontSize Source #
Methods (==) :: FontSize -> FontSize -> Bool # (/=) :: FontSize -> FontSize -> Bool #
Show FontSize Source #
Methods showsPrec :: Int -> FontSize -> ShowS # show :: FontSize -> String # showList :: [FontSize] -> ShowS #
Generic FontSize Source #
Associated Types type Rep FontSize :: * -> * # Methods from :: FontSize -> Rep FontSize x # to :: Rep FontSize x -> FontSize #
EmitXml FontSize Source #
Methods emitXml :: FontSize -> XmlRep Source #
type Rep FontSize Source #
type Rep FontSize = D1 * (MetaData "FontSize" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "FontSizeDecimal" PrefixI True) (S1 * (MetaSel (Just Symbol "fontSize1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Decimal))) (C1 * (MetaCons "FontSizeCssFontSize" PrefixI True) (S1 * (MetaSel (Just Symbol "fontSize2") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * CssFontSize))))

parseFontSize :: String -> XParse FontSize Source #

data FontStyle Source #

font-style (simple)

The font-style type represents a simplified version of the CSS font-style property.

Constructors

FontStyleNormal	normal
FontStyleItalic	italic

Instances

Bounded FontStyle Source #
Methods minBound :: FontStyle # maxBound :: FontStyle #
Enum FontStyle Source #
Methods succ :: FontStyle -> FontStyle # pred :: FontStyle -> FontStyle # toEnum :: Int -> FontStyle # fromEnum :: FontStyle -> Int # enumFrom :: FontStyle -> [FontStyle] # enumFromThen :: FontStyle -> FontStyle -> [FontStyle] # enumFromTo :: FontStyle -> FontStyle -> [FontStyle] # enumFromThenTo :: FontStyle -> FontStyle -> FontStyle -> [FontStyle] #
Eq FontStyle Source #
Methods (==) :: FontStyle -> FontStyle -> Bool # (/=) :: FontStyle -> FontStyle -> Bool #
Ord FontStyle Source #
Methods compare :: FontStyle -> FontStyle -> Ordering # (<) :: FontStyle -> FontStyle -> Bool # (<=) :: FontStyle -> FontStyle -> Bool # (>) :: FontStyle -> FontStyle -> Bool # (>=) :: FontStyle -> FontStyle -> Bool # max :: FontStyle -> FontStyle -> FontStyle # min :: FontStyle -> FontStyle -> FontStyle #
Show FontStyle Source #
Methods showsPrec :: Int -> FontStyle -> ShowS # show :: FontStyle -> String # showList :: [FontStyle] -> ShowS #
Generic FontStyle Source #
Associated Types type Rep FontStyle :: * -> * # Methods from :: FontStyle -> Rep FontStyle x # to :: Rep FontStyle x -> FontStyle #
EmitXml FontStyle Source #
Methods emitXml :: FontStyle -> XmlRep Source #
type Rep FontStyle Source #
type Rep FontStyle = D1 * (MetaData "FontStyle" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "FontStyleNormal" PrefixI False) (U1 )) (C1 (MetaCons "FontStyleItalic" PrefixI False) (U1 *)))

parseFontStyle :: String -> XParse FontStyle Source #

data FontWeight Source #

font-weight (simple)

The font-weight type represents a simplified version of the CSS font-weight property.

Constructors

FontWeightNormal	normal
FontWeightBold	bold

Instances

Bounded FontWeight Source #
Methods minBound :: FontWeight # maxBound :: FontWeight #
Enum FontWeight Source #
Methods succ :: FontWeight -> FontWeight # pred :: FontWeight -> FontWeight # toEnum :: Int -> FontWeight # fromEnum :: FontWeight -> Int # enumFrom :: FontWeight -> [FontWeight] # enumFromThen :: FontWeight -> FontWeight -> [FontWeight] # enumFromTo :: FontWeight -> FontWeight -> [FontWeight] # enumFromThenTo :: FontWeight -> FontWeight -> FontWeight -> [FontWeight] #
Eq FontWeight Source #
Methods (==) :: FontWeight -> FontWeight -> Bool # (/=) :: FontWeight -> FontWeight -> Bool #
Ord FontWeight Source #
Methods compare :: FontWeight -> FontWeight -> Ordering # (<) :: FontWeight -> FontWeight -> Bool # (<=) :: FontWeight -> FontWeight -> Bool # (>) :: FontWeight -> FontWeight -> Bool # (>=) :: FontWeight -> FontWeight -> Bool # max :: FontWeight -> FontWeight -> FontWeight # min :: FontWeight -> FontWeight -> FontWeight #
Show FontWeight Source #
Methods showsPrec :: Int -> FontWeight -> ShowS # show :: FontWeight -> String # showList :: [FontWeight] -> ShowS #
Generic FontWeight Source #
Associated Types type Rep FontWeight :: * -> * # Methods from :: FontWeight -> Rep FontWeight x # to :: Rep FontWeight x -> FontWeight #
EmitXml FontWeight Source #
Methods emitXml :: FontWeight -> XmlRep Source #
type Rep FontWeight Source #
type Rep FontWeight = D1 * (MetaData "FontWeight" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "FontWeightNormal" PrefixI False) (U1 )) (C1 (MetaCons "FontWeightBold" PrefixI False) (U1 *)))

parseFontWeight :: String -> XParse FontWeight Source #

data GroupBarlineValue Source #

group-barline-value (simple)

The group-barline-value type indicates if the group should have common barlines.

Constructors

GroupBarlineValueYes	yes
GroupBarlineValueNo	no
GroupBarlineValueMensurstrich	Mensurstrich

Instances

Bounded GroupBarlineValue Source #
Methods minBound :: GroupBarlineValue # maxBound :: GroupBarlineValue #
Enum GroupBarlineValue Source #
Methods succ :: GroupBarlineValue -> GroupBarlineValue # pred :: GroupBarlineValue -> GroupBarlineValue # toEnum :: Int -> GroupBarlineValue # fromEnum :: GroupBarlineValue -> Int # enumFrom :: GroupBarlineValue -> [GroupBarlineValue] # enumFromThen :: GroupBarlineValue -> GroupBarlineValue -> [GroupBarlineValue] # enumFromTo :: GroupBarlineValue -> GroupBarlineValue -> [GroupBarlineValue] # enumFromThenTo :: GroupBarlineValue -> GroupBarlineValue -> GroupBarlineValue -> [GroupBarlineValue] #
Eq GroupBarlineValue Source #
Methods (==) :: GroupBarlineValue -> GroupBarlineValue -> Bool # (/=) :: GroupBarlineValue -> GroupBarlineValue -> Bool #
Ord GroupBarlineValue Source #
Methods compare :: GroupBarlineValue -> GroupBarlineValue -> Ordering # (<) :: GroupBarlineValue -> GroupBarlineValue -> Bool # (<=) :: GroupBarlineValue -> GroupBarlineValue -> Bool # (>) :: GroupBarlineValue -> GroupBarlineValue -> Bool # (>=) :: GroupBarlineValue -> GroupBarlineValue -> Bool # max :: GroupBarlineValue -> GroupBarlineValue -> GroupBarlineValue # min :: GroupBarlineValue -> GroupBarlineValue -> GroupBarlineValue #
Show GroupBarlineValue Source #
Methods showsPrec :: Int -> GroupBarlineValue -> ShowS # show :: GroupBarlineValue -> String # showList :: [GroupBarlineValue] -> ShowS #
Generic GroupBarlineValue Source #
Associated Types type Rep GroupBarlineValue :: * -> * # Methods from :: GroupBarlineValue -> Rep GroupBarlineValue x # to :: Rep GroupBarlineValue x -> GroupBarlineValue #
EmitXml GroupBarlineValue Source #
Methods emitXml :: GroupBarlineValue -> XmlRep Source #
type Rep GroupBarlineValue Source #
type Rep GroupBarlineValue = D1 * (MetaData "GroupBarlineValue" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "GroupBarlineValueYes" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "GroupBarlineValueNo" PrefixI False) (U1 )) (C1 (MetaCons "GroupBarlineValueMensurstrich" PrefixI False) (U1 *))))

parseGroupBarlineValue :: String -> XParse GroupBarlineValue Source #

data GroupSymbolValue Source #

group-symbol-value (simple)

The group-symbol-value type indicates how the symbol for a group is indicated in the score. The default value is none.

Constructors

GroupSymbolValueNone	none
GroupSymbolValueBrace	brace
GroupSymbolValueLine	line
GroupSymbolValueBracket	bracket

Instances

Bounded GroupSymbolValue Source #
Methods minBound :: GroupSymbolValue # maxBound :: GroupSymbolValue #
Enum GroupSymbolValue Source #
Methods succ :: GroupSymbolValue -> GroupSymbolValue # pred :: GroupSymbolValue -> GroupSymbolValue # toEnum :: Int -> GroupSymbolValue # fromEnum :: GroupSymbolValue -> Int # enumFrom :: GroupSymbolValue -> [GroupSymbolValue] # enumFromThen :: GroupSymbolValue -> GroupSymbolValue -> [GroupSymbolValue] # enumFromTo :: GroupSymbolValue -> GroupSymbolValue -> [GroupSymbolValue] # enumFromThenTo :: GroupSymbolValue -> GroupSymbolValue -> GroupSymbolValue -> [GroupSymbolValue] #
Eq GroupSymbolValue Source #
Methods (==) :: GroupSymbolValue -> GroupSymbolValue -> Bool # (/=) :: GroupSymbolValue -> GroupSymbolValue -> Bool #
Ord GroupSymbolValue Source #
Methods compare :: GroupSymbolValue -> GroupSymbolValue -> Ordering # (<) :: GroupSymbolValue -> GroupSymbolValue -> Bool # (<=) :: GroupSymbolValue -> GroupSymbolValue -> Bool # (>) :: GroupSymbolValue -> GroupSymbolValue -> Bool # (>=) :: GroupSymbolValue -> GroupSymbolValue -> Bool # max :: GroupSymbolValue -> GroupSymbolValue -> GroupSymbolValue # min :: GroupSymbolValue -> GroupSymbolValue -> GroupSymbolValue #
Show GroupSymbolValue Source #
Methods showsPrec :: Int -> GroupSymbolValue -> ShowS # show :: GroupSymbolValue -> String # showList :: [GroupSymbolValue] -> ShowS #
Generic GroupSymbolValue Source #
Associated Types type Rep GroupSymbolValue :: * -> * # Methods from :: GroupSymbolValue -> Rep GroupSymbolValue x # to :: Rep GroupSymbolValue x -> GroupSymbolValue #
EmitXml GroupSymbolValue Source #
Methods emitXml :: GroupSymbolValue -> XmlRep Source #
type Rep GroupSymbolValue Source #
type Rep GroupSymbolValue = D1 * (MetaData "GroupSymbolValue" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "GroupSymbolValueNone" PrefixI False) (U1 )) (C1 (MetaCons "GroupSymbolValueBrace" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "GroupSymbolValueLine" PrefixI False) (U1 )) (C1 (MetaCons "GroupSymbolValueBracket" PrefixI False) (U1 *))))

parseGroupSymbolValue :: String -> XParse GroupSymbolValue Source #

data HarmonyType Source #

harmony-type (simple)

The harmony-type type differentiates different types of harmonies when alternate harmonies are possible. Explicit harmonies have all note present in the music; implied have some notes missing but implied; alternate represents alternate analyses.

Constructors

HarmonyTypeExplicit	explicit
HarmonyTypeImplied	implied
HarmonyTypeAlternate	alternate

Instances

Bounded HarmonyType Source #
Methods minBound :: HarmonyType # maxBound :: HarmonyType #
Enum HarmonyType Source #
Methods succ :: HarmonyType -> HarmonyType # pred :: HarmonyType -> HarmonyType # toEnum :: Int -> HarmonyType # fromEnum :: HarmonyType -> Int # enumFrom :: HarmonyType -> [HarmonyType] # enumFromThen :: HarmonyType -> HarmonyType -> [HarmonyType] # enumFromTo :: HarmonyType -> HarmonyType -> [HarmonyType] # enumFromThenTo :: HarmonyType -> HarmonyType -> HarmonyType -> [HarmonyType] #
Eq HarmonyType Source #
Methods (==) :: HarmonyType -> HarmonyType -> Bool # (/=) :: HarmonyType -> HarmonyType -> Bool #
Ord HarmonyType Source #
Methods compare :: HarmonyType -> HarmonyType -> Ordering # (<) :: HarmonyType -> HarmonyType -> Bool # (<=) :: HarmonyType -> HarmonyType -> Bool # (>) :: HarmonyType -> HarmonyType -> Bool # (>=) :: HarmonyType -> HarmonyType -> Bool # max :: HarmonyType -> HarmonyType -> HarmonyType # min :: HarmonyType -> HarmonyType -> HarmonyType #
Show HarmonyType Source #
Methods showsPrec :: Int -> HarmonyType -> ShowS # show :: HarmonyType -> String # showList :: [HarmonyType] -> ShowS #
Generic HarmonyType Source #
Associated Types type Rep HarmonyType :: * -> * # Methods from :: HarmonyType -> Rep HarmonyType x # to :: Rep HarmonyType x -> HarmonyType #
EmitXml HarmonyType Source #
Methods emitXml :: HarmonyType -> XmlRep Source #
type Rep HarmonyType Source #
type Rep HarmonyType = D1 * (MetaData "HarmonyType" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "HarmonyTypeExplicit" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "HarmonyTypeImplied" PrefixI False) (U1 )) (C1 (MetaCons "HarmonyTypeAlternate" PrefixI False) (U1 *))))

parseHarmonyType :: String -> XParse HarmonyType Source #

data KindValue Source #

kind-value (simple)

A kind-value indicates the type of chord. Degree elements can then add, subtract, or alter from these starting points. Values include:

	
Triads:
	major (major third, perfect fifth)
	minor (minor third, perfect fifth)
	augmented (major third, augmented fifth)
	diminished (minor third, diminished fifth)
Sevenths:
	dominant (major triad, minor seventh)
	major-seventh (major triad, major seventh)
	minor-seventh (minor triad, minor seventh)
	diminished-seventh (diminished triad, diminished seventh)
	augmented-seventh (augmented triad, minor seventh)
	half-diminished (diminished triad, minor seventh)
	major-minor (minor triad, major seventh)
Sixths:
	major-sixth (major triad, added sixth)
	minor-sixth (minor triad, added sixth)
Ninths:
	dominant-ninth (dominant-seventh, major ninth)
	major-ninth (major-seventh, major ninth)
	minor-ninth (minor-seventh, major ninth)
11ths (usually as the basis for alteration):
	dominant-11th (dominant-ninth, perfect 11th)
	major-11th (major-ninth, perfect 11th)
	minor-11th (minor-ninth, perfect 11th)
13ths (usually as the basis for alteration):
	dominant-13th (dominant-11th, major 13th)
	major-13th (major-11th, major 13th)
	minor-13th (minor-11th, major 13th)
Suspended:
	suspended-second (major second, perfect fifth)
	suspended-fourth (perfect fourth, perfect fifth)
Functional sixths:
	Neapolitan
	Italian
	French
	German
Other:
	pedal (pedal-point bass)
	power (perfect fifth)
	Tristan
	
The "other" kind is used when the harmony is entirely composed of add elements. The "none" kind is used to explicitly encode absence of chords or functional harmony.

Constructors

KindValueMajor	major
KindValueMinor	minor
KindValueAugmented	augmented
KindValueDiminished	diminished
KindValueDominant	dominant
KindValueMajorSeventh	major-seventh
KindValueMinorSeventh	minor-seventh
KindValueDiminishedSeventh	diminished-seventh
KindValueAugmentedSeventh	augmented-seventh
KindValueHalfDiminished	half-diminished
KindValueMajorMinor	major-minor
KindValueMajorSixth	major-sixth
KindValueMinorSixth	minor-sixth
KindValueDominantNinth	dominant-ninth
KindValueMajorNinth	major-ninth
KindValueMinorNinth	minor-ninth
KindValueDominant11th	dominant-11th
KindValueMajor11th	major-11th
KindValueMinor11th	minor-11th
KindValueDominant13th	dominant-13th
KindValueMajor13th	major-13th
KindValueMinor13th	minor-13th
KindValueSuspendedSecond	suspended-second
KindValueSuspendedFourth	suspended-fourth
KindValueNeapolitan	Neapolitan
KindValueItalian	Italian
KindValueFrench	French
KindValueGerman	German
KindValuePedal	pedal
KindValuePower	power
KindValueTristan	Tristan
KindValueOther	other
KindValueNone	none

Instances

Bounded KindValue Source #
Methods minBound :: KindValue # maxBound :: KindValue #
Enum KindValue Source #
Methods succ :: KindValue -> KindValue # pred :: KindValue -> KindValue # toEnum :: Int -> KindValue # fromEnum :: KindValue -> Int # enumFrom :: KindValue -> [KindValue] # enumFromThen :: KindValue -> KindValue -> [KindValue] # enumFromTo :: KindValue -> KindValue -> [KindValue] # enumFromThenTo :: KindValue -> KindValue -> KindValue -> [KindValue] #
Eq KindValue Source #
Methods (==) :: KindValue -> KindValue -> Bool # (/=) :: KindValue -> KindValue -> Bool #
Ord KindValue Source #
Methods compare :: KindValue -> KindValue -> Ordering # (<) :: KindValue -> KindValue -> Bool # (<=) :: KindValue -> KindValue -> Bool # (>) :: KindValue -> KindValue -> Bool # (>=) :: KindValue -> KindValue -> Bool # max :: KindValue -> KindValue -> KindValue # min :: KindValue -> KindValue -> KindValue #
Show KindValue Source #
Methods showsPrec :: Int -> KindValue -> ShowS # show :: KindValue -> String # showList :: [KindValue] -> ShowS #
Generic KindValue Source #
Associated Types type Rep KindValue :: * -> * # Methods from :: KindValue -> Rep KindValue x # to :: Rep KindValue x -> KindValue #
EmitXml KindValue Source #
Methods emitXml :: KindValue -> XmlRep Source #
type Rep KindValue Source #
type Rep KindValue = D1 * (MetaData "KindValue" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "KindValueMajor" PrefixI False) (U1 )) (C1 (MetaCons "KindValueMinor" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "KindValueAugmented" PrefixI False) (U1 )) (C1 (MetaCons "KindValueDiminished" PrefixI False) (U1 )))) ((:+:) ((:+:) * (C1 * (MetaCons "KindValueDominant" PrefixI False) (U1 )) (C1 (MetaCons "KindValueMajorSeventh" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "KindValueMinorSeventh" PrefixI False) (U1 )) (C1 (MetaCons "KindValueDiminishedSeventh" PrefixI False) (U1 ))))) ((:+:) ((:+:) * ((:+:) * (C1 * (MetaCons "KindValueAugmentedSeventh" PrefixI False) (U1 )) (C1 (MetaCons "KindValueHalfDiminished" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "KindValueMajorMinor" PrefixI False) (U1 )) (C1 (MetaCons "KindValueMajorSixth" PrefixI False) (U1 )))) ((:+:) ((:+:) * (C1 * (MetaCons "KindValueMinorSixth" PrefixI False) (U1 )) (C1 (MetaCons "KindValueDominantNinth" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "KindValueMajorNinth" PrefixI False) (U1 )) (C1 (MetaCons "KindValueMinorNinth" PrefixI False) (U1 )))))) ((:+:) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "KindValueDominant11th" PrefixI False) (U1 )) (C1 (MetaCons "KindValueMajor11th" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "KindValueMinor11th" PrefixI False) (U1 )) (C1 (MetaCons "KindValueDominant13th" PrefixI False) (U1 )))) ((:+:) ((:+:) * (C1 * (MetaCons "KindValueMajor13th" PrefixI False) (U1 )) (C1 (MetaCons "KindValueMinor13th" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "KindValueSuspendedSecond" PrefixI False) (U1 )) (C1 (MetaCons "KindValueSuspendedFourth" PrefixI False) (U1 ))))) ((:+:) ((:+:) * ((:+:) * (C1 * (MetaCons "KindValueNeapolitan" PrefixI False) (U1 )) (C1 (MetaCons "KindValueItalian" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "KindValueFrench" PrefixI False) (U1 )) (C1 (MetaCons "KindValueGerman" PrefixI False) (U1 )))) ((:+:) ((:+:) * (C1 * (MetaCons "KindValuePedal" PrefixI False) (U1 )) (C1 (MetaCons "KindValuePower" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "KindValueTristan" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "KindValueOther" PrefixI False) (U1 )) (C1 (MetaCons "KindValueNone" PrefixI False) (U1 *))))))))

parseKindValue :: String -> XParse KindValue Source #

data Lang Source #

xml:lang (simple)

Constructors

LangLanguage
Fields lang1 :: Language
LangLang
Fields lang2 :: SumLang

Instances

Eq Lang Source #
Methods (==) :: Lang -> Lang -> Bool # (/=) :: Lang -> Lang -> Bool #
Show Lang Source #
Methods showsPrec :: Int -> Lang -> ShowS # show :: Lang -> String # showList :: [Lang] -> ShowS #
Generic Lang Source #
Associated Types type Rep Lang :: * -> * # Methods from :: Lang -> Rep Lang x # to :: Rep Lang x -> Lang #
EmitXml Lang Source #
Methods emitXml :: Lang -> XmlRep Source #
type Rep Lang Source #
type Rep Lang = D1 * (MetaData "Lang" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "LangLanguage" PrefixI True) (S1 * (MetaSel (Just Symbol "lang1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Language))) (C1 * (MetaCons "LangLang" PrefixI True) (S1 * (MetaSel (Just Symbol "lang2") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * SumLang))))

parseLang :: String -> XParse Lang Source #

newtype Language Source #

xs:language (simple)

Constructors

Language
Fields language :: Token

Instances

Eq Language Source #
Methods (==) :: Language -> Language -> Bool # (/=) :: Language -> Language -> Bool #
Ord Language Source #
Methods compare :: Language -> Language -> Ordering # (<) :: Language -> Language -> Bool # (<=) :: Language -> Language -> Bool # (>) :: Language -> Language -> Bool # (>=) :: Language -> Language -> Bool # max :: Language -> Language -> Language # min :: Language -> Language -> Language #
Read Language Source #
Methods readsPrec :: Int -> ReadS Language # readList :: ReadS [Language] # readPrec :: ReadPrec Language # readListPrec :: ReadPrec [Language] #
Show Language Source #
Methods showsPrec :: Int -> Language -> ShowS # show :: Language -> String # showList :: [Language] -> ShowS #
IsString Language Source #
Methods fromString :: String -> Language #
Generic Language Source #
Associated Types type Rep Language :: * -> * # Methods from :: Language -> Rep Language x # to :: Rep Language x -> Language #
EmitXml Language Source #
Methods emitXml :: Language -> XmlRep Source #
type Rep Language Source #
type Rep Language = D1 * (MetaData "Language" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "Language" PrefixI True) (S1 * (MetaSel (Just Symbol "language") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Token)))

parseLanguage :: String -> XParse Language Source #

data LeftCenterRight Source #

left-center-right (simple)

The left-center-right type is used to define horizontal alignment and text justification.

Constructors

LeftCenterRightLeft	left
LeftCenterRightCenter	center
LeftCenterRightRight	right

Instances

Bounded LeftCenterRight Source #
Methods minBound :: LeftCenterRight # maxBound :: LeftCenterRight #
Enum LeftCenterRight Source #
Methods succ :: LeftCenterRight -> LeftCenterRight # pred :: LeftCenterRight -> LeftCenterRight # toEnum :: Int -> LeftCenterRight # fromEnum :: LeftCenterRight -> Int # enumFrom :: LeftCenterRight -> [LeftCenterRight] # enumFromThen :: LeftCenterRight -> LeftCenterRight -> [LeftCenterRight] # enumFromTo :: LeftCenterRight -> LeftCenterRight -> [LeftCenterRight] # enumFromThenTo :: LeftCenterRight -> LeftCenterRight -> LeftCenterRight -> [LeftCenterRight] #
Eq LeftCenterRight Source #
Methods (==) :: LeftCenterRight -> LeftCenterRight -> Bool # (/=) :: LeftCenterRight -> LeftCenterRight -> Bool #
Ord LeftCenterRight Source #
Methods compare :: LeftCenterRight -> LeftCenterRight -> Ordering # (<) :: LeftCenterRight -> LeftCenterRight -> Bool # (<=) :: LeftCenterRight -> LeftCenterRight -> Bool # (>) :: LeftCenterRight -> LeftCenterRight -> Bool # (>=) :: LeftCenterRight -> LeftCenterRight -> Bool # max :: LeftCenterRight -> LeftCenterRight -> LeftCenterRight # min :: LeftCenterRight -> LeftCenterRight -> LeftCenterRight #
Show LeftCenterRight Source #
Methods showsPrec :: Int -> LeftCenterRight -> ShowS # show :: LeftCenterRight -> String # showList :: [LeftCenterRight] -> ShowS #
Generic LeftCenterRight Source #
Associated Types type Rep LeftCenterRight :: * -> * # Methods from :: LeftCenterRight -> Rep LeftCenterRight x # to :: Rep LeftCenterRight x -> LeftCenterRight #
EmitXml LeftCenterRight Source #
Methods emitXml :: LeftCenterRight -> XmlRep Source #
type Rep LeftCenterRight Source #
type Rep LeftCenterRight = D1 * (MetaData "LeftCenterRight" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "LeftCenterRightLeft" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "LeftCenterRightCenter" PrefixI False) (U1 )) (C1 (MetaCons "LeftCenterRightRight" PrefixI False) (U1 *))))

parseLeftCenterRight :: String -> XParse LeftCenterRight Source #

data LeftRight Source #

left-right (simple)

The left-right type is used to indicate whether one element appears to the left or the right of another element.

Constructors

LeftRightLeft	left
LeftRightRight	right

Instances

Bounded LeftRight Source #
Methods minBound :: LeftRight # maxBound :: LeftRight #
Enum LeftRight Source #
Methods succ :: LeftRight -> LeftRight # pred :: LeftRight -> LeftRight # toEnum :: Int -> LeftRight # fromEnum :: LeftRight -> Int # enumFrom :: LeftRight -> [LeftRight] # enumFromThen :: LeftRight -> LeftRight -> [LeftRight] # enumFromTo :: LeftRight -> LeftRight -> [LeftRight] # enumFromThenTo :: LeftRight -> LeftRight -> LeftRight -> [LeftRight] #
Eq LeftRight Source #
Methods (==) :: LeftRight -> LeftRight -> Bool # (/=) :: LeftRight -> LeftRight -> Bool #
Ord LeftRight Source #
Methods compare :: LeftRight -> LeftRight -> Ordering # (<) :: LeftRight -> LeftRight -> Bool # (<=) :: LeftRight -> LeftRight -> Bool # (>) :: LeftRight -> LeftRight -> Bool # (>=) :: LeftRight -> LeftRight -> Bool # max :: LeftRight -> LeftRight -> LeftRight # min :: LeftRight -> LeftRight -> LeftRight #
Show LeftRight Source #
Methods showsPrec :: Int -> LeftRight -> ShowS # show :: LeftRight -> String # showList :: [LeftRight] -> ShowS #
Generic LeftRight Source #
Associated Types type Rep LeftRight :: * -> * # Methods from :: LeftRight -> Rep LeftRight x # to :: Rep LeftRight x -> LeftRight #
EmitXml LeftRight Source #
Methods emitXml :: LeftRight -> XmlRep Source #
type Rep LeftRight Source #
type Rep LeftRight = D1 * (MetaData "LeftRight" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "LeftRightLeft" PrefixI False) (U1 )) (C1 (MetaCons "LeftRightRight" PrefixI False) (U1 *)))

parseLeftRight :: String -> XParse LeftRight Source #

data LineEnd Source #

line-end (simple)

The line-end type specifies if there is a jog up or down (or both), an arrow, or nothing at the start or end of a bracket.

Constructors

LineEndUp	up
LineEndDown	down
LineEndBoth	both
LineEndArrow	arrow
LineEndNone	none

Instances

Bounded LineEnd Source #
Methods minBound :: LineEnd # maxBound :: LineEnd #
Enum LineEnd Source #
Methods succ :: LineEnd -> LineEnd # pred :: LineEnd -> LineEnd # toEnum :: Int -> LineEnd # fromEnum :: LineEnd -> Int # enumFrom :: LineEnd -> [LineEnd] # enumFromThen :: LineEnd -> LineEnd -> [LineEnd] # enumFromTo :: LineEnd -> LineEnd -> [LineEnd] # enumFromThenTo :: LineEnd -> LineEnd -> LineEnd -> [LineEnd] #
Eq LineEnd Source #
Methods (==) :: LineEnd -> LineEnd -> Bool # (/=) :: LineEnd -> LineEnd -> Bool #
Ord LineEnd Source #
Methods compare :: LineEnd -> LineEnd -> Ordering # (<) :: LineEnd -> LineEnd -> Bool # (<=) :: LineEnd -> LineEnd -> Bool # (>) :: LineEnd -> LineEnd -> Bool # (>=) :: LineEnd -> LineEnd -> Bool # max :: LineEnd -> LineEnd -> LineEnd # min :: LineEnd -> LineEnd -> LineEnd #
Show LineEnd Source #
Methods showsPrec :: Int -> LineEnd -> ShowS # show :: LineEnd -> String # showList :: [LineEnd] -> ShowS #
Generic LineEnd Source #
Associated Types type Rep LineEnd :: * -> * # Methods from :: LineEnd -> Rep LineEnd x # to :: Rep LineEnd x -> LineEnd #
EmitXml LineEnd Source #
Methods emitXml :: LineEnd -> XmlRep Source #
type Rep LineEnd Source #
type Rep LineEnd = D1 * (MetaData "LineEnd" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "LineEndUp" PrefixI False) (U1 )) (C1 (MetaCons "LineEndDown" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "LineEndBoth" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "LineEndArrow" PrefixI False) (U1 )) (C1 (MetaCons "LineEndNone" PrefixI False) (U1 *)))))

parseLineEnd :: String -> XParse LineEnd Source #

data LineShape Source #

line-shape (simple)

The line-shape type distinguishes between straight and curved lines.

Constructors

LineShapeStraight	straight
LineShapeCurved	curved

Instances

Bounded LineShape Source #
Methods minBound :: LineShape # maxBound :: LineShape #
Enum LineShape Source #
Methods succ :: LineShape -> LineShape # pred :: LineShape -> LineShape # toEnum :: Int -> LineShape # fromEnum :: LineShape -> Int # enumFrom :: LineShape -> [LineShape] # enumFromThen :: LineShape -> LineShape -> [LineShape] # enumFromTo :: LineShape -> LineShape -> [LineShape] # enumFromThenTo :: LineShape -> LineShape -> LineShape -> [LineShape] #
Eq LineShape Source #
Methods (==) :: LineShape -> LineShape -> Bool # (/=) :: LineShape -> LineShape -> Bool #
Ord LineShape Source #
Methods compare :: LineShape -> LineShape -> Ordering # (<) :: LineShape -> LineShape -> Bool # (<=) :: LineShape -> LineShape -> Bool # (>) :: LineShape -> LineShape -> Bool # (>=) :: LineShape -> LineShape -> Bool # max :: LineShape -> LineShape -> LineShape # min :: LineShape -> LineShape -> LineShape #
Show LineShape Source #
Methods showsPrec :: Int -> LineShape -> ShowS # show :: LineShape -> String # showList :: [LineShape] -> ShowS #
Generic LineShape Source #
Associated Types type Rep LineShape :: * -> * # Methods from :: LineShape -> Rep LineShape x # to :: Rep LineShape x -> LineShape #
EmitXml LineShape Source #
Methods emitXml :: LineShape -> XmlRep Source #
type Rep LineShape Source #
type Rep LineShape = D1 * (MetaData "LineShape" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "LineShapeStraight" PrefixI False) (U1 )) (C1 (MetaCons "LineShapeCurved" PrefixI False) (U1 *)))

parseLineShape :: String -> XParse LineShape Source #

data LineType Source #

line-type (simple)

The line-type type distinguishes between solid, dashed, dotted, and wavy lines.

Constructors

LineTypeSolid	solid
LineTypeDashed	dashed
LineTypeDotted	dotted
LineTypeWavy	wavy

Instances

Bounded LineType Source #
Methods minBound :: LineType # maxBound :: LineType #
Enum LineType Source #
Methods succ :: LineType -> LineType # pred :: LineType -> LineType # toEnum :: Int -> LineType # fromEnum :: LineType -> Int # enumFrom :: LineType -> [LineType] # enumFromThen :: LineType -> LineType -> [LineType] # enumFromTo :: LineType -> LineType -> [LineType] # enumFromThenTo :: LineType -> LineType -> LineType -> [LineType] #
Eq LineType Source #
Methods (==) :: LineType -> LineType -> Bool # (/=) :: LineType -> LineType -> Bool #
Ord LineType Source #
Methods compare :: LineType -> LineType -> Ordering # (<) :: LineType -> LineType -> Bool # (<=) :: LineType -> LineType -> Bool # (>) :: LineType -> LineType -> Bool # (>=) :: LineType -> LineType -> Bool # max :: LineType -> LineType -> LineType # min :: LineType -> LineType -> LineType #
Show LineType Source #
Methods showsPrec :: Int -> LineType -> ShowS # show :: LineType -> String # showList :: [LineType] -> ShowS #
Generic LineType Source #
Associated Types type Rep LineType :: * -> * # Methods from :: LineType -> Rep LineType x # to :: Rep LineType x -> LineType #
EmitXml LineType Source #
Methods emitXml :: LineType -> XmlRep Source #
type Rep LineType Source #
type Rep LineType = D1 * (MetaData "LineType" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "LineTypeSolid" PrefixI False) (U1 )) (C1 (MetaCons "LineTypeDashed" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "LineTypeDotted" PrefixI False) (U1 )) (C1 (MetaCons "LineTypeWavy" PrefixI False) (U1 *))))

parseLineType :: String -> XParse LineType Source #

newtype LineWidthType Source #

line-width-type (simple)

The line-width-type defines what type of line is being defined in a line-width element. Values include beam, bracket, dashes, enclosure, ending, extend, heavy barline, leger, light barline, octave shift, pedal, slur middle, slur tip, staff, stem, tie middle, tie tip, tuplet bracket, and wedge. This is left as a string so that other application-specific types can be defined, but it is made a separate type so that it can be redefined more strictly.

Constructors

LineWidthType
Fields lineWidthType :: Token

Instances

Eq LineWidthType Source #
Methods (==) :: LineWidthType -> LineWidthType -> Bool # (/=) :: LineWidthType -> LineWidthType -> Bool #
Ord LineWidthType Source #
Methods compare :: LineWidthType -> LineWidthType -> Ordering # (<) :: LineWidthType -> LineWidthType -> Bool # (<=) :: LineWidthType -> LineWidthType -> Bool # (>) :: LineWidthType -> LineWidthType -> Bool # (>=) :: LineWidthType -> LineWidthType -> Bool # max :: LineWidthType -> LineWidthType -> LineWidthType # min :: LineWidthType -> LineWidthType -> LineWidthType #
Read LineWidthType Source #
Methods readsPrec :: Int -> ReadS LineWidthType # readList :: ReadS [LineWidthType] # readPrec :: ReadPrec LineWidthType # readListPrec :: ReadPrec [LineWidthType] #
Show LineWidthType Source #
Methods showsPrec :: Int -> LineWidthType -> ShowS # show :: LineWidthType -> String # showList :: [LineWidthType] -> ShowS #
IsString LineWidthType Source #
Methods fromString :: String -> LineWidthType #
Generic LineWidthType Source #
Associated Types type Rep LineWidthType :: * -> * # Methods from :: LineWidthType -> Rep LineWidthType x # to :: Rep LineWidthType x -> LineWidthType #
EmitXml LineWidthType Source #
Methods emitXml :: LineWidthType -> XmlRep Source #
type Rep LineWidthType Source #
type Rep LineWidthType = D1 * (MetaData "LineWidthType" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "LineWidthType" PrefixI True) (S1 * (MetaSel (Just Symbol "lineWidthType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Token)))

parseLineWidthType :: String -> XParse LineWidthType Source #

data MarginType Source #

margin-type (simple)

The margin-type type specifies whether margins apply to even page, odd pages, or both.

Constructors

MarginTypeOdd	odd
MarginTypeEven	even
MarginTypeBoth	both

Instances

Bounded MarginType Source #
Methods minBound :: MarginType # maxBound :: MarginType #
Enum MarginType Source #
Methods succ :: MarginType -> MarginType # pred :: MarginType -> MarginType # toEnum :: Int -> MarginType # fromEnum :: MarginType -> Int # enumFrom :: MarginType -> [MarginType] # enumFromThen :: MarginType -> MarginType -> [MarginType] # enumFromTo :: MarginType -> MarginType -> [MarginType] # enumFromThenTo :: MarginType -> MarginType -> MarginType -> [MarginType] #
Eq MarginType Source #
Methods (==) :: MarginType -> MarginType -> Bool # (/=) :: MarginType -> MarginType -> Bool #
Ord MarginType Source #
Methods compare :: MarginType -> MarginType -> Ordering # (<) :: MarginType -> MarginType -> Bool # (<=) :: MarginType -> MarginType -> Bool # (>) :: MarginType -> MarginType -> Bool # (>=) :: MarginType -> MarginType -> Bool # max :: MarginType -> MarginType -> MarginType # min :: MarginType -> MarginType -> MarginType #
Show MarginType Source #
Methods showsPrec :: Int -> MarginType -> ShowS # show :: MarginType -> String # showList :: [MarginType] -> ShowS #
Generic MarginType Source #
Associated Types type Rep MarginType :: * -> * # Methods from :: MarginType -> Rep MarginType x # to :: Rep MarginType x -> MarginType #
EmitXml MarginType Source #
Methods emitXml :: MarginType -> XmlRep Source #
type Rep MarginType Source #
type Rep MarginType = D1 * (MetaData "MarginType" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "MarginTypeOdd" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "MarginTypeEven" PrefixI False) (U1 )) (C1 (MetaCons "MarginTypeBoth" PrefixI False) (U1 *))))

parseMarginType :: String -> XParse MarginType Source #

data MeasureNumberingValue Source #

measure-numbering-value (simple)

The measure-numbering-value type describes how measure numbers are displayed on this part: no numbers, numbers every measure, or numbers every system.

Constructors

MeasureNumberingValueNone	none
MeasureNumberingValueMeasure	measure
MeasureNumberingValueSystem	system

Instances

Bounded MeasureNumberingValue Source #
Methods minBound :: MeasureNumberingValue # maxBound :: MeasureNumberingValue #
Enum MeasureNumberingValue Source #
Methods succ :: MeasureNumberingValue -> MeasureNumberingValue # pred :: MeasureNumberingValue -> MeasureNumberingValue # toEnum :: Int -> MeasureNumberingValue # fromEnum :: MeasureNumberingValue -> Int # enumFrom :: MeasureNumberingValue -> [MeasureNumberingValue] # enumFromThen :: MeasureNumberingValue -> MeasureNumberingValue -> [MeasureNumberingValue] # enumFromTo :: MeasureNumberingValue -> MeasureNumberingValue -> [MeasureNumberingValue] # enumFromThenTo :: MeasureNumberingValue -> MeasureNumberingValue -> MeasureNumberingValue -> [MeasureNumberingValue] #
Eq MeasureNumberingValue Source #
Methods (==) :: MeasureNumberingValue -> MeasureNumberingValue -> Bool # (/=) :: MeasureNumberingValue -> MeasureNumberingValue -> Bool #
Ord MeasureNumberingValue Source #
Methods compare :: MeasureNumberingValue -> MeasureNumberingValue -> Ordering # (<) :: MeasureNumberingValue -> MeasureNumberingValue -> Bool # (<=) :: MeasureNumberingValue -> MeasureNumberingValue -> Bool # (>) :: MeasureNumberingValue -> MeasureNumberingValue -> Bool # (>=) :: MeasureNumberingValue -> MeasureNumberingValue -> Bool # max :: MeasureNumberingValue -> MeasureNumberingValue -> MeasureNumberingValue # min :: MeasureNumberingValue -> MeasureNumberingValue -> MeasureNumberingValue #
Show MeasureNumberingValue Source #
Methods showsPrec :: Int -> MeasureNumberingValue -> ShowS # show :: MeasureNumberingValue -> String # showList :: [MeasureNumberingValue] -> ShowS #
Generic MeasureNumberingValue Source #
Associated Types type Rep MeasureNumberingValue :: * -> * # Methods from :: MeasureNumberingValue -> Rep MeasureNumberingValue x # to :: Rep MeasureNumberingValue x -> MeasureNumberingValue #
EmitXml MeasureNumberingValue Source #
Methods emitXml :: MeasureNumberingValue -> XmlRep Source #
type Rep MeasureNumberingValue Source #
type Rep MeasureNumberingValue = D1 * (MetaData "MeasureNumberingValue" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "MeasureNumberingValueNone" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "MeasureNumberingValueMeasure" PrefixI False) (U1 )) (C1 (MetaCons "MeasureNumberingValueSystem" PrefixI False) (U1 *))))

parseMeasureNumberingValue :: String -> XParse MeasureNumberingValue Source #

newtype Midi128 Source #

midi-128 (simple)

The midi-16 type is used to express MIDI 1.0 values that range from 1 to 128.

Constructors

Midi128
Fields midi128 :: PositiveInteger

Instances

Bounded Midi128 Source #
Methods minBound :: Midi128 # maxBound :: Midi128 #
Enum Midi128 Source #
Methods succ :: Midi128 -> Midi128 # pred :: Midi128 -> Midi128 # toEnum :: Int -> Midi128 # fromEnum :: Midi128 -> Int # enumFrom :: Midi128 -> [Midi128] # enumFromThen :: Midi128 -> Midi128 -> [Midi128] # enumFromTo :: Midi128 -> Midi128 -> [Midi128] # enumFromThenTo :: Midi128 -> Midi128 -> Midi128 -> [Midi128] #
Eq Midi128 Source #
Methods (==) :: Midi128 -> Midi128 -> Bool # (/=) :: Midi128 -> Midi128 -> Bool #
Integral Midi128 Source #
Methods quot :: Midi128 -> Midi128 -> Midi128 # rem :: Midi128 -> Midi128 -> Midi128 # div :: Midi128 -> Midi128 -> Midi128 # mod :: Midi128 -> Midi128 -> Midi128 # quotRem :: Midi128 -> Midi128 -> (Midi128, Midi128) # divMod :: Midi128 -> Midi128 -> (Midi128, Midi128) # toInteger :: Midi128 -> Integer #
Num Midi128 Source #
Methods (+) :: Midi128 -> Midi128 -> Midi128 # (-) :: Midi128 -> Midi128 -> Midi128 # (*) :: Midi128 -> Midi128 -> Midi128 # negate :: Midi128 -> Midi128 # abs :: Midi128 -> Midi128 # signum :: Midi128 -> Midi128 # fromInteger :: Integer -> Midi128 #
Ord Midi128 Source #
Methods compare :: Midi128 -> Midi128 -> Ordering # (<) :: Midi128 -> Midi128 -> Bool # (<=) :: Midi128 -> Midi128 -> Bool # (>) :: Midi128 -> Midi128 -> Bool # (>=) :: Midi128 -> Midi128 -> Bool # max :: Midi128 -> Midi128 -> Midi128 # min :: Midi128 -> Midi128 -> Midi128 #
Read Midi128 Source #
Methods readsPrec :: Int -> ReadS Midi128 # readList :: ReadS [Midi128] # readPrec :: ReadPrec Midi128 # readListPrec :: ReadPrec [Midi128] #
Real Midi128 Source #
Methods toRational :: Midi128 -> Rational #
Show Midi128 Source #
Methods showsPrec :: Int -> Midi128 -> ShowS # show :: Midi128 -> String # showList :: [Midi128] -> ShowS #
Generic Midi128 Source #
Associated Types type Rep Midi128 :: * -> * # Methods from :: Midi128 -> Rep Midi128 x # to :: Rep Midi128 x -> Midi128 #
EmitXml Midi128 Source #
Methods emitXml :: Midi128 -> XmlRep Source #
type Rep Midi128 Source #
type Rep Midi128 = D1 * (MetaData "Midi128" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "Midi128" PrefixI True) (S1 * (MetaSel (Just Symbol "midi128") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveInteger)))

parseMidi128 :: String -> XParse Midi128 Source #

newtype Midi16 Source #

midi-16 (simple)

The midi-16 type is used to express MIDI 1.0 values that range from 1 to 16.

Constructors

Midi16
Fields midi16 :: PositiveInteger

Instances

Bounded Midi16 Source #
Methods minBound :: Midi16 # maxBound :: Midi16 #
Enum Midi16 Source #
Methods succ :: Midi16 -> Midi16 # pred :: Midi16 -> Midi16 # toEnum :: Int -> Midi16 # fromEnum :: Midi16 -> Int # enumFrom :: Midi16 -> [Midi16] # enumFromThen :: Midi16 -> Midi16 -> [Midi16] # enumFromTo :: Midi16 -> Midi16 -> [Midi16] # enumFromThenTo :: Midi16 -> Midi16 -> Midi16 -> [Midi16] #
Eq Midi16 Source #
Methods (==) :: Midi16 -> Midi16 -> Bool # (/=) :: Midi16 -> Midi16 -> Bool #
Integral Midi16 Source #
Methods quot :: Midi16 -> Midi16 -> Midi16 # rem :: Midi16 -> Midi16 -> Midi16 # div :: Midi16 -> Midi16 -> Midi16 # mod :: Midi16 -> Midi16 -> Midi16 # quotRem :: Midi16 -> Midi16 -> (Midi16, Midi16) # divMod :: Midi16 -> Midi16 -> (Midi16, Midi16) # toInteger :: Midi16 -> Integer #
Num Midi16 Source #
Methods (+) :: Midi16 -> Midi16 -> Midi16 # (-) :: Midi16 -> Midi16 -> Midi16 # (*) :: Midi16 -> Midi16 -> Midi16 # negate :: Midi16 -> Midi16 # abs :: Midi16 -> Midi16 # signum :: Midi16 -> Midi16 # fromInteger :: Integer -> Midi16 #
Ord Midi16 Source #
Methods compare :: Midi16 -> Midi16 -> Ordering # (<) :: Midi16 -> Midi16 -> Bool # (<=) :: Midi16 -> Midi16 -> Bool # (>) :: Midi16 -> Midi16 -> Bool # (>=) :: Midi16 -> Midi16 -> Bool # max :: Midi16 -> Midi16 -> Midi16 # min :: Midi16 -> Midi16 -> Midi16 #
Read Midi16 Source #
Methods readsPrec :: Int -> ReadS Midi16 # readList :: ReadS [Midi16] # readPrec :: ReadPrec Midi16 # readListPrec :: ReadPrec [Midi16] #
Real Midi16 Source #
Methods toRational :: Midi16 -> Rational #
Show Midi16 Source #
Methods showsPrec :: Int -> Midi16 -> ShowS # show :: Midi16 -> String # showList :: [Midi16] -> ShowS #
Generic Midi16 Source #
Associated Types type Rep Midi16 :: * -> * # Methods from :: Midi16 -> Rep Midi16 x # to :: Rep Midi16 x -> Midi16 #
EmitXml Midi16 Source #
Methods emitXml :: Midi16 -> XmlRep Source #
type Rep Midi16 Source #
type Rep Midi16 = D1 * (MetaData "Midi16" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "Midi16" PrefixI True) (S1 * (MetaSel (Just Symbol "midi16") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveInteger)))

parseMidi16 :: String -> XParse Midi16 Source #

newtype Midi16384 Source #

midi-16384 (simple)

The midi-16 type is used to express MIDI 1.0 values that range from 1 to 16,384.

Constructors

Midi16384
Fields midi16384 :: PositiveInteger

Instances

Bounded Midi16384 Source #
Methods minBound :: Midi16384 # maxBound :: Midi16384 #
Enum Midi16384 Source #
Methods succ :: Midi16384 -> Midi16384 # pred :: Midi16384 -> Midi16384 # toEnum :: Int -> Midi16384 # fromEnum :: Midi16384 -> Int # enumFrom :: Midi16384 -> [Midi16384] # enumFromThen :: Midi16384 -> Midi16384 -> [Midi16384] # enumFromTo :: Midi16384 -> Midi16384 -> [Midi16384] # enumFromThenTo :: Midi16384 -> Midi16384 -> Midi16384 -> [Midi16384] #
Eq Midi16384 Source #
Methods (==) :: Midi16384 -> Midi16384 -> Bool # (/=) :: Midi16384 -> Midi16384 -> Bool #
Integral Midi16384 Source #
Methods quot :: Midi16384 -> Midi16384 -> Midi16384 # rem :: Midi16384 -> Midi16384 -> Midi16384 # div :: Midi16384 -> Midi16384 -> Midi16384 # mod :: Midi16384 -> Midi16384 -> Midi16384 # quotRem :: Midi16384 -> Midi16384 -> (Midi16384, Midi16384) # divMod :: Midi16384 -> Midi16384 -> (Midi16384, Midi16384) # toInteger :: Midi16384 -> Integer #
Num Midi16384 Source #
Methods (+) :: Midi16384 -> Midi16384 -> Midi16384 # (-) :: Midi16384 -> Midi16384 -> Midi16384 # (*) :: Midi16384 -> Midi16384 -> Midi16384 # negate :: Midi16384 -> Midi16384 # abs :: Midi16384 -> Midi16384 # signum :: Midi16384 -> Midi16384 # fromInteger :: Integer -> Midi16384 #
Ord Midi16384 Source #
Methods compare :: Midi16384 -> Midi16384 -> Ordering # (<) :: Midi16384 -> Midi16384 -> Bool # (<=) :: Midi16384 -> Midi16384 -> Bool # (>) :: Midi16384 -> Midi16384 -> Bool # (>=) :: Midi16384 -> Midi16384 -> Bool # max :: Midi16384 -> Midi16384 -> Midi16384 # min :: Midi16384 -> Midi16384 -> Midi16384 #
Read Midi16384 Source #
Methods readsPrec :: Int -> ReadS Midi16384 # readList :: ReadS [Midi16384] # readPrec :: ReadPrec Midi16384 # readListPrec :: ReadPrec [Midi16384] #
Real Midi16384 Source #
Methods toRational :: Midi16384 -> Rational #
Show Midi16384 Source #
Methods showsPrec :: Int -> Midi16384 -> ShowS # show :: Midi16384 -> String # showList :: [Midi16384] -> ShowS #
Generic Midi16384 Source #
Associated Types type Rep Midi16384 :: * -> * # Methods from :: Midi16384 -> Rep Midi16384 x # to :: Rep Midi16384 x -> Midi16384 #
EmitXml Midi16384 Source #
Methods emitXml :: Midi16384 -> XmlRep Source #
type Rep Midi16384 Source #
type Rep Midi16384 = D1 * (MetaData "Midi16384" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "Midi16384" PrefixI True) (S1 * (MetaSel (Just Symbol "midi16384") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveInteger)))

parseMidi16384 :: String -> XParse Midi16384 Source #

newtype Millimeters Source #

millimeters (simple)

The millimeters type is a number representing millimeters. This is used in the scaling element to provide a default scaling from tenths to physical units.

Constructors

Millimeters
Fields millimeters :: Decimal

Instances

Eq Millimeters Source #
Methods (==) :: Millimeters -> Millimeters -> Bool # (/=) :: Millimeters -> Millimeters -> Bool #
Fractional Millimeters Source #
Methods (/) :: Millimeters -> Millimeters -> Millimeters # recip :: Millimeters -> Millimeters # fromRational :: Rational -> Millimeters #
Num Millimeters Source #
Methods (+) :: Millimeters -> Millimeters -> Millimeters # (-) :: Millimeters -> Millimeters -> Millimeters # (*) :: Millimeters -> Millimeters -> Millimeters # negate :: Millimeters -> Millimeters # abs :: Millimeters -> Millimeters # signum :: Millimeters -> Millimeters # fromInteger :: Integer -> Millimeters #
Ord Millimeters Source #
Methods compare :: Millimeters -> Millimeters -> Ordering # (<) :: Millimeters -> Millimeters -> Bool # (<=) :: Millimeters -> Millimeters -> Bool # (>) :: Millimeters -> Millimeters -> Bool # (>=) :: Millimeters -> Millimeters -> Bool # max :: Millimeters -> Millimeters -> Millimeters # min :: Millimeters -> Millimeters -> Millimeters #
Read Millimeters Source #
Methods readsPrec :: Int -> ReadS Millimeters # readList :: ReadS [Millimeters] # readPrec :: ReadPrec Millimeters # readListPrec :: ReadPrec [Millimeters] #
Real Millimeters Source #
Methods toRational :: Millimeters -> Rational #
RealFrac Millimeters Source #
Methods properFraction :: Integral b => Millimeters -> (b, Millimeters) # truncate :: Integral b => Millimeters -> b # round :: Integral b => Millimeters -> b # ceiling :: Integral b => Millimeters -> b # floor :: Integral b => Millimeters -> b #
Show Millimeters Source #
Methods showsPrec :: Int -> Millimeters -> ShowS # show :: Millimeters -> String # showList :: [Millimeters] -> ShowS #
Generic Millimeters Source #
Associated Types type Rep Millimeters :: * -> * # Methods from :: Millimeters -> Rep Millimeters x # to :: Rep Millimeters x -> Millimeters #
EmitXml Millimeters Source #
Methods emitXml :: Millimeters -> XmlRep Source #
type Rep Millimeters Source #
type Rep Millimeters = D1 * (MetaData "Millimeters" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "Millimeters" PrefixI True) (S1 * (MetaSel (Just Symbol "millimeters") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Decimal)))

parseMillimeters :: String -> XParse Millimeters Source #

newtype Mode Source #

mode (simple)

The mode type is used to specify major/minor and other mode distinctions. Valid mode values include major, minor, dorian, phrygian, lydian, mixolydian, aeolian, ionian, and locrian.

Constructors

Mode
Fields mode :: String

Instances

Eq Mode Source #
Methods (==) :: Mode -> Mode -> Bool # (/=) :: Mode -> Mode -> Bool #
Ord Mode Source #
Methods compare :: Mode -> Mode -> Ordering # (<) :: Mode -> Mode -> Bool # (<=) :: Mode -> Mode -> Bool # (>) :: Mode -> Mode -> Bool # (>=) :: Mode -> Mode -> Bool # max :: Mode -> Mode -> Mode # min :: Mode -> Mode -> Mode #
Read Mode Source #
Methods readsPrec :: Int -> ReadS Mode # readList :: ReadS [Mode] # readPrec :: ReadPrec Mode # readListPrec :: ReadPrec [Mode] #
Show Mode Source #
Methods showsPrec :: Int -> Mode -> ShowS # show :: Mode -> String # showList :: [Mode] -> ShowS #
IsString Mode Source #
Methods fromString :: String -> Mode #
Generic Mode Source #
Associated Types type Rep Mode :: * -> * # Methods from :: Mode -> Rep Mode x # to :: Rep Mode x -> Mode #
EmitXml Mode Source #
Methods emitXml :: Mode -> XmlRep Source #
type Rep Mode Source #
type Rep Mode = D1 * (MetaData "Mode" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "Mode" PrefixI True) (S1 * (MetaSel (Just Symbol "mode") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)))

parseMode :: String -> XParse Mode Source #

newtype NonNegativeDecimal Source #

non-negative-decimal (simple)

The non-negative-decimal type specifies a non-negative decimal value.

Constructors

NonNegativeDecimal
Fields nonNegativeDecimal :: Decimal

Instances

Eq NonNegativeDecimal Source #
Methods (==) :: NonNegativeDecimal -> NonNegativeDecimal -> Bool # (/=) :: NonNegativeDecimal -> NonNegativeDecimal -> Bool #
Fractional NonNegativeDecimal Source #
Methods (/) :: NonNegativeDecimal -> NonNegativeDecimal -> NonNegativeDecimal # recip :: NonNegativeDecimal -> NonNegativeDecimal # fromRational :: Rational -> NonNegativeDecimal #
Num NonNegativeDecimal Source #
Methods (+) :: NonNegativeDecimal -> NonNegativeDecimal -> NonNegativeDecimal # (-) :: NonNegativeDecimal -> NonNegativeDecimal -> NonNegativeDecimal # (*) :: NonNegativeDecimal -> NonNegativeDecimal -> NonNegativeDecimal # negate :: NonNegativeDecimal -> NonNegativeDecimal # abs :: NonNegativeDecimal -> NonNegativeDecimal # signum :: NonNegativeDecimal -> NonNegativeDecimal # fromInteger :: Integer -> NonNegativeDecimal #
Ord NonNegativeDecimal Source #
Methods compare :: NonNegativeDecimal -> NonNegativeDecimal -> Ordering # (<) :: NonNegativeDecimal -> NonNegativeDecimal -> Bool # (<=) :: NonNegativeDecimal -> NonNegativeDecimal -> Bool # (>) :: NonNegativeDecimal -> NonNegativeDecimal -> Bool # (>=) :: NonNegativeDecimal -> NonNegativeDecimal -> Bool # max :: NonNegativeDecimal -> NonNegativeDecimal -> NonNegativeDecimal # min :: NonNegativeDecimal -> NonNegativeDecimal -> NonNegativeDecimal #
Read NonNegativeDecimal Source #
Methods readsPrec :: Int -> ReadS NonNegativeDecimal # readList :: ReadS [NonNegativeDecimal] # readPrec :: ReadPrec NonNegativeDecimal # readListPrec :: ReadPrec [NonNegativeDecimal] #
Real NonNegativeDecimal Source #
Methods toRational :: NonNegativeDecimal -> Rational #
RealFrac NonNegativeDecimal Source #
Methods properFraction :: Integral b => NonNegativeDecimal -> (b, NonNegativeDecimal) # truncate :: Integral b => NonNegativeDecimal -> b # round :: Integral b => NonNegativeDecimal -> b # ceiling :: Integral b => NonNegativeDecimal -> b # floor :: Integral b => NonNegativeDecimal -> b #
Show NonNegativeDecimal Source #
Methods showsPrec :: Int -> NonNegativeDecimal -> ShowS # show :: NonNegativeDecimal -> String # showList :: [NonNegativeDecimal] -> ShowS #
Generic NonNegativeDecimal Source #
Associated Types type Rep NonNegativeDecimal :: * -> * # Methods from :: NonNegativeDecimal -> Rep NonNegativeDecimal x # to :: Rep NonNegativeDecimal x -> NonNegativeDecimal #
EmitXml NonNegativeDecimal Source #
Methods emitXml :: NonNegativeDecimal -> XmlRep Source #
type Rep NonNegativeDecimal Source #
type Rep NonNegativeDecimal = D1 * (MetaData "NonNegativeDecimal" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "NonNegativeDecimal" PrefixI True) (S1 * (MetaSel (Just Symbol "nonNegativeDecimal") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Decimal)))

parseNonNegativeDecimal :: String -> XParse NonNegativeDecimal Source #

newtype NonNegativeInteger Source #

xs:nonNegativeInteger (simple)

Constructors

NonNegativeInteger
Fields nonNegativeInteger :: Int

Instances

Bounded NonNegativeInteger Source #
Methods minBound :: NonNegativeInteger # maxBound :: NonNegativeInteger #
Enum NonNegativeInteger Source #
Methods succ :: NonNegativeInteger -> NonNegativeInteger # pred :: NonNegativeInteger -> NonNegativeInteger # toEnum :: Int -> NonNegativeInteger # fromEnum :: NonNegativeInteger -> Int # enumFrom :: NonNegativeInteger -> [NonNegativeInteger] # enumFromThen :: NonNegativeInteger -> NonNegativeInteger -> [NonNegativeInteger] # enumFromTo :: NonNegativeInteger -> NonNegativeInteger -> [NonNegativeInteger] # enumFromThenTo :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger -> [NonNegativeInteger] #
Eq NonNegativeInteger Source #
Methods (==) :: NonNegativeInteger -> NonNegativeInteger -> Bool # (/=) :: NonNegativeInteger -> NonNegativeInteger -> Bool #
Integral NonNegativeInteger Source #
Methods quot :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger # rem :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger # div :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger # mod :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger # quotRem :: NonNegativeInteger -> NonNegativeInteger -> (NonNegativeInteger, NonNegativeInteger) # divMod :: NonNegativeInteger -> NonNegativeInteger -> (NonNegativeInteger, NonNegativeInteger) # toInteger :: NonNegativeInteger -> Integer #
Num NonNegativeInteger Source #
Methods (+) :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger # (-) :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger # (*) :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger # negate :: NonNegativeInteger -> NonNegativeInteger # abs :: NonNegativeInteger -> NonNegativeInteger # signum :: NonNegativeInteger -> NonNegativeInteger # fromInteger :: Integer -> NonNegativeInteger #
Ord NonNegativeInteger Source #
Methods compare :: NonNegativeInteger -> NonNegativeInteger -> Ordering # (<) :: NonNegativeInteger -> NonNegativeInteger -> Bool # (<=) :: NonNegativeInteger -> NonNegativeInteger -> Bool # (>) :: NonNegativeInteger -> NonNegativeInteger -> Bool # (>=) :: NonNegativeInteger -> NonNegativeInteger -> Bool # max :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger # min :: NonNegativeInteger -> NonNegativeInteger -> NonNegativeInteger #
Read NonNegativeInteger Source #
Methods readsPrec :: Int -> ReadS NonNegativeInteger # readList :: ReadS [NonNegativeInteger] # readPrec :: ReadPrec NonNegativeInteger # readListPrec :: ReadPrec [NonNegativeInteger] #
Real NonNegativeInteger Source #
Methods toRational :: NonNegativeInteger -> Rational #
Show NonNegativeInteger Source #
Methods showsPrec :: Int -> NonNegativeInteger -> ShowS # show :: NonNegativeInteger -> String # showList :: [NonNegativeInteger] -> ShowS #
Generic NonNegativeInteger Source #
Associated Types type Rep NonNegativeInteger :: * -> * # Methods from :: NonNegativeInteger -> Rep NonNegativeInteger x # to :: Rep NonNegativeInteger x -> NonNegativeInteger #
EmitXml NonNegativeInteger Source #
Methods emitXml :: NonNegativeInteger -> XmlRep Source #
type Rep NonNegativeInteger Source #
type Rep NonNegativeInteger = D1 * (MetaData "NonNegativeInteger" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "NonNegativeInteger" PrefixI True) (S1 * (MetaSel (Just Symbol "nonNegativeInteger") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Int)))

parseNonNegativeInteger :: String -> XParse NonNegativeInteger Source #

newtype NormalizedString Source #

xs:normalizedString (simple)

Constructors

NormalizedString
Fields normalizedString :: String

Instances

Eq NormalizedString Source #
Methods (==) :: NormalizedString -> NormalizedString -> Bool # (/=) :: NormalizedString -> NormalizedString -> Bool #
Ord NormalizedString Source #
Methods compare :: NormalizedString -> NormalizedString -> Ordering # (<) :: NormalizedString -> NormalizedString -> Bool # (<=) :: NormalizedString -> NormalizedString -> Bool # (>) :: NormalizedString -> NormalizedString -> Bool # (>=) :: NormalizedString -> NormalizedString -> Bool # max :: NormalizedString -> NormalizedString -> NormalizedString # min :: NormalizedString -> NormalizedString -> NormalizedString #
Read NormalizedString Source #
Methods readsPrec :: Int -> ReadS NormalizedString # readList :: ReadS [NormalizedString] # readPrec :: ReadPrec NormalizedString # readListPrec :: ReadPrec [NormalizedString] #
Show NormalizedString Source #
Methods showsPrec :: Int -> NormalizedString -> ShowS # show :: NormalizedString -> String # showList :: [NormalizedString] -> ShowS #
IsString NormalizedString Source #
Methods fromString :: String -> NormalizedString #
Generic NormalizedString Source #
Associated Types type Rep NormalizedString :: * -> * # Methods from :: NormalizedString -> Rep NormalizedString x # to :: Rep NormalizedString x -> NormalizedString #
EmitXml NormalizedString Source #
Methods emitXml :: NormalizedString -> XmlRep Source #
type Rep NormalizedString Source #
type Rep NormalizedString = D1 * (MetaData "NormalizedString" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "NormalizedString" PrefixI True) (S1 * (MetaSel (Just Symbol "normalizedString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)))

parseNormalizedString :: String -> XParse NormalizedString Source #

data NoteSizeType Source #

note-size-type (simple)

The note-size-type type indicates the type of note being defined by a note-size element. The grace type is used for notes of cue size that that include a grace element. The cue type is used for all other notes with cue size, whether defined explicitly or implicitly via a cue element. The large type is used for notes of large size.

Constructors

NoteSizeTypeCue	cue
NoteSizeTypeGrace	grace
NoteSizeTypeLarge	large

Instances

Bounded NoteSizeType Source #
Methods minBound :: NoteSizeType # maxBound :: NoteSizeType #
Enum NoteSizeType Source #
Methods succ :: NoteSizeType -> NoteSizeType # pred :: NoteSizeType -> NoteSizeType # toEnum :: Int -> NoteSizeType # fromEnum :: NoteSizeType -> Int # enumFrom :: NoteSizeType -> [NoteSizeType] # enumFromThen :: NoteSizeType -> NoteSizeType -> [NoteSizeType] # enumFromTo :: NoteSizeType -> NoteSizeType -> [NoteSizeType] # enumFromThenTo :: NoteSizeType -> NoteSizeType -> NoteSizeType -> [NoteSizeType] #
Eq NoteSizeType Source #
Methods (==) :: NoteSizeType -> NoteSizeType -> Bool # (/=) :: NoteSizeType -> NoteSizeType -> Bool #
Ord NoteSizeType Source #
Methods compare :: NoteSizeType -> NoteSizeType -> Ordering # (<) :: NoteSizeType -> NoteSizeType -> Bool # (<=) :: NoteSizeType -> NoteSizeType -> Bool # (>) :: NoteSizeType -> NoteSizeType -> Bool # (>=) :: NoteSizeType -> NoteSizeType -> Bool # max :: NoteSizeType -> NoteSizeType -> NoteSizeType # min :: NoteSizeType -> NoteSizeType -> NoteSizeType #
Show NoteSizeType Source #
Methods showsPrec :: Int -> NoteSizeType -> ShowS # show :: NoteSizeType -> String # showList :: [NoteSizeType] -> ShowS #
Generic NoteSizeType Source #
Associated Types type Rep NoteSizeType :: * -> * # Methods from :: NoteSizeType -> Rep NoteSizeType x # to :: Rep NoteSizeType x -> NoteSizeType #
EmitXml NoteSizeType Source #
Methods emitXml :: NoteSizeType -> XmlRep Source #
type Rep NoteSizeType Source #
type Rep NoteSizeType = D1 * (MetaData "NoteSizeType" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "NoteSizeTypeCue" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "NoteSizeTypeGrace" PrefixI False) (U1 )) (C1 (MetaCons "NoteSizeTypeLarge" PrefixI False) (U1 *))))

parseNoteSizeType :: String -> XParse NoteSizeType Source #

data NoteTypeValue Source #

note-type-value (simple)

The note-type type is used for the MusicXML type element and represents the graphic note type, from 256th (shortest) to long (longest).

Constructors

NoteTypeValue256th	256th
NoteTypeValue128th	128th
NoteTypeValue64th	64th
NoteTypeValue32nd	32nd
NoteTypeValue16th	16th
NoteTypeValueEighth	eighth
NoteTypeValueQuarter	quarter
NoteTypeValueHalf	half
NoteTypeValueWhole	whole
NoteTypeValueBreve	breve
NoteTypeValueLong	long

Instances

Bounded NoteTypeValue Source #
Methods minBound :: NoteTypeValue # maxBound :: NoteTypeValue #
Enum NoteTypeValue Source #
Methods succ :: NoteTypeValue -> NoteTypeValue # pred :: NoteTypeValue -> NoteTypeValue # toEnum :: Int -> NoteTypeValue # fromEnum :: NoteTypeValue -> Int # enumFrom :: NoteTypeValue -> [NoteTypeValue] # enumFromThen :: NoteTypeValue -> NoteTypeValue -> [NoteTypeValue] # enumFromTo :: NoteTypeValue -> NoteTypeValue -> [NoteTypeValue] # enumFromThenTo :: NoteTypeValue -> NoteTypeValue -> NoteTypeValue -> [NoteTypeValue] #
Eq NoteTypeValue Source #
Methods (==) :: NoteTypeValue -> NoteTypeValue -> Bool # (/=) :: NoteTypeValue -> NoteTypeValue -> Bool #
Ord NoteTypeValue Source #
Methods compare :: NoteTypeValue -> NoteTypeValue -> Ordering # (<) :: NoteTypeValue -> NoteTypeValue -> Bool # (<=) :: NoteTypeValue -> NoteTypeValue -> Bool # (>) :: NoteTypeValue -> NoteTypeValue -> Bool # (>=) :: NoteTypeValue -> NoteTypeValue -> Bool # max :: NoteTypeValue -> NoteTypeValue -> NoteTypeValue # min :: NoteTypeValue -> NoteTypeValue -> NoteTypeValue #
Show NoteTypeValue Source #
Methods showsPrec :: Int -> NoteTypeValue -> ShowS # show :: NoteTypeValue -> String # showList :: [NoteTypeValue] -> ShowS #
Generic NoteTypeValue Source #
Associated Types type Rep NoteTypeValue :: * -> * # Methods from :: NoteTypeValue -> Rep NoteTypeValue x # to :: Rep NoteTypeValue x -> NoteTypeValue #
EmitXml NoteTypeValue Source #
Methods emitXml :: NoteTypeValue -> XmlRep Source #
type Rep NoteTypeValue Source #
type Rep NoteTypeValue = D1 * (MetaData "NoteTypeValue" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "NoteTypeValue256th" PrefixI False) (U1 )) (C1 (MetaCons "NoteTypeValue128th" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "NoteTypeValue64th" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "NoteTypeValue32nd" PrefixI False) (U1 )) (C1 (MetaCons "NoteTypeValue16th" PrefixI False) (U1 ))))) ((:+:) ((:+:) * (C1 * (MetaCons "NoteTypeValueEighth" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "NoteTypeValueQuarter" PrefixI False) (U1 )) (C1 (MetaCons "NoteTypeValueHalf" PrefixI False) (U1 )))) ((:+:) (C1 * (MetaCons "NoteTypeValueWhole" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "NoteTypeValueBreve" PrefixI False) (U1 )) (C1 (MetaCons "NoteTypeValueLong" PrefixI False) (U1 *))))))

parseNoteTypeValue :: String -> XParse NoteTypeValue Source #

data NoteheadValue Source #

notehead-value (simple)

The notehead type indicates shapes other than the open and closed ovals associated with note durations. The values do, re, mi, fa, so, la, and ti correspond to Aikin's 7-shape system.

The arrow shapes differ from triangle and inverted triangle by being centered on the stem. Slashed and back slashed notes include both the normal notehead and a slash. The triangle shape has the tip of the triangle pointing up; the inverted triangle shape has the tip of the triangle pointing down.

Constructors

NoteheadValueSlash	slash
NoteheadValueTriangle	triangle
NoteheadValueDiamond	diamond
NoteheadValueSquare	square
NoteheadValueCross	cross
NoteheadValueX	x
NoteheadValueCircleX	circle-x
NoteheadValueInvertedTriangle	inverted triangle
NoteheadValueArrowDown	arrow down
NoteheadValueArrowUp	arrow up
NoteheadValueSlashed	slashed
NoteheadValueBackSlashed	back slashed
NoteheadValueNormal	normal
NoteheadValueCluster	cluster
NoteheadValueNone	none
NoteheadValueDo	do
NoteheadValueRe	re
NoteheadValueMi	mi
NoteheadValueFa	fa
NoteheadValueSo	so
NoteheadValueLa	la
NoteheadValueTi	ti

Instances

Bounded NoteheadValue Source #
Methods minBound :: NoteheadValue # maxBound :: NoteheadValue #
Enum NoteheadValue Source #
Methods succ :: NoteheadValue -> NoteheadValue # pred :: NoteheadValue -> NoteheadValue # toEnum :: Int -> NoteheadValue # fromEnum :: NoteheadValue -> Int # enumFrom :: NoteheadValue -> [NoteheadValue] # enumFromThen :: NoteheadValue -> NoteheadValue -> [NoteheadValue] # enumFromTo :: NoteheadValue -> NoteheadValue -> [NoteheadValue] # enumFromThenTo :: NoteheadValue -> NoteheadValue -> NoteheadValue -> [NoteheadValue] #
Eq NoteheadValue Source #
Methods (==) :: NoteheadValue -> NoteheadValue -> Bool # (/=) :: NoteheadValue -> NoteheadValue -> Bool #
Ord NoteheadValue Source #
Methods compare :: NoteheadValue -> NoteheadValue -> Ordering # (<) :: NoteheadValue -> NoteheadValue -> Bool # (<=) :: NoteheadValue -> NoteheadValue -> Bool # (>) :: NoteheadValue -> NoteheadValue -> Bool # (>=) :: NoteheadValue -> NoteheadValue -> Bool # max :: NoteheadValue -> NoteheadValue -> NoteheadValue # min :: NoteheadValue -> NoteheadValue -> NoteheadValue #
Show NoteheadValue Source #
Methods showsPrec :: Int -> NoteheadValue -> ShowS # show :: NoteheadValue -> String # showList :: [NoteheadValue] -> ShowS #
Generic NoteheadValue Source #
Associated Types type Rep NoteheadValue :: * -> * # Methods from :: NoteheadValue -> Rep NoteheadValue x # to :: Rep NoteheadValue x -> NoteheadValue #
EmitXml NoteheadValue Source #
Methods emitXml :: NoteheadValue -> XmlRep Source #
type Rep NoteheadValue Source #
type Rep NoteheadValue = D1 * (MetaData "NoteheadValue" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "NoteheadValueSlash" PrefixI False) (U1 )) (C1 (MetaCons "NoteheadValueTriangle" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "NoteheadValueDiamond" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "NoteheadValueSquare" PrefixI False) (U1 )) (C1 (MetaCons "NoteheadValueCross" PrefixI False) (U1 ))))) ((:+:) ((:+:) * (C1 * (MetaCons "NoteheadValueX" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "NoteheadValueCircleX" PrefixI False) (U1 )) (C1 (MetaCons "NoteheadValueInvertedTriangle" PrefixI False) (U1 )))) ((:+:) (C1 * (MetaCons "NoteheadValueArrowDown" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "NoteheadValueArrowUp" PrefixI False) (U1 )) (C1 (MetaCons "NoteheadValueSlashed" PrefixI False) (U1 )))))) ((:+:) ((:+:) * ((:+:) * (C1 * (MetaCons "NoteheadValueBackSlashed" PrefixI False) (U1 )) (C1 (MetaCons "NoteheadValueNormal" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "NoteheadValueCluster" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "NoteheadValueNone" PrefixI False) (U1 )) (C1 (MetaCons "NoteheadValueDo" PrefixI False) (U1 ))))) ((:+:) ((:+:) * (C1 * (MetaCons "NoteheadValueRe" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "NoteheadValueMi" PrefixI False) (U1 )) (C1 (MetaCons "NoteheadValueFa" PrefixI False) (U1 )))) ((:+:) (C1 * (MetaCons "NoteheadValueSo" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "NoteheadValueLa" PrefixI False) (U1 )) (C1 (MetaCons "NoteheadValueTi" PrefixI False) (U1 *)))))))

parseNoteheadValue :: String -> XParse NoteheadValue Source #

newtype NumberLevel Source #

number-level (simple)

Slurs, tuplets, and many other features can be concurrent and overlapping within a single musical part. The number-level type distinguishes up to six concurrent objects of the same type. A reading program should be prepared to handle cases where the number-levels stop in an arbitrary order. Different numbers are needed when the features overlap in MusicXML file order. When a number-level value is implied, the value is 1 by default.

Constructors

NumberLevel
Fields numberLevel :: PositiveInteger

Instances

Bounded NumberLevel Source #
Methods minBound :: NumberLevel # maxBound :: NumberLevel #
Enum NumberLevel Source #
Methods succ :: NumberLevel -> NumberLevel # pred :: NumberLevel -> NumberLevel # toEnum :: Int -> NumberLevel # fromEnum :: NumberLevel -> Int # enumFrom :: NumberLevel -> [NumberLevel] # enumFromThen :: NumberLevel -> NumberLevel -> [NumberLevel] # enumFromTo :: NumberLevel -> NumberLevel -> [NumberLevel] # enumFromThenTo :: NumberLevel -> NumberLevel -> NumberLevel -> [NumberLevel] #
Eq NumberLevel Source #
Methods (==) :: NumberLevel -> NumberLevel -> Bool # (/=) :: NumberLevel -> NumberLevel -> Bool #
Integral NumberLevel Source #
Methods quot :: NumberLevel -> NumberLevel -> NumberLevel # rem :: NumberLevel -> NumberLevel -> NumberLevel # div :: NumberLevel -> NumberLevel -> NumberLevel # mod :: NumberLevel -> NumberLevel -> NumberLevel # quotRem :: NumberLevel -> NumberLevel -> (NumberLevel, NumberLevel) # divMod :: NumberLevel -> NumberLevel -> (NumberLevel, NumberLevel) # toInteger :: NumberLevel -> Integer #
Num NumberLevel Source #
Methods (+) :: NumberLevel -> NumberLevel -> NumberLevel # (-) :: NumberLevel -> NumberLevel -> NumberLevel # (*) :: NumberLevel -> NumberLevel -> NumberLevel # negate :: NumberLevel -> NumberLevel # abs :: NumberLevel -> NumberLevel # signum :: NumberLevel -> NumberLevel # fromInteger :: Integer -> NumberLevel #
Ord NumberLevel Source #
Methods compare :: NumberLevel -> NumberLevel -> Ordering # (<) :: NumberLevel -> NumberLevel -> Bool # (<=) :: NumberLevel -> NumberLevel -> Bool # (>) :: NumberLevel -> NumberLevel -> Bool # (>=) :: NumberLevel -> NumberLevel -> Bool # max :: NumberLevel -> NumberLevel -> NumberLevel # min :: NumberLevel -> NumberLevel -> NumberLevel #
Read NumberLevel Source #
Methods readsPrec :: Int -> ReadS NumberLevel # readList :: ReadS [NumberLevel] # readPrec :: ReadPrec NumberLevel # readListPrec :: ReadPrec [NumberLevel] #
Real NumberLevel Source #
Methods toRational :: NumberLevel -> Rational #
Show NumberLevel Source #
Methods showsPrec :: Int -> NumberLevel -> ShowS # show :: NumberLevel -> String # showList :: [NumberLevel] -> ShowS #
Generic NumberLevel Source #
Associated Types type Rep NumberLevel :: * -> * # Methods from :: NumberLevel -> Rep NumberLevel x # to :: Rep NumberLevel x -> NumberLevel #
EmitXml NumberLevel Source #
Methods emitXml :: NumberLevel -> XmlRep Source #
type Rep NumberLevel Source #
type Rep NumberLevel = D1 * (MetaData "NumberLevel" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "NumberLevel" PrefixI True) (S1 * (MetaSel (Just Symbol "numberLevel") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveInteger)))

parseNumberLevel :: String -> XParse NumberLevel Source #

newtype NumberOfLines Source #

number-of-lines (simple)

The number-of-lines type is used to specify the number of lines in text decoration attributes.

Constructors

NumberOfLines
Fields numberOfLines :: NonNegativeInteger

Instances

Bounded NumberOfLines Source #
Methods minBound :: NumberOfLines # maxBound :: NumberOfLines #
Enum NumberOfLines Source #
Methods succ :: NumberOfLines -> NumberOfLines # pred :: NumberOfLines -> NumberOfLines # toEnum :: Int -> NumberOfLines # fromEnum :: NumberOfLines -> Int # enumFrom :: NumberOfLines -> [NumberOfLines] # enumFromThen :: NumberOfLines -> NumberOfLines -> [NumberOfLines] # enumFromTo :: NumberOfLines -> NumberOfLines -> [NumberOfLines] # enumFromThenTo :: NumberOfLines -> NumberOfLines -> NumberOfLines -> [NumberOfLines] #
Eq NumberOfLines Source #
Methods (==) :: NumberOfLines -> NumberOfLines -> Bool # (/=) :: NumberOfLines -> NumberOfLines -> Bool #
Integral NumberOfLines Source #
Methods quot :: NumberOfLines -> NumberOfLines -> NumberOfLines # rem :: NumberOfLines -> NumberOfLines -> NumberOfLines # div :: NumberOfLines -> NumberOfLines -> NumberOfLines # mod :: NumberOfLines -> NumberOfLines -> NumberOfLines # quotRem :: NumberOfLines -> NumberOfLines -> (NumberOfLines, NumberOfLines) # divMod :: NumberOfLines -> NumberOfLines -> (NumberOfLines, NumberOfLines) # toInteger :: NumberOfLines -> Integer #
Num NumberOfLines Source #
Methods (+) :: NumberOfLines -> NumberOfLines -> NumberOfLines # (-) :: NumberOfLines -> NumberOfLines -> NumberOfLines # (*) :: NumberOfLines -> NumberOfLines -> NumberOfLines # negate :: NumberOfLines -> NumberOfLines # abs :: NumberOfLines -> NumberOfLines # signum :: NumberOfLines -> NumberOfLines # fromInteger :: Integer -> NumberOfLines #
Ord NumberOfLines Source #
Methods compare :: NumberOfLines -> NumberOfLines -> Ordering # (<) :: NumberOfLines -> NumberOfLines -> Bool # (<=) :: NumberOfLines -> NumberOfLines -> Bool # (>) :: NumberOfLines -> NumberOfLines -> Bool # (>=) :: NumberOfLines -> NumberOfLines -> Bool # max :: NumberOfLines -> NumberOfLines -> NumberOfLines # min :: NumberOfLines -> NumberOfLines -> NumberOfLines #
Read NumberOfLines Source #
Methods readsPrec :: Int -> ReadS NumberOfLines # readList :: ReadS [NumberOfLines] # readPrec :: ReadPrec NumberOfLines # readListPrec :: ReadPrec [NumberOfLines] #
Real NumberOfLines Source #
Methods toRational :: NumberOfLines -> Rational #
Show NumberOfLines Source #
Methods showsPrec :: Int -> NumberOfLines -> ShowS # show :: NumberOfLines -> String # showList :: [NumberOfLines] -> ShowS #
Generic NumberOfLines Source #
Associated Types type Rep NumberOfLines :: * -> * # Methods from :: NumberOfLines -> Rep NumberOfLines x # to :: Rep NumberOfLines x -> NumberOfLines #
EmitXml NumberOfLines Source #
Methods emitXml :: NumberOfLines -> XmlRep Source #
type Rep NumberOfLines Source #
type Rep NumberOfLines = D1 * (MetaData "NumberOfLines" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "NumberOfLines" PrefixI True) (S1 * (MetaSel (Just Symbol "numberOfLines") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NonNegativeInteger)))

parseNumberOfLines :: String -> XParse NumberOfLines Source #

data NumberOrNormal Source #

number-or-normal (simple)

The number-or-normal values can be either a decimal number or the string "normal". This is used by the line-height and letter-spacing attributes.

Constructors

NumberOrNormalDecimal
Fields numberOrNormal1 :: Decimal
NumberOrNormalNumberOrNormal
Fields numberOrNormal2 :: SumNumberOrNormal

Instances

Eq NumberOrNormal Source #
Methods (==) :: NumberOrNormal -> NumberOrNormal -> Bool # (/=) :: NumberOrNormal -> NumberOrNormal -> Bool #
Show NumberOrNormal Source #
Methods showsPrec :: Int -> NumberOrNormal -> ShowS # show :: NumberOrNormal -> String # showList :: [NumberOrNormal] -> ShowS #
Generic NumberOrNormal Source #
Associated Types type Rep NumberOrNormal :: * -> * # Methods from :: NumberOrNormal -> Rep NumberOrNormal x # to :: Rep NumberOrNormal x -> NumberOrNormal #
EmitXml NumberOrNormal Source #
Methods emitXml :: NumberOrNormal -> XmlRep Source #
type Rep NumberOrNormal Source #
type Rep NumberOrNormal = D1 * (MetaData "NumberOrNormal" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "NumberOrNormalDecimal" PrefixI True) (S1 * (MetaSel (Just Symbol "numberOrNormal1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Decimal))) (C1 * (MetaCons "NumberOrNormalNumberOrNormal" PrefixI True) (S1 * (MetaSel (Just Symbol "numberOrNormal2") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * SumNumberOrNormal))))

parseNumberOrNormal :: String -> XParse NumberOrNormal Source #

newtype Octave Source #

octave (simple)

Octaves are represented by the numbers 0 to 9, where 4 indicates the octave started by middle C.

Constructors

Octave
Fields octave :: Int

Instances

Bounded Octave Source #
Methods minBound :: Octave # maxBound :: Octave #
Enum Octave Source #
Methods succ :: Octave -> Octave # pred :: Octave -> Octave # toEnum :: Int -> Octave # fromEnum :: Octave -> Int # enumFrom :: Octave -> [Octave] # enumFromThen :: Octave -> Octave -> [Octave] # enumFromTo :: Octave -> Octave -> [Octave] # enumFromThenTo :: Octave -> Octave -> Octave -> [Octave] #
Eq Octave Source #
Methods (==) :: Octave -> Octave -> Bool # (/=) :: Octave -> Octave -> Bool #
Integral Octave Source #
Methods quot :: Octave -> Octave -> Octave # rem :: Octave -> Octave -> Octave # div :: Octave -> Octave -> Octave # mod :: Octave -> Octave -> Octave # quotRem :: Octave -> Octave -> (Octave, Octave) # divMod :: Octave -> Octave -> (Octave, Octave) # toInteger :: Octave -> Integer #
Num Octave Source #
Methods (+) :: Octave -> Octave -> Octave # (-) :: Octave -> Octave -> Octave # (*) :: Octave -> Octave -> Octave # negate :: Octave -> Octave # abs :: Octave -> Octave # signum :: Octave -> Octave # fromInteger :: Integer -> Octave #
Ord Octave Source #
Methods compare :: Octave -> Octave -> Ordering # (<) :: Octave -> Octave -> Bool # (<=) :: Octave -> Octave -> Bool # (>) :: Octave -> Octave -> Bool # (>=) :: Octave -> Octave -> Bool # max :: Octave -> Octave -> Octave # min :: Octave -> Octave -> Octave #
Read Octave Source #
Methods readsPrec :: Int -> ReadS Octave # readList :: ReadS [Octave] # readPrec :: ReadPrec Octave # readListPrec :: ReadPrec [Octave] #
Real Octave Source #
Methods toRational :: Octave -> Rational #
Show Octave Source #
Methods showsPrec :: Int -> Octave -> ShowS # show :: Octave -> String # showList :: [Octave] -> ShowS #
Generic Octave Source #
Associated Types type Rep Octave :: * -> * # Methods from :: Octave -> Rep Octave x # to :: Rep Octave x -> Octave #
EmitXml Octave Source #
Methods emitXml :: Octave -> XmlRep Source #
type Rep Octave Source #
type Rep Octave = D1 * (MetaData "Octave" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "Octave" PrefixI True) (S1 * (MetaSel (Just Symbol "octave") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Int)))

parseOctave :: String -> XParse Octave Source #

data OverUnder Source #

over-under (simple)

The over-under type is used to indicate whether the tips of curved lines such as slurs and ties are overhand (tips down) or underhand (tips up).

Constructors

OverUnderOver	over
OverUnderUnder	under

Instances

Bounded OverUnder Source #
Methods minBound :: OverUnder # maxBound :: OverUnder #
Enum OverUnder Source #
Methods succ :: OverUnder -> OverUnder # pred :: OverUnder -> OverUnder # toEnum :: Int -> OverUnder # fromEnum :: OverUnder -> Int # enumFrom :: OverUnder -> [OverUnder] # enumFromThen :: OverUnder -> OverUnder -> [OverUnder] # enumFromTo :: OverUnder -> OverUnder -> [OverUnder] # enumFromThenTo :: OverUnder -> OverUnder -> OverUnder -> [OverUnder] #
Eq OverUnder Source #
Methods (==) :: OverUnder -> OverUnder -> Bool # (/=) :: OverUnder -> OverUnder -> Bool #
Ord OverUnder Source #
Methods compare :: OverUnder -> OverUnder -> Ordering # (<) :: OverUnder -> OverUnder -> Bool # (<=) :: OverUnder -> OverUnder -> Bool # (>) :: OverUnder -> OverUnder -> Bool # (>=) :: OverUnder -> OverUnder -> Bool # max :: OverUnder -> OverUnder -> OverUnder # min :: OverUnder -> OverUnder -> OverUnder #
Show OverUnder Source #
Methods showsPrec :: Int -> OverUnder -> ShowS # show :: OverUnder -> String # showList :: [OverUnder] -> ShowS #
Generic OverUnder Source #
Associated Types type Rep OverUnder :: * -> * # Methods from :: OverUnder -> Rep OverUnder x # to :: Rep OverUnder x -> OverUnder #
EmitXml OverUnder Source #
Methods emitXml :: OverUnder -> XmlRep Source #
type Rep OverUnder Source #
type Rep OverUnder = D1 * (MetaData "OverUnder" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "OverUnderOver" PrefixI False) (U1 )) (C1 (MetaCons "OverUnderUnder" PrefixI False) (U1 *)))

parseOverUnder :: String -> XParse OverUnder Source #

newtype Percent Source #

percent (simple)

The percent type specifies a percentage from 0 to 100.

Constructors

Percent
Fields percent :: Decimal

Instances

Eq Percent Source #
Methods (==) :: Percent -> Percent -> Bool # (/=) :: Percent -> Percent -> Bool #
Fractional Percent Source #
Methods (/) :: Percent -> Percent -> Percent # recip :: Percent -> Percent # fromRational :: Rational -> Percent #
Num Percent Source #
Methods (+) :: Percent -> Percent -> Percent # (-) :: Percent -> Percent -> Percent # (*) :: Percent -> Percent -> Percent # negate :: Percent -> Percent # abs :: Percent -> Percent # signum :: Percent -> Percent # fromInteger :: Integer -> Percent #
Ord Percent Source #
Methods compare :: Percent -> Percent -> Ordering # (<) :: Percent -> Percent -> Bool # (<=) :: Percent -> Percent -> Bool # (>) :: Percent -> Percent -> Bool # (>=) :: Percent -> Percent -> Bool # max :: Percent -> Percent -> Percent # min :: Percent -> Percent -> Percent #
Read Percent Source #
Methods readsPrec :: Int -> ReadS Percent # readList :: ReadS [Percent] # readPrec :: ReadPrec Percent # readListPrec :: ReadPrec [Percent] #
Real Percent Source #
Methods toRational :: Percent -> Rational #
RealFrac Percent Source #
Methods properFraction :: Integral b => Percent -> (b, Percent) # truncate :: Integral b => Percent -> b # round :: Integral b => Percent -> b # ceiling :: Integral b => Percent -> b # floor :: Integral b => Percent -> b #
Show Percent Source #
Methods showsPrec :: Int -> Percent -> ShowS # show :: Percent -> String # showList :: [Percent] -> ShowS #
Generic Percent Source #
Associated Types type Rep Percent :: * -> * # Methods from :: Percent -> Rep Percent x # to :: Rep Percent x -> Percent #
EmitXml Percent Source #
Methods emitXml :: Percent -> XmlRep Source #
type Rep Percent Source #
type Rep Percent = D1 * (MetaData "Percent" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "Percent" PrefixI True) (S1 * (MetaSel (Just Symbol "percent") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Decimal)))

parsePercent :: String -> XParse Percent Source #

newtype PositiveDivisions Source #

positive-divisions (simple)

The positive-divisions type restricts divisions values to positive numbers.

Constructors

PositiveDivisions
Fields positiveDivisions :: Divisions

Instances

Eq PositiveDivisions Source #
Methods (==) :: PositiveDivisions -> PositiveDivisions -> Bool # (/=) :: PositiveDivisions -> PositiveDivisions -> Bool #
Fractional PositiveDivisions Source #
Methods (/) :: PositiveDivisions -> PositiveDivisions -> PositiveDivisions # recip :: PositiveDivisions -> PositiveDivisions # fromRational :: Rational -> PositiveDivisions #
Num PositiveDivisions Source #
Methods (+) :: PositiveDivisions -> PositiveDivisions -> PositiveDivisions # (-) :: PositiveDivisions -> PositiveDivisions -> PositiveDivisions # (*) :: PositiveDivisions -> PositiveDivisions -> PositiveDivisions # negate :: PositiveDivisions -> PositiveDivisions # abs :: PositiveDivisions -> PositiveDivisions # signum :: PositiveDivisions -> PositiveDivisions # fromInteger :: Integer -> PositiveDivisions #
Ord PositiveDivisions Source #
Methods compare :: PositiveDivisions -> PositiveDivisions -> Ordering # (<) :: PositiveDivisions -> PositiveDivisions -> Bool # (<=) :: PositiveDivisions -> PositiveDivisions -> Bool # (>) :: PositiveDivisions -> PositiveDivisions -> Bool # (>=) :: PositiveDivisions -> PositiveDivisions -> Bool # max :: PositiveDivisions -> PositiveDivisions -> PositiveDivisions # min :: PositiveDivisions -> PositiveDivisions -> PositiveDivisions #
Read PositiveDivisions Source #
Methods readsPrec :: Int -> ReadS PositiveDivisions # readList :: ReadS [PositiveDivisions] # readPrec :: ReadPrec PositiveDivisions # readListPrec :: ReadPrec [PositiveDivisions] #
Real PositiveDivisions Source #
Methods toRational :: PositiveDivisions -> Rational #
RealFrac PositiveDivisions Source #
Methods properFraction :: Integral b => PositiveDivisions -> (b, PositiveDivisions) # truncate :: Integral b => PositiveDivisions -> b # round :: Integral b => PositiveDivisions -> b # ceiling :: Integral b => PositiveDivisions -> b # floor :: Integral b => PositiveDivisions -> b #
Show PositiveDivisions Source #
Methods showsPrec :: Int -> PositiveDivisions -> ShowS # show :: PositiveDivisions -> String # showList :: [PositiveDivisions] -> ShowS #
Generic PositiveDivisions Source #
Associated Types type Rep PositiveDivisions :: * -> * # Methods from :: PositiveDivisions -> Rep PositiveDivisions x # to :: Rep PositiveDivisions x -> PositiveDivisions #
EmitXml PositiveDivisions Source #
Methods emitXml :: PositiveDivisions -> XmlRep Source #
type Rep PositiveDivisions Source #
type Rep PositiveDivisions = D1 * (MetaData "PositiveDivisions" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "PositiveDivisions" PrefixI True) (S1 * (MetaSel (Just Symbol "positiveDivisions") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Divisions)))

parsePositiveDivisions :: String -> XParse PositiveDivisions Source #

data PositiveIntegerOrEmpty Source #

positive-integer-or-empty (simple)

The positive-integer-or-empty values can be either a positive integer or an empty string.

Constructors

PositiveIntegerOrEmptyPositiveInteger
Fields positiveIntegerOrEmpty1 :: PositiveInteger
PositiveIntegerOrEmptyPositiveIntegerOrEmpty
Fields positiveIntegerOrEmpty2 :: SumPositiveIntegerOrEmpty

Instances

Eq PositiveIntegerOrEmpty Source #
Methods (==) :: PositiveIntegerOrEmpty -> PositiveIntegerOrEmpty -> Bool # (/=) :: PositiveIntegerOrEmpty -> PositiveIntegerOrEmpty -> Bool #
Show PositiveIntegerOrEmpty Source #
Methods showsPrec :: Int -> PositiveIntegerOrEmpty -> ShowS # show :: PositiveIntegerOrEmpty -> String # showList :: [PositiveIntegerOrEmpty] -> ShowS #
Generic PositiveIntegerOrEmpty Source #
Associated Types type Rep PositiveIntegerOrEmpty :: * -> * # Methods from :: PositiveIntegerOrEmpty -> Rep PositiveIntegerOrEmpty x # to :: Rep PositiveIntegerOrEmpty x -> PositiveIntegerOrEmpty #
EmitXml PositiveIntegerOrEmpty Source #
Methods emitXml :: PositiveIntegerOrEmpty -> XmlRep Source #
type Rep PositiveIntegerOrEmpty Source #
type Rep PositiveIntegerOrEmpty = D1 * (MetaData "PositiveIntegerOrEmpty" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "PositiveIntegerOrEmptyPositiveInteger" PrefixI True) (S1 * (MetaSel (Just Symbol "positiveIntegerOrEmpty1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveInteger))) (C1 * (MetaCons "PositiveIntegerOrEmptyPositiveIntegerOrEmpty" PrefixI True) (S1 * (MetaSel (Just Symbol "positiveIntegerOrEmpty2") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * SumPositiveIntegerOrEmpty))))

parsePositiveIntegerOrEmpty :: String -> XParse PositiveIntegerOrEmpty Source #

newtype PositiveInteger Source #

xs:positiveInteger (simple)

Constructors

PositiveInteger
Fields positiveInteger :: NonNegativeInteger

Instances

Bounded PositiveInteger Source #
Methods minBound :: PositiveInteger # maxBound :: PositiveInteger #
Enum PositiveInteger Source #
Methods succ :: PositiveInteger -> PositiveInteger # pred :: PositiveInteger -> PositiveInteger # toEnum :: Int -> PositiveInteger # fromEnum :: PositiveInteger -> Int # enumFrom :: PositiveInteger -> [PositiveInteger] # enumFromThen :: PositiveInteger -> PositiveInteger -> [PositiveInteger] # enumFromTo :: PositiveInteger -> PositiveInteger -> [PositiveInteger] # enumFromThenTo :: PositiveInteger -> PositiveInteger -> PositiveInteger -> [PositiveInteger] #
Eq PositiveInteger Source #
Methods (==) :: PositiveInteger -> PositiveInteger -> Bool # (/=) :: PositiveInteger -> PositiveInteger -> Bool #
Integral PositiveInteger Source #
Methods quot :: PositiveInteger -> PositiveInteger -> PositiveInteger # rem :: PositiveInteger -> PositiveInteger -> PositiveInteger # div :: PositiveInteger -> PositiveInteger -> PositiveInteger # mod :: PositiveInteger -> PositiveInteger -> PositiveInteger # quotRem :: PositiveInteger -> PositiveInteger -> (PositiveInteger, PositiveInteger) # divMod :: PositiveInteger -> PositiveInteger -> (PositiveInteger, PositiveInteger) # toInteger :: PositiveInteger -> Integer #
Num PositiveInteger Source #
Methods (+) :: PositiveInteger -> PositiveInteger -> PositiveInteger # (-) :: PositiveInteger -> PositiveInteger -> PositiveInteger # (*) :: PositiveInteger -> PositiveInteger -> PositiveInteger # negate :: PositiveInteger -> PositiveInteger # abs :: PositiveInteger -> PositiveInteger # signum :: PositiveInteger -> PositiveInteger # fromInteger :: Integer -> PositiveInteger #
Ord PositiveInteger Source #
Methods compare :: PositiveInteger -> PositiveInteger -> Ordering # (<) :: PositiveInteger -> PositiveInteger -> Bool # (<=) :: PositiveInteger -> PositiveInteger -> Bool # (>) :: PositiveInteger -> PositiveInteger -> Bool # (>=) :: PositiveInteger -> PositiveInteger -> Bool # max :: PositiveInteger -> PositiveInteger -> PositiveInteger # min :: PositiveInteger -> PositiveInteger -> PositiveInteger #
Read PositiveInteger Source #
Methods readsPrec :: Int -> ReadS PositiveInteger # readList :: ReadS [PositiveInteger] # readPrec :: ReadPrec PositiveInteger # readListPrec :: ReadPrec [PositiveInteger] #
Real PositiveInteger Source #
Methods toRational :: PositiveInteger -> Rational #
Show PositiveInteger Source #
Methods showsPrec :: Int -> PositiveInteger -> ShowS # show :: PositiveInteger -> String # showList :: [PositiveInteger] -> ShowS #
Generic PositiveInteger Source #
Associated Types type Rep PositiveInteger :: * -> * # Methods from :: PositiveInteger -> Rep PositiveInteger x # to :: Rep PositiveInteger x -> PositiveInteger #
EmitXml PositiveInteger Source #
Methods emitXml :: PositiveInteger -> XmlRep Source #
type Rep PositiveInteger Source #
type Rep PositiveInteger = D1 * (MetaData "PositiveInteger" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "PositiveInteger" PrefixI True) (S1 * (MetaSel (Just Symbol "positiveInteger") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NonNegativeInteger)))

parsePositiveInteger :: String -> XParse PositiveInteger Source #

data RehearsalEnclosure Source #

rehearsal-enclosure (simple)

The rehearsal-enclosure type describes the shape and presence / absence of an enclosure around rehearsal text.

Constructors

RehearsalEnclosureSquare	square
RehearsalEnclosureCircle	circle
RehearsalEnclosureNone	none

Instances

Bounded RehearsalEnclosure Source #
Methods minBound :: RehearsalEnclosure # maxBound :: RehearsalEnclosure #
Enum RehearsalEnclosure Source #
Methods succ :: RehearsalEnclosure -> RehearsalEnclosure # pred :: RehearsalEnclosure -> RehearsalEnclosure # toEnum :: Int -> RehearsalEnclosure # fromEnum :: RehearsalEnclosure -> Int # enumFrom :: RehearsalEnclosure -> [RehearsalEnclosure] # enumFromThen :: RehearsalEnclosure -> RehearsalEnclosure -> [RehearsalEnclosure] # enumFromTo :: RehearsalEnclosure -> RehearsalEnclosure -> [RehearsalEnclosure] # enumFromThenTo :: RehearsalEnclosure -> RehearsalEnclosure -> RehearsalEnclosure -> [RehearsalEnclosure] #
Eq RehearsalEnclosure Source #
Methods (==) :: RehearsalEnclosure -> RehearsalEnclosure -> Bool # (/=) :: RehearsalEnclosure -> RehearsalEnclosure -> Bool #
Ord RehearsalEnclosure Source #
Methods compare :: RehearsalEnclosure -> RehearsalEnclosure -> Ordering # (<) :: RehearsalEnclosure -> RehearsalEnclosure -> Bool # (<=) :: RehearsalEnclosure -> RehearsalEnclosure -> Bool # (>) :: RehearsalEnclosure -> RehearsalEnclosure -> Bool # (>=) :: RehearsalEnclosure -> RehearsalEnclosure -> Bool # max :: RehearsalEnclosure -> RehearsalEnclosure -> RehearsalEnclosure # min :: RehearsalEnclosure -> RehearsalEnclosure -> RehearsalEnclosure #
Show RehearsalEnclosure Source #
Methods showsPrec :: Int -> RehearsalEnclosure -> ShowS # show :: RehearsalEnclosure -> String # showList :: [RehearsalEnclosure] -> ShowS #
Generic RehearsalEnclosure Source #
Associated Types type Rep RehearsalEnclosure :: * -> * # Methods from :: RehearsalEnclosure -> Rep RehearsalEnclosure x # to :: Rep RehearsalEnclosure x -> RehearsalEnclosure #
EmitXml RehearsalEnclosure Source #
Methods emitXml :: RehearsalEnclosure -> XmlRep Source #
type Rep RehearsalEnclosure Source #
type Rep RehearsalEnclosure = D1 * (MetaData "RehearsalEnclosure" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "RehearsalEnclosureSquare" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "RehearsalEnclosureCircle" PrefixI False) (U1 )) (C1 (MetaCons "RehearsalEnclosureNone" PrefixI False) (U1 *))))

parseRehearsalEnclosure :: String -> XParse RehearsalEnclosure Source #

data RightLeftMiddle Source #

right-left-middle (simple)

The right-left-middle type is used to specify barline location.

Constructors

RightLeftMiddleRight	right
RightLeftMiddleLeft	left
RightLeftMiddleMiddle	middle

Instances

Bounded RightLeftMiddle Source #
Methods minBound :: RightLeftMiddle # maxBound :: RightLeftMiddle #
Enum RightLeftMiddle Source #
Methods succ :: RightLeftMiddle -> RightLeftMiddle # pred :: RightLeftMiddle -> RightLeftMiddle # toEnum :: Int -> RightLeftMiddle # fromEnum :: RightLeftMiddle -> Int # enumFrom :: RightLeftMiddle -> [RightLeftMiddle] # enumFromThen :: RightLeftMiddle -> RightLeftMiddle -> [RightLeftMiddle] # enumFromTo :: RightLeftMiddle -> RightLeftMiddle -> [RightLeftMiddle] # enumFromThenTo :: RightLeftMiddle -> RightLeftMiddle -> RightLeftMiddle -> [RightLeftMiddle] #
Eq RightLeftMiddle Source #
Methods (==) :: RightLeftMiddle -> RightLeftMiddle -> Bool # (/=) :: RightLeftMiddle -> RightLeftMiddle -> Bool #
Ord RightLeftMiddle Source #
Methods compare :: RightLeftMiddle -> RightLeftMiddle -> Ordering # (<) :: RightLeftMiddle -> RightLeftMiddle -> Bool # (<=) :: RightLeftMiddle -> RightLeftMiddle -> Bool # (>) :: RightLeftMiddle -> RightLeftMiddle -> Bool # (>=) :: RightLeftMiddle -> RightLeftMiddle -> Bool # max :: RightLeftMiddle -> RightLeftMiddle -> RightLeftMiddle # min :: RightLeftMiddle -> RightLeftMiddle -> RightLeftMiddle #
Show RightLeftMiddle Source #
Methods showsPrec :: Int -> RightLeftMiddle -> ShowS # show :: RightLeftMiddle -> String # showList :: [RightLeftMiddle] -> ShowS #
Generic RightLeftMiddle Source #
Associated Types type Rep RightLeftMiddle :: * -> * # Methods from :: RightLeftMiddle -> Rep RightLeftMiddle x # to :: Rep RightLeftMiddle x -> RightLeftMiddle #
EmitXml RightLeftMiddle Source #
Methods emitXml :: RightLeftMiddle -> XmlRep Source #
type Rep RightLeftMiddle Source #
type Rep RightLeftMiddle = D1 * (MetaData "RightLeftMiddle" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "RightLeftMiddleRight" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "RightLeftMiddleLeft" PrefixI False) (U1 )) (C1 (MetaCons "RightLeftMiddleMiddle" PrefixI False) (U1 *))))

parseRightLeftMiddle :: String -> XParse RightLeftMiddle Source #

newtype RotationDegrees Source #

rotation-degrees (simple)

The rotation-degrees type specifies rotation, pan, and elevation values in degrees. Values range from -180 to 180.

Constructors

RotationDegrees
Fields rotationDegrees :: Decimal

Instances

Eq RotationDegrees Source #
Methods (==) :: RotationDegrees -> RotationDegrees -> Bool # (/=) :: RotationDegrees -> RotationDegrees -> Bool #
Fractional RotationDegrees Source #
Methods (/) :: RotationDegrees -> RotationDegrees -> RotationDegrees # recip :: RotationDegrees -> RotationDegrees # fromRational :: Rational -> RotationDegrees #
Num RotationDegrees Source #
Methods (+) :: RotationDegrees -> RotationDegrees -> RotationDegrees # (-) :: RotationDegrees -> RotationDegrees -> RotationDegrees # (*) :: RotationDegrees -> RotationDegrees -> RotationDegrees # negate :: RotationDegrees -> RotationDegrees # abs :: RotationDegrees -> RotationDegrees # signum :: RotationDegrees -> RotationDegrees # fromInteger :: Integer -> RotationDegrees #
Ord RotationDegrees Source #
Methods compare :: RotationDegrees -> RotationDegrees -> Ordering # (<) :: RotationDegrees -> RotationDegrees -> Bool # (<=) :: RotationDegrees -> RotationDegrees -> Bool # (>) :: RotationDegrees -> RotationDegrees -> Bool # (>=) :: RotationDegrees -> RotationDegrees -> Bool # max :: RotationDegrees -> RotationDegrees -> RotationDegrees # min :: RotationDegrees -> RotationDegrees -> RotationDegrees #
Read RotationDegrees Source #
Methods readsPrec :: Int -> ReadS RotationDegrees # readList :: ReadS [RotationDegrees] # readPrec :: ReadPrec RotationDegrees # readListPrec :: ReadPrec [RotationDegrees] #
Real RotationDegrees Source #
Methods toRational :: RotationDegrees -> Rational #
RealFrac RotationDegrees Source #
Methods properFraction :: Integral b => RotationDegrees -> (b, RotationDegrees) # truncate :: Integral b => RotationDegrees -> b # round :: Integral b => RotationDegrees -> b # ceiling :: Integral b => RotationDegrees -> b # floor :: Integral b => RotationDegrees -> b #
Show RotationDegrees Source #
Methods showsPrec :: Int -> RotationDegrees -> ShowS # show :: RotationDegrees -> String # showList :: [RotationDegrees] -> ShowS #
Generic RotationDegrees Source #
Associated Types type Rep RotationDegrees :: * -> * # Methods from :: RotationDegrees -> Rep RotationDegrees x # to :: Rep RotationDegrees x -> RotationDegrees #
EmitXml RotationDegrees Source #
Methods emitXml :: RotationDegrees -> XmlRep Source #
type Rep RotationDegrees Source #
type Rep RotationDegrees = D1 * (MetaData "RotationDegrees" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "RotationDegrees" PrefixI True) (S1 * (MetaSel (Just Symbol "rotationDegrees") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Decimal)))

parseRotationDegrees :: String -> XParse RotationDegrees Source #

newtype Semitones Source #

semitones (simple)

The semintones type is a number representing semitones, used for chromatic alteration. A value of -1 corresponds to a flat and a value of 1 to a sharp. Decimal values like 0.5 (quarter tone sharp) may be used for microtones.

Constructors

Semitones
Fields semitones :: Decimal

Instances

Eq Semitones Source #
Methods (==) :: Semitones -> Semitones -> Bool # (/=) :: Semitones -> Semitones -> Bool #
Fractional Semitones Source #
Methods (/) :: Semitones -> Semitones -> Semitones # recip :: Semitones -> Semitones # fromRational :: Rational -> Semitones #
Num Semitones Source #
Methods (+) :: Semitones -> Semitones -> Semitones # (-) :: Semitones -> Semitones -> Semitones # (*) :: Semitones -> Semitones -> Semitones # negate :: Semitones -> Semitones # abs :: Semitones -> Semitones # signum :: Semitones -> Semitones # fromInteger :: Integer -> Semitones #
Ord Semitones Source #
Methods compare :: Semitones -> Semitones -> Ordering # (<) :: Semitones -> Semitones -> Bool # (<=) :: Semitones -> Semitones -> Bool # (>) :: Semitones -> Semitones -> Bool # (>=) :: Semitones -> Semitones -> Bool # max :: Semitones -> Semitones -> Semitones # min :: Semitones -> Semitones -> Semitones #
Read Semitones Source #
Methods readsPrec :: Int -> ReadS Semitones # readList :: ReadS [Semitones] # readPrec :: ReadPrec Semitones # readListPrec :: ReadPrec [Semitones] #
Real Semitones Source #
Methods toRational :: Semitones -> Rational #
RealFrac Semitones Source #
Methods properFraction :: Integral b => Semitones -> (b, Semitones) # truncate :: Integral b => Semitones -> b # round :: Integral b => Semitones -> b # ceiling :: Integral b => Semitones -> b # floor :: Integral b => Semitones -> b #
Show Semitones Source #
Methods showsPrec :: Int -> Semitones -> ShowS # show :: Semitones -> String # showList :: [Semitones] -> ShowS #
Generic Semitones Source #
Associated Types type Rep Semitones :: * -> * # Methods from :: Semitones -> Rep Semitones x # to :: Rep Semitones x -> Semitones #
EmitXml Semitones Source #
Methods emitXml :: Semitones -> XmlRep Source #
type Rep Semitones Source #
type Rep Semitones = D1 * (MetaData "Semitones" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "Semitones" PrefixI True) (S1 * (MetaSel (Just Symbol "semitones") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Decimal)))

parseSemitones :: String -> XParse Semitones Source #

data SmpShow Source #

xlink:show (simple)

Constructors

ShowNew	new
ShowReplace	replace
ShowEmbed	embed
ShowOther	other
ShowNone	none

Instances

Bounded SmpShow Source #
Methods minBound :: SmpShow # maxBound :: SmpShow #
Enum SmpShow Source #
Methods succ :: SmpShow -> SmpShow # pred :: SmpShow -> SmpShow # toEnum :: Int -> SmpShow # fromEnum :: SmpShow -> Int # enumFrom :: SmpShow -> [SmpShow] # enumFromThen :: SmpShow -> SmpShow -> [SmpShow] # enumFromTo :: SmpShow -> SmpShow -> [SmpShow] # enumFromThenTo :: SmpShow -> SmpShow -> SmpShow -> [SmpShow] #
Eq SmpShow Source #
Methods (==) :: SmpShow -> SmpShow -> Bool # (/=) :: SmpShow -> SmpShow -> Bool #
Ord SmpShow Source #
Methods compare :: SmpShow -> SmpShow -> Ordering # (<) :: SmpShow -> SmpShow -> Bool # (<=) :: SmpShow -> SmpShow -> Bool # (>) :: SmpShow -> SmpShow -> Bool # (>=) :: SmpShow -> SmpShow -> Bool # max :: SmpShow -> SmpShow -> SmpShow # min :: SmpShow -> SmpShow -> SmpShow #
Show SmpShow Source #
Methods showsPrec :: Int -> SmpShow -> ShowS # show :: SmpShow -> String # showList :: [SmpShow] -> ShowS #
Generic SmpShow Source #
Associated Types type Rep SmpShow :: * -> * # Methods from :: SmpShow -> Rep SmpShow x # to :: Rep SmpShow x -> SmpShow #
EmitXml SmpShow Source #
Methods emitXml :: SmpShow -> XmlRep Source #
type Rep SmpShow Source #
type Rep SmpShow = D1 * (MetaData "SmpShow" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "ShowNew" PrefixI False) (U1 )) (C1 (MetaCons "ShowReplace" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "ShowEmbed" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "ShowOther" PrefixI False) (U1 )) (C1 (MetaCons "ShowNone" PrefixI False) (U1 *)))))

parseSmpShow :: String -> XParse SmpShow Source #

data ShowFrets Source #

show-frets (simple)

The show-frets type indicates whether to show tablature frets as numbers (0, 1, 2) or letters (a, b, c). The default choice is numbers.

Constructors

ShowFretsNumbers	numbers
ShowFretsLetters	letters

Instances

Bounded ShowFrets Source #
Methods minBound :: ShowFrets # maxBound :: ShowFrets #
Enum ShowFrets Source #
Methods succ :: ShowFrets -> ShowFrets # pred :: ShowFrets -> ShowFrets # toEnum :: Int -> ShowFrets # fromEnum :: ShowFrets -> Int # enumFrom :: ShowFrets -> [ShowFrets] # enumFromThen :: ShowFrets -> ShowFrets -> [ShowFrets] # enumFromTo :: ShowFrets -> ShowFrets -> [ShowFrets] # enumFromThenTo :: ShowFrets -> ShowFrets -> ShowFrets -> [ShowFrets] #
Eq ShowFrets Source #
Methods (==) :: ShowFrets -> ShowFrets -> Bool # (/=) :: ShowFrets -> ShowFrets -> Bool #
Ord ShowFrets Source #
Methods compare :: ShowFrets -> ShowFrets -> Ordering # (<) :: ShowFrets -> ShowFrets -> Bool # (<=) :: ShowFrets -> ShowFrets -> Bool # (>) :: ShowFrets -> ShowFrets -> Bool # (>=) :: ShowFrets -> ShowFrets -> Bool # max :: ShowFrets -> ShowFrets -> ShowFrets # min :: ShowFrets -> ShowFrets -> ShowFrets #
Show ShowFrets Source #
Methods showsPrec :: Int -> ShowFrets -> ShowS # show :: ShowFrets -> String # showList :: [ShowFrets] -> ShowS #
Generic ShowFrets Source #
Associated Types type Rep ShowFrets :: * -> * # Methods from :: ShowFrets -> Rep ShowFrets x # to :: Rep ShowFrets x -> ShowFrets #
EmitXml ShowFrets Source #
Methods emitXml :: ShowFrets -> XmlRep Source #
type Rep ShowFrets Source #
type Rep ShowFrets = D1 * (MetaData "ShowFrets" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "ShowFretsNumbers" PrefixI False) (U1 )) (C1 (MetaCons "ShowFretsLetters" PrefixI False) (U1 *)))

parseShowFrets :: String -> XParse ShowFrets Source #

data ShowTuplet Source #

show-tuplet (simple)

The show-tuplet type indicates whether to show a part of a tuplet relating to the tuplet-actual element, both the tuplet-actual and tuplet-normal elements, or neither.

Constructors

ShowTupletActual	actual
ShowTupletBoth	both
ShowTupletNone	none

Instances

Bounded ShowTuplet Source #
Methods minBound :: ShowTuplet # maxBound :: ShowTuplet #
Enum ShowTuplet Source #
Methods succ :: ShowTuplet -> ShowTuplet # pred :: ShowTuplet -> ShowTuplet # toEnum :: Int -> ShowTuplet # fromEnum :: ShowTuplet -> Int # enumFrom :: ShowTuplet -> [ShowTuplet] # enumFromThen :: ShowTuplet -> ShowTuplet -> [ShowTuplet] # enumFromTo :: ShowTuplet -> ShowTuplet -> [ShowTuplet] # enumFromThenTo :: ShowTuplet -> ShowTuplet -> ShowTuplet -> [ShowTuplet] #
Eq ShowTuplet Source #
Methods (==) :: ShowTuplet -> ShowTuplet -> Bool # (/=) :: ShowTuplet -> ShowTuplet -> Bool #
Ord ShowTuplet Source #
Methods compare :: ShowTuplet -> ShowTuplet -> Ordering # (<) :: ShowTuplet -> ShowTuplet -> Bool # (<=) :: ShowTuplet -> ShowTuplet -> Bool # (>) :: ShowTuplet -> ShowTuplet -> Bool # (>=) :: ShowTuplet -> ShowTuplet -> Bool # max :: ShowTuplet -> ShowTuplet -> ShowTuplet # min :: ShowTuplet -> ShowTuplet -> ShowTuplet #
Show ShowTuplet Source #
Methods showsPrec :: Int -> ShowTuplet -> ShowS # show :: ShowTuplet -> String # showList :: [ShowTuplet] -> ShowS #
Generic ShowTuplet Source #
Associated Types type Rep ShowTuplet :: * -> * # Methods from :: ShowTuplet -> Rep ShowTuplet x # to :: Rep ShowTuplet x -> ShowTuplet #
EmitXml ShowTuplet Source #
Methods emitXml :: ShowTuplet -> XmlRep Source #
type Rep ShowTuplet Source #
type Rep ShowTuplet = D1 * (MetaData "ShowTuplet" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "ShowTupletActual" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "ShowTupletBoth" PrefixI False) (U1 )) (C1 (MetaCons "ShowTupletNone" PrefixI False) (U1 *))))

parseShowTuplet :: String -> XParse ShowTuplet Source #

newtype StaffLine Source #

staff-line (simple)

The staff-line type indicates the line on a given staff. Staff lines are numbered from bottom to top, with 1 being the bottom line on a staff. Staff line values can be used to specify positions outside the staff, such as a C clef positioned in the middle of a grand staff.

Constructors

StaffLine
Fields staffLine :: Int

Instances

Bounded StaffLine Source #
Methods minBound :: StaffLine # maxBound :: StaffLine #
Enum StaffLine Source #
Methods succ :: StaffLine -> StaffLine # pred :: StaffLine -> StaffLine # toEnum :: Int -> StaffLine # fromEnum :: StaffLine -> Int # enumFrom :: StaffLine -> [StaffLine] # enumFromThen :: StaffLine -> StaffLine -> [StaffLine] # enumFromTo :: StaffLine -> StaffLine -> [StaffLine] # enumFromThenTo :: StaffLine -> StaffLine -> StaffLine -> [StaffLine] #
Eq StaffLine Source #
Methods (==) :: StaffLine -> StaffLine -> Bool # (/=) :: StaffLine -> StaffLine -> Bool #
Integral StaffLine Source #
Methods quot :: StaffLine -> StaffLine -> StaffLine # rem :: StaffLine -> StaffLine -> StaffLine # div :: StaffLine -> StaffLine -> StaffLine # mod :: StaffLine -> StaffLine -> StaffLine # quotRem :: StaffLine -> StaffLine -> (StaffLine, StaffLine) # divMod :: StaffLine -> StaffLine -> (StaffLine, StaffLine) # toInteger :: StaffLine -> Integer #
Num StaffLine Source #
Methods (+) :: StaffLine -> StaffLine -> StaffLine # (-) :: StaffLine -> StaffLine -> StaffLine # (*) :: StaffLine -> StaffLine -> StaffLine # negate :: StaffLine -> StaffLine # abs :: StaffLine -> StaffLine # signum :: StaffLine -> StaffLine # fromInteger :: Integer -> StaffLine #
Ord StaffLine Source #
Methods compare :: StaffLine -> StaffLine -> Ordering # (<) :: StaffLine -> StaffLine -> Bool # (<=) :: StaffLine -> StaffLine -> Bool # (>) :: StaffLine -> StaffLine -> Bool # (>=) :: StaffLine -> StaffLine -> Bool # max :: StaffLine -> StaffLine -> StaffLine # min :: StaffLine -> StaffLine -> StaffLine #
Read StaffLine Source #
Methods readsPrec :: Int -> ReadS StaffLine # readList :: ReadS [StaffLine] # readPrec :: ReadPrec StaffLine # readListPrec :: ReadPrec [StaffLine] #
Real StaffLine Source #
Methods toRational :: StaffLine -> Rational #
Show StaffLine Source #
Methods showsPrec :: Int -> StaffLine -> ShowS # show :: StaffLine -> String # showList :: [StaffLine] -> ShowS #
Generic StaffLine Source #
Associated Types type Rep StaffLine :: * -> * # Methods from :: StaffLine -> Rep StaffLine x # to :: Rep StaffLine x -> StaffLine #
EmitXml StaffLine Source #
Methods emitXml :: StaffLine -> XmlRep Source #
type Rep StaffLine Source #
type Rep StaffLine = D1 * (MetaData "StaffLine" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "StaffLine" PrefixI True) (S1 * (MetaSel (Just Symbol "staffLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Int)))

parseStaffLine :: String -> XParse StaffLine Source #

newtype StaffNumber Source #

staff-number (simple)

The staff-number type indicates staff numbers within a multi-staff part. Staves are numbered from top to bottom, with 1 being the top staff on a part.

Constructors

StaffNumber
Fields staffNumber :: PositiveInteger

Instances

Bounded StaffNumber Source #
Methods minBound :: StaffNumber # maxBound :: StaffNumber #
Enum StaffNumber Source #
Methods succ :: StaffNumber -> StaffNumber # pred :: StaffNumber -> StaffNumber # toEnum :: Int -> StaffNumber # fromEnum :: StaffNumber -> Int # enumFrom :: StaffNumber -> [StaffNumber] # enumFromThen :: StaffNumber -> StaffNumber -> [StaffNumber] # enumFromTo :: StaffNumber -> StaffNumber -> [StaffNumber] # enumFromThenTo :: StaffNumber -> StaffNumber -> StaffNumber -> [StaffNumber] #
Eq StaffNumber Source #
Methods (==) :: StaffNumber -> StaffNumber -> Bool # (/=) :: StaffNumber -> StaffNumber -> Bool #
Integral StaffNumber Source #
Methods quot :: StaffNumber -> StaffNumber -> StaffNumber # rem :: StaffNumber -> StaffNumber -> StaffNumber # div :: StaffNumber -> StaffNumber -> StaffNumber # mod :: StaffNumber -> StaffNumber -> StaffNumber # quotRem :: StaffNumber -> StaffNumber -> (StaffNumber, StaffNumber) # divMod :: StaffNumber -> StaffNumber -> (StaffNumber, StaffNumber) # toInteger :: StaffNumber -> Integer #
Num StaffNumber Source #
Methods (+) :: StaffNumber -> StaffNumber -> StaffNumber # (-) :: StaffNumber -> StaffNumber -> StaffNumber # (*) :: StaffNumber -> StaffNumber -> StaffNumber # negate :: StaffNumber -> StaffNumber # abs :: StaffNumber -> StaffNumber # signum :: StaffNumber -> StaffNumber # fromInteger :: Integer -> StaffNumber #
Ord StaffNumber Source #
Methods compare :: StaffNumber -> StaffNumber -> Ordering # (<) :: StaffNumber -> StaffNumber -> Bool # (<=) :: StaffNumber -> StaffNumber -> Bool # (>) :: StaffNumber -> StaffNumber -> Bool # (>=) :: StaffNumber -> StaffNumber -> Bool # max :: StaffNumber -> StaffNumber -> StaffNumber # min :: StaffNumber -> StaffNumber -> StaffNumber #
Read StaffNumber Source #
Methods readsPrec :: Int -> ReadS StaffNumber # readList :: ReadS [StaffNumber] # readPrec :: ReadPrec StaffNumber # readListPrec :: ReadPrec [StaffNumber] #
Real StaffNumber Source #
Methods toRational :: StaffNumber -> Rational #
Show StaffNumber Source #
Methods showsPrec :: Int -> StaffNumber -> ShowS # show :: StaffNumber -> String # showList :: [StaffNumber] -> ShowS #
Generic StaffNumber Source #
Associated Types type Rep StaffNumber :: * -> * # Methods from :: StaffNumber -> Rep StaffNumber x # to :: Rep StaffNumber x -> StaffNumber #
EmitXml StaffNumber Source #
Methods emitXml :: StaffNumber -> XmlRep Source #
type Rep StaffNumber Source #
type Rep StaffNumber = D1 * (MetaData "StaffNumber" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "StaffNumber" PrefixI True) (S1 * (MetaSel (Just Symbol "staffNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveInteger)))

parseStaffNumber :: String -> XParse StaffNumber Source #

data StaffType Source #

staff-type (simple)

The staff-type value can be ossia, cue, editorial, regular, or alternate. An alternate staff indicates one that shares the same musical data as the prior staff, but displayed differently (e.g., treble and bass clef, standard notation and tab).

Constructors

StaffTypeOssia	ossia
StaffTypeCue	cue
StaffTypeEditorial	editorial
StaffTypeRegular	regular
StaffTypeAlternate	alternate

Instances

Bounded StaffType Source #
Methods minBound :: StaffType # maxBound :: StaffType #
Enum StaffType Source #
Methods succ :: StaffType -> StaffType # pred :: StaffType -> StaffType # toEnum :: Int -> StaffType # fromEnum :: StaffType -> Int # enumFrom :: StaffType -> [StaffType] # enumFromThen :: StaffType -> StaffType -> [StaffType] # enumFromTo :: StaffType -> StaffType -> [StaffType] # enumFromThenTo :: StaffType -> StaffType -> StaffType -> [StaffType] #
Eq StaffType Source #
Methods (==) :: StaffType -> StaffType -> Bool # (/=) :: StaffType -> StaffType -> Bool #
Ord StaffType Source #
Methods compare :: StaffType -> StaffType -> Ordering # (<) :: StaffType -> StaffType -> Bool # (<=) :: StaffType -> StaffType -> Bool # (>) :: StaffType -> StaffType -> Bool # (>=) :: StaffType -> StaffType -> Bool # max :: StaffType -> StaffType -> StaffType # min :: StaffType -> StaffType -> StaffType #
Show StaffType Source #
Methods showsPrec :: Int -> StaffType -> ShowS # show :: StaffType -> String # showList :: [StaffType] -> ShowS #
Generic StaffType Source #
Associated Types type Rep StaffType :: * -> * # Methods from :: StaffType -> Rep StaffType x # to :: Rep StaffType x -> StaffType #
EmitXml StaffType Source #
Methods emitXml :: StaffType -> XmlRep Source #
type Rep StaffType Source #
type Rep StaffType = D1 * (MetaData "StaffType" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "StaffTypeOssia" PrefixI False) (U1 )) (C1 (MetaCons "StaffTypeCue" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "StaffTypeEditorial" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "StaffTypeRegular" PrefixI False) (U1 )) (C1 (MetaCons "StaffTypeAlternate" PrefixI False) (U1 *)))))

parseStaffType :: String -> XParse StaffType Source #

data StartNote Source #

start-note (simple)

The start-note type describes the starting note of trills and mordents for playback, relative to the current note.

Constructors

StartNoteUpper	upper
StartNoteMain	main
StartNoteBelow	below

Instances

Bounded StartNote Source #
Methods minBound :: StartNote # maxBound :: StartNote #
Enum StartNote Source #
Methods succ :: StartNote -> StartNote # pred :: StartNote -> StartNote # toEnum :: Int -> StartNote # fromEnum :: StartNote -> Int # enumFrom :: StartNote -> [StartNote] # enumFromThen :: StartNote -> StartNote -> [StartNote] # enumFromTo :: StartNote -> StartNote -> [StartNote] # enumFromThenTo :: StartNote -> StartNote -> StartNote -> [StartNote] #
Eq StartNote Source #
Methods (==) :: StartNote -> StartNote -> Bool # (/=) :: StartNote -> StartNote -> Bool #
Ord StartNote Source #
Methods compare :: StartNote -> StartNote -> Ordering # (<) :: StartNote -> StartNote -> Bool # (<=) :: StartNote -> StartNote -> Bool # (>) :: StartNote -> StartNote -> Bool # (>=) :: StartNote -> StartNote -> Bool # max :: StartNote -> StartNote -> StartNote # min :: StartNote -> StartNote -> StartNote #
Show StartNote Source #
Methods showsPrec :: Int -> StartNote -> ShowS # show :: StartNote -> String # showList :: [StartNote] -> ShowS #
Generic StartNote Source #
Associated Types type Rep StartNote :: * -> * # Methods from :: StartNote -> Rep StartNote x # to :: Rep StartNote x -> StartNote #
EmitXml StartNote Source #
Methods emitXml :: StartNote -> XmlRep Source #
type Rep StartNote Source #
type Rep StartNote = D1 * (MetaData "StartNote" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "StartNoteUpper" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "StartNoteMain" PrefixI False) (U1 )) (C1 (MetaCons "StartNoteBelow" PrefixI False) (U1 *))))

parseStartNote :: String -> XParse StartNote Source #

data StartStop Source #

start-stop (simple)

The start-stop type is used for an attribute of musical elements that can either start or stop, such as tuplets, wedges, and lines.

Constructors

StartStopStart	start
StartStopStop	stop

Instances

Bounded StartStop Source #
Methods minBound :: StartStop # maxBound :: StartStop #
Enum StartStop Source #
Methods succ :: StartStop -> StartStop # pred :: StartStop -> StartStop # toEnum :: Int -> StartStop # fromEnum :: StartStop -> Int # enumFrom :: StartStop -> [StartStop] # enumFromThen :: StartStop -> StartStop -> [StartStop] # enumFromTo :: StartStop -> StartStop -> [StartStop] # enumFromThenTo :: StartStop -> StartStop -> StartStop -> [StartStop] #
Eq StartStop Source #
Methods (==) :: StartStop -> StartStop -> Bool # (/=) :: StartStop -> StartStop -> Bool #
Ord StartStop Source #
Methods compare :: StartStop -> StartStop -> Ordering # (<) :: StartStop -> StartStop -> Bool # (<=) :: StartStop -> StartStop -> Bool # (>) :: StartStop -> StartStop -> Bool # (>=) :: StartStop -> StartStop -> Bool # max :: StartStop -> StartStop -> StartStop # min :: StartStop -> StartStop -> StartStop #
Show StartStop Source #
Methods showsPrec :: Int -> StartStop -> ShowS # show :: StartStop -> String # showList :: [StartStop] -> ShowS #
Generic StartStop Source #
Associated Types type Rep StartStop :: * -> * # Methods from :: StartStop -> Rep StartStop x # to :: Rep StartStop x -> StartStop #
EmitXml StartStop Source #
Methods emitXml :: StartStop -> XmlRep Source #
type Rep StartStop Source #
type Rep StartStop = D1 * (MetaData "StartStop" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "StartStopStart" PrefixI False) (U1 )) (C1 (MetaCons "StartStopStop" PrefixI False) (U1 *)))

parseStartStop :: String -> XParse StartStop Source #

data StartStopChange Source #

start-stop-change (simple)

The start-stop-change type is used to distinguish types of pedal directions.

Constructors

StartStopChangeStart	start
StartStopChangeStop	stop
StartStopChangeChange	change

Instances

Bounded StartStopChange Source #
Methods minBound :: StartStopChange # maxBound :: StartStopChange #
Enum StartStopChange Source #
Methods succ :: StartStopChange -> StartStopChange # pred :: StartStopChange -> StartStopChange # toEnum :: Int -> StartStopChange # fromEnum :: StartStopChange -> Int # enumFrom :: StartStopChange -> [StartStopChange] # enumFromThen :: StartStopChange -> StartStopChange -> [StartStopChange] # enumFromTo :: StartStopChange -> StartStopChange -> [StartStopChange] # enumFromThenTo :: StartStopChange -> StartStopChange -> StartStopChange -> [StartStopChange] #
Eq StartStopChange Source #
Methods (==) :: StartStopChange -> StartStopChange -> Bool # (/=) :: StartStopChange -> StartStopChange -> Bool #
Ord StartStopChange Source #
Methods compare :: StartStopChange -> StartStopChange -> Ordering # (<) :: StartStopChange -> StartStopChange -> Bool # (<=) :: StartStopChange -> StartStopChange -> Bool # (>) :: StartStopChange -> StartStopChange -> Bool # (>=) :: StartStopChange -> StartStopChange -> Bool # max :: StartStopChange -> StartStopChange -> StartStopChange # min :: StartStopChange -> StartStopChange -> StartStopChange #
Show StartStopChange Source #
Methods showsPrec :: Int -> StartStopChange -> ShowS # show :: StartStopChange -> String # showList :: [StartStopChange] -> ShowS #
Generic StartStopChange Source #
Associated Types type Rep StartStopChange :: * -> * # Methods from :: StartStopChange -> Rep StartStopChange x # to :: Rep StartStopChange x -> StartStopChange #
EmitXml StartStopChange Source #
Methods emitXml :: StartStopChange -> XmlRep Source #
type Rep StartStopChange Source #
type Rep StartStopChange = D1 * (MetaData "StartStopChange" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "StartStopChangeStart" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "StartStopChangeStop" PrefixI False) (U1 )) (C1 (MetaCons "StartStopChangeChange" PrefixI False) (U1 *))))

parseStartStopChange :: String -> XParse StartStopChange Source #

data StartStopContinue Source #

start-stop-continue (simple)

The start-stop-continue type is used for an attribute of musical elements that can either start or stop, but also need to refer to an intermediate point in the symbol, as for complex slurs.

Constructors

StartStopContinueStart	start
StartStopContinueStop	stop
StartStopContinueContinue	continue

Instances

Bounded StartStopContinue Source #
Methods minBound :: StartStopContinue # maxBound :: StartStopContinue #
Enum StartStopContinue Source #
Methods succ :: StartStopContinue -> StartStopContinue # pred :: StartStopContinue -> StartStopContinue # toEnum :: Int -> StartStopContinue # fromEnum :: StartStopContinue -> Int # enumFrom :: StartStopContinue -> [StartStopContinue] # enumFromThen :: StartStopContinue -> StartStopContinue -> [StartStopContinue] # enumFromTo :: StartStopContinue -> StartStopContinue -> [StartStopContinue] # enumFromThenTo :: StartStopContinue -> StartStopContinue -> StartStopContinue -> [StartStopContinue] #
Eq StartStopContinue Source #
Methods (==) :: StartStopContinue -> StartStopContinue -> Bool # (/=) :: StartStopContinue -> StartStopContinue -> Bool #
Ord StartStopContinue Source #
Methods compare :: StartStopContinue -> StartStopContinue -> Ordering # (<) :: StartStopContinue -> StartStopContinue -> Bool # (<=) :: StartStopContinue -> StartStopContinue -> Bool # (>) :: StartStopContinue -> StartStopContinue -> Bool # (>=) :: StartStopContinue -> StartStopContinue -> Bool # max :: StartStopContinue -> StartStopContinue -> StartStopContinue # min :: StartStopContinue -> StartStopContinue -> StartStopContinue #
Show StartStopContinue Source #
Methods showsPrec :: Int -> StartStopContinue -> ShowS # show :: StartStopContinue -> String # showList :: [StartStopContinue] -> ShowS #
Generic StartStopContinue Source #
Associated Types type Rep StartStopContinue :: * -> * # Methods from :: StartStopContinue -> Rep StartStopContinue x # to :: Rep StartStopContinue x -> StartStopContinue #
EmitXml StartStopContinue Source #
Methods emitXml :: StartStopContinue -> XmlRep Source #
type Rep StartStopContinue Source #
type Rep StartStopContinue = D1 * (MetaData "StartStopContinue" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "StartStopContinueStart" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "StartStopContinueStop" PrefixI False) (U1 )) (C1 (MetaCons "StartStopContinueContinue" PrefixI False) (U1 *))))

parseStartStopContinue :: String -> XParse StartStopContinue Source #

data StartStopDiscontinue Source #

start-stop-discontinue (simple)

The start-stop-discontinue type is used to specify ending types. Typically, the start type is associated with the left barline of the first measure in an ending. The stop and discontinue types are associated with the right barline of the last measure in an ending. Stop is used when the ending mark concludes with a downward jog, as is typical for first endings. Discontinue is used when there is no downward jog, as is typical for second endings that do not conclude a piece.

Constructors

StartStopDiscontinueStart	start
StartStopDiscontinueStop	stop
StartStopDiscontinueDiscontinue	discontinue

Instances

Bounded StartStopDiscontinue Source #
Methods minBound :: StartStopDiscontinue # maxBound :: StartStopDiscontinue #
Enum StartStopDiscontinue Source #
Methods succ :: StartStopDiscontinue -> StartStopDiscontinue # pred :: StartStopDiscontinue -> StartStopDiscontinue # toEnum :: Int -> StartStopDiscontinue # fromEnum :: StartStopDiscontinue -> Int # enumFrom :: StartStopDiscontinue -> [StartStopDiscontinue] # enumFromThen :: StartStopDiscontinue -> StartStopDiscontinue -> [StartStopDiscontinue] # enumFromTo :: StartStopDiscontinue -> StartStopDiscontinue -> [StartStopDiscontinue] # enumFromThenTo :: StartStopDiscontinue -> StartStopDiscontinue -> StartStopDiscontinue -> [StartStopDiscontinue] #
Eq StartStopDiscontinue Source #
Methods (==) :: StartStopDiscontinue -> StartStopDiscontinue -> Bool # (/=) :: StartStopDiscontinue -> StartStopDiscontinue -> Bool #
Ord StartStopDiscontinue Source #
Methods compare :: StartStopDiscontinue -> StartStopDiscontinue -> Ordering # (<) :: StartStopDiscontinue -> StartStopDiscontinue -> Bool # (<=) :: StartStopDiscontinue -> StartStopDiscontinue -> Bool # (>) :: StartStopDiscontinue -> StartStopDiscontinue -> Bool # (>=) :: StartStopDiscontinue -> StartStopDiscontinue -> Bool # max :: StartStopDiscontinue -> StartStopDiscontinue -> StartStopDiscontinue # min :: StartStopDiscontinue -> StartStopDiscontinue -> StartStopDiscontinue #
Show StartStopDiscontinue Source #
Methods showsPrec :: Int -> StartStopDiscontinue -> ShowS # show :: StartStopDiscontinue -> String # showList :: [StartStopDiscontinue] -> ShowS #
Generic StartStopDiscontinue Source #
Associated Types type Rep StartStopDiscontinue :: * -> * # Methods from :: StartStopDiscontinue -> Rep StartStopDiscontinue x # to :: Rep StartStopDiscontinue x -> StartStopDiscontinue #
EmitXml StartStopDiscontinue Source #
Methods emitXml :: StartStopDiscontinue -> XmlRep Source #
type Rep StartStopDiscontinue Source #
type Rep StartStopDiscontinue = D1 * (MetaData "StartStopDiscontinue" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "StartStopDiscontinueStart" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "StartStopDiscontinueStop" PrefixI False) (U1 )) (C1 (MetaCons "StartStopDiscontinueDiscontinue" PrefixI False) (U1 *))))

parseStartStopDiscontinue :: String -> XParse StartStopDiscontinue Source #

data StartStopSingle Source #

start-stop-single (simple)

The start-stop-single type is used for an attribute of musical elements that can be used for either multi-note or single-note musical elements, as for tremolos.

Constructors

StartStopSingleStart	start
StartStopSingleStop	stop
StartStopSingleSingle	single

Instances

Bounded StartStopSingle Source #
Methods minBound :: StartStopSingle # maxBound :: StartStopSingle #
Enum StartStopSingle Source #
Methods succ :: StartStopSingle -> StartStopSingle # pred :: StartStopSingle -> StartStopSingle # toEnum :: Int -> StartStopSingle # fromEnum :: StartStopSingle -> Int # enumFrom :: StartStopSingle -> [StartStopSingle] # enumFromThen :: StartStopSingle -> StartStopSingle -> [StartStopSingle] # enumFromTo :: StartStopSingle -> StartStopSingle -> [StartStopSingle] # enumFromThenTo :: StartStopSingle -> StartStopSingle -> StartStopSingle -> [StartStopSingle] #
Eq StartStopSingle Source #
Methods (==) :: StartStopSingle -> StartStopSingle -> Bool # (/=) :: StartStopSingle -> StartStopSingle -> Bool #
Ord StartStopSingle Source #
Methods compare :: StartStopSingle -> StartStopSingle -> Ordering # (<) :: StartStopSingle -> StartStopSingle -> Bool # (<=) :: StartStopSingle -> StartStopSingle -> Bool # (>) :: StartStopSingle -> StartStopSingle -> Bool # (>=) :: StartStopSingle -> StartStopSingle -> Bool # max :: StartStopSingle -> StartStopSingle -> StartStopSingle # min :: StartStopSingle -> StartStopSingle -> StartStopSingle #
Show StartStopSingle Source #
Methods showsPrec :: Int -> StartStopSingle -> ShowS # show :: StartStopSingle -> String # showList :: [StartStopSingle] -> ShowS #
Generic StartStopSingle Source #
Associated Types type Rep StartStopSingle :: * -> * # Methods from :: StartStopSingle -> Rep StartStopSingle x # to :: Rep StartStopSingle x -> StartStopSingle #
EmitXml StartStopSingle Source #
Methods emitXml :: StartStopSingle -> XmlRep Source #
type Rep StartStopSingle Source #
type Rep StartStopSingle = D1 * (MetaData "StartStopSingle" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "StartStopSingleStart" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "StartStopSingleStop" PrefixI False) (U1 )) (C1 (MetaCons "StartStopSingleSingle" PrefixI False) (U1 *))))

parseStartStopSingle :: String -> XParse StartStopSingle Source #

data StemValue Source #

stem-value (simple)

The stem type represents the notated stem direction.

Constructors

StemValueDown	down
StemValueUp	up
StemValueDouble	double
StemValueNone	none

Instances

Bounded StemValue Source #
Methods minBound :: StemValue # maxBound :: StemValue #
Enum StemValue Source #
Methods succ :: StemValue -> StemValue # pred :: StemValue -> StemValue # toEnum :: Int -> StemValue # fromEnum :: StemValue -> Int # enumFrom :: StemValue -> [StemValue] # enumFromThen :: StemValue -> StemValue -> [StemValue] # enumFromTo :: StemValue -> StemValue -> [StemValue] # enumFromThenTo :: StemValue -> StemValue -> StemValue -> [StemValue] #
Eq StemValue Source #
Methods (==) :: StemValue -> StemValue -> Bool # (/=) :: StemValue -> StemValue -> Bool #
Ord StemValue Source #
Methods compare :: StemValue -> StemValue -> Ordering # (<) :: StemValue -> StemValue -> Bool # (<=) :: StemValue -> StemValue -> Bool # (>) :: StemValue -> StemValue -> Bool # (>=) :: StemValue -> StemValue -> Bool # max :: StemValue -> StemValue -> StemValue # min :: StemValue -> StemValue -> StemValue #
Show StemValue Source #
Methods showsPrec :: Int -> StemValue -> ShowS # show :: StemValue -> String # showList :: [StemValue] -> ShowS #
Generic StemValue Source #
Associated Types type Rep StemValue :: * -> * # Methods from :: StemValue -> Rep StemValue x # to :: Rep StemValue x -> StemValue #
EmitXml StemValue Source #
Methods emitXml :: StemValue -> XmlRep Source #
type Rep StemValue Source #
type Rep StemValue = D1 * (MetaData "StemValue" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "StemValueDown" PrefixI False) (U1 )) (C1 (MetaCons "StemValueUp" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "StemValueDouble" PrefixI False) (U1 )) (C1 (MetaCons "StemValueNone" PrefixI False) (U1 *))))

parseStemValue :: String -> XParse StemValue Source #

data Step Source #

step (simple)

The step type represents a step of the diatonic scale, represented using the English letters A through G.

Constructors

StepA	A
StepB	B
StepC	C
StepD	D
StepE	E
StepF	F
StepG	G

Instances

Bounded Step Source #
Methods minBound :: Step # maxBound :: Step #
Enum Step Source #
Methods succ :: Step -> Step # pred :: Step -> Step # toEnum :: Int -> Step # fromEnum :: Step -> Int # enumFrom :: Step -> [Step] # enumFromThen :: Step -> Step -> [Step] # enumFromTo :: Step -> Step -> [Step] # enumFromThenTo :: Step -> Step -> Step -> [Step] #
Eq Step Source #
Methods (==) :: Step -> Step -> Bool # (/=) :: Step -> Step -> Bool #
Ord Step Source #
Methods compare :: Step -> Step -> Ordering # (<) :: Step -> Step -> Bool # (<=) :: Step -> Step -> Bool # (>) :: Step -> Step -> Bool # (>=) :: Step -> Step -> Bool # max :: Step -> Step -> Step # min :: Step -> Step -> Step #
Show Step Source #
Methods showsPrec :: Int -> Step -> ShowS # show :: Step -> String # showList :: [Step] -> ShowS #
Generic Step Source #
Associated Types type Rep Step :: * -> * # Methods from :: Step -> Rep Step x # to :: Rep Step x -> Step #
EmitXml Step Source #
Methods emitXml :: Step -> XmlRep Source #
type Rep Step Source #
type Rep Step = D1 * (MetaData "Step" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "StepA" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "StepB" PrefixI False) (U1 )) (C1 (MetaCons "StepC" PrefixI False) (U1 )))) ((:+:) ((:+:) * (C1 * (MetaCons "StepD" PrefixI False) (U1 )) (C1 (MetaCons "StepE" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "StepF" PrefixI False) (U1 )) (C1 (MetaCons "StepG" PrefixI False) (U1 *)))))

parseStep :: String -> XParse Step Source #

newtype StringNumber Source #

string-number (simple)

The string-number type indicates a string number. Strings are numbered from high to low, with 1 being the highest pitched string.

Constructors

StringNumber
Fields stringNumber :: PositiveInteger

Instances

Bounded StringNumber Source #
Methods minBound :: StringNumber # maxBound :: StringNumber #
Enum StringNumber Source #
Methods succ :: StringNumber -> StringNumber # pred :: StringNumber -> StringNumber # toEnum :: Int -> StringNumber # fromEnum :: StringNumber -> Int # enumFrom :: StringNumber -> [StringNumber] # enumFromThen :: StringNumber -> StringNumber -> [StringNumber] # enumFromTo :: StringNumber -> StringNumber -> [StringNumber] # enumFromThenTo :: StringNumber -> StringNumber -> StringNumber -> [StringNumber] #
Eq StringNumber Source #
Methods (==) :: StringNumber -> StringNumber -> Bool # (/=) :: StringNumber -> StringNumber -> Bool #
Integral StringNumber Source #
Methods quot :: StringNumber -> StringNumber -> StringNumber # rem :: StringNumber -> StringNumber -> StringNumber # div :: StringNumber -> StringNumber -> StringNumber # mod :: StringNumber -> StringNumber -> StringNumber # quotRem :: StringNumber -> StringNumber -> (StringNumber, StringNumber) # divMod :: StringNumber -> StringNumber -> (StringNumber, StringNumber) # toInteger :: StringNumber -> Integer #
Num StringNumber Source #
Methods (+) :: StringNumber -> StringNumber -> StringNumber # (-) :: StringNumber -> StringNumber -> StringNumber # (*) :: StringNumber -> StringNumber -> StringNumber # negate :: StringNumber -> StringNumber # abs :: StringNumber -> StringNumber # signum :: StringNumber -> StringNumber # fromInteger :: Integer -> StringNumber #
Ord StringNumber Source #
Methods compare :: StringNumber -> StringNumber -> Ordering # (<) :: StringNumber -> StringNumber -> Bool # (<=) :: StringNumber -> StringNumber -> Bool # (>) :: StringNumber -> StringNumber -> Bool # (>=) :: StringNumber -> StringNumber -> Bool # max :: StringNumber -> StringNumber -> StringNumber # min :: StringNumber -> StringNumber -> StringNumber #
Read StringNumber Source #
Methods readsPrec :: Int -> ReadS StringNumber # readList :: ReadS [StringNumber] # readPrec :: ReadPrec StringNumber # readListPrec :: ReadPrec [StringNumber] #
Real StringNumber Source #
Methods toRational :: StringNumber -> Rational #
Show StringNumber Source #
Methods showsPrec :: Int -> StringNumber -> ShowS # show :: StringNumber -> String # showList :: [StringNumber] -> ShowS #
Generic StringNumber Source #
Associated Types type Rep StringNumber :: * -> * # Methods from :: StringNumber -> Rep StringNumber x # to :: Rep StringNumber x -> StringNumber #
EmitXml StringNumber Source #
Methods emitXml :: StringNumber -> XmlRep Source #
type Rep StringNumber Source #
type Rep StringNumber = D1 * (MetaData "StringNumber" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "StringNumber" PrefixI True) (S1 * (MetaSel (Just Symbol "stringNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveInteger)))

parseStringNumber :: String -> XParse StringNumber Source #

data Syllabic Source #

syllabic (simple)

Lyric hyphenation is indicated by the syllabic type. The single, begin, end, and middle values represent single-syllable words, word-beginning syllables, word-ending syllables, and mid-word syllables, respectively.

Constructors

SyllabicSingle	single
SyllabicBegin	begin
SyllabicEnd	end
SyllabicMiddle	middle

Instances

Bounded Syllabic Source #
Methods minBound :: Syllabic # maxBound :: Syllabic #
Enum Syllabic Source #
Methods succ :: Syllabic -> Syllabic # pred :: Syllabic -> Syllabic # toEnum :: Int -> Syllabic # fromEnum :: Syllabic -> Int # enumFrom :: Syllabic -> [Syllabic] # enumFromThen :: Syllabic -> Syllabic -> [Syllabic] # enumFromTo :: Syllabic -> Syllabic -> [Syllabic] # enumFromThenTo :: Syllabic -> Syllabic -> Syllabic -> [Syllabic] #
Eq Syllabic Source #
Methods (==) :: Syllabic -> Syllabic -> Bool # (/=) :: Syllabic -> Syllabic -> Bool #
Ord Syllabic Source #
Methods compare :: Syllabic -> Syllabic -> Ordering # (<) :: Syllabic -> Syllabic -> Bool # (<=) :: Syllabic -> Syllabic -> Bool # (>) :: Syllabic -> Syllabic -> Bool # (>=) :: Syllabic -> Syllabic -> Bool # max :: Syllabic -> Syllabic -> Syllabic # min :: Syllabic -> Syllabic -> Syllabic #
Show Syllabic Source #
Methods showsPrec :: Int -> Syllabic -> ShowS # show :: Syllabic -> String # showList :: [Syllabic] -> ShowS #
Generic Syllabic Source #
Associated Types type Rep Syllabic :: * -> * # Methods from :: Syllabic -> Rep Syllabic x # to :: Rep Syllabic x -> Syllabic #
EmitXml Syllabic Source #
Methods emitXml :: Syllabic -> XmlRep Source #
type Rep Syllabic Source #
type Rep Syllabic = D1 * (MetaData "Syllabic" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "SyllabicSingle" PrefixI False) (U1 )) (C1 (MetaCons "SyllabicBegin" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "SyllabicEnd" PrefixI False) (U1 )) (C1 (MetaCons "SyllabicMiddle" PrefixI False) (U1 *))))

parseSyllabic :: String -> XParse Syllabic Source #

data SymbolSize Source #

symbol-size (simple)

The symbol-size type is used to indicate full vs. cue-sized vs. oversized symbols. The large value for oversized symbols was added in version 1.1.

Constructors

SymbolSizeFull	full
SymbolSizeCue	cue
SymbolSizeLarge	large

Instances

Bounded SymbolSize Source #
Methods minBound :: SymbolSize # maxBound :: SymbolSize #
Enum SymbolSize Source #
Methods succ :: SymbolSize -> SymbolSize # pred :: SymbolSize -> SymbolSize # toEnum :: Int -> SymbolSize # fromEnum :: SymbolSize -> Int # enumFrom :: SymbolSize -> [SymbolSize] # enumFromThen :: SymbolSize -> SymbolSize -> [SymbolSize] # enumFromTo :: SymbolSize -> SymbolSize -> [SymbolSize] # enumFromThenTo :: SymbolSize -> SymbolSize -> SymbolSize -> [SymbolSize] #
Eq SymbolSize Source #
Methods (==) :: SymbolSize -> SymbolSize -> Bool # (/=) :: SymbolSize -> SymbolSize -> Bool #
Ord SymbolSize Source #
Methods compare :: SymbolSize -> SymbolSize -> Ordering # (<) :: SymbolSize -> SymbolSize -> Bool # (<=) :: SymbolSize -> SymbolSize -> Bool # (>) :: SymbolSize -> SymbolSize -> Bool # (>=) :: SymbolSize -> SymbolSize -> Bool # max :: SymbolSize -> SymbolSize -> SymbolSize # min :: SymbolSize -> SymbolSize -> SymbolSize #
Show SymbolSize Source #
Methods showsPrec :: Int -> SymbolSize -> ShowS # show :: SymbolSize -> String # showList :: [SymbolSize] -> ShowS #
Generic SymbolSize Source #
Associated Types type Rep SymbolSize :: * -> * # Methods from :: SymbolSize -> Rep SymbolSize x # to :: Rep SymbolSize x -> SymbolSize #
EmitXml SymbolSize Source #
Methods emitXml :: SymbolSize -> XmlRep Source #
type Rep SymbolSize Source #
type Rep SymbolSize = D1 * (MetaData "SymbolSize" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "SymbolSizeFull" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "SymbolSizeCue" PrefixI False) (U1 )) (C1 (MetaCons "SymbolSizeLarge" PrefixI False) (U1 *))))

parseSymbolSize :: String -> XParse SymbolSize Source #

newtype Tenths Source #

tenths (simple)

The tenths type is a number representing tenths of interline staff space (positive or negative). Both integer and decimal values are allowed, such as 5 for a half space and 2.5 for a quarter space. Interline space is measured from the middle of a staff line.

Distances in a MusicXML file are measured in tenths of staff space. Tenths are then scaled to millimeters within the scaling element, used in the defaults element at the start of a score. Individual staves can apply a scaling factor to adjust staff size. When a MusicXML element or attribute refers to tenths, it means the global tenths defined by the scaling element, not the local tenths as adjusted by the staff-size element.

Constructors

Tenths
Fields tenths :: Decimal

Instances

Eq Tenths Source #
Methods (==) :: Tenths -> Tenths -> Bool # (/=) :: Tenths -> Tenths -> Bool #
Fractional Tenths Source #
Methods (/) :: Tenths -> Tenths -> Tenths # recip :: Tenths -> Tenths # fromRational :: Rational -> Tenths #
Num Tenths Source #
Methods (+) :: Tenths -> Tenths -> Tenths # (-) :: Tenths -> Tenths -> Tenths # (*) :: Tenths -> Tenths -> Tenths # negate :: Tenths -> Tenths # abs :: Tenths -> Tenths # signum :: Tenths -> Tenths # fromInteger :: Integer -> Tenths #
Ord Tenths Source #
Methods compare :: Tenths -> Tenths -> Ordering # (<) :: Tenths -> Tenths -> Bool # (<=) :: Tenths -> Tenths -> Bool # (>) :: Tenths -> Tenths -> Bool # (>=) :: Tenths -> Tenths -> Bool # max :: Tenths -> Tenths -> Tenths # min :: Tenths -> Tenths -> Tenths #
Read Tenths Source #
Methods readsPrec :: Int -> ReadS Tenths # readList :: ReadS [Tenths] # readPrec :: ReadPrec Tenths # readListPrec :: ReadPrec [Tenths] #
Real Tenths Source #
Methods toRational :: Tenths -> Rational #
RealFrac Tenths Source #
Methods properFraction :: Integral b => Tenths -> (b, Tenths) # truncate :: Integral b => Tenths -> b # round :: Integral b => Tenths -> b # ceiling :: Integral b => Tenths -> b # floor :: Integral b => Tenths -> b #
Show Tenths Source #
Methods showsPrec :: Int -> Tenths -> ShowS # show :: Tenths -> String # showList :: [Tenths] -> ShowS #
Generic Tenths Source #
Associated Types type Rep Tenths :: * -> * # Methods from :: Tenths -> Rep Tenths x # to :: Rep Tenths x -> Tenths #
EmitXml Tenths Source #
Methods emitXml :: Tenths -> XmlRep Source #
type Rep Tenths Source #
type Rep Tenths = D1 * (MetaData "Tenths" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "Tenths" PrefixI True) (S1 * (MetaSel (Just Symbol "tenths") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Decimal)))

parseTenths :: String -> XParse Tenths Source #

data TextDirection Source #

text-direction (simple)

The text-direction type is used to adjust and override the Unicode bidirectional text algorithm, similar to the W3C Internationalization Tag Set recommendation. Values are ltr (left-to-right embed), rtl (right-to-left embed), lro (left-to-right bidi-override), and rlo (right-to-left bidi-override). The default value is ltr. This type is typically used by applications that store text in left-to-right visual order rather than logical order. Such applications can use the lro value to better communicate with other applications that more fully support bidirectional text.

Constructors

TextDirectionLtr	ltr
TextDirectionRtl	rtl
TextDirectionLro	lro
TextDirectionRlo	rlo

Instances

Bounded TextDirection Source #
Methods minBound :: TextDirection # maxBound :: TextDirection #
Enum TextDirection Source #
Methods succ :: TextDirection -> TextDirection # pred :: TextDirection -> TextDirection # toEnum :: Int -> TextDirection # fromEnum :: TextDirection -> Int # enumFrom :: TextDirection -> [TextDirection] # enumFromThen :: TextDirection -> TextDirection -> [TextDirection] # enumFromTo :: TextDirection -> TextDirection -> [TextDirection] # enumFromThenTo :: TextDirection -> TextDirection -> TextDirection -> [TextDirection] #
Eq TextDirection Source #
Methods (==) :: TextDirection -> TextDirection -> Bool # (/=) :: TextDirection -> TextDirection -> Bool #
Ord TextDirection Source #
Methods compare :: TextDirection -> TextDirection -> Ordering # (<) :: TextDirection -> TextDirection -> Bool # (<=) :: TextDirection -> TextDirection -> Bool # (>) :: TextDirection -> TextDirection -> Bool # (>=) :: TextDirection -> TextDirection -> Bool # max :: TextDirection -> TextDirection -> TextDirection # min :: TextDirection -> TextDirection -> TextDirection #
Show TextDirection Source #
Methods showsPrec :: Int -> TextDirection -> ShowS # show :: TextDirection -> String # showList :: [TextDirection] -> ShowS #
Generic TextDirection Source #
Associated Types type Rep TextDirection :: * -> * # Methods from :: TextDirection -> Rep TextDirection x # to :: Rep TextDirection x -> TextDirection #
EmitXml TextDirection Source #
Methods emitXml :: TextDirection -> XmlRep Source #
type Rep TextDirection Source #
type Rep TextDirection = D1 * (MetaData "TextDirection" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "TextDirectionLtr" PrefixI False) (U1 )) (C1 (MetaCons "TextDirectionRtl" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "TextDirectionLro" PrefixI False) (U1 )) (C1 (MetaCons "TextDirectionRlo" PrefixI False) (U1 *))))

parseTextDirection :: String -> XParse TextDirection Source #

data TimeSymbol Source #

time-symbol (simple)

The time-symbol type indicates how to display a time signature. The normal value is the usual fractional display, and is the implied symbol type if none is specified. Other options are the common and cut time symbols, as well as a single number with an implied denominator.

Constructors

TimeSymbolCommon	common
TimeSymbolCut	cut
TimeSymbolSingleNumber	single-number
TimeSymbolNormal	normal

Instances

Bounded TimeSymbol Source #
Methods minBound :: TimeSymbol # maxBound :: TimeSymbol #
Enum TimeSymbol Source #
Methods succ :: TimeSymbol -> TimeSymbol # pred :: TimeSymbol -> TimeSymbol # toEnum :: Int -> TimeSymbol # fromEnum :: TimeSymbol -> Int # enumFrom :: TimeSymbol -> [TimeSymbol] # enumFromThen :: TimeSymbol -> TimeSymbol -> [TimeSymbol] # enumFromTo :: TimeSymbol -> TimeSymbol -> [TimeSymbol] # enumFromThenTo :: TimeSymbol -> TimeSymbol -> TimeSymbol -> [TimeSymbol] #
Eq TimeSymbol Source #
Methods (==) :: TimeSymbol -> TimeSymbol -> Bool # (/=) :: TimeSymbol -> TimeSymbol -> Bool #
Ord TimeSymbol Source #
Methods compare :: TimeSymbol -> TimeSymbol -> Ordering # (<) :: TimeSymbol -> TimeSymbol -> Bool # (<=) :: TimeSymbol -> TimeSymbol -> Bool # (>) :: TimeSymbol -> TimeSymbol -> Bool # (>=) :: TimeSymbol -> TimeSymbol -> Bool # max :: TimeSymbol -> TimeSymbol -> TimeSymbol # min :: TimeSymbol -> TimeSymbol -> TimeSymbol #
Show TimeSymbol Source #
Methods showsPrec :: Int -> TimeSymbol -> ShowS # show :: TimeSymbol -> String # showList :: [TimeSymbol] -> ShowS #
Generic TimeSymbol Source #
Associated Types type Rep TimeSymbol :: * -> * # Methods from :: TimeSymbol -> Rep TimeSymbol x # to :: Rep TimeSymbol x -> TimeSymbol #
EmitXml TimeSymbol Source #
Methods emitXml :: TimeSymbol -> XmlRep Source #
type Rep TimeSymbol Source #
type Rep TimeSymbol = D1 * (MetaData "TimeSymbol" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "TimeSymbolCommon" PrefixI False) (U1 )) (C1 (MetaCons "TimeSymbolCut" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "TimeSymbolSingleNumber" PrefixI False) (U1 )) (C1 (MetaCons "TimeSymbolNormal" PrefixI False) (U1 *))))

parseTimeSymbol :: String -> XParse TimeSymbol Source #

newtype Token Source #

xs:token (simple)

Constructors

Token
Fields token :: NormalizedString

Instances

Eq Token Source #
Methods (==) :: Token -> Token -> Bool # (/=) :: Token -> Token -> Bool #
Ord Token Source #
Methods compare :: Token -> Token -> Ordering # (<) :: Token -> Token -> Bool # (<=) :: Token -> Token -> Bool # (>) :: Token -> Token -> Bool # (>=) :: Token -> Token -> Bool # max :: Token -> Token -> Token # min :: Token -> Token -> Token #
Read Token Source #
Methods readsPrec :: Int -> ReadS Token # readList :: ReadS [Token] # readPrec :: ReadPrec Token # readListPrec :: ReadPrec [Token] #
Show Token Source #
Methods showsPrec :: Int -> Token -> ShowS # show :: Token -> String # showList :: [Token] -> ShowS #
IsString Token Source #
Methods fromString :: String -> Token #
Generic Token Source #
Associated Types type Rep Token :: * -> * # Methods from :: Token -> Rep Token x # to :: Rep Token x -> Token #
EmitXml Token Source #
Methods emitXml :: Token -> XmlRep Source #
type Rep Token Source #
type Rep Token = D1 * (MetaData "Token" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "Token" PrefixI True) (S1 * (MetaSel (Just Symbol "token") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NormalizedString)))

parseToken :: String -> XParse Token Source #

data TopBottom Source #

top-bottom (simple)

The top-bottom type is used to indicate the top or bottom part of a vertical shape like non-arpeggiate.

Constructors

TopBottomTop	top
TopBottomBottom	bottom

Instances

Bounded TopBottom Source #
Methods minBound :: TopBottom # maxBound :: TopBottom #
Enum TopBottom Source #
Methods succ :: TopBottom -> TopBottom # pred :: TopBottom -> TopBottom # toEnum :: Int -> TopBottom # fromEnum :: TopBottom -> Int # enumFrom :: TopBottom -> [TopBottom] # enumFromThen :: TopBottom -> TopBottom -> [TopBottom] # enumFromTo :: TopBottom -> TopBottom -> [TopBottom] # enumFromThenTo :: TopBottom -> TopBottom -> TopBottom -> [TopBottom] #
Eq TopBottom Source #
Methods (==) :: TopBottom -> TopBottom -> Bool # (/=) :: TopBottom -> TopBottom -> Bool #
Ord TopBottom Source #
Methods compare :: TopBottom -> TopBottom -> Ordering # (<) :: TopBottom -> TopBottom -> Bool # (<=) :: TopBottom -> TopBottom -> Bool # (>) :: TopBottom -> TopBottom -> Bool # (>=) :: TopBottom -> TopBottom -> Bool # max :: TopBottom -> TopBottom -> TopBottom # min :: TopBottom -> TopBottom -> TopBottom #
Show TopBottom Source #
Methods showsPrec :: Int -> TopBottom -> ShowS # show :: TopBottom -> String # showList :: [TopBottom] -> ShowS #
Generic TopBottom Source #
Associated Types type Rep TopBottom :: * -> * # Methods from :: TopBottom -> Rep TopBottom x # to :: Rep TopBottom x -> TopBottom #
EmitXml TopBottom Source #
Methods emitXml :: TopBottom -> XmlRep Source #
type Rep TopBottom Source #
type Rep TopBottom = D1 * (MetaData "TopBottom" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "TopBottomTop" PrefixI False) (U1 )) (C1 (MetaCons "TopBottomBottom" PrefixI False) (U1 *)))

parseTopBottom :: String -> XParse TopBottom Source #

newtype TremoloMarks Source #

tremolo-marks (simple)

The number of tremolo marks is represented by a number from 0 to 6: the same as beam-level with 0 added.

Constructors

TremoloMarks
Fields tremoloMarks :: Int

Instances

Bounded TremoloMarks Source #
Methods minBound :: TremoloMarks # maxBound :: TremoloMarks #
Enum TremoloMarks Source #
Methods succ :: TremoloMarks -> TremoloMarks # pred :: TremoloMarks -> TremoloMarks # toEnum :: Int -> TremoloMarks # fromEnum :: TremoloMarks -> Int # enumFrom :: TremoloMarks -> [TremoloMarks] # enumFromThen :: TremoloMarks -> TremoloMarks -> [TremoloMarks] # enumFromTo :: TremoloMarks -> TremoloMarks -> [TremoloMarks] # enumFromThenTo :: TremoloMarks -> TremoloMarks -> TremoloMarks -> [TremoloMarks] #
Eq TremoloMarks Source #
Methods (==) :: TremoloMarks -> TremoloMarks -> Bool # (/=) :: TremoloMarks -> TremoloMarks -> Bool #
Integral TremoloMarks Source #
Methods quot :: TremoloMarks -> TremoloMarks -> TremoloMarks # rem :: TremoloMarks -> TremoloMarks -> TremoloMarks # div :: TremoloMarks -> TremoloMarks -> TremoloMarks # mod :: TremoloMarks -> TremoloMarks -> TremoloMarks # quotRem :: TremoloMarks -> TremoloMarks -> (TremoloMarks, TremoloMarks) # divMod :: TremoloMarks -> TremoloMarks -> (TremoloMarks, TremoloMarks) # toInteger :: TremoloMarks -> Integer #
Num TremoloMarks Source #
Methods (+) :: TremoloMarks -> TremoloMarks -> TremoloMarks # (-) :: TremoloMarks -> TremoloMarks -> TremoloMarks # (*) :: TremoloMarks -> TremoloMarks -> TremoloMarks # negate :: TremoloMarks -> TremoloMarks # abs :: TremoloMarks -> TremoloMarks # signum :: TremoloMarks -> TremoloMarks # fromInteger :: Integer -> TremoloMarks #
Ord TremoloMarks Source #
Methods compare :: TremoloMarks -> TremoloMarks -> Ordering # (<) :: TremoloMarks -> TremoloMarks -> Bool # (<=) :: TremoloMarks -> TremoloMarks -> Bool # (>) :: TremoloMarks -> TremoloMarks -> Bool # (>=) :: TremoloMarks -> TremoloMarks -> Bool # max :: TremoloMarks -> TremoloMarks -> TremoloMarks # min :: TremoloMarks -> TremoloMarks -> TremoloMarks #
Read TremoloMarks Source #
Methods readsPrec :: Int -> ReadS TremoloMarks # readList :: ReadS [TremoloMarks] # readPrec :: ReadPrec TremoloMarks # readListPrec :: ReadPrec [TremoloMarks] #
Real TremoloMarks Source #
Methods toRational :: TremoloMarks -> Rational #
Show TremoloMarks Source #
Methods showsPrec :: Int -> TremoloMarks -> ShowS # show :: TremoloMarks -> String # showList :: [TremoloMarks] -> ShowS #
Generic TremoloMarks Source #
Associated Types type Rep TremoloMarks :: * -> * # Methods from :: TremoloMarks -> Rep TremoloMarks x # to :: Rep TremoloMarks x -> TremoloMarks #
EmitXml TremoloMarks Source #
Methods emitXml :: TremoloMarks -> XmlRep Source #
type Rep TremoloMarks Source #
type Rep TremoloMarks = D1 * (MetaData "TremoloMarks" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "TremoloMarks" PrefixI True) (S1 * (MetaSel (Just Symbol "tremoloMarks") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Int)))

parseTremoloMarks :: String -> XParse TremoloMarks Source #

newtype TrillBeats Source #

trill-beats (simple)

The trill-beats type specifies the beats used in a trill-sound or bend-sound attribute group. It is a decimal value with a minimum value of 2.

Constructors

TrillBeats
Fields trillBeats :: Decimal

Instances

Eq TrillBeats Source #
Methods (==) :: TrillBeats -> TrillBeats -> Bool # (/=) :: TrillBeats -> TrillBeats -> Bool #
Fractional TrillBeats Source #
Methods (/) :: TrillBeats -> TrillBeats -> TrillBeats # recip :: TrillBeats -> TrillBeats # fromRational :: Rational -> TrillBeats #
Num TrillBeats Source #
Methods (+) :: TrillBeats -> TrillBeats -> TrillBeats # (-) :: TrillBeats -> TrillBeats -> TrillBeats # (*) :: TrillBeats -> TrillBeats -> TrillBeats # negate :: TrillBeats -> TrillBeats # abs :: TrillBeats -> TrillBeats # signum :: TrillBeats -> TrillBeats # fromInteger :: Integer -> TrillBeats #
Ord TrillBeats Source #
Methods compare :: TrillBeats -> TrillBeats -> Ordering # (<) :: TrillBeats -> TrillBeats -> Bool # (<=) :: TrillBeats -> TrillBeats -> Bool # (>) :: TrillBeats -> TrillBeats -> Bool # (>=) :: TrillBeats -> TrillBeats -> Bool # max :: TrillBeats -> TrillBeats -> TrillBeats # min :: TrillBeats -> TrillBeats -> TrillBeats #
Read TrillBeats Source #
Methods readsPrec :: Int -> ReadS TrillBeats # readList :: ReadS [TrillBeats] # readPrec :: ReadPrec TrillBeats # readListPrec :: ReadPrec [TrillBeats] #
Real TrillBeats Source #
Methods toRational :: TrillBeats -> Rational #
RealFrac TrillBeats Source #
Methods properFraction :: Integral b => TrillBeats -> (b, TrillBeats) # truncate :: Integral b => TrillBeats -> b # round :: Integral b => TrillBeats -> b # ceiling :: Integral b => TrillBeats -> b # floor :: Integral b => TrillBeats -> b #
Show TrillBeats Source #
Methods showsPrec :: Int -> TrillBeats -> ShowS # show :: TrillBeats -> String # showList :: [TrillBeats] -> ShowS #
Generic TrillBeats Source #
Associated Types type Rep TrillBeats :: * -> * # Methods from :: TrillBeats -> Rep TrillBeats x # to :: Rep TrillBeats x -> TrillBeats #
EmitXml TrillBeats Source #
Methods emitXml :: TrillBeats -> XmlRep Source #
type Rep TrillBeats Source #
type Rep TrillBeats = D1 * (MetaData "TrillBeats" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "TrillBeats" PrefixI True) (S1 * (MetaSel (Just Symbol "trillBeats") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Decimal)))

parseTrillBeats :: String -> XParse TrillBeats Source #

data TrillStep Source #

trill-step (simple)

The trill-step type describes the alternating note of trills and mordents for playback, relative to the current note.

Constructors

TrillStepWhole	whole
TrillStepHalf	half
TrillStepUnison	unison

Instances

Bounded TrillStep Source #
Methods minBound :: TrillStep # maxBound :: TrillStep #
Enum TrillStep Source #
Methods succ :: TrillStep -> TrillStep # pred :: TrillStep -> TrillStep # toEnum :: Int -> TrillStep # fromEnum :: TrillStep -> Int # enumFrom :: TrillStep -> [TrillStep] # enumFromThen :: TrillStep -> TrillStep -> [TrillStep] # enumFromTo :: TrillStep -> TrillStep -> [TrillStep] # enumFromThenTo :: TrillStep -> TrillStep -> TrillStep -> [TrillStep] #
Eq TrillStep Source #
Methods (==) :: TrillStep -> TrillStep -> Bool # (/=) :: TrillStep -> TrillStep -> Bool #
Ord TrillStep Source #
Methods compare :: TrillStep -> TrillStep -> Ordering # (<) :: TrillStep -> TrillStep -> Bool # (<=) :: TrillStep -> TrillStep -> Bool # (>) :: TrillStep -> TrillStep -> Bool # (>=) :: TrillStep -> TrillStep -> Bool # max :: TrillStep -> TrillStep -> TrillStep # min :: TrillStep -> TrillStep -> TrillStep #
Show TrillStep Source #
Methods showsPrec :: Int -> TrillStep -> ShowS # show :: TrillStep -> String # showList :: [TrillStep] -> ShowS #
Generic TrillStep Source #
Associated Types type Rep TrillStep :: * -> * # Methods from :: TrillStep -> Rep TrillStep x # to :: Rep TrillStep x -> TrillStep #
EmitXml TrillStep Source #
Methods emitXml :: TrillStep -> XmlRep Source #
type Rep TrillStep Source #
type Rep TrillStep = D1 * (MetaData "TrillStep" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "TrillStepWhole" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "TrillStepHalf" PrefixI False) (U1 )) (C1 (MetaCons "TrillStepUnison" PrefixI False) (U1 *))))

parseTrillStep :: String -> XParse TrillStep Source #

data TwoNoteTurn Source #

two-note-turn (simple)

The two-note-turn type describes the ending notes of trills and mordents for playback, relative to the current note.

Constructors

TwoNoteTurnWhole	whole
TwoNoteTurnHalf	half
TwoNoteTurnNone	none

Instances

Bounded TwoNoteTurn Source #
Methods minBound :: TwoNoteTurn # maxBound :: TwoNoteTurn #
Enum TwoNoteTurn Source #
Methods succ :: TwoNoteTurn -> TwoNoteTurn # pred :: TwoNoteTurn -> TwoNoteTurn # toEnum :: Int -> TwoNoteTurn # fromEnum :: TwoNoteTurn -> Int # enumFrom :: TwoNoteTurn -> [TwoNoteTurn] # enumFromThen :: TwoNoteTurn -> TwoNoteTurn -> [TwoNoteTurn] # enumFromTo :: TwoNoteTurn -> TwoNoteTurn -> [TwoNoteTurn] # enumFromThenTo :: TwoNoteTurn -> TwoNoteTurn -> TwoNoteTurn -> [TwoNoteTurn] #
Eq TwoNoteTurn Source #
Methods (==) :: TwoNoteTurn -> TwoNoteTurn -> Bool # (/=) :: TwoNoteTurn -> TwoNoteTurn -> Bool #
Ord TwoNoteTurn Source #
Methods compare :: TwoNoteTurn -> TwoNoteTurn -> Ordering # (<) :: TwoNoteTurn -> TwoNoteTurn -> Bool # (<=) :: TwoNoteTurn -> TwoNoteTurn -> Bool # (>) :: TwoNoteTurn -> TwoNoteTurn -> Bool # (>=) :: TwoNoteTurn -> TwoNoteTurn -> Bool # max :: TwoNoteTurn -> TwoNoteTurn -> TwoNoteTurn # min :: TwoNoteTurn -> TwoNoteTurn -> TwoNoteTurn #
Show TwoNoteTurn Source #
Methods showsPrec :: Int -> TwoNoteTurn -> ShowS # show :: TwoNoteTurn -> String # showList :: [TwoNoteTurn] -> ShowS #
Generic TwoNoteTurn Source #
Associated Types type Rep TwoNoteTurn :: * -> * # Methods from :: TwoNoteTurn -> Rep TwoNoteTurn x # to :: Rep TwoNoteTurn x -> TwoNoteTurn #
EmitXml TwoNoteTurn Source #
Methods emitXml :: TwoNoteTurn -> XmlRep Source #
type Rep TwoNoteTurn Source #
type Rep TwoNoteTurn = D1 * (MetaData "TwoNoteTurn" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "TwoNoteTurnWhole" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "TwoNoteTurnHalf" PrefixI False) (U1 )) (C1 (MetaCons "TwoNoteTurnNone" PrefixI False) (U1 *))))

parseTwoNoteTurn :: String -> XParse TwoNoteTurn Source #

data Type Source #

xlink:type (simple)

Constructors

TypeSimple

simple

Instances

Bounded Type Source #
Methods minBound :: Type # maxBound :: Type #
Enum Type Source #
Methods succ :: Type -> Type # pred :: Type -> Type # toEnum :: Int -> Type # fromEnum :: Type -> Int # enumFrom :: Type -> [Type] # enumFromThen :: Type -> Type -> [Type] # enumFromTo :: Type -> Type -> [Type] # enumFromThenTo :: Type -> Type -> Type -> [Type] #
Eq Type Source #
Methods (==) :: Type -> Type -> Bool # (/=) :: Type -> Type -> Bool #
Ord Type Source #
Methods compare :: Type -> Type -> Ordering # (<) :: Type -> Type -> Bool # (<=) :: Type -> Type -> Bool # (>) :: Type -> Type -> Bool # (>=) :: Type -> Type -> Bool # max :: Type -> Type -> Type # min :: Type -> Type -> Type #
Show Type Source #
Methods showsPrec :: Int -> Type -> ShowS # show :: Type -> String # showList :: [Type] -> ShowS #
Generic Type Source #
Associated Types type Rep Type :: * -> * # Methods from :: Type -> Rep Type x # to :: Rep Type x -> Type #
EmitXml Type Source #
Methods emitXml :: Type -> XmlRep Source #
type Rep Type Source #
type Rep Type = D1 * (MetaData "Type" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "TypeSimple" PrefixI False) (U1 *))

parseType :: String -> XParse Type Source #

data UpDown Source #

up-down (simple)

The up-down type is used for arrow direction, indicating which way the tip is pointing.

Constructors

UpDownUp	up
UpDownDown	down

Instances

Bounded UpDown Source #
Methods minBound :: UpDown # maxBound :: UpDown #
Enum UpDown Source #
Methods succ :: UpDown -> UpDown # pred :: UpDown -> UpDown # toEnum :: Int -> UpDown # fromEnum :: UpDown -> Int # enumFrom :: UpDown -> [UpDown] # enumFromThen :: UpDown -> UpDown -> [UpDown] # enumFromTo :: UpDown -> UpDown -> [UpDown] # enumFromThenTo :: UpDown -> UpDown -> UpDown -> [UpDown] #
Eq UpDown Source #
Methods (==) :: UpDown -> UpDown -> Bool # (/=) :: UpDown -> UpDown -> Bool #
Ord UpDown Source #
Methods compare :: UpDown -> UpDown -> Ordering # (<) :: UpDown -> UpDown -> Bool # (<=) :: UpDown -> UpDown -> Bool # (>) :: UpDown -> UpDown -> Bool # (>=) :: UpDown -> UpDown -> Bool # max :: UpDown -> UpDown -> UpDown # min :: UpDown -> UpDown -> UpDown #
Show UpDown Source #
Methods showsPrec :: Int -> UpDown -> ShowS # show :: UpDown -> String # showList :: [UpDown] -> ShowS #
Generic UpDown Source #
Associated Types type Rep UpDown :: * -> * # Methods from :: UpDown -> Rep UpDown x # to :: Rep UpDown x -> UpDown #
EmitXml UpDown Source #
Methods emitXml :: UpDown -> XmlRep Source #
type Rep UpDown Source #
type Rep UpDown = D1 * (MetaData "UpDown" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "UpDownUp" PrefixI False) (U1 )) (C1 (MetaCons "UpDownDown" PrefixI False) (U1 *)))

parseUpDown :: String -> XParse UpDown Source #

data UpDownStop Source #

up-down-stop (simple)

The up-down-stop type is used for octave-shift elements, indicating the direction of the shift from their true pitched values because of printing difficulty.

Constructors

UpDownStopUp	up
UpDownStopDown	down
UpDownStopStop	stop

Instances

Bounded UpDownStop Source #
Methods minBound :: UpDownStop # maxBound :: UpDownStop #
Enum UpDownStop Source #
Methods succ :: UpDownStop -> UpDownStop # pred :: UpDownStop -> UpDownStop # toEnum :: Int -> UpDownStop # fromEnum :: UpDownStop -> Int # enumFrom :: UpDownStop -> [UpDownStop] # enumFromThen :: UpDownStop -> UpDownStop -> [UpDownStop] # enumFromTo :: UpDownStop -> UpDownStop -> [UpDownStop] # enumFromThenTo :: UpDownStop -> UpDownStop -> UpDownStop -> [UpDownStop] #
Eq UpDownStop Source #
Methods (==) :: UpDownStop -> UpDownStop -> Bool # (/=) :: UpDownStop -> UpDownStop -> Bool #
Ord UpDownStop Source #
Methods compare :: UpDownStop -> UpDownStop -> Ordering # (<) :: UpDownStop -> UpDownStop -> Bool # (<=) :: UpDownStop -> UpDownStop -> Bool # (>) :: UpDownStop -> UpDownStop -> Bool # (>=) :: UpDownStop -> UpDownStop -> Bool # max :: UpDownStop -> UpDownStop -> UpDownStop # min :: UpDownStop -> UpDownStop -> UpDownStop #
Show UpDownStop Source #
Methods showsPrec :: Int -> UpDownStop -> ShowS # show :: UpDownStop -> String # showList :: [UpDownStop] -> ShowS #
Generic UpDownStop Source #
Associated Types type Rep UpDownStop :: * -> * # Methods from :: UpDownStop -> Rep UpDownStop x # to :: Rep UpDownStop x -> UpDownStop #
EmitXml UpDownStop Source #
Methods emitXml :: UpDownStop -> XmlRep Source #
type Rep UpDownStop Source #
type Rep UpDownStop = D1 * (MetaData "UpDownStop" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "UpDownStopUp" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "UpDownStopDown" PrefixI False) (U1 )) (C1 (MetaCons "UpDownStopStop" PrefixI False) (U1 *))))

parseUpDownStop :: String -> XParse UpDownStop Source #

data UprightInverted Source #

upright-inverted (simple)

The upright-inverted type describes the appearance of a fermata element. The value is upright if not specified.

Constructors

UprightInvertedUpright	upright
UprightInvertedInverted	inverted

Instances

Bounded UprightInverted Source #
Methods minBound :: UprightInverted # maxBound :: UprightInverted #
Enum UprightInverted Source #
Methods succ :: UprightInverted -> UprightInverted # pred :: UprightInverted -> UprightInverted # toEnum :: Int -> UprightInverted # fromEnum :: UprightInverted -> Int # enumFrom :: UprightInverted -> [UprightInverted] # enumFromThen :: UprightInverted -> UprightInverted -> [UprightInverted] # enumFromTo :: UprightInverted -> UprightInverted -> [UprightInverted] # enumFromThenTo :: UprightInverted -> UprightInverted -> UprightInverted -> [UprightInverted] #
Eq UprightInverted Source #
Methods (==) :: UprightInverted -> UprightInverted -> Bool # (/=) :: UprightInverted -> UprightInverted -> Bool #
Ord UprightInverted Source #
Methods compare :: UprightInverted -> UprightInverted -> Ordering # (<) :: UprightInverted -> UprightInverted -> Bool # (<=) :: UprightInverted -> UprightInverted -> Bool # (>) :: UprightInverted -> UprightInverted -> Bool # (>=) :: UprightInverted -> UprightInverted -> Bool # max :: UprightInverted -> UprightInverted -> UprightInverted # min :: UprightInverted -> UprightInverted -> UprightInverted #
Show UprightInverted Source #
Methods showsPrec :: Int -> UprightInverted -> ShowS # show :: UprightInverted -> String # showList :: [UprightInverted] -> ShowS #
Generic UprightInverted Source #
Associated Types type Rep UprightInverted :: * -> * # Methods from :: UprightInverted -> Rep UprightInverted x # to :: Rep UprightInverted x -> UprightInverted #
EmitXml UprightInverted Source #
Methods emitXml :: UprightInverted -> XmlRep Source #
type Rep UprightInverted Source #
type Rep UprightInverted = D1 * (MetaData "UprightInverted" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "UprightInvertedUpright" PrefixI False) (U1 )) (C1 (MetaCons "UprightInvertedInverted" PrefixI False) (U1 *)))

parseUprightInverted :: String -> XParse UprightInverted Source #

data Valign Source #

valign (simple)

The valign type is used to indicate vertical alignment to the top, middle, bottom, or baseline of the text. Defaults are implementation-dependent.

Constructors

ValignTop	top
ValignMiddle	middle
ValignBottom	bottom
ValignBaseline	baseline

Instances

Bounded Valign Source #
Methods minBound :: Valign # maxBound :: Valign #
Enum Valign Source #
Methods succ :: Valign -> Valign # pred :: Valign -> Valign # toEnum :: Int -> Valign # fromEnum :: Valign -> Int # enumFrom :: Valign -> [Valign] # enumFromThen :: Valign -> Valign -> [Valign] # enumFromTo :: Valign -> Valign -> [Valign] # enumFromThenTo :: Valign -> Valign -> Valign -> [Valign] #
Eq Valign Source #
Methods (==) :: Valign -> Valign -> Bool # (/=) :: Valign -> Valign -> Bool #
Ord Valign Source #
Methods compare :: Valign -> Valign -> Ordering # (<) :: Valign -> Valign -> Bool # (<=) :: Valign -> Valign -> Bool # (>) :: Valign -> Valign -> Bool # (>=) :: Valign -> Valign -> Bool # max :: Valign -> Valign -> Valign # min :: Valign -> Valign -> Valign #
Show Valign Source #
Methods showsPrec :: Int -> Valign -> ShowS # show :: Valign -> String # showList :: [Valign] -> ShowS #
Generic Valign Source #
Associated Types type Rep Valign :: * -> * # Methods from :: Valign -> Rep Valign x # to :: Rep Valign x -> Valign #
EmitXml Valign Source #
Methods emitXml :: Valign -> XmlRep Source #
type Rep Valign Source #
type Rep Valign = D1 * (MetaData "Valign" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "ValignTop" PrefixI False) (U1 )) (C1 (MetaCons "ValignMiddle" PrefixI False) (U1 ))) ((:+:) (C1 * (MetaCons "ValignBottom" PrefixI False) (U1 )) (C1 (MetaCons "ValignBaseline" PrefixI False) (U1 *))))

parseValign :: String -> XParse Valign Source #

data ValignImage Source #

valign-image (simple)

The valign-image type is used to indicate vertical alignment for images and graphics, so it does not include a baseline value. Defaults are implementation-dependent.

Constructors

ValignImageTop	top
ValignImageMiddle	middle
ValignImageBottom	bottom

Instances

Bounded ValignImage Source #
Methods minBound :: ValignImage # maxBound :: ValignImage #
Enum ValignImage Source #
Methods succ :: ValignImage -> ValignImage # pred :: ValignImage -> ValignImage # toEnum :: Int -> ValignImage # fromEnum :: ValignImage -> Int # enumFrom :: ValignImage -> [ValignImage] # enumFromThen :: ValignImage -> ValignImage -> [ValignImage] # enumFromTo :: ValignImage -> ValignImage -> [ValignImage] # enumFromThenTo :: ValignImage -> ValignImage -> ValignImage -> [ValignImage] #
Eq ValignImage Source #
Methods (==) :: ValignImage -> ValignImage -> Bool # (/=) :: ValignImage -> ValignImage -> Bool #
Ord ValignImage Source #
Methods compare :: ValignImage -> ValignImage -> Ordering # (<) :: ValignImage -> ValignImage -> Bool # (<=) :: ValignImage -> ValignImage -> Bool # (>) :: ValignImage -> ValignImage -> Bool # (>=) :: ValignImage -> ValignImage -> Bool # max :: ValignImage -> ValignImage -> ValignImage # min :: ValignImage -> ValignImage -> ValignImage #
Show ValignImage Source #
Methods showsPrec :: Int -> ValignImage -> ShowS # show :: ValignImage -> String # showList :: [ValignImage] -> ShowS #
Generic ValignImage Source #
Associated Types type Rep ValignImage :: * -> * # Methods from :: ValignImage -> Rep ValignImage x # to :: Rep ValignImage x -> ValignImage #
EmitXml ValignImage Source #
Methods emitXml :: ValignImage -> XmlRep Source #
type Rep ValignImage Source #
type Rep ValignImage = D1 * (MetaData "ValignImage" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "ValignImageTop" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "ValignImageMiddle" PrefixI False) (U1 )) (C1 (MetaCons "ValignImageBottom" PrefixI False) (U1 *))))

parseValignImage :: String -> XParse ValignImage Source #

data WedgeType Source #

wedge-type (simple)

The wedge type is crescendo for the start of a wedge that is closed at the left side, diminuendo for the start of a wedge that is closed on the right side, and stop for the end of a wedge.

Constructors

WedgeTypeCrescendo	crescendo
WedgeTypeDiminuendo	diminuendo
WedgeTypeStop	stop

Instances

Bounded WedgeType Source #
Methods minBound :: WedgeType # maxBound :: WedgeType #
Enum WedgeType Source #
Methods succ :: WedgeType -> WedgeType # pred :: WedgeType -> WedgeType # toEnum :: Int -> WedgeType # fromEnum :: WedgeType -> Int # enumFrom :: WedgeType -> [WedgeType] # enumFromThen :: WedgeType -> WedgeType -> [WedgeType] # enumFromTo :: WedgeType -> WedgeType -> [WedgeType] # enumFromThenTo :: WedgeType -> WedgeType -> WedgeType -> [WedgeType] #
Eq WedgeType Source #
Methods (==) :: WedgeType -> WedgeType -> Bool # (/=) :: WedgeType -> WedgeType -> Bool #
Ord WedgeType Source #
Methods compare :: WedgeType -> WedgeType -> Ordering # (<) :: WedgeType -> WedgeType -> Bool # (<=) :: WedgeType -> WedgeType -> Bool # (>) :: WedgeType -> WedgeType -> Bool # (>=) :: WedgeType -> WedgeType -> Bool # max :: WedgeType -> WedgeType -> WedgeType # min :: WedgeType -> WedgeType -> WedgeType #
Show WedgeType Source #
Methods showsPrec :: Int -> WedgeType -> ShowS # show :: WedgeType -> String # showList :: [WedgeType] -> ShowS #
Generic WedgeType Source #
Associated Types type Rep WedgeType :: * -> * # Methods from :: WedgeType -> Rep WedgeType x # to :: Rep WedgeType x -> WedgeType #
EmitXml WedgeType Source #
Methods emitXml :: WedgeType -> XmlRep Source #
type Rep WedgeType Source #
type Rep WedgeType = D1 * (MetaData "WedgeType" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "WedgeTypeCrescendo" PrefixI False) (U1 )) ((:+:) (C1 * (MetaCons "WedgeTypeDiminuendo" PrefixI False) (U1 )) (C1 (MetaCons "WedgeTypeStop" PrefixI False) (U1 *))))

parseWedgeType :: String -> XParse WedgeType Source #

data YesNo Source #

yes-no (simple)

The yes-no type is used for boolean-like attributes. We cannot use W3C XML Schema booleans due to their restrictions on expression of boolean values.

Constructors

YesNoYes	yes
YesNoNo	no

Instances

Bounded YesNo Source #
Methods minBound :: YesNo # maxBound :: YesNo #
Enum YesNo Source #
Methods succ :: YesNo -> YesNo # pred :: YesNo -> YesNo # toEnum :: Int -> YesNo # fromEnum :: YesNo -> Int # enumFrom :: YesNo -> [YesNo] # enumFromThen :: YesNo -> YesNo -> [YesNo] # enumFromTo :: YesNo -> YesNo -> [YesNo] # enumFromThenTo :: YesNo -> YesNo -> YesNo -> [YesNo] #
Eq YesNo Source #
Methods (==) :: YesNo -> YesNo -> Bool # (/=) :: YesNo -> YesNo -> Bool #
Ord YesNo Source #
Methods compare :: YesNo -> YesNo -> Ordering # (<) :: YesNo -> YesNo -> Bool # (<=) :: YesNo -> YesNo -> Bool # (>) :: YesNo -> YesNo -> Bool # (>=) :: YesNo -> YesNo -> Bool # max :: YesNo -> YesNo -> YesNo # min :: YesNo -> YesNo -> YesNo #
Show YesNo Source #
Methods showsPrec :: Int -> YesNo -> ShowS # show :: YesNo -> String # showList :: [YesNo] -> ShowS #
Generic YesNo Source #
Associated Types type Rep YesNo :: * -> * # Methods from :: YesNo -> Rep YesNo x # to :: Rep YesNo x -> YesNo #
EmitXml YesNo Source #
Methods emitXml :: YesNo -> XmlRep Source #
type Rep YesNo Source #
type Rep YesNo = D1 * (MetaData "YesNo" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "YesNoYes" PrefixI False) (U1 )) (C1 (MetaCons "YesNoNo" PrefixI False) (U1 *)))

parseYesNo :: String -> XParse YesNo Source #

data YesNoNumber Source #

yes-no-number (simple)

The yes-no-number type is used for attributes that can be either boolean or numeric values.

Constructors

YesNoNumberYesNo
Fields yesNoNumber1 :: YesNo
YesNoNumberDecimal
Fields yesNoNumber2 :: Decimal

Instances

Eq YesNoNumber Source #
Methods (==) :: YesNoNumber -> YesNoNumber -> Bool # (/=) :: YesNoNumber -> YesNoNumber -> Bool #
Show YesNoNumber Source #
Methods showsPrec :: Int -> YesNoNumber -> ShowS # show :: YesNoNumber -> String # showList :: [YesNoNumber] -> ShowS #
Generic YesNoNumber Source #
Associated Types type Rep YesNoNumber :: * -> * # Methods from :: YesNoNumber -> Rep YesNoNumber x # to :: Rep YesNoNumber x -> YesNoNumber #
EmitXml YesNoNumber Source #
Methods emitXml :: YesNoNumber -> XmlRep Source #
type Rep YesNoNumber Source #
type Rep YesNoNumber = D1 * (MetaData "YesNoNumber" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "YesNoNumberYesNo" PrefixI True) (S1 * (MetaSel (Just Symbol "yesNoNumber1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * YesNo))) (C1 * (MetaCons "YesNoNumberDecimal" PrefixI True) (S1 * (MetaSel (Just Symbol "yesNoNumber2") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Decimal))))

parseYesNoNumber :: String -> XParse YesNoNumber Source #

newtype YyyyMmDd Source #

yyyy-mm-dd (simple)

Calendar dates are represented yyyy-mm-dd format, following ISO 8601. This is a W3C XML Schema date type, but without the optional timezone data.

Constructors

YyyyMmDd
Fields yyyyMmDd :: String

Instances

Eq YyyyMmDd Source #
Methods (==) :: YyyyMmDd -> YyyyMmDd -> Bool # (/=) :: YyyyMmDd -> YyyyMmDd -> Bool #
Ord YyyyMmDd Source #
Methods compare :: YyyyMmDd -> YyyyMmDd -> Ordering # (<) :: YyyyMmDd -> YyyyMmDd -> Bool # (<=) :: YyyyMmDd -> YyyyMmDd -> Bool # (>) :: YyyyMmDd -> YyyyMmDd -> Bool # (>=) :: YyyyMmDd -> YyyyMmDd -> Bool # max :: YyyyMmDd -> YyyyMmDd -> YyyyMmDd # min :: YyyyMmDd -> YyyyMmDd -> YyyyMmDd #
Read YyyyMmDd Source #
Methods readsPrec :: Int -> ReadS YyyyMmDd # readList :: ReadS [YyyyMmDd] # readPrec :: ReadPrec YyyyMmDd # readListPrec :: ReadPrec [YyyyMmDd] #
Show YyyyMmDd Source #
Methods showsPrec :: Int -> YyyyMmDd -> ShowS # show :: YyyyMmDd -> String # showList :: [YyyyMmDd] -> ShowS #
IsString YyyyMmDd Source #
Methods fromString :: String -> YyyyMmDd #
Generic YyyyMmDd Source #
Associated Types type Rep YyyyMmDd :: * -> * # Methods from :: YyyyMmDd -> Rep YyyyMmDd x # to :: Rep YyyyMmDd x -> YyyyMmDd #
EmitXml YyyyMmDd Source #
Methods emitXml :: YyyyMmDd -> XmlRep Source #
type Rep YyyyMmDd Source #
type Rep YyyyMmDd = D1 * (MetaData "YyyyMmDd" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" True) (C1 * (MetaCons "YyyyMmDd" PrefixI True) (S1 * (MetaSel (Just Symbol "yyyyMmDd") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)))

parseYyyyMmDd :: String -> XParse YyyyMmDd Source #

data SumLang Source #

xml:lang (union)

Constructors

SumLang

//

Instances

Bounded SumLang Source #
Methods minBound :: SumLang # maxBound :: SumLang #
Enum SumLang Source #
Methods succ :: SumLang -> SumLang # pred :: SumLang -> SumLang # toEnum :: Int -> SumLang # fromEnum :: SumLang -> Int # enumFrom :: SumLang -> [SumLang] # enumFromThen :: SumLang -> SumLang -> [SumLang] # enumFromTo :: SumLang -> SumLang -> [SumLang] # enumFromThenTo :: SumLang -> SumLang -> SumLang -> [SumLang] #
Eq SumLang Source #
Methods (==) :: SumLang -> SumLang -> Bool # (/=) :: SumLang -> SumLang -> Bool #
Ord SumLang Source #
Methods compare :: SumLang -> SumLang -> Ordering # (<) :: SumLang -> SumLang -> Bool # (<=) :: SumLang -> SumLang -> Bool # (>) :: SumLang -> SumLang -> Bool # (>=) :: SumLang -> SumLang -> Bool # max :: SumLang -> SumLang -> SumLang # min :: SumLang -> SumLang -> SumLang #
Show SumLang Source #
Methods showsPrec :: Int -> SumLang -> ShowS # show :: SumLang -> String # showList :: [SumLang] -> ShowS #
Generic SumLang Source #
Associated Types type Rep SumLang :: * -> * # Methods from :: SumLang -> Rep SumLang x # to :: Rep SumLang x -> SumLang #
EmitXml SumLang Source #
Methods emitXml :: SumLang -> XmlRep Source #
type Rep SumLang Source #
type Rep SumLang = D1 * (MetaData "SumLang" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "SumLang" PrefixI False) (U1 *))

parseSumLang :: String -> XParse SumLang Source #

data SumNumberOrNormal Source #

number-or-normal (union)

Constructors

NumberOrNormalNormal

normal

Instances

Bounded SumNumberOrNormal Source #
Methods minBound :: SumNumberOrNormal # maxBound :: SumNumberOrNormal #
Enum SumNumberOrNormal Source #
Methods succ :: SumNumberOrNormal -> SumNumberOrNormal # pred :: SumNumberOrNormal -> SumNumberOrNormal # toEnum :: Int -> SumNumberOrNormal # fromEnum :: SumNumberOrNormal -> Int # enumFrom :: SumNumberOrNormal -> [SumNumberOrNormal] # enumFromThen :: SumNumberOrNormal -> SumNumberOrNormal -> [SumNumberOrNormal] # enumFromTo :: SumNumberOrNormal -> SumNumberOrNormal -> [SumNumberOrNormal] # enumFromThenTo :: SumNumberOrNormal -> SumNumberOrNormal -> SumNumberOrNormal -> [SumNumberOrNormal] #
Eq SumNumberOrNormal Source #
Methods (==) :: SumNumberOrNormal -> SumNumberOrNormal -> Bool # (/=) :: SumNumberOrNormal -> SumNumberOrNormal -> Bool #
Ord SumNumberOrNormal Source #
Methods compare :: SumNumberOrNormal -> SumNumberOrNormal -> Ordering # (<) :: SumNumberOrNormal -> SumNumberOrNormal -> Bool # (<=) :: SumNumberOrNormal -> SumNumberOrNormal -> Bool # (>) :: SumNumberOrNormal -> SumNumberOrNormal -> Bool # (>=) :: SumNumberOrNormal -> SumNumberOrNormal -> Bool # max :: SumNumberOrNormal -> SumNumberOrNormal -> SumNumberOrNormal # min :: SumNumberOrNormal -> SumNumberOrNormal -> SumNumberOrNormal #
Show SumNumberOrNormal Source #
Methods showsPrec :: Int -> SumNumberOrNormal -> ShowS # show :: SumNumberOrNormal -> String # showList :: [SumNumberOrNormal] -> ShowS #
Generic SumNumberOrNormal Source #
Associated Types type Rep SumNumberOrNormal :: * -> * # Methods from :: SumNumberOrNormal -> Rep SumNumberOrNormal x # to :: Rep SumNumberOrNormal x -> SumNumberOrNormal #
EmitXml SumNumberOrNormal Source #
Methods emitXml :: SumNumberOrNormal -> XmlRep Source #
type Rep SumNumberOrNormal Source #
type Rep SumNumberOrNormal = D1 * (MetaData "SumNumberOrNormal" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "NumberOrNormalNormal" PrefixI False) (U1 *))

parseSumNumberOrNormal :: String -> XParse SumNumberOrNormal Source #

data SumPositiveIntegerOrEmpty Source #

positive-integer-or-empty (union)

Constructors

SumPositiveIntegerOrEmpty

//

Instances

Bounded SumPositiveIntegerOrEmpty Source #
Methods minBound :: SumPositiveIntegerOrEmpty # maxBound :: SumPositiveIntegerOrEmpty #
Enum SumPositiveIntegerOrEmpty Source #
Methods succ :: SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty # pred :: SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty # toEnum :: Int -> SumPositiveIntegerOrEmpty # fromEnum :: SumPositiveIntegerOrEmpty -> Int # enumFrom :: SumPositiveIntegerOrEmpty -> [SumPositiveIntegerOrEmpty] # enumFromThen :: SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty -> [SumPositiveIntegerOrEmpty] # enumFromTo :: SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty -> [SumPositiveIntegerOrEmpty] # enumFromThenTo :: SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty -> [SumPositiveIntegerOrEmpty] #
Eq SumPositiveIntegerOrEmpty Source #
Methods (==) :: SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty -> Bool # (/=) :: SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty -> Bool #
Ord SumPositiveIntegerOrEmpty Source #
Methods compare :: SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty -> Ordering # (<) :: SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty -> Bool # (<=) :: SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty -> Bool # (>) :: SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty -> Bool # (>=) :: SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty -> Bool # max :: SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty # min :: SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty -> SumPositiveIntegerOrEmpty #
Show SumPositiveIntegerOrEmpty Source #
Methods showsPrec :: Int -> SumPositiveIntegerOrEmpty -> ShowS # show :: SumPositiveIntegerOrEmpty -> String # showList :: [SumPositiveIntegerOrEmpty] -> ShowS #
Generic SumPositiveIntegerOrEmpty Source #
Associated Types type Rep SumPositiveIntegerOrEmpty :: * -> * # Methods from :: SumPositiveIntegerOrEmpty -> Rep SumPositiveIntegerOrEmpty x # to :: Rep SumPositiveIntegerOrEmpty x -> SumPositiveIntegerOrEmpty #
EmitXml SumPositiveIntegerOrEmpty Source #
Methods emitXml :: SumPositiveIntegerOrEmpty -> XmlRep Source #
type Rep SumPositiveIntegerOrEmpty Source #
type Rep SumPositiveIntegerOrEmpty = D1 * (MetaData "SumPositiveIntegerOrEmpty" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "SumPositiveIntegerOrEmpty" PrefixI False) (U1 *))

parseSumPositiveIntegerOrEmpty :: String -> XParse SumPositiveIntegerOrEmpty Source #

data Accidental Source #

accidental (complex)

The accidental type represents actual notated accidentals. Editorial and cautionary indications are indicated by attributes. Values for these attributes are "no" if not present. Specific graphic display such as parentheses, brackets, and size are controlled by the level-display attribute group.

Constructors

Accidental

Fields

accidentalAccidentalValue :: AccidentalValue
text content
accidentalCautionary :: Maybe YesNo
cautionary attribute
accidentalEditorial :: Maybe YesNo
editorial attribute
accidentalParentheses :: Maybe YesNo
parentheses attribute
accidentalBracket :: Maybe YesNo
bracket attribute
accidentalSize :: Maybe SymbolSize
size attribute
accidentalDefaultX :: Maybe Tenths
default-x attribute
accidentalDefaultY :: Maybe Tenths
default-y attribute
accidentalRelativeX :: Maybe Tenths
relative-x attribute
accidentalRelativeY :: Maybe Tenths
relative-y attribute
accidentalFontFamily :: Maybe CommaSeparatedText
font-family attribute
accidentalFontStyle :: Maybe FontStyle
font-style attribute
accidentalFontSize :: Maybe FontSize
font-size attribute
accidentalFontWeight :: Maybe FontWeight
font-weight attribute
accidentalColor :: Maybe Color
color attribute

Instances

Eq Accidental Source #
Methods (==) :: Accidental -> Accidental -> Bool # (/=) :: Accidental -> Accidental -> Bool #
Show Accidental Source #
Methods showsPrec :: Int -> Accidental -> ShowS # show :: Accidental -> String # showList :: [Accidental] -> ShowS #
Generic Accidental Source #
Associated Types type Rep Accidental :: * -> * # Methods from :: Accidental -> Rep Accidental x # to :: Rep Accidental x -> Accidental #
EmitXml Accidental Source #
Methods emitXml :: Accidental -> XmlRep Source #
type Rep Accidental Source #
type Rep Accidental = D1 * (MetaData "Accidental" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Accidental" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "accidentalAccidentalValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * AccidentalValue)) ((::) (S1 * (MetaSel (Just Symbol "accidentalCautionary") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "accidentalEditorial") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "accidentalParentheses") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "accidentalBracket") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "accidentalSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe SymbolSize))) (S1 * (MetaSel (Just Symbol "accidentalDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "accidentalDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "accidentalRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "accidentalRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "accidentalFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "accidentalFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "accidentalFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize)))) ((::) (S1 * (MetaSel (Just Symbol "accidentalFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "accidentalColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseAccidental :: XParse Accidental Source #

mkAccidental :: AccidentalValue -> Accidental Source #

Smart constructor for Accidental

data AccidentalMark Source #

accidental-mark (complex)

An accidental-mark can be used as a separate notation or as part of an ornament. When used in an ornament, position and placement are relative to the ornament, not relative to the note.

Constructors

AccidentalMark

Fields

accidentalMarkAccidentalValue :: AccidentalValue
text content
accidentalMarkDefaultX :: Maybe Tenths
default-x attribute
accidentalMarkDefaultY :: Maybe Tenths
default-y attribute
accidentalMarkRelativeX :: Maybe Tenths
relative-x attribute
accidentalMarkRelativeY :: Maybe Tenths
relative-y attribute
accidentalMarkFontFamily :: Maybe CommaSeparatedText
font-family attribute
accidentalMarkFontStyle :: Maybe FontStyle
font-style attribute
accidentalMarkFontSize :: Maybe FontSize
font-size attribute
accidentalMarkFontWeight :: Maybe FontWeight
font-weight attribute
accidentalMarkColor :: Maybe Color
color attribute
accidentalMarkPlacement :: Maybe AboveBelow
placement attribute

Instances

Eq AccidentalMark Source #
Methods (==) :: AccidentalMark -> AccidentalMark -> Bool # (/=) :: AccidentalMark -> AccidentalMark -> Bool #
Show AccidentalMark Source #
Methods showsPrec :: Int -> AccidentalMark -> ShowS # show :: AccidentalMark -> String # showList :: [AccidentalMark] -> ShowS #
Generic AccidentalMark Source #
Associated Types type Rep AccidentalMark :: * -> * # Methods from :: AccidentalMark -> Rep AccidentalMark x # to :: Rep AccidentalMark x -> AccidentalMark #
EmitXml AccidentalMark Source #
Methods emitXml :: AccidentalMark -> XmlRep Source #
type Rep AccidentalMark Source #
type Rep AccidentalMark = D1 * (MetaData "AccidentalMark" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "AccidentalMark" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "accidentalMarkAccidentalValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * AccidentalValue)) (S1 * (MetaSel (Just Symbol "accidentalMarkDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "accidentalMarkDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "accidentalMarkRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "accidentalMarkRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "accidentalMarkFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) ((::) (S1 * (MetaSel (Just Symbol "accidentalMarkFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "accidentalMarkFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))))) ((::) (S1 * (MetaSel (Just Symbol "accidentalMarkFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) ((::) (S1 * (MetaSel (Just Symbol "accidentalMarkColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "accidentalMarkPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow))))))))

parseAccidentalMark :: XParse AccidentalMark Source #

mkAccidentalMark :: AccidentalValue -> AccidentalMark Source #

Smart constructor for AccidentalMark

data AccidentalText Source #

accidental-text (complex)

The accidental-text type represents an element with an accidental value and text-formatting attributes.

Constructors

AccidentalText

Fields

accidentalTextAccidentalValue :: AccidentalValue
text content
accidentalTextLang :: Maybe Lang
xml:lang attribute
accidentalTextEnclosure :: Maybe Enclosure
enclosure attribute
accidentalTextJustify :: Maybe LeftCenterRight
justify attribute
accidentalTextHalign :: Maybe LeftCenterRight
halign attribute
accidentalTextValign :: Maybe Valign
valign attribute
accidentalTextDefaultX :: Maybe Tenths
default-x attribute
accidentalTextDefaultY :: Maybe Tenths
default-y attribute
accidentalTextRelativeX :: Maybe Tenths
relative-x attribute
accidentalTextRelativeY :: Maybe Tenths
relative-y attribute
accidentalTextFontFamily :: Maybe CommaSeparatedText
font-family attribute
accidentalTextFontStyle :: Maybe FontStyle
font-style attribute
accidentalTextFontSize :: Maybe FontSize
font-size attribute
accidentalTextFontWeight :: Maybe FontWeight
font-weight attribute
accidentalTextColor :: Maybe Color
color attribute
accidentalTextUnderline :: Maybe NumberOfLines
underline attribute
accidentalTextOverline :: Maybe NumberOfLines
overline attribute
accidentalTextLineThrough :: Maybe NumberOfLines
line-through attribute
accidentalTextRotation :: Maybe RotationDegrees
rotation attribute
accidentalTextLetterSpacing :: Maybe NumberOrNormal
letter-spacing attribute
accidentalTextLineHeight :: Maybe NumberOrNormal
line-height attribute
accidentalTextDir :: Maybe TextDirection
dir attribute

Instances

Eq AccidentalText Source #
Methods (==) :: AccidentalText -> AccidentalText -> Bool # (/=) :: AccidentalText -> AccidentalText -> Bool #
Show AccidentalText Source #
Methods showsPrec :: Int -> AccidentalText -> ShowS # show :: AccidentalText -> String # showList :: [AccidentalText] -> ShowS #
Generic AccidentalText Source #
Associated Types type Rep AccidentalText :: * -> * # Methods from :: AccidentalText -> Rep AccidentalText x # to :: Rep AccidentalText x -> AccidentalText #
EmitXml AccidentalText Source #
Methods emitXml :: AccidentalText -> XmlRep Source #
type Rep AccidentalText Source #
type Rep AccidentalText = D1 * (MetaData "AccidentalText" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "AccidentalText" PrefixI True) ((::) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "accidentalTextAccidentalValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * AccidentalValue)) (S1 * (MetaSel (Just Symbol "accidentalTextLang") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Lang)))) ((::) (S1 * (MetaSel (Just Symbol "accidentalTextEnclosure") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Enclosure))) ((::) (S1 * (MetaSel (Just Symbol "accidentalTextJustify") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LeftCenterRight))) (S1 * (MetaSel (Just Symbol "accidentalTextHalign") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LeftCenterRight)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "accidentalTextValign") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Valign))) ((::) (S1 * (MetaSel (Just Symbol "accidentalTextDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "accidentalTextDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) (S1 * (MetaSel (Just Symbol "accidentalTextRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "accidentalTextRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "accidentalTextFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "accidentalTextFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "accidentalTextFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize)))) ((::) (S1 * (MetaSel (Just Symbol "accidentalTextFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) ((::) (S1 * (MetaSel (Just Symbol "accidentalTextColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "accidentalTextUnderline") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOfLines)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "accidentalTextOverline") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOfLines))) ((::) (S1 * (MetaSel (Just Symbol "accidentalTextLineThrough") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOfLines))) (S1 * (MetaSel (Just Symbol "accidentalTextRotation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe RotationDegrees))))) ((::) (S1 * (MetaSel (Just Symbol "accidentalTextLetterSpacing") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOrNormal))) ((::) (S1 * (MetaSel (Just Symbol "accidentalTextLineHeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOrNormal))) (S1 * (MetaSel (Just Symbol "accidentalTextDir") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TextDirection)))))))))

parseAccidentalText :: XParse AccidentalText Source #

mkAccidentalText :: AccidentalValue -> AccidentalText Source #

Smart constructor for AccidentalText

data Accord Source #

accord (complex)

The accord type represents the tuning of a single string in the scordatura element. It uses the same group of elements as the staff-tuning element. Strings are numbered from high to low.

Constructors

Accord
Fields accordString :: Maybe StringNumber string attribute accordTuning :: Tuning

Instances

Eq Accord Source #
Methods (==) :: Accord -> Accord -> Bool # (/=) :: Accord -> Accord -> Bool #
Show Accord Source #
Methods showsPrec :: Int -> Accord -> ShowS # show :: Accord -> String # showList :: [Accord] -> ShowS #
Generic Accord Source #
Associated Types type Rep Accord :: * -> * # Methods from :: Accord -> Rep Accord x # to :: Rep Accord x -> Accord #
EmitXml Accord Source #
Methods emitXml :: Accord -> XmlRep Source #
type Rep Accord Source #
type Rep Accord = D1 * (MetaData "Accord" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Accord" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "accordString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StringNumber))) (S1 * (MetaSel (Just Symbol "accordTuning") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Tuning))))

parseAccord :: XParse Accord Source #

mkAccord :: Tuning -> Accord Source #

Smart constructor for Accord

data AccordionRegistration Source #

accordion-registration (complex)

The accordion-registration type is use for accordion registration symbols. These are circular symbols divided horizontally into high, middle, and low sections that correspond to 4', 8', and 16' pipes. Each accordion-high, accordion-middle, and accordion-low element represents the presence of one or more dots in the registration diagram. An accordion-registration element needs to have at least one of the child elements present.

Constructors

AccordionRegistration

Fields

accordionRegistrationDefaultX :: Maybe Tenths
default-x attribute
accordionRegistrationDefaultY :: Maybe Tenths
default-y attribute
accordionRegistrationRelativeX :: Maybe Tenths
relative-x attribute
accordionRegistrationRelativeY :: Maybe Tenths
relative-y attribute
accordionRegistrationFontFamily :: Maybe CommaSeparatedText
font-family attribute
accordionRegistrationFontStyle :: Maybe FontStyle
font-style attribute
accordionRegistrationFontSize :: Maybe FontSize
font-size attribute
accordionRegistrationFontWeight :: Maybe FontWeight
font-weight attribute
accordionRegistrationColor :: Maybe Color
color attribute
accordionRegistrationAccordionHigh :: Maybe Empty
accordion-high child element
accordionRegistrationAccordionMiddle :: Maybe AccordionMiddle
accordion-middle child element
accordionRegistrationAccordionLow :: Maybe Empty
accordion-low child element

Instances

Eq AccordionRegistration Source #
Methods (==) :: AccordionRegistration -> AccordionRegistration -> Bool # (/=) :: AccordionRegistration -> AccordionRegistration -> Bool #
Show AccordionRegistration Source #
Methods showsPrec :: Int -> AccordionRegistration -> ShowS # show :: AccordionRegistration -> String # showList :: [AccordionRegistration] -> ShowS #
Generic AccordionRegistration Source #
Associated Types type Rep AccordionRegistration :: * -> * # Methods from :: AccordionRegistration -> Rep AccordionRegistration x # to :: Rep AccordionRegistration x -> AccordionRegistration #
EmitXml AccordionRegistration Source #
Methods emitXml :: AccordionRegistration -> XmlRep Source #
type Rep AccordionRegistration Source #
type Rep AccordionRegistration = D1 * (MetaData "AccordionRegistration" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "AccordionRegistration" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "accordionRegistrationDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "accordionRegistrationDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "accordionRegistrationRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) (S1 * (MetaSel (Just Symbol "accordionRegistrationRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "accordionRegistrationFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "accordionRegistrationFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "accordionRegistrationFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "accordionRegistrationFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "accordionRegistrationColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))) ((::) (S1 * (MetaSel (Just Symbol "accordionRegistrationAccordionHigh") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Empty))) ((::) (S1 * (MetaSel (Just Symbol "accordionRegistrationAccordionMiddle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AccordionMiddle))) (S1 * (MetaSel (Just Symbol "accordionRegistrationAccordionLow") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Empty))))))))

parseAccordionRegistration :: XParse AccordionRegistration Source #

mkAccordionRegistration :: AccordionRegistration Source #

Smart constructor for AccordionRegistration

data Appearance Source #

appearance (complex)

The appearance type controls general graphical settings for the music's final form appearance on a printed page of display. Currently this includes support for line widths and definitions for note sizes, plus an extension element for other aspects of appearance.

Constructors

Appearance
Fields appearanceLineWidth :: [LineWidth] line-width child element appearanceNoteSize :: [NoteSize] note-size child element appearanceOtherAppearance :: [OtherAppearance] other-appearance child element

Instances

Eq Appearance Source #
Methods (==) :: Appearance -> Appearance -> Bool # (/=) :: Appearance -> Appearance -> Bool #
Show Appearance Source #
Methods showsPrec :: Int -> Appearance -> ShowS # show :: Appearance -> String # showList :: [Appearance] -> ShowS #
Generic Appearance Source #
Associated Types type Rep Appearance :: * -> * # Methods from :: Appearance -> Rep Appearance x # to :: Rep Appearance x -> Appearance #
EmitXml Appearance Source #
Methods emitXml :: Appearance -> XmlRep Source #
type Rep Appearance Source #
type Rep Appearance = D1 * (MetaData "Appearance" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Appearance" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "appearanceLineWidth") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [LineWidth])) ((::) (S1 * (MetaSel (Just Symbol "appearanceNoteSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [NoteSize])) (S1 * (MetaSel (Just Symbol "appearanceOtherAppearance") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [OtherAppearance])))))

parseAppearance :: XParse Appearance Source #

mkAppearance :: Appearance Source #

Smart constructor for Appearance

data Arpeggiate Source #

arpeggiate (complex)

The arpeggiate type indicates that this note is part of an arpeggiated chord. The number attribute can be used to distinguish between two simultaneous chords arpeggiated separately (different numbers) or together (same number). The up-down attribute is used if there is an arrow on the arpeggio sign. By default, arpeggios go from the lowest to highest note.

Constructors

Arpeggiate

Fields

arpeggiateNumber :: Maybe NumberLevel
number attribute
arpeggiateDirection :: Maybe UpDown
direction attribute
arpeggiateDefaultX :: Maybe Tenths
default-x attribute
arpeggiateDefaultY :: Maybe Tenths
default-y attribute
arpeggiateRelativeX :: Maybe Tenths
relative-x attribute
arpeggiateRelativeY :: Maybe Tenths
relative-y attribute
arpeggiatePlacement :: Maybe AboveBelow
placement attribute
arpeggiateColor :: Maybe Color
color attribute

Instances

Eq Arpeggiate Source #
Methods (==) :: Arpeggiate -> Arpeggiate -> Bool # (/=) :: Arpeggiate -> Arpeggiate -> Bool #
Show Arpeggiate Source #
Methods showsPrec :: Int -> Arpeggiate -> ShowS # show :: Arpeggiate -> String # showList :: [Arpeggiate] -> ShowS #
Generic Arpeggiate Source #
Associated Types type Rep Arpeggiate :: * -> * # Methods from :: Arpeggiate -> Rep Arpeggiate x # to :: Rep Arpeggiate x -> Arpeggiate #
EmitXml Arpeggiate Source #
Methods emitXml :: Arpeggiate -> XmlRep Source #
type Rep Arpeggiate Source #
type Rep Arpeggiate = D1 * (MetaData "Arpeggiate" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Arpeggiate" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "arpeggiateNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberLevel))) (S1 * (MetaSel (Just Symbol "arpeggiateDirection") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe UpDown)))) ((::) (S1 * (MetaSel (Just Symbol "arpeggiateDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "arpeggiateDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "arpeggiateRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "arpeggiateRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "arpeggiatePlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow))) (S1 * (MetaSel (Just Symbol "arpeggiateColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))))

parseArpeggiate :: XParse Arpeggiate Source #

mkArpeggiate :: Arpeggiate Source #

Smart constructor for Arpeggiate

data Articulations Source #

articulations (complex)

Articulations and accents are grouped together here.

Constructors

Articulations
Fields articulationsArticulations :: [ChxArticulations]

Instances

Eq Articulations Source #
Methods (==) :: Articulations -> Articulations -> Bool # (/=) :: Articulations -> Articulations -> Bool #
Show Articulations Source #
Methods showsPrec :: Int -> Articulations -> ShowS # show :: Articulations -> String # showList :: [Articulations] -> ShowS #
Generic Articulations Source #
Associated Types type Rep Articulations :: * -> * # Methods from :: Articulations -> Rep Articulations x # to :: Rep Articulations x -> Articulations #
EmitXml Articulations Source #
Methods emitXml :: Articulations -> XmlRep Source #
type Rep Articulations Source #
type Rep Articulations = D1 * (MetaData "Articulations" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Articulations" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsArticulations") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [ChxArticulations])))

parseArticulations :: XParse Articulations Source #

mkArticulations :: Articulations Source #

Smart constructor for Articulations

data Attributes Source #

attributes (complex)

The attributes element contains musical information that typically changes on measure boundaries. This includes key and time signatures, clefs, transpositions, and staving.

Constructors

Attributes

Fields

attributesEditorial :: Editorial
attributesDivisions :: Maybe PositiveDivisions
divisions child element
attributesKey :: [Key]
key child element
attributesTime :: [Time]
time child element
attributesStaves :: Maybe NonNegativeInteger
staves child element
attributesPartSymbol :: Maybe PartSymbol
part-symbol child element
attributesInstruments :: Maybe NonNegativeInteger
instruments child element
attributesClef :: [Clef]
clef child element
attributesStaffDetails :: [StaffDetails]
staff-details child element
attributesTranspose :: Maybe Transpose
transpose child element
attributesDirective :: [Directive]
directive child element
attributesMeasureStyle :: [MeasureStyle]
measure-style child element

Instances

Eq Attributes Source #
Methods (==) :: Attributes -> Attributes -> Bool # (/=) :: Attributes -> Attributes -> Bool #
Show Attributes Source #
Methods showsPrec :: Int -> Attributes -> ShowS # show :: Attributes -> String # showList :: [Attributes] -> ShowS #
Generic Attributes Source #
Associated Types type Rep Attributes :: * -> * # Methods from :: Attributes -> Rep Attributes x # to :: Rep Attributes x -> Attributes #
EmitXml Attributes Source #
Methods emitXml :: Attributes -> XmlRep Source #
type Rep Attributes Source #
type Rep Attributes = D1 * (MetaData "Attributes" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Attributes" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "attributesEditorial") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Editorial)) ((::) (S1 * (MetaSel (Just Symbol "attributesDivisions") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe PositiveDivisions))) (S1 * (MetaSel (Just Symbol "attributesKey") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Key])))) ((::) (S1 * (MetaSel (Just Symbol "attributesTime") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Time])) ((::) (S1 * (MetaSel (Just Symbol "attributesStaves") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NonNegativeInteger))) (S1 * (MetaSel (Just Symbol "attributesPartSymbol") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe PartSymbol)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "attributesInstruments") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NonNegativeInteger))) ((::) (S1 * (MetaSel (Just Symbol "attributesClef") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Clef])) (S1 * (MetaSel (Just Symbol "attributesStaffDetails") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [StaffDetails])))) ((::) (S1 * (MetaSel (Just Symbol "attributesTranspose") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Transpose))) ((::) (S1 * (MetaSel (Just Symbol "attributesDirective") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Directive])) (S1 * (MetaSel (Just Symbol "attributesMeasureStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [MeasureStyle])))))))

parseAttributes :: XParse Attributes Source #

mkAttributes :: Editorial -> Attributes Source #

Smart constructor for Attributes

data Backup Source #

backup (complex)

The backup and forward elements are required to coordinate multiple voices in one part, including music on multiple staves. The backup type is generally used to move between voices and staves. Thus the backup element does not include voice or staff elements. Duration values should always be positive, and should not cross measure boundaries.

Constructors

Backup
Fields backupDuration :: Duration backupEditorial :: Editorial

Instances

Eq Backup Source #
Methods (==) :: Backup -> Backup -> Bool # (/=) :: Backup -> Backup -> Bool #
Show Backup Source #
Methods showsPrec :: Int -> Backup -> ShowS # show :: Backup -> String # showList :: [Backup] -> ShowS #
Generic Backup Source #
Associated Types type Rep Backup :: * -> * # Methods from :: Backup -> Rep Backup x # to :: Rep Backup x -> Backup #
EmitXml Backup Source #
Methods emitXml :: Backup -> XmlRep Source #
type Rep Backup Source #
type Rep Backup = D1 * (MetaData "Backup" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Backup" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "backupDuration") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Duration)) (S1 * (MetaSel (Just Symbol "backupEditorial") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Editorial))))

parseBackup :: XParse Backup Source #

mkBackup :: Duration -> Editorial -> Backup Source #

Smart constructor for Backup

data BarStyleColor Source #

bar-style-color (complex)

The bar-style-color type contains barline style and color information.

Constructors

BarStyleColor
Fields barStyleColorBarStyle :: BarStyle text content barStyleColorColor :: Maybe Color color attribute

Instances

Eq BarStyleColor Source #
Methods (==) :: BarStyleColor -> BarStyleColor -> Bool # (/=) :: BarStyleColor -> BarStyleColor -> Bool #
Show BarStyleColor Source #
Methods showsPrec :: Int -> BarStyleColor -> ShowS # show :: BarStyleColor -> String # showList :: [BarStyleColor] -> ShowS #
Generic BarStyleColor Source #
Associated Types type Rep BarStyleColor :: * -> * # Methods from :: BarStyleColor -> Rep BarStyleColor x # to :: Rep BarStyleColor x -> BarStyleColor #
EmitXml BarStyleColor Source #
Methods emitXml :: BarStyleColor -> XmlRep Source #
type Rep BarStyleColor Source #
type Rep BarStyleColor = D1 * (MetaData "BarStyleColor" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "BarStyleColor" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "barStyleColorBarStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * BarStyle)) (S1 * (MetaSel (Just Symbol "barStyleColorColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))

parseBarStyleColor :: XParse BarStyleColor Source #

mkBarStyleColor :: BarStyle -> BarStyleColor Source #

Smart constructor for BarStyleColor

data Barline Source #

barline (complex)

If a barline is other than a normal single barline, it should be represented by a barline type that describes it. This includes information about repeats and multiple endings, as well as line style. Barline data is on the same level as the other musical data in a score - a child of a measure in a partwise score, or a part in a timewise score. This allows for barlines within measures, as in dotted barlines that subdivide measures in complex meters. The two fermata elements allow for fermatas on both sides of the barline (the lower one inverted).

Barlines have a location attribute to make it easier to process barlines independently of the other musical data in a score. It is often easier to set up measures separately from entering notes. The location attribute must match where the barline element occurs within the rest of the musical data in the score. If location is left, it should be the first element in the measure, aside from the print, bookmark, and link elements. If location is right, it should be the last element, again with the possible exception of the print, bookmark, and link elements. If no location is specified, the right barline is the default. The segno, coda, and divisions attributes work the same way as in the sound element. They are used for playback when barline elements contain segno or coda child elements.

Constructors

Barline

Fields

barlineLocation :: Maybe RightLeftMiddle
location attribute
barlineSegno :: Maybe Token
segno attribute
barlineCoda :: Maybe Token
coda attribute
barlineDivisions :: Maybe Divisions
divisions attribute
barlineBarStyle :: Maybe BarStyleColor
bar-style child element
barlineEditorial :: Editorial
barlineWavyLine :: Maybe WavyLine
wavy-line child element
barlineSegno1 :: Maybe EmptyPrintStyle
segno child element
barlineCoda1 :: Maybe EmptyPrintStyle
coda child element
barlineFermata :: [Fermata]
fermata child element
barlineEnding :: Maybe Ending
ending child element
barlineRepeat :: Maybe Repeat
repeat child element

Instances

Eq Barline Source #
Methods (==) :: Barline -> Barline -> Bool # (/=) :: Barline -> Barline -> Bool #
Show Barline Source #
Methods showsPrec :: Int -> Barline -> ShowS # show :: Barline -> String # showList :: [Barline] -> ShowS #
Generic Barline Source #
Associated Types type Rep Barline :: * -> * # Methods from :: Barline -> Rep Barline x # to :: Rep Barline x -> Barline #
EmitXml Barline Source #
Methods emitXml :: Barline -> XmlRep Source #
type Rep Barline Source #
type Rep Barline = D1 * (MetaData "Barline" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Barline" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "barlineLocation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe RightLeftMiddle))) ((::) (S1 * (MetaSel (Just Symbol "barlineSegno") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) (S1 * (MetaSel (Just Symbol "barlineCoda") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))))) ((::) (S1 * (MetaSel (Just Symbol "barlineDivisions") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Divisions))) ((::) (S1 * (MetaSel (Just Symbol "barlineBarStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe BarStyleColor))) (S1 * (MetaSel (Just Symbol "barlineEditorial") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Editorial))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "barlineWavyLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe WavyLine))) ((::) (S1 * (MetaSel (Just Symbol "barlineSegno1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe EmptyPrintStyle))) (S1 * (MetaSel (Just Symbol "barlineCoda1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe EmptyPrintStyle))))) ((::) (S1 * (MetaSel (Just Symbol "barlineFermata") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Fermata])) ((::) (S1 * (MetaSel (Just Symbol "barlineEnding") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Ending))) (S1 * (MetaSel (Just Symbol "barlineRepeat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Repeat))))))))

parseBarline :: XParse Barline Source #

mkBarline :: Editorial -> Barline Source #

Smart constructor for Barline

data Barre Source #

barre (complex)

The barre element indicates placing a finger over multiple strings on a single fret. The type is "start" for the lowest pitched string (e.g., the string with the highest MusicXML number) and is "stop" for the highest pitched string.

Constructors

Barre
Fields barreType :: StartStop type attribute barreColor :: Maybe Color color attribute

Instances

Eq Barre Source #
Methods (==) :: Barre -> Barre -> Bool # (/=) :: Barre -> Barre -> Bool #
Show Barre Source #
Methods showsPrec :: Int -> Barre -> ShowS # show :: Barre -> String # showList :: [Barre] -> ShowS #
Generic Barre Source #
Associated Types type Rep Barre :: * -> * # Methods from :: Barre -> Rep Barre x # to :: Rep Barre x -> Barre #
EmitXml Barre Source #
Methods emitXml :: Barre -> XmlRep Source #
type Rep Barre Source #
type Rep Barre = D1 * (MetaData "Barre" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Barre" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "barreType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStop)) (S1 * (MetaSel (Just Symbol "barreColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))

parseBarre :: XParse Barre Source #

mkBarre :: StartStop -> Barre Source #

Smart constructor for Barre

data Bass Source #

bass (complex)

The bass type is used to indicate a bass note in popular music chord symbols, e.g. G/C. It is generally not used in functional harmony, as inversion is generally not used in pop chord symbols. As with root, it is divided into step and alter elements, similar to pitches.

Constructors

Bass
Fields bassBassStep :: BassStep bass-step child element bassBassAlter :: Maybe BassAlter bass-alter child element

Instances

Eq Bass Source #
Methods (==) :: Bass -> Bass -> Bool # (/=) :: Bass -> Bass -> Bool #
Show Bass Source #
Methods showsPrec :: Int -> Bass -> ShowS # show :: Bass -> String # showList :: [Bass] -> ShowS #
Generic Bass Source #
Associated Types type Rep Bass :: * -> * # Methods from :: Bass -> Rep Bass x # to :: Rep Bass x -> Bass #
EmitXml Bass Source #
Methods emitXml :: Bass -> XmlRep Source #
type Rep Bass Source #
type Rep Bass = D1 * (MetaData "Bass" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Bass" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "bassBassStep") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * BassStep)) (S1 * (MetaSel (Just Symbol "bassBassAlter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe BassAlter)))))

parseBass :: XParse Bass Source #

mkBass :: BassStep -> Bass Source #

Smart constructor for Bass

data BassAlter Source #

bass-alter (complex)

The bass-alter type represents the chromatic alteration of the bass of the current chord within the harmony element. In some chord styles, the text for the bass-step element may include bass-alter information. In that case, the print-object attribute of the bass-alter element can be set to no. The location attribute indicates whether the alteration should appear to the left or the right of the bass-step; it is right by default.

Constructors

BassAlter

Fields

bassAlterSemitones :: Semitones
text content
bassAlterLocation :: Maybe LeftRight
location attribute
bassAlterPrintObject :: Maybe YesNo
print-object attribute
bassAlterDefaultX :: Maybe Tenths
default-x attribute
bassAlterDefaultY :: Maybe Tenths
default-y attribute
bassAlterRelativeX :: Maybe Tenths
relative-x attribute
bassAlterRelativeY :: Maybe Tenths
relative-y attribute
bassAlterFontFamily :: Maybe CommaSeparatedText
font-family attribute
bassAlterFontStyle :: Maybe FontStyle
font-style attribute
bassAlterFontSize :: Maybe FontSize
font-size attribute
bassAlterFontWeight :: Maybe FontWeight
font-weight attribute
bassAlterColor :: Maybe Color
color attribute

Instances

Eq BassAlter Source #
Methods (==) :: BassAlter -> BassAlter -> Bool # (/=) :: BassAlter -> BassAlter -> Bool #
Show BassAlter Source #
Methods showsPrec :: Int -> BassAlter -> ShowS # show :: BassAlter -> String # showList :: [BassAlter] -> ShowS #
Generic BassAlter Source #
Associated Types type Rep BassAlter :: * -> * # Methods from :: BassAlter -> Rep BassAlter x # to :: Rep BassAlter x -> BassAlter #
EmitXml BassAlter Source #
Methods emitXml :: BassAlter -> XmlRep Source #
type Rep BassAlter Source #
type Rep BassAlter = D1 * (MetaData "BassAlter" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "BassAlter" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "bassAlterSemitones") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Semitones)) ((::) (S1 * (MetaSel (Just Symbol "bassAlterLocation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LeftRight))) (S1 * (MetaSel (Just Symbol "bassAlterPrintObject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))))) ((::) (S1 * (MetaSel (Just Symbol "bassAlterDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "bassAlterDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "bassAlterRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "bassAlterRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "bassAlterFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "bassAlterFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) (S1 * (MetaSel (Just Symbol "bassAlterFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "bassAlterFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "bassAlterColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseBassAlter :: XParse BassAlter Source #

mkBassAlter :: Semitones -> BassAlter Source #

Smart constructor for BassAlter

data BassStep Source #

bass-step (complex)

The bass-step type represents the pitch step of the bass of the current chord within the harmony element. The text attribute indicates how the bass should appear on the page if not using the element contents.

Constructors

BassStep

Fields

bassStepStep :: Step
text content
bassStepText :: Maybe Token
text attribute
bassStepDefaultX :: Maybe Tenths
default-x attribute
bassStepDefaultY :: Maybe Tenths
default-y attribute
bassStepRelativeX :: Maybe Tenths
relative-x attribute
bassStepRelativeY :: Maybe Tenths
relative-y attribute
bassStepFontFamily :: Maybe CommaSeparatedText
font-family attribute
bassStepFontStyle :: Maybe FontStyle
font-style attribute
bassStepFontSize :: Maybe FontSize
font-size attribute
bassStepFontWeight :: Maybe FontWeight
font-weight attribute
bassStepColor :: Maybe Color
color attribute

Instances

Eq BassStep Source #
Methods (==) :: BassStep -> BassStep -> Bool # (/=) :: BassStep -> BassStep -> Bool #
Show BassStep Source #
Methods showsPrec :: Int -> BassStep -> ShowS # show :: BassStep -> String # showList :: [BassStep] -> ShowS #
Generic BassStep Source #
Associated Types type Rep BassStep :: * -> * # Methods from :: BassStep -> Rep BassStep x # to :: Rep BassStep x -> BassStep #
EmitXml BassStep Source #
Methods emitXml :: BassStep -> XmlRep Source #
type Rep BassStep Source #
type Rep BassStep = D1 * (MetaData "BassStep" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "BassStep" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "bassStepStep") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Step)) (S1 * (MetaSel (Just Symbol "bassStepText") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token)))) ((::) (S1 * (MetaSel (Just Symbol "bassStepDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "bassStepDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "bassStepRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "bassStepRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "bassStepFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "bassStepFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) (S1 * (MetaSel (Just Symbol "bassStepFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "bassStepFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "bassStepColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseBassStep :: XParse BassStep Source #

mkBassStep :: Step -> BassStep Source #

Smart constructor for BassStep

data Beam Source #

beam (complex)

Beam values include begin, continue, end, forward hook, and backward hook. Up to six concurrent beam levels are available to cover up to 256th notes. The repeater attribute, used for tremolos, needs to be specified with a "yes" value for each beam using it. Beams that have a begin value can also have a fan attribute to indicate accelerandos and ritardandos using fanned beams. The fan attribute may also be used with a continue value if the fanning direction changes on that note. The value is "none" if not specified.

Note that the beam number does not distinguish sets of beams that overlap, as it does for slur and other elements. Beaming groups are distinguished by being in different voices and/or the presence or absence of grace and cue elements.

Constructors

Beam
Fields beamBeamValue :: BeamValue text content beamNumber :: Maybe BeamLevel number attribute beamRepeater :: Maybe YesNo repeater attribute beamFan :: Maybe Fan fan attribute beamColor :: Maybe Color color attribute

Instances

Eq Beam Source #
Methods (==) :: Beam -> Beam -> Bool # (/=) :: Beam -> Beam -> Bool #
Show Beam Source #
Methods showsPrec :: Int -> Beam -> ShowS # show :: Beam -> String # showList :: [Beam] -> ShowS #
Generic Beam Source #
Associated Types type Rep Beam :: * -> * # Methods from :: Beam -> Rep Beam x # to :: Rep Beam x -> Beam #
EmitXml Beam Source #
Methods emitXml :: Beam -> XmlRep Source #
type Rep Beam Source #
type Rep Beam = D1 * (MetaData "Beam" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Beam" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "beamBeamValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * BeamValue)) (S1 * (MetaSel (Just Symbol "beamNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe BeamLevel)))) ((::) (S1 * (MetaSel (Just Symbol "beamRepeater") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) ((::) (S1 * (MetaSel (Just Symbol "beamFan") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Fan))) (S1 * (MetaSel (Just Symbol "beamColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))))

parseBeam :: XParse Beam Source #

mkBeam :: BeamValue -> Beam Source #

Smart constructor for Beam

data BeatRepeat Source #

beat-repeat (complex)

The beat-repeat type is used to indicate that a single beat (but possibly many notes) is repeated. Both the start and stop of the beat being repeated should be specified. The slashes attribute specifies the number of slashes to use in the symbol. The use-dots attribute indicates whether or not to use dots as well (for instance, with mixed rhythm patterns). By default, the value for slashes is 1 and the value for use-dots is no.

The beat-repeat element specifies a notation style for repetitions. The actual music being repeated needs to be repeated within the MusicXML file. This element specifies the notation that indicates the repeat.

Constructors

BeatRepeat
Fields beatRepeatType :: StartStop type attribute beatRepeatSlashes :: Maybe PositiveInteger slashes attribute beatRepeatUseDots :: Maybe YesNo use-dots attribute beatRepeatSlash :: Maybe Slash

Instances

Eq BeatRepeat Source #
Methods (==) :: BeatRepeat -> BeatRepeat -> Bool # (/=) :: BeatRepeat -> BeatRepeat -> Bool #
Show BeatRepeat Source #
Methods showsPrec :: Int -> BeatRepeat -> ShowS # show :: BeatRepeat -> String # showList :: [BeatRepeat] -> ShowS #
Generic BeatRepeat Source #
Associated Types type Rep BeatRepeat :: * -> * # Methods from :: BeatRepeat -> Rep BeatRepeat x # to :: Rep BeatRepeat x -> BeatRepeat #
EmitXml BeatRepeat Source #
Methods emitXml :: BeatRepeat -> XmlRep Source #
type Rep BeatRepeat Source #
type Rep BeatRepeat = D1 * (MetaData "BeatRepeat" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "BeatRepeat" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "beatRepeatType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStop)) (S1 * (MetaSel (Just Symbol "beatRepeatSlashes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe PositiveInteger)))) ((::) (S1 * (MetaSel (Just Symbol "beatRepeatUseDots") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "beatRepeatSlash") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Slash))))))

parseBeatRepeat :: XParse BeatRepeat Source #

mkBeatRepeat :: StartStop -> BeatRepeat Source #

Smart constructor for BeatRepeat

data Bend Source #

bend (complex)

The bend type is used in guitar and tablature. The bend-alter element indicates the number of steps in the bend, similar to the alter element. As with the alter element, numbers like 0.5 can be used to indicate microtones. Negative numbers indicate pre-bends or releases; the pre-bend and release elements are used to distinguish what is intended. A with-bar element indicates that the bend is to be done at the bridge with a whammy or vibrato bar. The content of the element indicates how this should be notated.

Constructors

Bend

Fields

bendDefaultX :: Maybe Tenths
default-x attribute
bendDefaultY :: Maybe Tenths
default-y attribute
bendRelativeX :: Maybe Tenths
relative-x attribute
bendRelativeY :: Maybe Tenths
relative-y attribute
bendFontFamily :: Maybe CommaSeparatedText
font-family attribute
bendFontStyle :: Maybe FontStyle
font-style attribute
bendFontSize :: Maybe FontSize
font-size attribute
bendFontWeight :: Maybe FontWeight
font-weight attribute
bendColor :: Maybe Color
color attribute
bendAccelerate :: Maybe YesNo
accelerate attribute
bendBeats :: Maybe TrillBeats
beats attribute
bendFirstBeat :: Maybe Percent
first-beat attribute
bendLastBeat :: Maybe Percent
last-beat attribute
bendBendAlter :: Semitones
bend-alter child element
bendBend :: Maybe ChxBend
bendWithBar :: Maybe PlacementText
with-bar child element

Instances

Eq Bend Source #
Methods (==) :: Bend -> Bend -> Bool # (/=) :: Bend -> Bend -> Bool #
Show Bend Source #
Methods showsPrec :: Int -> Bend -> ShowS # show :: Bend -> String # showList :: [Bend] -> ShowS #
Generic Bend Source #
Associated Types type Rep Bend :: * -> * # Methods from :: Bend -> Rep Bend x # to :: Rep Bend x -> Bend #
EmitXml Bend Source #
Methods emitXml :: Bend -> XmlRep Source #
type Rep Bend Source #
type Rep Bend = D1 * (MetaData "Bend" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Bend" PrefixI True) ((::) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "bendDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "bendDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "bendRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "bendRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "bendFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "bendFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle)))) ((::) (S1 * (MetaSel (Just Symbol "bendFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "bendFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight)))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "bendColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "bendAccelerate") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "bendBeats") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TrillBeats))) (S1 * (MetaSel (Just Symbol "bendFirstBeat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Percent))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "bendLastBeat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Percent))) (S1 * (MetaSel (Just Symbol "bendBendAlter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Semitones))) ((::) (S1 * (MetaSel (Just Symbol "bendBend") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe ChxBend))) (S1 * (MetaSel (Just Symbol "bendWithBar") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe PlacementText))))))))

parseBend :: XParse Bend Source #

mkBend :: Semitones -> Bend Source #

Smart constructor for Bend

data Bookmark Source #

bookmark (complex)

The bookmark type serves as a well-defined target for an incoming simple XLink.

Constructors

Bookmark
Fields bookmarkId :: ID id attribute bookmarkName :: Maybe Token name attribute bookmarkElement :: Maybe NMTOKEN element attribute bookmarkPosition :: Maybe PositiveInteger position attribute

Instances

Eq Bookmark Source #
Methods (==) :: Bookmark -> Bookmark -> Bool # (/=) :: Bookmark -> Bookmark -> Bool #
Show Bookmark Source #
Methods showsPrec :: Int -> Bookmark -> ShowS # show :: Bookmark -> String # showList :: [Bookmark] -> ShowS #
Generic Bookmark Source #
Associated Types type Rep Bookmark :: * -> * # Methods from :: Bookmark -> Rep Bookmark x # to :: Rep Bookmark x -> Bookmark #
EmitXml Bookmark Source #
Methods emitXml :: Bookmark -> XmlRep Source #
type Rep Bookmark Source #
type Rep Bookmark = D1 * (MetaData "Bookmark" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Bookmark" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "bookmarkId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ID)) (S1 * (MetaSel (Just Symbol "bookmarkName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token)))) ((::) (S1 * (MetaSel (Just Symbol "bookmarkElement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NMTOKEN))) (S1 * (MetaSel (Just Symbol "bookmarkPosition") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe PositiveInteger))))))

parseBookmark :: XParse Bookmark Source #

mkBookmark :: ID -> Bookmark Source #

Smart constructor for Bookmark

data Bracket Source #

bracket (complex)

Brackets are combined with words in a variety of modern directions. The line-end attribute specifies if there is a jog up or down (or both), an arrow, or nothing at the start or end of the bracket. If the line-end is up or down, the length of the jog can be specified using the end-length attribute. The line-type is solid by default.

Constructors

Bracket

Fields

bracketType :: StartStop
type attribute
bracketNumber :: Maybe NumberLevel
number attribute
bracketLineEnd :: LineEnd
line-end attribute
bracketEndLength :: Maybe Tenths
end-length attribute
bracketLineType :: Maybe LineType
line-type attribute
bracketDefaultX :: Maybe Tenths
default-x attribute
bracketDefaultY :: Maybe Tenths
default-y attribute
bracketRelativeX :: Maybe Tenths
relative-x attribute
bracketRelativeY :: Maybe Tenths
relative-y attribute
bracketColor :: Maybe Color
color attribute

Instances

Eq Bracket Source #
Methods (==) :: Bracket -> Bracket -> Bool # (/=) :: Bracket -> Bracket -> Bool #
Show Bracket Source #
Methods showsPrec :: Int -> Bracket -> ShowS # show :: Bracket -> String # showList :: [Bracket] -> ShowS #
Generic Bracket Source #
Associated Types type Rep Bracket :: * -> * # Methods from :: Bracket -> Rep Bracket x # to :: Rep Bracket x -> Bracket #
EmitXml Bracket Source #
Methods emitXml :: Bracket -> XmlRep Source #
type Rep Bracket Source #
type Rep Bracket = D1 * (MetaData "Bracket" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Bracket" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "bracketType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStop)) (S1 * (MetaSel (Just Symbol "bracketNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberLevel)))) ((::) (S1 * (MetaSel (Just Symbol "bracketLineEnd") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * LineEnd)) ((::) (S1 * (MetaSel (Just Symbol "bracketEndLength") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "bracketLineType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LineType)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "bracketDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "bracketDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "bracketRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "bracketRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "bracketColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseBracket :: XParse Bracket Source #

mkBracket :: StartStop -> LineEnd -> Bracket Source #

Smart constructor for Bracket

data Cancel Source #

cancel (complex)

A cancel element indicates that the old key signature should be cancelled before the new one appears. This will always happen when changing to C major or A minor and need not be specified then. The cancel value matches the fifths value of the cancelled key signature (e.g., a cancel of -2 will provide an explicit cancellation for changing from B flat major to F major). The optional location attribute indicates whether the cancellation appears to the left or the right of the new key signature. It is left by default.

Constructors

Cancel
Fields cancelFifths :: Fifths text content cancelLocation :: Maybe LeftRight location attribute

Instances

Eq Cancel Source #
Methods (==) :: Cancel -> Cancel -> Bool # (/=) :: Cancel -> Cancel -> Bool #
Show Cancel Source #
Methods showsPrec :: Int -> Cancel -> ShowS # show :: Cancel -> String # showList :: [Cancel] -> ShowS #
Generic Cancel Source #
Associated Types type Rep Cancel :: * -> * # Methods from :: Cancel -> Rep Cancel x # to :: Rep Cancel x -> Cancel #
EmitXml Cancel Source #
Methods emitXml :: Cancel -> XmlRep Source #
type Rep Cancel Source #
type Rep Cancel = D1 * (MetaData "Cancel" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Cancel" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "cancelFifths") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Fifths)) (S1 * (MetaSel (Just Symbol "cancelLocation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LeftRight)))))

parseCancel :: XParse Cancel Source #

mkCancel :: Fifths -> Cancel Source #

Smart constructor for Cancel

data Clef Source #

clef (complex)

Clefs are represented by a combination of sign, line, and clef-octave-change elements. The optional number attribute refers to staff numbers within the part. A value of 1 is assumed if not present.

Sometimes clefs are added to the staff in non-standard line positions, either to indicate cue passages, or when there are multiple clefs present simultaneously on one staff. In this situation, the additional attribute is set to "yes" and the line value is ignored. The size attribute is used for clefs where the additional attribute is "yes". It is typically used to indicate cue clefs.

Constructors

Clef

Fields

clefNumber :: Maybe StaffNumber
number attribute
clefAdditional :: Maybe YesNo
additional attribute
clefSize :: Maybe SymbolSize
size attribute
clefDefaultX :: Maybe Tenths
default-x attribute
clefDefaultY :: Maybe Tenths
default-y attribute
clefRelativeX :: Maybe Tenths
relative-x attribute
clefRelativeY :: Maybe Tenths
relative-y attribute
clefFontFamily :: Maybe CommaSeparatedText
font-family attribute
clefFontStyle :: Maybe FontStyle
font-style attribute
clefFontSize :: Maybe FontSize
font-size attribute
clefFontWeight :: Maybe FontWeight
font-weight attribute
clefColor :: Maybe Color
color attribute
clefPrintObject :: Maybe YesNo
print-object attribute
clefSign :: ClefSign
sign child element
clefLine :: Maybe StaffLine
line child element
clefClefOctaveChange :: Maybe Int
clef-octave-change child element

Instances

Eq Clef Source #
Methods (==) :: Clef -> Clef -> Bool # (/=) :: Clef -> Clef -> Bool #
Show Clef Source #
Methods showsPrec :: Int -> Clef -> ShowS # show :: Clef -> String # showList :: [Clef] -> ShowS #
Generic Clef Source #
Associated Types type Rep Clef :: * -> * # Methods from :: Clef -> Rep Clef x # to :: Rep Clef x -> Clef #
EmitXml Clef Source #
Methods emitXml :: Clef -> XmlRep Source #
type Rep Clef Source #
type Rep Clef = D1 * (MetaData "Clef" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Clef" PrefixI True) ((::) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "clefNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StaffNumber))) (S1 * (MetaSel (Just Symbol "clefAdditional") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "clefSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe SymbolSize))) (S1 * (MetaSel (Just Symbol "clefDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "clefDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "clefRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "clefRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "clefFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText)))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "clefFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "clefFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize)))) ((::) (S1 * (MetaSel (Just Symbol "clefFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "clefColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "clefPrintObject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "clefSign") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ClefSign))) ((::) (S1 * (MetaSel (Just Symbol "clefLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StaffLine))) (S1 * (MetaSel (Just Symbol "clefClefOctaveChange") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Int))))))))

parseClef :: XParse Clef Source #

mkClef :: ClefSign -> Clef Source #

Smart constructor for Clef

data Credit Source #

credit (complex)

The credit type represents the appearance of the title, composer, arranger, lyricist, copyright, dedication, and other text and graphics that commonly appears on the first page of a score. The credit-words and credit-image elements are similar to the words and image elements for directions. However, since the credit is not part of a measure, the default-x and default-y attributes adjust the origin relative to the bottom left-hand corner of the first page. The enclosure for credit-words is none by default.

By default, a series of credit-words elements within a single credit element follow one another in sequence visually. Non-positional formatting attributes are carried over from the previous element by default.

The page attribute for the credit element, new in Version 2.0, specifies the page number where the credit should appear. This is an integer value that starts with 1 for the first page. Its value is 1 by default. Since credits occur before the music, these page numbers do not refer to the page numbering specified by the print element's page-number attribute.

Constructors

Credit
Fields creditPage :: Maybe PositiveInteger page attribute creditLink :: [Link] link child element creditBookmark :: [Bookmark] bookmark child element creditCredit :: ChxCredit

Instances

Eq Credit Source #
Methods (==) :: Credit -> Credit -> Bool # (/=) :: Credit -> Credit -> Bool #
Show Credit Source #
Methods showsPrec :: Int -> Credit -> ShowS # show :: Credit -> String # showList :: [Credit] -> ShowS #
Generic Credit Source #
Associated Types type Rep Credit :: * -> * # Methods from :: Credit -> Rep Credit x # to :: Rep Credit x -> Credit #
EmitXml Credit Source #
Methods emitXml :: Credit -> XmlRep Source #
type Rep Credit Source #
type Rep Credit = D1 * (MetaData "Credit" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Credit" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "creditPage") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe PositiveInteger))) (S1 * (MetaSel (Just Symbol "creditLink") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Link]))) ((::) (S1 * (MetaSel (Just Symbol "creditBookmark") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Bookmark])) (S1 * (MetaSel (Just Symbol "creditCredit") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ChxCredit)))))

parseCredit :: XParse Credit Source #

mkCredit :: ChxCredit -> Credit Source #

Smart constructor for Credit

data Dashes Source #

dashes (complex)

The dashes type represents dashes, used for instance with cresc. and dim. marks.

Constructors

Dashes
Fields dashesType :: StartStop type attribute dashesNumber :: Maybe NumberLevel number attribute dashesDefaultX :: Maybe Tenths default-x attribute dashesDefaultY :: Maybe Tenths default-y attribute dashesRelativeX :: Maybe Tenths relative-x attribute dashesRelativeY :: Maybe Tenths relative-y attribute dashesColor :: Maybe Color color attribute

Instances

Eq Dashes Source #
Methods (==) :: Dashes -> Dashes -> Bool # (/=) :: Dashes -> Dashes -> Bool #
Show Dashes Source #
Methods showsPrec :: Int -> Dashes -> ShowS # show :: Dashes -> String # showList :: [Dashes] -> ShowS #
Generic Dashes Source #
Associated Types type Rep Dashes :: * -> * # Methods from :: Dashes -> Rep Dashes x # to :: Rep Dashes x -> Dashes #
EmitXml Dashes Source #
Methods emitXml :: Dashes -> XmlRep Source #
type Rep Dashes Source #
type Rep Dashes = D1 * (MetaData "Dashes" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Dashes" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "dashesType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStop)) ((::) (S1 * (MetaSel (Just Symbol "dashesNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberLevel))) (S1 * (MetaSel (Just Symbol "dashesDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "dashesDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "dashesRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "dashesRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "dashesColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))))

parseDashes :: XParse Dashes Source #

mkDashes :: StartStop -> Dashes Source #

Smart constructor for Dashes

data Defaults Source #

defaults (complex)

The defaults type specifies score-wide defaults for scaling, layout, and appearance.

Constructors

Defaults

Fields

defaultsScaling :: Maybe Scaling
scaling child element
defaultsLayout :: Layout
defaultsAppearance :: Maybe Appearance
appearance child element
defaultsMusicFont :: Maybe EmptyFont
music-font child element
defaultsWordFont :: Maybe EmptyFont
word-font child element
defaultsLyricFont :: [LyricFont]
lyric-font child element
defaultsLyricLanguage :: [LyricLanguage]
lyric-language child element

Instances

Eq Defaults Source #
Methods (==) :: Defaults -> Defaults -> Bool # (/=) :: Defaults -> Defaults -> Bool #
Show Defaults Source #
Methods showsPrec :: Int -> Defaults -> ShowS # show :: Defaults -> String # showList :: [Defaults] -> ShowS #
Generic Defaults Source #
Associated Types type Rep Defaults :: * -> * # Methods from :: Defaults -> Rep Defaults x # to :: Rep Defaults x -> Defaults #
EmitXml Defaults Source #
Methods emitXml :: Defaults -> XmlRep Source #
type Rep Defaults Source #
type Rep Defaults = D1 * (MetaData "Defaults" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Defaults" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "defaultsScaling") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Scaling))) ((::) (S1 * (MetaSel (Just Symbol "defaultsLayout") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Layout)) (S1 * (MetaSel (Just Symbol "defaultsAppearance") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Appearance))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "defaultsMusicFont") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe EmptyFont))) (S1 * (MetaSel (Just Symbol "defaultsWordFont") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe EmptyFont)))) ((::) (S1 * (MetaSel (Just Symbol "defaultsLyricFont") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [LyricFont])) (S1 * (MetaSel (Just Symbol "defaultsLyricLanguage") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [LyricLanguage]))))))

parseDefaults :: XParse Defaults Source #

mkDefaults :: Layout -> Defaults Source #

Smart constructor for Defaults

data Degree Source #

degree (complex)

The degree type is used to add, alter, or subtract individual notes in the chord. The print-object attribute can be used to keep the degree from printing separately when it has already taken into account in the text attribute of the kind element. The degree-value and degree-type text attributes specify how the value and type of the degree should be displayed.

A harmony of kind "other" can be spelled explicitly by using a series of degree elements together with a root.

Constructors

Degree
Fields degreePrintObject :: Maybe YesNo print-object attribute degreeDegreeValue :: DegreeValue degree-value child element degreeDegreeAlter :: DegreeAlter degree-alter child element degreeDegreeType :: DegreeType degree-type child element

Instances

Eq Degree Source #
Methods (==) :: Degree -> Degree -> Bool # (/=) :: Degree -> Degree -> Bool #
Show Degree Source #
Methods showsPrec :: Int -> Degree -> ShowS # show :: Degree -> String # showList :: [Degree] -> ShowS #
Generic Degree Source #
Associated Types type Rep Degree :: * -> * # Methods from :: Degree -> Rep Degree x # to :: Rep Degree x -> Degree #
EmitXml Degree Source #
Methods emitXml :: Degree -> XmlRep Source #
type Rep Degree Source #
type Rep Degree = D1 * (MetaData "Degree" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Degree" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "degreePrintObject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "degreeDegreeValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * DegreeValue))) ((::) (S1 * (MetaSel (Just Symbol "degreeDegreeAlter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * DegreeAlter)) (S1 * (MetaSel (Just Symbol "degreeDegreeType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * DegreeType)))))

parseDegree :: XParse Degree Source #

mkDegree :: DegreeValue -> DegreeAlter -> DegreeType -> Degree Source #

Smart constructor for Degree

data DegreeAlter Source #

degree-alter (complex)

The degree-alter type represents the chromatic alteration for the current degree. If the degree-type value is alter or subtract, the degree-alter value is relative to the degree already in the chord based on its kind element. If the degree-type value is add, the degree-alter is relative to a dominant chord (major and perfect intervals except for a minor seventh). The plus-minus attribute is used to indicate if plus and minus symbols should be used instead of sharp and flat symbols to display the degree alteration; it is no by default.

Constructors

DegreeAlter

Fields

degreeAlterSemitones :: Semitones
text content
degreeAlterPlusMinus :: Maybe YesNo
plus-minus attribute
degreeAlterDefaultX :: Maybe Tenths
default-x attribute
degreeAlterDefaultY :: Maybe Tenths
default-y attribute
degreeAlterRelativeX :: Maybe Tenths
relative-x attribute
degreeAlterRelativeY :: Maybe Tenths
relative-y attribute
degreeAlterFontFamily :: Maybe CommaSeparatedText
font-family attribute
degreeAlterFontStyle :: Maybe FontStyle
font-style attribute
degreeAlterFontSize :: Maybe FontSize
font-size attribute
degreeAlterFontWeight :: Maybe FontWeight
font-weight attribute
degreeAlterColor :: Maybe Color
color attribute

Instances

Eq DegreeAlter Source #
Methods (==) :: DegreeAlter -> DegreeAlter -> Bool # (/=) :: DegreeAlter -> DegreeAlter -> Bool #
Show DegreeAlter Source #
Methods showsPrec :: Int -> DegreeAlter -> ShowS # show :: DegreeAlter -> String # showList :: [DegreeAlter] -> ShowS #
Generic DegreeAlter Source #
Associated Types type Rep DegreeAlter :: * -> * # Methods from :: DegreeAlter -> Rep DegreeAlter x # to :: Rep DegreeAlter x -> DegreeAlter #
EmitXml DegreeAlter Source #
Methods emitXml :: DegreeAlter -> XmlRep Source #
type Rep DegreeAlter Source #
type Rep DegreeAlter = D1 * (MetaData "DegreeAlter" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "DegreeAlter" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "degreeAlterSemitones") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Semitones)) (S1 * (MetaSel (Just Symbol "degreeAlterPlusMinus") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "degreeAlterDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "degreeAlterDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "degreeAlterRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "degreeAlterRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "degreeAlterFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "degreeAlterFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) (S1 * (MetaSel (Just Symbol "degreeAlterFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "degreeAlterFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "degreeAlterColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseDegreeAlter :: XParse DegreeAlter Source #

mkDegreeAlter :: Semitones -> DegreeAlter Source #

Smart constructor for DegreeAlter

data DegreeType Source #

degree-type (complex)

The degree-type type indicates if this degree is an addition, alteration, or subtraction relative to the kind of the current chord. The value of the degree-type element affects the interpretation of the value of the degree-alter element. The text attribute specifies how the type of the degree should be displayed.

Constructors

DegreeType

Fields

degreeTypeDegreeTypeValue :: DegreeTypeValue
text content
degreeTypeText :: Maybe Token
text attribute
degreeTypeDefaultX :: Maybe Tenths
default-x attribute
degreeTypeDefaultY :: Maybe Tenths
default-y attribute
degreeTypeRelativeX :: Maybe Tenths
relative-x attribute
degreeTypeRelativeY :: Maybe Tenths
relative-y attribute
degreeTypeFontFamily :: Maybe CommaSeparatedText
font-family attribute
degreeTypeFontStyle :: Maybe FontStyle
font-style attribute
degreeTypeFontSize :: Maybe FontSize
font-size attribute
degreeTypeFontWeight :: Maybe FontWeight
font-weight attribute
degreeTypeColor :: Maybe Color
color attribute

Instances

Eq DegreeType Source #
Methods (==) :: DegreeType -> DegreeType -> Bool # (/=) :: DegreeType -> DegreeType -> Bool #
Show DegreeType Source #
Methods showsPrec :: Int -> DegreeType -> ShowS # show :: DegreeType -> String # showList :: [DegreeType] -> ShowS #
Generic DegreeType Source #
Associated Types type Rep DegreeType :: * -> * # Methods from :: DegreeType -> Rep DegreeType x # to :: Rep DegreeType x -> DegreeType #
EmitXml DegreeType Source #
Methods emitXml :: DegreeType -> XmlRep Source #
type Rep DegreeType Source #
type Rep DegreeType = D1 * (MetaData "DegreeType" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "DegreeType" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "degreeTypeDegreeTypeValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * DegreeTypeValue)) (S1 * (MetaSel (Just Symbol "degreeTypeText") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token)))) ((::) (S1 * (MetaSel (Just Symbol "degreeTypeDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "degreeTypeDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "degreeTypeRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "degreeTypeRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "degreeTypeFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "degreeTypeFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) (S1 * (MetaSel (Just Symbol "degreeTypeFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "degreeTypeFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "degreeTypeColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseDegreeType :: XParse DegreeType Source #

mkDegreeType :: DegreeTypeValue -> DegreeType Source #

Smart constructor for DegreeType

data DegreeValue Source #

degree-value (complex)

The content of the degree-value type is a number indicating the degree of the chord (1 for the root, 3 for third, etc). The text attribute specifies how the type of the degree should be displayed.

Constructors

DegreeValue

Fields

degreeValuePositiveInteger :: PositiveInteger
text content
degreeValueText :: Maybe Token
text attribute
degreeValueDefaultX :: Maybe Tenths
default-x attribute
degreeValueDefaultY :: Maybe Tenths
default-y attribute
degreeValueRelativeX :: Maybe Tenths
relative-x attribute
degreeValueRelativeY :: Maybe Tenths
relative-y attribute
degreeValueFontFamily :: Maybe CommaSeparatedText
font-family attribute
degreeValueFontStyle :: Maybe FontStyle
font-style attribute
degreeValueFontSize :: Maybe FontSize
font-size attribute
degreeValueFontWeight :: Maybe FontWeight
font-weight attribute
degreeValueColor :: Maybe Color
color attribute

Instances

Eq DegreeValue Source #
Methods (==) :: DegreeValue -> DegreeValue -> Bool # (/=) :: DegreeValue -> DegreeValue -> Bool #
Show DegreeValue Source #
Methods showsPrec :: Int -> DegreeValue -> ShowS # show :: DegreeValue -> String # showList :: [DegreeValue] -> ShowS #
Generic DegreeValue Source #
Associated Types type Rep DegreeValue :: * -> * # Methods from :: DegreeValue -> Rep DegreeValue x # to :: Rep DegreeValue x -> DegreeValue #
EmitXml DegreeValue Source #
Methods emitXml :: DegreeValue -> XmlRep Source #
type Rep DegreeValue Source #
type Rep DegreeValue = D1 * (MetaData "DegreeValue" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "DegreeValue" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "degreeValuePositiveInteger") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveInteger)) (S1 * (MetaSel (Just Symbol "degreeValueText") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token)))) ((::) (S1 * (MetaSel (Just Symbol "degreeValueDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "degreeValueDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "degreeValueRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "degreeValueRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "degreeValueFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "degreeValueFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) (S1 * (MetaSel (Just Symbol "degreeValueFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "degreeValueFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "degreeValueColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseDegreeValue :: XParse DegreeValue Source #

mkDegreeValue :: PositiveInteger -> DegreeValue Source #

Smart constructor for DegreeValue

data Direction Source #

direction (complex)

A direction is a musical indication that is not attached to a specific note. Two or more may be combined to indicate starts and stops of wedges, dashes, etc.

By default, a series of direction-type elements and a series of child elements of a direction-type within a single direction element follow one another in sequence visually. For a series of direction-type children, non-positional formatting attributes are carried over from the previous element by default.

Constructors

Direction
Fields directionPlacement :: Maybe AboveBelow placement attribute directionDirective :: Maybe YesNo directive attribute directionDirectionType :: [DirectionType] direction-type child element directionOffset :: Maybe Offset offset child element directionEditorialVoiceDirection :: EditorialVoiceDirection directionStaff :: Maybe Staff directionSound :: Maybe Sound sound child element

Instances

Eq Direction Source #
Methods (==) :: Direction -> Direction -> Bool # (/=) :: Direction -> Direction -> Bool #
Show Direction Source #
Methods showsPrec :: Int -> Direction -> ShowS # show :: Direction -> String # showList :: [Direction] -> ShowS #
Generic Direction Source #
Associated Types type Rep Direction :: * -> * # Methods from :: Direction -> Rep Direction x # to :: Rep Direction x -> Direction #
EmitXml Direction Source #
Methods emitXml :: Direction -> XmlRep Source #
type Rep Direction Source #
type Rep Direction = D1 * (MetaData "Direction" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Direction" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "directionPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow))) ((::) (S1 * (MetaSel (Just Symbol "directionDirective") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "directionDirectionType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [DirectionType])))) ((::) ((::) (S1 * (MetaSel (Just Symbol "directionOffset") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Offset))) (S1 * (MetaSel (Just Symbol "directionEditorialVoiceDirection") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EditorialVoiceDirection))) ((::) (S1 * (MetaSel (Just Symbol "directionStaff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Staff))) (S1 * (MetaSel (Just Symbol "directionSound") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Sound)))))))

parseDirection :: XParse Direction Source #

mkDirection :: EditorialVoiceDirection -> Direction Source #

Smart constructor for Direction

data DirectionType Source #

direction-type (complex)

Textual direction types may have more than 1 component due to multiple fonts. The dynamics element may also be used in the notations element. Attribute groups related to print suggestions apply to the individual direction-type, not to the overall direction.

Constructors

DirectionType
Fields directionTypeDirectionType :: ChxDirectionType

Instances

Eq DirectionType Source #
Methods (==) :: DirectionType -> DirectionType -> Bool # (/=) :: DirectionType -> DirectionType -> Bool #
Show DirectionType Source #
Methods showsPrec :: Int -> DirectionType -> ShowS # show :: DirectionType -> String # showList :: [DirectionType] -> ShowS #
Generic DirectionType Source #
Associated Types type Rep DirectionType :: * -> * # Methods from :: DirectionType -> Rep DirectionType x # to :: Rep DirectionType x -> DirectionType #
EmitXml DirectionType Source #
Methods emitXml :: DirectionType -> XmlRep Source #
type Rep DirectionType Source #
type Rep DirectionType = D1 * (MetaData "DirectionType" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "DirectionType" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeDirectionType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ChxDirectionType)))

parseDirectionType :: XParse DirectionType Source #

mkDirectionType :: ChxDirectionType -> DirectionType Source #

Smart constructor for DirectionType

data Directive Source #

directive (complex)

Constructors

Directive

Fields

directiveString :: String
text content
directiveLang :: Maybe Lang
xml:lang attribute
directiveDefaultX :: Maybe Tenths
default-x attribute
directiveDefaultY :: Maybe Tenths
default-y attribute
directiveRelativeX :: Maybe Tenths
relative-x attribute
directiveRelativeY :: Maybe Tenths
relative-y attribute
directiveFontFamily :: Maybe CommaSeparatedText
font-family attribute
directiveFontStyle :: Maybe FontStyle
font-style attribute
directiveFontSize :: Maybe FontSize
font-size attribute
directiveFontWeight :: Maybe FontWeight
font-weight attribute
directiveColor :: Maybe Color
color attribute

Instances

Eq Directive Source #
Methods (==) :: Directive -> Directive -> Bool # (/=) :: Directive -> Directive -> Bool #
Show Directive Source #
Methods showsPrec :: Int -> Directive -> ShowS # show :: Directive -> String # showList :: [Directive] -> ShowS #
Generic Directive Source #
Associated Types type Rep Directive :: * -> * # Methods from :: Directive -> Rep Directive x # to :: Rep Directive x -> Directive #
EmitXml Directive Source #
Methods emitXml :: Directive -> XmlRep Source #
type Rep Directive Source #
type Rep Directive = D1 * (MetaData "Directive" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Directive" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "directiveString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "directiveLang") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Lang)))) ((::) (S1 * (MetaSel (Just Symbol "directiveDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "directiveDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "directiveRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "directiveRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "directiveFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "directiveFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) (S1 * (MetaSel (Just Symbol "directiveFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "directiveFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "directiveColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseDirective :: XParse Directive Source #

mkDirective :: String -> Directive Source #

Smart constructor for Directive

data DisplayStepOctave Source #

display-step-octave (complex)

The display-step-octave type contains the sequence of elements used by both the rest and unpitched elements. This group is used to place rests and unpitched elements on the staff without implying that these elements have pitch. Positioning follows the current clef. If percussion clef is used, the display-step and display-octave elements are interpreted as if in treble clef, with a G in octave 4 on line 2. If not present, the note is placed on the middle line of the staff, generally used for one-line staffs.

Constructors

DisplayStepOctave
Fields displayStepOctaveDisplayStepOctave :: Maybe SeqDisplayStepOctave

Instances

Eq DisplayStepOctave Source #
Methods (==) :: DisplayStepOctave -> DisplayStepOctave -> Bool # (/=) :: DisplayStepOctave -> DisplayStepOctave -> Bool #
Show DisplayStepOctave Source #
Methods showsPrec :: Int -> DisplayStepOctave -> ShowS # show :: DisplayStepOctave -> String # showList :: [DisplayStepOctave] -> ShowS #
Generic DisplayStepOctave Source #
Associated Types type Rep DisplayStepOctave :: * -> * # Methods from :: DisplayStepOctave -> Rep DisplayStepOctave x # to :: Rep DisplayStepOctave x -> DisplayStepOctave #
EmitXml DisplayStepOctave Source #
Methods emitXml :: DisplayStepOctave -> XmlRep Source #
type Rep DisplayStepOctave Source #
type Rep DisplayStepOctave = D1 * (MetaData "DisplayStepOctave" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "DisplayStepOctave" PrefixI True) (S1 * (MetaSel (Just Symbol "displayStepOctaveDisplayStepOctave") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe SeqDisplayStepOctave))))

parseDisplayStepOctave :: XParse DisplayStepOctave Source #

mkDisplayStepOctave :: DisplayStepOctave Source #

Smart constructor for DisplayStepOctave

data Dynamics Source #

dynamics (complex)

Dynamics can be associated either with a note or a general musical direction. To avoid inconsistencies between and amongst the letter abbreviations for dynamics (what is sf vs. sfz, standing alone or with a trailing dynamic that is not always piano), we use the actual letters as the names of these dynamic elements. The other-dynamics element allows other dynamic marks that are not covered here, but many of those should perhaps be included in a more general musical direction element. Dynamics elements may also be combined to create marks not covered by a single element, such as sfmp.

These letter dynamic symbols are separated from crescendo, decrescendo, and wedge indications. Dynamic representation is inconsistent in scores. Many things are assumed by the composer and left out, such as returns to original dynamics. Systematic representations are quite complex: for example, Humdrum has at least 3 representation formats related to dynamics. The MusicXML format captures what is in the score, but does not try to be optimal for analysis or synthesis of dynamics.

Constructors

Dynamics

Fields

dynamicsDefaultX :: Maybe Tenths
default-x attribute
dynamicsDefaultY :: Maybe Tenths
default-y attribute
dynamicsRelativeX :: Maybe Tenths
relative-x attribute
dynamicsRelativeY :: Maybe Tenths
relative-y attribute
dynamicsFontFamily :: Maybe CommaSeparatedText
font-family attribute
dynamicsFontStyle :: Maybe FontStyle
font-style attribute
dynamicsFontSize :: Maybe FontSize
font-size attribute
dynamicsFontWeight :: Maybe FontWeight
font-weight attribute
dynamicsColor :: Maybe Color
color attribute
dynamicsPlacement :: Maybe AboveBelow
placement attribute
dynamicsDynamics :: [ChxDynamics]

Instances

Eq Dynamics Source #
Methods (==) :: Dynamics -> Dynamics -> Bool # (/=) :: Dynamics -> Dynamics -> Bool #
Show Dynamics Source #
Methods showsPrec :: Int -> Dynamics -> ShowS # show :: Dynamics -> String # showList :: [Dynamics] -> ShowS #
Generic Dynamics Source #
Associated Types type Rep Dynamics :: * -> * # Methods from :: Dynamics -> Rep Dynamics x # to :: Rep Dynamics x -> Dynamics #
EmitXml Dynamics Source #
Methods emitXml :: Dynamics -> XmlRep Source #
type Rep Dynamics Source #
type Rep Dynamics = D1 * (MetaData "Dynamics" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Dynamics" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "dynamicsDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "dynamicsDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "dynamicsRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "dynamicsRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "dynamicsFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "dynamicsFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) ((::) (S1 * (MetaSel (Just Symbol "dynamicsFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "dynamicsFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))))) ((::) (S1 * (MetaSel (Just Symbol "dynamicsColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) ((::) (S1 * (MetaSel (Just Symbol "dynamicsPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow))) (S1 * (MetaSel (Just Symbol "dynamicsDynamics") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [ChxDynamics])))))))

parseDynamics :: XParse Dynamics Source #

mkDynamics :: Dynamics Source #

Smart constructor for Dynamics

data Elision Source #

elision (complex)

In Version 2.0, the content of the elision type is used to specify the symbol used to display the elision. Common values are a no-break space (Unicode 00A0), an underscore (Unicode 005F), or an undertie (Unicode 203F).

Constructors

Elision
Fields elisionString :: String text content elisionFontFamily :: Maybe CommaSeparatedText font-family attribute elisionFontStyle :: Maybe FontStyle font-style attribute elisionFontSize :: Maybe FontSize font-size attribute elisionFontWeight :: Maybe FontWeight font-weight attribute elisionColor :: Maybe Color color attribute

Instances

Eq Elision Source #
Methods (==) :: Elision -> Elision -> Bool # (/=) :: Elision -> Elision -> Bool #
Show Elision Source #
Methods showsPrec :: Int -> Elision -> ShowS # show :: Elision -> String # showList :: [Elision] -> ShowS #
Generic Elision Source #
Associated Types type Rep Elision :: * -> * # Methods from :: Elision -> Rep Elision x # to :: Rep Elision x -> Elision #
EmitXml Elision Source #
Methods emitXml :: Elision -> XmlRep Source #
type Rep Elision Source #
type Rep Elision = D1 * (MetaData "Elision" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Elision" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "elisionString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) ((::) (S1 * (MetaSel (Just Symbol "elisionFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "elisionFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) (S1 * (MetaSel (Just Symbol "elisionFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "elisionFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "elisionColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))))

parseElision :: XParse Elision Source #

mkElision :: String -> Elision Source #

Smart constructor for Elision

data Empty Source #

empty (complex)

The empty type represents an empty element with no attributes.

Constructors

Empty

Instances

Eq Empty Source #
Methods (==) :: Empty -> Empty -> Bool # (/=) :: Empty -> Empty -> Bool #
Show Empty Source #
Methods showsPrec :: Int -> Empty -> ShowS # show :: Empty -> String # showList :: [Empty] -> ShowS #
Generic Empty Source #
Associated Types type Rep Empty :: * -> * # Methods from :: Empty -> Rep Empty x # to :: Rep Empty x -> Empty #
EmitXml Empty Source #
Methods emitXml :: Empty -> XmlRep Source #
type Rep Empty Source #
type Rep Empty = D1 * (MetaData "Empty" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Empty" PrefixI False) (U1 *))

parseEmpty :: XParse Empty Source #

mkEmpty :: Empty Source #

Smart constructor for Empty

data EmptyFont Source #

empty-font (complex)

The empty-font type represents an empty element with font attributes.

Constructors

EmptyFont
Fields emptyFontFontFamily :: Maybe CommaSeparatedText font-family attribute emptyFontFontStyle :: Maybe FontStyle font-style attribute emptyFontFontSize :: Maybe FontSize font-size attribute emptyFontFontWeight :: Maybe FontWeight font-weight attribute

Instances

Eq EmptyFont Source #
Methods (==) :: EmptyFont -> EmptyFont -> Bool # (/=) :: EmptyFont -> EmptyFont -> Bool #
Show EmptyFont Source #
Methods showsPrec :: Int -> EmptyFont -> ShowS # show :: EmptyFont -> String # showList :: [EmptyFont] -> ShowS #
Generic EmptyFont Source #
Associated Types type Rep EmptyFont :: * -> * # Methods from :: EmptyFont -> Rep EmptyFont x # to :: Rep EmptyFont x -> EmptyFont #
EmitXml EmptyFont Source #
Methods emitXml :: EmptyFont -> XmlRep Source #
type Rep EmptyFont Source #
type Rep EmptyFont = D1 * (MetaData "EmptyFont" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "EmptyFont" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "emptyFontFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "emptyFontFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle)))) ((::) (S1 * (MetaSel (Just Symbol "emptyFontFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "emptyFontFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))))))

parseEmptyFont :: XParse EmptyFont Source #

mkEmptyFont :: EmptyFont Source #

Smart constructor for EmptyFont

data EmptyLine Source #

empty-line (complex)

The empty-line type represents an empty element with line-shape, line-type, print-style and placement attributes.

Constructors

EmptyLine

Fields

emptyLineLineShape :: Maybe LineShape
line-shape attribute
emptyLineLineType :: Maybe LineType
line-type attribute
emptyLineDefaultX :: Maybe Tenths
default-x attribute
emptyLineDefaultY :: Maybe Tenths
default-y attribute
emptyLineRelativeX :: Maybe Tenths
relative-x attribute
emptyLineRelativeY :: Maybe Tenths
relative-y attribute
emptyLineFontFamily :: Maybe CommaSeparatedText
font-family attribute
emptyLineFontStyle :: Maybe FontStyle
font-style attribute
emptyLineFontSize :: Maybe FontSize
font-size attribute
emptyLineFontWeight :: Maybe FontWeight
font-weight attribute
emptyLineColor :: Maybe Color
color attribute
emptyLinePlacement :: Maybe AboveBelow
placement attribute

Instances

Eq EmptyLine Source #
Methods (==) :: EmptyLine -> EmptyLine -> Bool # (/=) :: EmptyLine -> EmptyLine -> Bool #
Show EmptyLine Source #
Methods showsPrec :: Int -> EmptyLine -> ShowS # show :: EmptyLine -> String # showList :: [EmptyLine] -> ShowS #
Generic EmptyLine Source #
Associated Types type Rep EmptyLine :: * -> * # Methods from :: EmptyLine -> Rep EmptyLine x # to :: Rep EmptyLine x -> EmptyLine #
EmitXml EmptyLine Source #
Methods emitXml :: EmptyLine -> XmlRep Source #
type Rep EmptyLine Source #
type Rep EmptyLine = D1 * (MetaData "EmptyLine" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "EmptyLine" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "emptyLineLineShape") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LineShape))) ((::) (S1 * (MetaSel (Just Symbol "emptyLineLineType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LineType))) (S1 * (MetaSel (Just Symbol "emptyLineDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) (S1 * (MetaSel (Just Symbol "emptyLineDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "emptyLineRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "emptyLineRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "emptyLineFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) ((::) (S1 * (MetaSel (Just Symbol "emptyLineFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "emptyLineFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))))) ((::) (S1 * (MetaSel (Just Symbol "emptyLineFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) ((::) (S1 * (MetaSel (Just Symbol "emptyLineColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "emptyLinePlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow))))))))

parseEmptyLine :: XParse EmptyLine Source #

mkEmptyLine :: EmptyLine Source #

Smart constructor for EmptyLine

data EmptyPlacement Source #

empty-placement (complex)

The empty-placement type represents an empty element with print-style and placement attributes.

Constructors

EmptyPlacement

Fields

emptyPlacementDefaultX :: Maybe Tenths
default-x attribute
emptyPlacementDefaultY :: Maybe Tenths
default-y attribute
emptyPlacementRelativeX :: Maybe Tenths
relative-x attribute
emptyPlacementRelativeY :: Maybe Tenths
relative-y attribute
emptyPlacementFontFamily :: Maybe CommaSeparatedText
font-family attribute
emptyPlacementFontStyle :: Maybe FontStyle
font-style attribute
emptyPlacementFontSize :: Maybe FontSize
font-size attribute
emptyPlacementFontWeight :: Maybe FontWeight
font-weight attribute
emptyPlacementColor :: Maybe Color
color attribute
emptyPlacementPlacement :: Maybe AboveBelow
placement attribute

Instances

Eq EmptyPlacement Source #
Methods (==) :: EmptyPlacement -> EmptyPlacement -> Bool # (/=) :: EmptyPlacement -> EmptyPlacement -> Bool #
Show EmptyPlacement Source #
Methods showsPrec :: Int -> EmptyPlacement -> ShowS # show :: EmptyPlacement -> String # showList :: [EmptyPlacement] -> ShowS #
Generic EmptyPlacement Source #
Associated Types type Rep EmptyPlacement :: * -> * # Methods from :: EmptyPlacement -> Rep EmptyPlacement x # to :: Rep EmptyPlacement x -> EmptyPlacement #
EmitXml EmptyPlacement Source #
Methods emitXml :: EmptyPlacement -> XmlRep Source #
type Rep EmptyPlacement Source #
type Rep EmptyPlacement = D1 * (MetaData "EmptyPlacement" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "EmptyPlacement" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "emptyPlacementDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "emptyPlacementDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "emptyPlacementRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "emptyPlacementRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "emptyPlacementFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "emptyPlacementFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "emptyPlacementFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize)))) ((::) (S1 * (MetaSel (Just Symbol "emptyPlacementFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) ((::) (S1 * (MetaSel (Just Symbol "emptyPlacementColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "emptyPlacementPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow))))))))

parseEmptyPlacement :: XParse EmptyPlacement Source #

mkEmptyPlacement :: EmptyPlacement Source #

Smart constructor for EmptyPlacement

data EmptyPrintStyle Source #

empty-print-style (complex)

The empty-print-style type represents an empty element with print-style attributes.

Constructors

EmptyPrintStyle

Fields

emptyPrintStyleDefaultX :: Maybe Tenths
default-x attribute
emptyPrintStyleDefaultY :: Maybe Tenths
default-y attribute
emptyPrintStyleRelativeX :: Maybe Tenths
relative-x attribute
emptyPrintStyleRelativeY :: Maybe Tenths
relative-y attribute
emptyPrintStyleFontFamily :: Maybe CommaSeparatedText
font-family attribute
emptyPrintStyleFontStyle :: Maybe FontStyle
font-style attribute
emptyPrintStyleFontSize :: Maybe FontSize
font-size attribute
emptyPrintStyleFontWeight :: Maybe FontWeight
font-weight attribute
emptyPrintStyleColor :: Maybe Color
color attribute

Instances

Eq EmptyPrintStyle Source #
Methods (==) :: EmptyPrintStyle -> EmptyPrintStyle -> Bool # (/=) :: EmptyPrintStyle -> EmptyPrintStyle -> Bool #
Show EmptyPrintStyle Source #
Methods showsPrec :: Int -> EmptyPrintStyle -> ShowS # show :: EmptyPrintStyle -> String # showList :: [EmptyPrintStyle] -> ShowS #
Generic EmptyPrintStyle Source #
Associated Types type Rep EmptyPrintStyle :: * -> * # Methods from :: EmptyPrintStyle -> Rep EmptyPrintStyle x # to :: Rep EmptyPrintStyle x -> EmptyPrintStyle #
EmitXml EmptyPrintStyle Source #
Methods emitXml :: EmptyPrintStyle -> XmlRep Source #
type Rep EmptyPrintStyle Source #
type Rep EmptyPrintStyle = D1 * (MetaData "EmptyPrintStyle" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "EmptyPrintStyle" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "emptyPrintStyleDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "emptyPrintStyleDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "emptyPrintStyleRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "emptyPrintStyleRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "emptyPrintStyleFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "emptyPrintStyleFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle)))) ((::) (S1 * (MetaSel (Just Symbol "emptyPrintStyleFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "emptyPrintStyleFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "emptyPrintStyleColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseEmptyPrintStyle :: XParse EmptyPrintStyle Source #

mkEmptyPrintStyle :: EmptyPrintStyle Source #

Smart constructor for EmptyPrintStyle

data EmptyTrillSound Source #

empty-trill-sound (complex)

The empty-trill-sound type represents an empty element with print-style, placement, and trill-sound attributes.

Constructors

EmptyTrillSound

Fields

emptyTrillSoundDefaultX :: Maybe Tenths
default-x attribute
emptyTrillSoundDefaultY :: Maybe Tenths
default-y attribute
emptyTrillSoundRelativeX :: Maybe Tenths
relative-x attribute
emptyTrillSoundRelativeY :: Maybe Tenths
relative-y attribute
emptyTrillSoundFontFamily :: Maybe CommaSeparatedText
font-family attribute
emptyTrillSoundFontStyle :: Maybe FontStyle
font-style attribute
emptyTrillSoundFontSize :: Maybe FontSize
font-size attribute
emptyTrillSoundFontWeight :: Maybe FontWeight
font-weight attribute
emptyTrillSoundColor :: Maybe Color
color attribute
emptyTrillSoundPlacement :: Maybe AboveBelow
placement attribute
emptyTrillSoundStartNote :: Maybe StartNote
start-note attribute
emptyTrillSoundTrillStep :: Maybe TrillStep
trill-step attribute
emptyTrillSoundTwoNoteTurn :: Maybe TwoNoteTurn
two-note-turn attribute
emptyTrillSoundAccelerate :: Maybe YesNo
accelerate attribute
emptyTrillSoundBeats :: Maybe TrillBeats
beats attribute
emptyTrillSoundSecondBeat :: Maybe Percent
second-beat attribute
emptyTrillSoundLastBeat :: Maybe Percent
last-beat attribute

Instances

Eq EmptyTrillSound Source #
Methods (==) :: EmptyTrillSound -> EmptyTrillSound -> Bool # (/=) :: EmptyTrillSound -> EmptyTrillSound -> Bool #
Show EmptyTrillSound Source #
Methods showsPrec :: Int -> EmptyTrillSound -> ShowS # show :: EmptyTrillSound -> String # showList :: [EmptyTrillSound] -> ShowS #
Generic EmptyTrillSound Source #
Associated Types type Rep EmptyTrillSound :: * -> * # Methods from :: EmptyTrillSound -> Rep EmptyTrillSound x # to :: Rep EmptyTrillSound x -> EmptyTrillSound #
EmitXml EmptyTrillSound Source #
Methods emitXml :: EmptyTrillSound -> XmlRep Source #
type Rep EmptyTrillSound Source #
type Rep EmptyTrillSound = D1 * (MetaData "EmptyTrillSound" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "EmptyTrillSound" PrefixI True) ((::) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "emptyTrillSoundDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "emptyTrillSoundDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "emptyTrillSoundRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "emptyTrillSoundRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "emptyTrillSoundFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "emptyTrillSoundFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle)))) ((::) (S1 * (MetaSel (Just Symbol "emptyTrillSoundFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "emptyTrillSoundFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight)))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "emptyTrillSoundColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "emptyTrillSoundPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow)))) ((::) (S1 * (MetaSel (Just Symbol "emptyTrillSoundStartNote") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StartNote))) (S1 * (MetaSel (Just Symbol "emptyTrillSoundTrillStep") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TrillStep))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "emptyTrillSoundTwoNoteTurn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TwoNoteTurn))) (S1 * (MetaSel (Just Symbol "emptyTrillSoundAccelerate") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "emptyTrillSoundBeats") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TrillBeats))) ((::) (S1 * (MetaSel (Just Symbol "emptyTrillSoundSecondBeat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Percent))) (S1 * (MetaSel (Just Symbol "emptyTrillSoundLastBeat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Percent)))))))))

parseEmptyTrillSound :: XParse EmptyTrillSound Source #

mkEmptyTrillSound :: EmptyTrillSound Source #

Smart constructor for EmptyTrillSound

data Encoding Source #

encoding (complex)

The encoding element contains information about who did the digital encoding, when, with what software, and in what aspects. Standard type values for the encoder element are music, words, and arrangement, but other types may be used. The type attribute is only needed when there are multiple encoder elements.

Constructors

Encoding
Fields encodingEncoding :: [ChxEncoding]

Instances

Eq Encoding Source #
Methods (==) :: Encoding -> Encoding -> Bool # (/=) :: Encoding -> Encoding -> Bool #
Show Encoding Source #
Methods showsPrec :: Int -> Encoding -> ShowS # show :: Encoding -> String # showList :: [Encoding] -> ShowS #
Generic Encoding Source #
Associated Types type Rep Encoding :: * -> * # Methods from :: Encoding -> Rep Encoding x # to :: Rep Encoding x -> Encoding #
EmitXml Encoding Source #
Methods emitXml :: Encoding -> XmlRep Source #
type Rep Encoding Source #
type Rep Encoding = D1 * (MetaData "Encoding" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Encoding" PrefixI True) (S1 * (MetaSel (Just Symbol "encodingEncoding") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [ChxEncoding])))

parseEncoding :: XParse Encoding Source #

mkEncoding :: Encoding Source #

Smart constructor for Encoding

data Ending Source #

ending (complex)

The ending type represents multiple (e.g. first and second) endings. Typically, the start type is associated with the left barline of the first measure in an ending. The stop and discontinue types are associated with the right barline of the last measure in an ending. Stop is used when the ending mark concludes with a downward jog, as is typical for first endings. Discontinue is used when there is no downward jog, as is typical for second endings that do not conclude a piece. The length of the jog can be specified using the end-length attribute. The text-x and text-y attributes are offsets that specify where the baseline of the start of the ending text appears, relative to the start of the ending line.

The number attribute reflects the numeric values of what is under the ending line. Single endings such as "1" or comma-separated multiple endings such as "1,2" may be used. The ending element text is used when the text displayed in the ending is different than what appears in the number attribute. The print-object element is used to indicate when an ending is present but not printed, as is often the case for many parts in a full score.

Constructors

Ending

Fields

endingString :: String
text content
cmpendingNumber :: EndingNumber
number attribute
endingType :: StartStopDiscontinue
type attribute
endingEndLength :: Maybe Tenths
end-length attribute
endingTextX :: Maybe Tenths
text-x attribute
endingTextY :: Maybe Tenths
text-y attribute
endingPrintObject :: Maybe YesNo
print-object attribute
endingDefaultX :: Maybe Tenths
default-x attribute
endingDefaultY :: Maybe Tenths
default-y attribute
endingRelativeX :: Maybe Tenths
relative-x attribute
endingRelativeY :: Maybe Tenths
relative-y attribute
endingFontFamily :: Maybe CommaSeparatedText
font-family attribute
endingFontStyle :: Maybe FontStyle
font-style attribute
endingFontSize :: Maybe FontSize
font-size attribute
endingFontWeight :: Maybe FontWeight
font-weight attribute
endingColor :: Maybe Color
color attribute

Instances

Eq Ending Source #
Methods (==) :: Ending -> Ending -> Bool # (/=) :: Ending -> Ending -> Bool #
Show Ending Source #
Methods showsPrec :: Int -> Ending -> ShowS # show :: Ending -> String # showList :: [Ending] -> ShowS #
Generic Ending Source #
Associated Types type Rep Ending :: * -> * # Methods from :: Ending -> Rep Ending x # to :: Rep Ending x -> Ending #
EmitXml Ending Source #
Methods emitXml :: Ending -> XmlRep Source #
type Rep Ending Source #
type Rep Ending = D1 * (MetaData "Ending" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Ending" PrefixI True) ((::) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "endingString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "cmpendingNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EndingNumber))) ((::) (S1 * (MetaSel (Just Symbol "endingType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStopDiscontinue)) (S1 * (MetaSel (Just Symbol "endingEndLength") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "endingTextX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "endingTextY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "endingPrintObject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "endingDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "endingDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "endingRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "endingRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "endingFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "endingFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "endingFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize)))) ((::) (S1 * (MetaSel (Just Symbol "endingFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "endingColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseEnding :: XParse Ending Source #

mkEnding :: String -> EndingNumber -> StartStopDiscontinue -> Ending Source #

Smart constructor for Ending

data Extend Source #

extend (complex)

The extend type represents word extensions for lyrics.

Constructors

Extend
Fields extendFontFamily :: Maybe CommaSeparatedText font-family attribute extendFontStyle :: Maybe FontStyle font-style attribute extendFontSize :: Maybe FontSize font-size attribute extendFontWeight :: Maybe FontWeight font-weight attribute extendColor :: Maybe Color color attribute

Instances

Eq Extend Source #
Methods (==) :: Extend -> Extend -> Bool # (/=) :: Extend -> Extend -> Bool #
Show Extend Source #
Methods showsPrec :: Int -> Extend -> ShowS # show :: Extend -> String # showList :: [Extend] -> ShowS #
Generic Extend Source #
Associated Types type Rep Extend :: * -> * # Methods from :: Extend -> Rep Extend x # to :: Rep Extend x -> Extend #
EmitXml Extend Source #
Methods emitXml :: Extend -> XmlRep Source #
type Rep Extend Source #
type Rep Extend = D1 * (MetaData "Extend" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Extend" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "extendFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "extendFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle)))) ((::) (S1 * (MetaSel (Just Symbol "extendFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "extendFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "extendColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))))

parseExtend :: XParse Extend Source #

mkExtend :: Extend Source #

Smart constructor for Extend

data Feature Source #

feature (complex)

The feature type is a part of the grouping element used for musical analysis. The type attribute represents the type of the feature and the element content represents its value. This type is flexible to allow for different analyses.

Constructors

Feature
Fields featureString :: String text content featureType :: Maybe Token type attribute

Instances

Eq Feature Source #
Methods (==) :: Feature -> Feature -> Bool # (/=) :: Feature -> Feature -> Bool #
Show Feature Source #
Methods showsPrec :: Int -> Feature -> ShowS # show :: Feature -> String # showList :: [Feature] -> ShowS #
Generic Feature Source #
Associated Types type Rep Feature :: * -> * # Methods from :: Feature -> Rep Feature x # to :: Rep Feature x -> Feature #
EmitXml Feature Source #
Methods emitXml :: Feature -> XmlRep Source #
type Rep Feature Source #
type Rep Feature = D1 * (MetaData "Feature" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Feature" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "featureString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "featureType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token)))))

parseFeature :: XParse Feature Source #

mkFeature :: String -> Feature Source #

Smart constructor for Feature

data Fermata Source #

fermata (complex)

The fermata text content represents the shape of the fermata sign. An empty fermata element represents a normal fermata. The fermata type is upright if not specified.

Constructors

Fermata

Fields

fermataFermataShape :: FermataShape
text content
fermataType :: Maybe UprightInverted
type attribute
fermataDefaultX :: Maybe Tenths
default-x attribute
fermataDefaultY :: Maybe Tenths
default-y attribute
fermataRelativeX :: Maybe Tenths
relative-x attribute
fermataRelativeY :: Maybe Tenths
relative-y attribute
fermataFontFamily :: Maybe CommaSeparatedText
font-family attribute
fermataFontStyle :: Maybe FontStyle
font-style attribute
fermataFontSize :: Maybe FontSize
font-size attribute
fermataFontWeight :: Maybe FontWeight
font-weight attribute
fermataColor :: Maybe Color
color attribute

Instances

Eq Fermata Source #
Methods (==) :: Fermata -> Fermata -> Bool # (/=) :: Fermata -> Fermata -> Bool #
Show Fermata Source #
Methods showsPrec :: Int -> Fermata -> ShowS # show :: Fermata -> String # showList :: [Fermata] -> ShowS #
Generic Fermata Source #
Associated Types type Rep Fermata :: * -> * # Methods from :: Fermata -> Rep Fermata x # to :: Rep Fermata x -> Fermata #
EmitXml Fermata Source #
Methods emitXml :: Fermata -> XmlRep Source #
type Rep Fermata Source #
type Rep Fermata = D1 * (MetaData "Fermata" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Fermata" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "fermataFermataShape") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * FermataShape)) (S1 * (MetaSel (Just Symbol "fermataType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe UprightInverted)))) ((::) (S1 * (MetaSel (Just Symbol "fermataDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "fermataDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "fermataRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "fermataRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "fermataFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "fermataFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) (S1 * (MetaSel (Just Symbol "fermataFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "fermataFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "fermataColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseFermata :: XParse Fermata Source #

mkFermata :: FermataShape -> Fermata Source #

Smart constructor for Fermata

data Figure Source #

figure (complex)

The figure type represents a single figure within a figured-bass element.

Constructors

Figure
Fields figurePrefix :: Maybe StyleText prefix child element figureFigureNumber :: Maybe StyleText figure-number child element figureSuffix :: Maybe StyleText suffix child element figureExtend :: Maybe Extend extend child element

Instances

Eq Figure Source #
Methods (==) :: Figure -> Figure -> Bool # (/=) :: Figure -> Figure -> Bool #
Show Figure Source #
Methods showsPrec :: Int -> Figure -> ShowS # show :: Figure -> String # showList :: [Figure] -> ShowS #
Generic Figure Source #
Associated Types type Rep Figure :: * -> * # Methods from :: Figure -> Rep Figure x # to :: Rep Figure x -> Figure #
EmitXml Figure Source #
Methods emitXml :: Figure -> XmlRep Source #
type Rep Figure Source #
type Rep Figure = D1 * (MetaData "Figure" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Figure" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "figurePrefix") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StyleText))) (S1 * (MetaSel (Just Symbol "figureFigureNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StyleText)))) ((::) (S1 * (MetaSel (Just Symbol "figureSuffix") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StyleText))) (S1 * (MetaSel (Just Symbol "figureExtend") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Extend))))))

parseFigure :: XParse Figure Source #

mkFigure :: Figure Source #

Smart constructor for Figure

data FiguredBass Source #

figured-bass (complex)

The figured-bass element represents figured bass notation. Figured bass elements take their position from the first regular note that follows. Figures are ordered from top to bottom. The value of parentheses is "no" if not present.

Constructors

FiguredBass

Fields

figuredBassParentheses :: Maybe YesNo
parentheses attribute
figuredBassDefaultX :: Maybe Tenths
default-x attribute
figuredBassDefaultY :: Maybe Tenths
default-y attribute
figuredBassRelativeX :: Maybe Tenths
relative-x attribute
figuredBassRelativeY :: Maybe Tenths
relative-y attribute
figuredBassFontFamily :: Maybe CommaSeparatedText
font-family attribute
figuredBassFontStyle :: Maybe FontStyle
font-style attribute
figuredBassFontSize :: Maybe FontSize
font-size attribute
figuredBassFontWeight :: Maybe FontWeight
font-weight attribute
figuredBassColor :: Maybe Color
color attribute
figuredBassPrintDot :: Maybe YesNo
print-dot attribute
figuredBassPrintLyric :: Maybe YesNo
print-lyric attribute
figuredBassPrintObject :: Maybe YesNo
print-object attribute
figuredBassPrintSpacing :: Maybe YesNo
print-spacing attribute
figuredBassFigure :: [Figure]
figure child element
figuredBassDuration :: Maybe Duration
figuredBassEditorial :: Editorial

Instances

Eq FiguredBass Source #
Methods (==) :: FiguredBass -> FiguredBass -> Bool # (/=) :: FiguredBass -> FiguredBass -> Bool #
Show FiguredBass Source #
Methods showsPrec :: Int -> FiguredBass -> ShowS # show :: FiguredBass -> String # showList :: [FiguredBass] -> ShowS #
Generic FiguredBass Source #
Associated Types type Rep FiguredBass :: * -> * # Methods from :: FiguredBass -> Rep FiguredBass x # to :: Rep FiguredBass x -> FiguredBass #
EmitXml FiguredBass Source #
Methods emitXml :: FiguredBass -> XmlRep Source #
type Rep FiguredBass Source #
type Rep FiguredBass = D1 * (MetaData "FiguredBass" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "FiguredBass" PrefixI True) ((::) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "figuredBassParentheses") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "figuredBassDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "figuredBassDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "figuredBassRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "figuredBassRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "figuredBassFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText)))) ((::) (S1 * (MetaSel (Just Symbol "figuredBassFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "figuredBassFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize)))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "figuredBassFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "figuredBassColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))) ((::) (S1 * (MetaSel (Just Symbol "figuredBassPrintDot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "figuredBassPrintLyric") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "figuredBassPrintObject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "figuredBassPrintSpacing") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "figuredBassFigure") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Figure])) ((::) (S1 * (MetaSel (Just Symbol "figuredBassDuration") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Duration))) (S1 * (MetaSel (Just Symbol "figuredBassEditorial") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Editorial))))))))

parseFiguredBass :: XParse FiguredBass Source #

mkFiguredBass :: Editorial -> FiguredBass Source #

Smart constructor for FiguredBass

data Fingering Source #

fingering (complex)

Fingering is typically indicated 1,2,3,4,5. Multiple fingerings may be given, typically to substitute fingerings in the middle of a note. The substitution and alternate values are "no" if the attribute is not present. For guitar and other fretted instruments, the fingering element represents the fretting finger; the pluck element represents the plucking finger.

Constructors

Fingering

Fields

fingeringString :: String
text content
fingeringSubstitution :: Maybe YesNo
substitution attribute
fingeringAlternate :: Maybe YesNo
alternate attribute
fingeringDefaultX :: Maybe Tenths
default-x attribute
fingeringDefaultY :: Maybe Tenths
default-y attribute
fingeringRelativeX :: Maybe Tenths
relative-x attribute
fingeringRelativeY :: Maybe Tenths
relative-y attribute
fingeringFontFamily :: Maybe CommaSeparatedText
font-family attribute
fingeringFontStyle :: Maybe FontStyle
font-style attribute
fingeringFontSize :: Maybe FontSize
font-size attribute
fingeringFontWeight :: Maybe FontWeight
font-weight attribute
fingeringColor :: Maybe Color
color attribute
fingeringPlacement :: Maybe AboveBelow
placement attribute

Instances

Eq Fingering Source #
Methods (==) :: Fingering -> Fingering -> Bool # (/=) :: Fingering -> Fingering -> Bool #
Show Fingering Source #
Methods showsPrec :: Int -> Fingering -> ShowS # show :: Fingering -> String # showList :: [Fingering] -> ShowS #
Generic Fingering Source #
Associated Types type Rep Fingering :: * -> * # Methods from :: Fingering -> Rep Fingering x # to :: Rep Fingering x -> Fingering #
EmitXml Fingering Source #
Methods emitXml :: Fingering -> XmlRep Source #
type Rep Fingering Source #
type Rep Fingering = D1 * (MetaData "Fingering" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Fingering" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "fingeringString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) ((::) (S1 * (MetaSel (Just Symbol "fingeringSubstitution") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "fingeringAlternate") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))))) ((::) (S1 * (MetaSel (Just Symbol "fingeringDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "fingeringDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "fingeringRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "fingeringRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "fingeringFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "fingeringFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "fingeringFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "fingeringFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight)))) ((::) (S1 * (MetaSel (Just Symbol "fingeringColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "fingeringPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow))))))))

parseFingering :: XParse Fingering Source #

mkFingering :: String -> Fingering Source #

Smart constructor for Fingering

data FirstFret Source #

first-fret (complex)

The first-fret type indicates which fret is shown in the top space of the frame; it is fret 1 if the element is not present. The optional text attribute indicates how this is represented in the fret diagram, while the location attribute indicates whether the text appears to the left or right of the frame.

Constructors

FirstFret
Fields firstFretPositiveInteger :: PositiveInteger text content firstFretText :: Maybe Token text attribute firstFretLocation :: Maybe LeftRight location attribute

Instances

Eq FirstFret Source #
Methods (==) :: FirstFret -> FirstFret -> Bool # (/=) :: FirstFret -> FirstFret -> Bool #
Show FirstFret Source #
Methods showsPrec :: Int -> FirstFret -> ShowS # show :: FirstFret -> String # showList :: [FirstFret] -> ShowS #
Generic FirstFret Source #
Associated Types type Rep FirstFret :: * -> * # Methods from :: FirstFret -> Rep FirstFret x # to :: Rep FirstFret x -> FirstFret #
EmitXml FirstFret Source #
Methods emitXml :: FirstFret -> XmlRep Source #
type Rep FirstFret Source #
type Rep FirstFret = D1 * (MetaData "FirstFret" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "FirstFret" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "firstFretPositiveInteger") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveInteger)) ((::) (S1 * (MetaSel (Just Symbol "firstFretText") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) (S1 * (MetaSel (Just Symbol "firstFretLocation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LeftRight))))))

parseFirstFret :: XParse FirstFret Source #

mkFirstFret :: PositiveInteger -> FirstFret Source #

Smart constructor for FirstFret

data FormattedText Source #

formatted-text (complex)

The formatted-text type represents a text element with text-formatting attributes.

Constructors

FormattedText

Fields

formattedTextString :: String
text content
formattedTextLang :: Maybe Lang
xml:lang attribute
formattedTextEnclosure :: Maybe Enclosure
enclosure attribute
formattedTextJustify :: Maybe LeftCenterRight
justify attribute
formattedTextHalign :: Maybe LeftCenterRight
halign attribute
formattedTextValign :: Maybe Valign
valign attribute
formattedTextDefaultX :: Maybe Tenths
default-x attribute
formattedTextDefaultY :: Maybe Tenths
default-y attribute
formattedTextRelativeX :: Maybe Tenths
relative-x attribute
formattedTextRelativeY :: Maybe Tenths
relative-y attribute
formattedTextFontFamily :: Maybe CommaSeparatedText
font-family attribute
formattedTextFontStyle :: Maybe FontStyle
font-style attribute
formattedTextFontSize :: Maybe FontSize
font-size attribute
formattedTextFontWeight :: Maybe FontWeight
font-weight attribute
formattedTextColor :: Maybe Color
color attribute
formattedTextUnderline :: Maybe NumberOfLines
underline attribute
formattedTextOverline :: Maybe NumberOfLines
overline attribute
formattedTextLineThrough :: Maybe NumberOfLines
line-through attribute
formattedTextRotation :: Maybe RotationDegrees
rotation attribute
formattedTextLetterSpacing :: Maybe NumberOrNormal
letter-spacing attribute
formattedTextLineHeight :: Maybe NumberOrNormal
line-height attribute
formattedTextDir :: Maybe TextDirection
dir attribute

Instances

Eq FormattedText Source #
Methods (==) :: FormattedText -> FormattedText -> Bool # (/=) :: FormattedText -> FormattedText -> Bool #
Show FormattedText Source #
Methods showsPrec :: Int -> FormattedText -> ShowS # show :: FormattedText -> String # showList :: [FormattedText] -> ShowS #
Generic FormattedText Source #
Associated Types type Rep FormattedText :: * -> * # Methods from :: FormattedText -> Rep FormattedText x # to :: Rep FormattedText x -> FormattedText #
EmitXml FormattedText Source #
Methods emitXml :: FormattedText -> XmlRep Source #
type Rep FormattedText Source #
type Rep FormattedText = D1 * (MetaData "FormattedText" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "FormattedText" PrefixI True) ((::) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "formattedTextString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "formattedTextLang") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Lang)))) ((::) (S1 * (MetaSel (Just Symbol "formattedTextEnclosure") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Enclosure))) ((::) (S1 * (MetaSel (Just Symbol "formattedTextJustify") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LeftCenterRight))) (S1 * (MetaSel (Just Symbol "formattedTextHalign") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LeftCenterRight)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "formattedTextValign") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Valign))) ((::) (S1 * (MetaSel (Just Symbol "formattedTextDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "formattedTextDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) (S1 * (MetaSel (Just Symbol "formattedTextRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "formattedTextRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "formattedTextFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "formattedTextFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "formattedTextFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize)))) ((::) (S1 * (MetaSel (Just Symbol "formattedTextFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) ((::) (S1 * (MetaSel (Just Symbol "formattedTextColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "formattedTextUnderline") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOfLines)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "formattedTextOverline") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOfLines))) ((::) (S1 * (MetaSel (Just Symbol "formattedTextLineThrough") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOfLines))) (S1 * (MetaSel (Just Symbol "formattedTextRotation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe RotationDegrees))))) ((::) (S1 * (MetaSel (Just Symbol "formattedTextLetterSpacing") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOrNormal))) ((::) (S1 * (MetaSel (Just Symbol "formattedTextLineHeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOrNormal))) (S1 * (MetaSel (Just Symbol "formattedTextDir") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TextDirection)))))))))

parseFormattedText :: XParse FormattedText Source #

mkFormattedText :: String -> FormattedText Source #

Smart constructor for FormattedText

data Forward Source #

forward (complex)

The backup and forward elements are required to coordinate multiple voices in one part, including music on multiple staves. The forward element is generally used within voices and staves. Duration values should always be positive, and should not cross measure boundaries.

Constructors

Forward
Fields forwardDuration :: Duration forwardEditorialVoice :: EditorialVoice forwardStaff :: Maybe Staff

Instances

Eq Forward Source #
Methods (==) :: Forward -> Forward -> Bool # (/=) :: Forward -> Forward -> Bool #
Show Forward Source #
Methods showsPrec :: Int -> Forward -> ShowS # show :: Forward -> String # showList :: [Forward] -> ShowS #
Generic Forward Source #
Associated Types type Rep Forward :: * -> * # Methods from :: Forward -> Rep Forward x # to :: Rep Forward x -> Forward #
EmitXml Forward Source #
Methods emitXml :: Forward -> XmlRep Source #
type Rep Forward Source #
type Rep Forward = D1 * (MetaData "Forward" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Forward" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "forwardDuration") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Duration)) ((::) (S1 * (MetaSel (Just Symbol "forwardEditorialVoice") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EditorialVoice)) (S1 * (MetaSel (Just Symbol "forwardStaff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Staff))))))

parseForward :: XParse Forward Source #

mkForward :: Duration -> EditorialVoice -> Forward Source #

Smart constructor for Forward

data Frame Source #

frame (complex)

The frame type represents a frame or fretboard diagram used together with a chord symbol. The representation is based on the NIFF guitar grid with additional information.

Constructors

Frame

Fields

frameHeight :: Maybe Tenths
height attribute
frameWidth :: Maybe Tenths
width attribute
frameDefaultX :: Maybe Tenths
default-x attribute
frameDefaultY :: Maybe Tenths
default-y attribute
frameRelativeX :: Maybe Tenths
relative-x attribute
frameRelativeY :: Maybe Tenths
relative-y attribute
frameColor :: Maybe Color
color attribute
frameHalign :: Maybe LeftCenterRight
halign attribute
frameValign :: Maybe Valign
valign attribute
frameFrameStrings :: PositiveInteger
frame-strings child element
frameFrameFrets :: PositiveInteger
frame-frets child element
frameFirstFret :: Maybe FirstFret
first-fret child element
frameFrameNote :: [FrameNote]
frame-note child element

Instances

Eq Frame Source #
Methods (==) :: Frame -> Frame -> Bool # (/=) :: Frame -> Frame -> Bool #
Show Frame Source #
Methods showsPrec :: Int -> Frame -> ShowS # show :: Frame -> String # showList :: [Frame] -> ShowS #
Generic Frame Source #
Associated Types type Rep Frame :: * -> * # Methods from :: Frame -> Rep Frame x # to :: Rep Frame x -> Frame #
EmitXml Frame Source #
Methods emitXml :: Frame -> XmlRep Source #
type Rep Frame Source #
type Rep Frame = D1 * (MetaData "Frame" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Frame" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "frameHeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "frameWidth") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "frameDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) (S1 * (MetaSel (Just Symbol "frameDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "frameRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "frameRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "frameColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) ((::) (S1 * (MetaSel (Just Symbol "frameHalign") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LeftCenterRight))) (S1 * (MetaSel (Just Symbol "frameValign") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Valign))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "frameFrameStrings") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveInteger)) (S1 * (MetaSel (Just Symbol "frameFrameFrets") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveInteger))) ((::) (S1 * (MetaSel (Just Symbol "frameFirstFret") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FirstFret))) (S1 * (MetaSel (Just Symbol "frameFrameNote") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [FrameNote])))))))

parseFrame :: XParse Frame Source #

mkFrame :: PositiveInteger -> PositiveInteger -> Frame Source #

Smart constructor for Frame

data FrameNote Source #

frame-note (complex)

The frame-note type represents each note included in the frame. An open string will have a fret value of 0, while a muted string will not be associated with a frame-note element.

Constructors

FrameNote
Fields frameNoteString :: CmpString string child element frameNoteFret :: Fret fret child element frameNoteFingering :: Maybe Fingering fingering child element frameNoteBarre :: Maybe Barre barre child element

Instances

Eq FrameNote Source #
Methods (==) :: FrameNote -> FrameNote -> Bool # (/=) :: FrameNote -> FrameNote -> Bool #
Show FrameNote Source #
Methods showsPrec :: Int -> FrameNote -> ShowS # show :: FrameNote -> String # showList :: [FrameNote] -> ShowS #
Generic FrameNote Source #
Associated Types type Rep FrameNote :: * -> * # Methods from :: FrameNote -> Rep FrameNote x # to :: Rep FrameNote x -> FrameNote #
EmitXml FrameNote Source #
Methods emitXml :: FrameNote -> XmlRep Source #
type Rep FrameNote Source #
type Rep FrameNote = D1 * (MetaData "FrameNote" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "FrameNote" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "frameNoteString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * CmpString)) (S1 * (MetaSel (Just Symbol "frameNoteFret") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Fret))) ((::) (S1 * (MetaSel (Just Symbol "frameNoteFingering") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Fingering))) (S1 * (MetaSel (Just Symbol "frameNoteBarre") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Barre))))))

parseFrameNote :: XParse FrameNote Source #

mkFrameNote :: CmpString -> Fret -> FrameNote Source #

Smart constructor for FrameNote

data Fret Source #

fret (complex)

The fret element is used with tablature notation and chord diagrams. Fret numbers start with 0 for an open string and 1 for the first fret.

Constructors

Fret
Fields fretNonNegativeInteger :: NonNegativeInteger text content fretFontFamily :: Maybe CommaSeparatedText font-family attribute fretFontStyle :: Maybe FontStyle font-style attribute fretFontSize :: Maybe FontSize font-size attribute fretFontWeight :: Maybe FontWeight font-weight attribute fretColor :: Maybe Color color attribute

Instances

Eq Fret Source #
Methods (==) :: Fret -> Fret -> Bool # (/=) :: Fret -> Fret -> Bool #
Show Fret Source #
Methods showsPrec :: Int -> Fret -> ShowS # show :: Fret -> String # showList :: [Fret] -> ShowS #
Generic Fret Source #
Associated Types type Rep Fret :: * -> * # Methods from :: Fret -> Rep Fret x # to :: Rep Fret x -> Fret #
EmitXml Fret Source #
Methods emitXml :: Fret -> XmlRep Source #
type Rep Fret Source #
type Rep Fret = D1 * (MetaData "Fret" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Fret" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "fretNonNegativeInteger") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NonNegativeInteger)) ((::) (S1 * (MetaSel (Just Symbol "fretFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "fretFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) (S1 * (MetaSel (Just Symbol "fretFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "fretFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "fretColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))))

parseFret :: XParse Fret Source #

mkFret :: NonNegativeInteger -> Fret Source #

Smart constructor for Fret

data Glissando Source #

glissando (complex)

Glissando and slide types both indicate rapidly moving from one pitch to the other so that individual notes are not discerned. The distinction is similar to that between NIFF's glissando and portamento elements. A glissando sounds the half notes in between the slide and defaults to a wavy line. The optional text is printed alongside the line.

Constructors

Glissando

Fields

glissandoString :: String
text content
glissandoType :: StartStop
type attribute
glissandoNumber :: Maybe NumberLevel
number attribute
glissandoLineType :: Maybe LineType
line-type attribute
glissandoDefaultX :: Maybe Tenths
default-x attribute
glissandoDefaultY :: Maybe Tenths
default-y attribute
glissandoRelativeX :: Maybe Tenths
relative-x attribute
glissandoRelativeY :: Maybe Tenths
relative-y attribute
glissandoFontFamily :: Maybe CommaSeparatedText
font-family attribute
glissandoFontStyle :: Maybe FontStyle
font-style attribute
glissandoFontSize :: Maybe FontSize
font-size attribute
glissandoFontWeight :: Maybe FontWeight
font-weight attribute
glissandoColor :: Maybe Color
color attribute

Instances

Eq Glissando Source #
Methods (==) :: Glissando -> Glissando -> Bool # (/=) :: Glissando -> Glissando -> Bool #
Show Glissando Source #
Methods showsPrec :: Int -> Glissando -> ShowS # show :: Glissando -> String # showList :: [Glissando] -> ShowS #
Generic Glissando Source #
Associated Types type Rep Glissando :: * -> * # Methods from :: Glissando -> Rep Glissando x # to :: Rep Glissando x -> Glissando #
EmitXml Glissando Source #
Methods emitXml :: Glissando -> XmlRep Source #
type Rep Glissando Source #
type Rep Glissando = D1 * (MetaData "Glissando" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Glissando" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "glissandoString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) ((::) (S1 * (MetaSel (Just Symbol "glissandoType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStop)) (S1 * (MetaSel (Just Symbol "glissandoNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberLevel))))) ((::) (S1 * (MetaSel (Just Symbol "glissandoLineType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LineType))) ((::) (S1 * (MetaSel (Just Symbol "glissandoDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "glissandoDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "glissandoRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "glissandoRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "glissandoFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "glissandoFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "glissandoFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize)))) ((::) (S1 * (MetaSel (Just Symbol "glissandoFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "glissandoColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseGlissando :: XParse Glissando Source #

mkGlissando :: String -> StartStop -> Glissando Source #

Smart constructor for Glissando

data Grace Source #

grace (complex)

The grace type indicates the presence of a grace note. The slash attribute for a grace note is yes for slashed eighth notes. The other grace note attributes come from MuseData sound suggestions. Steal-time-previous indicates the percentage of time to steal from the previous note for the grace note. Steal-time-following indicates the percentage of time to steal from the following note for the grace note. Make-time indicates to make time, not steal time; the units are in real-time divisions for the grace note.

Constructors

Grace
Fields graceStealTimePrevious :: Maybe Percent steal-time-previous attribute graceStealTimeFollowing :: Maybe Percent steal-time-following attribute graceMakeTime :: Maybe Divisions make-time attribute graceSlash :: Maybe YesNo slash attribute

Instances

Eq Grace Source #
Methods (==) :: Grace -> Grace -> Bool # (/=) :: Grace -> Grace -> Bool #
Show Grace Source #
Methods showsPrec :: Int -> Grace -> ShowS # show :: Grace -> String # showList :: [Grace] -> ShowS #
Generic Grace Source #
Associated Types type Rep Grace :: * -> * # Methods from :: Grace -> Rep Grace x # to :: Rep Grace x -> Grace #
EmitXml Grace Source #
Methods emitXml :: Grace -> XmlRep Source #
type Rep Grace Source #
type Rep Grace = D1 * (MetaData "Grace" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Grace" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "graceStealTimePrevious") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Percent))) (S1 * (MetaSel (Just Symbol "graceStealTimeFollowing") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Percent)))) ((::) (S1 * (MetaSel (Just Symbol "graceMakeTime") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Divisions))) (S1 * (MetaSel (Just Symbol "graceSlash") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))))))

parseGrace :: XParse Grace Source #

mkGrace :: Grace Source #

Smart constructor for Grace

data GroupBarline Source #

group-barline (complex)

The group-barline type indicates if the group should have common barlines.

Constructors

GroupBarline
Fields groupBarlineGroupBarlineValue :: GroupBarlineValue text content groupBarlineColor :: Maybe Color color attribute

Instances

Eq GroupBarline Source #
Methods (==) :: GroupBarline -> GroupBarline -> Bool # (/=) :: GroupBarline -> GroupBarline -> Bool #
Show GroupBarline Source #
Methods showsPrec :: Int -> GroupBarline -> ShowS # show :: GroupBarline -> String # showList :: [GroupBarline] -> ShowS #
Generic GroupBarline Source #
Associated Types type Rep GroupBarline :: * -> * # Methods from :: GroupBarline -> Rep GroupBarline x # to :: Rep GroupBarline x -> GroupBarline #
EmitXml GroupBarline Source #
Methods emitXml :: GroupBarline -> XmlRep Source #
type Rep GroupBarline Source #
type Rep GroupBarline = D1 * (MetaData "GroupBarline" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "GroupBarline" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "groupBarlineGroupBarlineValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * GroupBarlineValue)) (S1 * (MetaSel (Just Symbol "groupBarlineColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))

parseGroupBarline :: XParse GroupBarline Source #

mkGroupBarline :: GroupBarlineValue -> GroupBarline Source #

Smart constructor for GroupBarline

data GroupName Source #

group-name (complex)

The group-name type describes the name or abbreviation of a part-group element. Formatting attributes in the group-name type are deprecated in Version 2.0 in favor of the new group-name-display and group-abbreviation-display elements.

Constructors

GroupName

Fields

groupNameString :: String
text content
groupNameDefaultX :: Maybe Tenths
default-x attribute
groupNameDefaultY :: Maybe Tenths
default-y attribute
groupNameRelativeX :: Maybe Tenths
relative-x attribute
groupNameRelativeY :: Maybe Tenths
relative-y attribute
groupNameFontFamily :: Maybe CommaSeparatedText
font-family attribute
groupNameFontStyle :: Maybe FontStyle
font-style attribute
groupNameFontSize :: Maybe FontSize
font-size attribute
groupNameFontWeight :: Maybe FontWeight
font-weight attribute
groupNameColor :: Maybe Color
color attribute
groupNameJustify :: Maybe LeftCenterRight
justify attribute

Instances

Eq GroupName Source #
Methods (==) :: GroupName -> GroupName -> Bool # (/=) :: GroupName -> GroupName -> Bool #
Show GroupName Source #
Methods showsPrec :: Int -> GroupName -> ShowS # show :: GroupName -> String # showList :: [GroupName] -> ShowS #
Generic GroupName Source #
Associated Types type Rep GroupName :: * -> * # Methods from :: GroupName -> Rep GroupName x # to :: Rep GroupName x -> GroupName #
EmitXml GroupName Source #
Methods emitXml :: GroupName -> XmlRep Source #
type Rep GroupName Source #
type Rep GroupName = D1 * (MetaData "GroupName" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "GroupName" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "groupNameString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "groupNameDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "groupNameDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "groupNameRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "groupNameRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "groupNameFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) ((::) (S1 * (MetaSel (Just Symbol "groupNameFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "groupNameFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))))) ((::) (S1 * (MetaSel (Just Symbol "groupNameFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) ((::) (S1 * (MetaSel (Just Symbol "groupNameColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "groupNameJustify") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LeftCenterRight))))))))

parseGroupName :: XParse GroupName Source #

mkGroupName :: String -> GroupName Source #

Smart constructor for GroupName

data GroupSymbol Source #

group-symbol (complex)

The group-symbol type indicates how the symbol for a group is indicated in the score.

Constructors

GroupSymbol
Fields groupSymbolGroupSymbolValue :: GroupSymbolValue text content groupSymbolDefaultX :: Maybe Tenths default-x attribute groupSymbolDefaultY :: Maybe Tenths default-y attribute groupSymbolRelativeX :: Maybe Tenths relative-x attribute groupSymbolRelativeY :: Maybe Tenths relative-y attribute groupSymbolColor :: Maybe Color color attribute

Instances

Eq GroupSymbol Source #
Methods (==) :: GroupSymbol -> GroupSymbol -> Bool # (/=) :: GroupSymbol -> GroupSymbol -> Bool #
Show GroupSymbol Source #
Methods showsPrec :: Int -> GroupSymbol -> ShowS # show :: GroupSymbol -> String # showList :: [GroupSymbol] -> ShowS #
Generic GroupSymbol Source #
Associated Types type Rep GroupSymbol :: * -> * # Methods from :: GroupSymbol -> Rep GroupSymbol x # to :: Rep GroupSymbol x -> GroupSymbol #
EmitXml GroupSymbol Source #
Methods emitXml :: GroupSymbol -> XmlRep Source #
type Rep GroupSymbol Source #
type Rep GroupSymbol = D1 * (MetaData "GroupSymbol" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "GroupSymbol" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "groupSymbolGroupSymbolValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * GroupSymbolValue)) ((::) (S1 * (MetaSel (Just Symbol "groupSymbolDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "groupSymbolDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) (S1 * (MetaSel (Just Symbol "groupSymbolRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "groupSymbolRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "groupSymbolColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))))

parseGroupSymbol :: XParse GroupSymbol Source #

mkGroupSymbol :: GroupSymbolValue -> GroupSymbol Source #

Smart constructor for GroupSymbol

data Grouping Source #

grouping (complex)

The grouping type is used for musical analysis. When the type attribute is "start" or "single", it usually contains one or more feature elements. The number attribute is used for distinguishing between overlapping and hierarchical groupings. The member-of attribute allows for easy distinguishing of what grouping elements are in what hierarchy. Feature elements contained within a "stop" type of grouping may be ignored.

This element is flexible to allow for different types of analyses. Future versions of the MusicXML format may add elements that can represent more standardized categories of analysis data, allowing for easier data sharing.

Constructors

Grouping
Fields groupingType :: StartStopSingle type attribute groupingNumber :: Maybe Token number attribute groupingMemberOf :: Maybe Token member-of attribute groupingFeature :: [Feature] feature child element

Instances

Eq Grouping Source #
Methods (==) :: Grouping -> Grouping -> Bool # (/=) :: Grouping -> Grouping -> Bool #
Show Grouping Source #
Methods showsPrec :: Int -> Grouping -> ShowS # show :: Grouping -> String # showList :: [Grouping] -> ShowS #
Generic Grouping Source #
Associated Types type Rep Grouping :: * -> * # Methods from :: Grouping -> Rep Grouping x # to :: Rep Grouping x -> Grouping #
EmitXml Grouping Source #
Methods emitXml :: Grouping -> XmlRep Source #
type Rep Grouping Source #
type Rep Grouping = D1 * (MetaData "Grouping" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Grouping" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "groupingType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStopSingle)) (S1 * (MetaSel (Just Symbol "groupingNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token)))) ((::) (S1 * (MetaSel (Just Symbol "groupingMemberOf") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) (S1 * (MetaSel (Just Symbol "groupingFeature") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Feature])))))

parseGrouping :: XParse Grouping Source #

mkGrouping :: StartStopSingle -> Grouping Source #

Smart constructor for Grouping

data HammerOnPullOff Source #

hammer-on-pull-off (complex)

The hammer-on and pull-off elements are used in guitar and fretted instrument notation. Since a single slur can be marked over many notes, the hammer-on and pull-off elements are separate so the individual pair of notes can be specified. The element content can be used to specify how the hammer-on or pull-off should be notated. An empty element leaves this choice up to the application.

Constructors

HammerOnPullOff

Fields

hammerOnPullOffString :: String
text content
hammerOnPullOffType :: StartStop
type attribute
hammerOnPullOffNumber :: Maybe NumberLevel
number attribute
hammerOnPullOffDefaultX :: Maybe Tenths
default-x attribute
hammerOnPullOffDefaultY :: Maybe Tenths
default-y attribute
hammerOnPullOffRelativeX :: Maybe Tenths
relative-x attribute
hammerOnPullOffRelativeY :: Maybe Tenths
relative-y attribute
hammerOnPullOffFontFamily :: Maybe CommaSeparatedText
font-family attribute
hammerOnPullOffFontStyle :: Maybe FontStyle
font-style attribute
hammerOnPullOffFontSize :: Maybe FontSize
font-size attribute
hammerOnPullOffFontWeight :: Maybe FontWeight
font-weight attribute
hammerOnPullOffColor :: Maybe Color
color attribute
hammerOnPullOffPlacement :: Maybe AboveBelow
placement attribute

Instances

Eq HammerOnPullOff Source #
Methods (==) :: HammerOnPullOff -> HammerOnPullOff -> Bool # (/=) :: HammerOnPullOff -> HammerOnPullOff -> Bool #
Show HammerOnPullOff Source #
Methods showsPrec :: Int -> HammerOnPullOff -> ShowS # show :: HammerOnPullOff -> String # showList :: [HammerOnPullOff] -> ShowS #
Generic HammerOnPullOff Source #
Associated Types type Rep HammerOnPullOff :: * -> * # Methods from :: HammerOnPullOff -> Rep HammerOnPullOff x # to :: Rep HammerOnPullOff x -> HammerOnPullOff #
EmitXml HammerOnPullOff Source #
Methods emitXml :: HammerOnPullOff -> XmlRep Source #
type Rep HammerOnPullOff Source #
type Rep HammerOnPullOff = D1 * (MetaData "HammerOnPullOff" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "HammerOnPullOff" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "hammerOnPullOffString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) ((::) (S1 * (MetaSel (Just Symbol "hammerOnPullOffType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStop)) (S1 * (MetaSel (Just Symbol "hammerOnPullOffNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberLevel))))) ((::) (S1 * (MetaSel (Just Symbol "hammerOnPullOffDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "hammerOnPullOffDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "hammerOnPullOffRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "hammerOnPullOffRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "hammerOnPullOffFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "hammerOnPullOffFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "hammerOnPullOffFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "hammerOnPullOffFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight)))) ((::) (S1 * (MetaSel (Just Symbol "hammerOnPullOffColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "hammerOnPullOffPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow))))))))

parseHammerOnPullOff :: XParse HammerOnPullOff Source #

mkHammerOnPullOff :: String -> StartStop -> HammerOnPullOff Source #

Smart constructor for HammerOnPullOff

data Harmonic Source #

harmonic (complex)

The harmonic type indicates natural and artificial harmonics. Allowing the type of pitch to be specified, combined with controls for appearance/playback differences, allows both the notation and the sound to be represented. Artificial harmonics can add a notated touching-pitch; artificial pinch harmonics will usually not notate a touching pitch. The attributes for the harmonic element refer to the use of the circular harmonic symbol, typically but not always used with natural harmonics.

Constructors

Harmonic

Fields

harmonicPrintObject :: Maybe YesNo
print-object attribute
harmonicDefaultX :: Maybe Tenths
default-x attribute
harmonicDefaultY :: Maybe Tenths
default-y attribute
harmonicRelativeX :: Maybe Tenths
relative-x attribute
harmonicRelativeY :: Maybe Tenths
relative-y attribute
harmonicFontFamily :: Maybe CommaSeparatedText
font-family attribute
harmonicFontStyle :: Maybe FontStyle
font-style attribute
harmonicFontSize :: Maybe FontSize
font-size attribute
harmonicFontWeight :: Maybe FontWeight
font-weight attribute
harmonicColor :: Maybe Color
color attribute
harmonicPlacement :: Maybe AboveBelow
placement attribute
harmonicHarmonic :: Maybe ChxHarmonic
harmonicHarmonic1 :: Maybe ChxHarmonic1

Instances

Eq Harmonic Source #
Methods (==) :: Harmonic -> Harmonic -> Bool # (/=) :: Harmonic -> Harmonic -> Bool #
Show Harmonic Source #
Methods showsPrec :: Int -> Harmonic -> ShowS # show :: Harmonic -> String # showList :: [Harmonic] -> ShowS #
Generic Harmonic Source #
Associated Types type Rep Harmonic :: * -> * # Methods from :: Harmonic -> Rep Harmonic x # to :: Rep Harmonic x -> Harmonic #
EmitXml Harmonic Source #
Methods emitXml :: Harmonic -> XmlRep Source #
type Rep Harmonic Source #
type Rep Harmonic = D1 * (MetaData "Harmonic" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Harmonic" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "harmonicPrintObject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) ((::) (S1 * (MetaSel (Just Symbol "harmonicDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "harmonicDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) (S1 * (MetaSel (Just Symbol "harmonicRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "harmonicRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "harmonicFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "harmonicFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) ((::) (S1 * (MetaSel (Just Symbol "harmonicFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "harmonicFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "harmonicColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "harmonicPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow)))) ((::) (S1 * (MetaSel (Just Symbol "harmonicHarmonic") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe ChxHarmonic))) (S1 * (MetaSel (Just Symbol "harmonicHarmonic1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe ChxHarmonic1))))))))

parseHarmonic :: XParse Harmonic Source #

mkHarmonic :: Harmonic Source #

Smart constructor for Harmonic

data Harmony Source #

harmony (complex)

The harmony type is based on Humdrum's **harm encoding, extended to support chord symbols in popular music as well as functional harmony analysis in classical music.

If there are alternate harmonies possible, this can be specified using multiple harmony elements differentiated by type. Explicit harmonies have all note present in the music; implied have some notes missing but implied; alternate represents alternate analyses.

The harmony object may be used for analysis or for chord symbols. The print-object attribute controls whether or not anything is printed due to the harmony element. The print-frame attribute controls printing of a frame or fretboard diagram. The print-style attribute group sets the default for the harmony, but individual elements can override this with their own print-style values.

Constructors

Harmony

Fields

harmonyType :: Maybe HarmonyType
type attribute
harmonyPrintFrame :: Maybe YesNo
print-frame attribute
harmonyPrintObject :: Maybe YesNo
print-object attribute
harmonyDefaultX :: Maybe Tenths
default-x attribute
harmonyDefaultY :: Maybe Tenths
default-y attribute
harmonyRelativeX :: Maybe Tenths
relative-x attribute
harmonyRelativeY :: Maybe Tenths
relative-y attribute
harmonyFontFamily :: Maybe CommaSeparatedText
font-family attribute
harmonyFontStyle :: Maybe FontStyle
font-style attribute
harmonyFontSize :: Maybe FontSize
font-size attribute
harmonyFontWeight :: Maybe FontWeight
font-weight attribute
harmonyColor :: Maybe Color
color attribute
harmonyPlacement :: Maybe AboveBelow
placement attribute
harmonyHarmonyChord :: [HarmonyChord]
harmonyFrame :: Maybe Frame
frame child element
harmonyOffset :: Maybe Offset
offset child element
harmonyEditorial :: Editorial
harmonyStaff :: Maybe Staff

Instances

Eq Harmony Source #
Methods (==) :: Harmony -> Harmony -> Bool # (/=) :: Harmony -> Harmony -> Bool #
Show Harmony Source #
Methods showsPrec :: Int -> Harmony -> ShowS # show :: Harmony -> String # showList :: [Harmony] -> ShowS #
Generic Harmony Source #
Associated Types type Rep Harmony :: * -> * # Methods from :: Harmony -> Rep Harmony x # to :: Rep Harmony x -> Harmony #
EmitXml Harmony Source #
Methods emitXml :: Harmony -> XmlRep Source #
type Rep Harmony Source #
type Rep Harmony = D1 * (MetaData "Harmony" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Harmony" PrefixI True) ((::) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "harmonyType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe HarmonyType))) (S1 * (MetaSel (Just Symbol "harmonyPrintFrame") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "harmonyPrintObject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "harmonyDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "harmonyDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "harmonyRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "harmonyRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "harmonyFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "harmonyFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "harmonyFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "harmonyFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight)))) ((::) (S1 * (MetaSel (Just Symbol "harmonyColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "harmonyPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "harmonyHarmonyChord") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [HarmonyChord])) (S1 * (MetaSel (Just Symbol "harmonyFrame") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Frame)))) ((::) (S1 * (MetaSel (Just Symbol "harmonyOffset") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Offset))) ((::) (S1 * (MetaSel (Just Symbol "harmonyEditorial") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Editorial)) (S1 * (MetaSel (Just Symbol "harmonyStaff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Staff)))))))))

parseHarmony :: XParse Harmony Source #

mkHarmony :: Editorial -> Harmony Source #

Smart constructor for Harmony

data HarpPedals Source #

harp-pedals (complex)

The harp-pedals type is used to create harp pedal diagrams. The pedal-step and pedal-alter elements use the same values as the step and alter elements. For easiest reading, the pedal-tuning elements should follow standard harp pedal order, with pedal-step values of D, C, B, E, F, G, and A.

Constructors

HarpPedals

Fields

harpPedalsDefaultX :: Maybe Tenths
default-x attribute
harpPedalsDefaultY :: Maybe Tenths
default-y attribute
harpPedalsRelativeX :: Maybe Tenths
relative-x attribute
harpPedalsRelativeY :: Maybe Tenths
relative-y attribute
harpPedalsFontFamily :: Maybe CommaSeparatedText
font-family attribute
harpPedalsFontStyle :: Maybe FontStyle
font-style attribute
harpPedalsFontSize :: Maybe FontSize
font-size attribute
harpPedalsFontWeight :: Maybe FontWeight
font-weight attribute
harpPedalsColor :: Maybe Color
color attribute
harpPedalsPedalTuning :: [PedalTuning]
pedal-tuning child element

Instances

Eq HarpPedals Source #
Methods (==) :: HarpPedals -> HarpPedals -> Bool # (/=) :: HarpPedals -> HarpPedals -> Bool #
Show HarpPedals Source #
Methods showsPrec :: Int -> HarpPedals -> ShowS # show :: HarpPedals -> String # showList :: [HarpPedals] -> ShowS #
Generic HarpPedals Source #
Associated Types type Rep HarpPedals :: * -> * # Methods from :: HarpPedals -> Rep HarpPedals x # to :: Rep HarpPedals x -> HarpPedals #
EmitXml HarpPedals Source #
Methods emitXml :: HarpPedals -> XmlRep Source #
type Rep HarpPedals Source #
type Rep HarpPedals = D1 * (MetaData "HarpPedals" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "HarpPedals" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "harpPedalsDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "harpPedalsDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "harpPedalsRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "harpPedalsRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "harpPedalsFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "harpPedalsFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "harpPedalsFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize)))) ((::) (S1 * (MetaSel (Just Symbol "harpPedalsFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) ((::) (S1 * (MetaSel (Just Symbol "harpPedalsColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "harpPedalsPedalTuning") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [PedalTuning])))))))

parseHarpPedals :: XParse HarpPedals Source #

mkHarpPedals :: HarpPedals Source #

Smart constructor for HarpPedals

data HeelToe Source #

heel-toe (complex)

The heel and toe elements are used with organ pedals. The substitution value is "no" if the attribute is not present.

Constructors

HeelToe
Fields heelToeEmptyPlacement :: HeelToe heelToeSubstitution :: Maybe YesNo substitution attribute

Instances

Eq HeelToe Source #
Methods (==) :: HeelToe -> HeelToe -> Bool # (/=) :: HeelToe -> HeelToe -> Bool #
Show HeelToe Source #
Methods showsPrec :: Int -> HeelToe -> ShowS # show :: HeelToe -> String # showList :: [HeelToe] -> ShowS #
Generic HeelToe Source #
Associated Types type Rep HeelToe :: * -> * # Methods from :: HeelToe -> Rep HeelToe x # to :: Rep HeelToe x -> HeelToe #
EmitXml HeelToe Source #
Methods emitXml :: HeelToe -> XmlRep Source #
type Rep HeelToe Source #
type Rep HeelToe = D1 * (MetaData "HeelToe" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "HeelToe" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "heelToeEmptyPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * HeelToe)) (S1 * (MetaSel (Just Symbol "heelToeSubstitution") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))))

parseHeelToe :: XParse HeelToe Source #

mkHeelToe :: HeelToe -> HeelToe Source #

Smart constructor for HeelToe

data Identification Source #

identification (complex)

Identification contains basic metadata about the score. It includes the information in MuseData headers that may apply at a score-wide, movement-wide, or part-wide level. The creator, rights, source, and relation elements are based on Dublin Core.

Constructors

Identification
Fields identificationCreator :: [TypedText] creator child element identificationRights :: [TypedText] rights child element identificationEncoding :: Maybe Encoding encoding child element identificationSource :: Maybe String source child element identificationRelation :: [TypedText] relation child element identificationMiscellaneous :: Maybe Miscellaneous miscellaneous child element

Instances

Eq Identification Source #
Methods (==) :: Identification -> Identification -> Bool # (/=) :: Identification -> Identification -> Bool #
Show Identification Source #
Methods showsPrec :: Int -> Identification -> ShowS # show :: Identification -> String # showList :: [Identification] -> ShowS #
Generic Identification Source #
Associated Types type Rep Identification :: * -> * # Methods from :: Identification -> Rep Identification x # to :: Rep Identification x -> Identification #
EmitXml Identification Source #
Methods emitXml :: Identification -> XmlRep Source #
type Rep Identification Source #
type Rep Identification = D1 * (MetaData "Identification" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Identification" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "identificationCreator") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [TypedText])) ((::) (S1 * (MetaSel (Just Symbol "identificationRights") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [TypedText])) (S1 * (MetaSel (Just Symbol "identificationEncoding") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Encoding))))) ((::) (S1 * (MetaSel (Just Symbol "identificationSource") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe String))) ((::) (S1 * (MetaSel (Just Symbol "identificationRelation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [TypedText])) (S1 * (MetaSel (Just Symbol "identificationMiscellaneous") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Miscellaneous)))))))

parseIdentification :: XParse Identification Source #

mkIdentification :: Identification Source #

Smart constructor for Identification

data Image Source #

image (complex)

The image type is used to include graphical images in a score.

Constructors

Image

Fields

imageSource :: String
source attribute
imageType :: Token
type attribute
imageDefaultX :: Maybe Tenths
default-x attribute
imageDefaultY :: Maybe Tenths
default-y attribute
imageRelativeX :: Maybe Tenths
relative-x attribute
imageRelativeY :: Maybe Tenths
relative-y attribute
imageHalign :: Maybe LeftCenterRight
halign attribute
imageValign :: Maybe ValignImage
valign attribute

Instances

Eq Image Source #
Methods (==) :: Image -> Image -> Bool # (/=) :: Image -> Image -> Bool #
Show Image Source #
Methods showsPrec :: Int -> Image -> ShowS # show :: Image -> String # showList :: [Image] -> ShowS #
Generic Image Source #
Associated Types type Rep Image :: * -> * # Methods from :: Image -> Rep Image x # to :: Rep Image x -> Image #
EmitXml Image Source #
Methods emitXml :: Image -> XmlRep Source #
type Rep Image Source #
type Rep Image = D1 * (MetaData "Image" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Image" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "imageSource") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "imageType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Token))) ((::) (S1 * (MetaSel (Just Symbol "imageDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "imageDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "imageRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "imageRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "imageHalign") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LeftCenterRight))) (S1 * (MetaSel (Just Symbol "imageValign") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe ValignImage)))))))

parseImage :: XParse Image Source #

mkImage :: String -> Token -> Image Source #

Smart constructor for Image

data Instrument Source #

instrument (complex)

The instrument type distinguishes between score-instrument elements in a score-part. The id attribute is an IDREF back to the score-instrument ID. If multiple score-instruments are specified on a score-part, there should be an instrument element for each note in the part.

Constructors

Instrument
Fields instrumentId :: IDREF id attribute

Instances

Eq Instrument Source #
Methods (==) :: Instrument -> Instrument -> Bool # (/=) :: Instrument -> Instrument -> Bool #
Show Instrument Source #
Methods showsPrec :: Int -> Instrument -> ShowS # show :: Instrument -> String # showList :: [Instrument] -> ShowS #
Generic Instrument Source #
Associated Types type Rep Instrument :: * -> * # Methods from :: Instrument -> Rep Instrument x # to :: Rep Instrument x -> Instrument #
EmitXml Instrument Source #
Methods emitXml :: Instrument -> XmlRep Source #
type Rep Instrument Source #
type Rep Instrument = D1 * (MetaData "Instrument" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Instrument" PrefixI True) (S1 * (MetaSel (Just Symbol "instrumentId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * IDREF)))

parseInstrument :: XParse Instrument Source #

mkInstrument :: IDREF -> Instrument Source #

Smart constructor for Instrument

data Inversion Source #

inversion (complex)

The inversion type represents harmony inversions. The value is a number indicating which inversion is used: 0 for root position, 1 for first inversion, etc.

Constructors

Inversion

Fields

inversionNonNegativeInteger :: NonNegativeInteger
text content
inversionDefaultX :: Maybe Tenths
default-x attribute
inversionDefaultY :: Maybe Tenths
default-y attribute
inversionRelativeX :: Maybe Tenths
relative-x attribute
inversionRelativeY :: Maybe Tenths
relative-y attribute
inversionFontFamily :: Maybe CommaSeparatedText
font-family attribute
inversionFontStyle :: Maybe FontStyle
font-style attribute
inversionFontSize :: Maybe FontSize
font-size attribute
inversionFontWeight :: Maybe FontWeight
font-weight attribute
inversionColor :: Maybe Color
color attribute

Instances

Eq Inversion Source #
Methods (==) :: Inversion -> Inversion -> Bool # (/=) :: Inversion -> Inversion -> Bool #
Show Inversion Source #
Methods showsPrec :: Int -> Inversion -> ShowS # show :: Inversion -> String # showList :: [Inversion] -> ShowS #
Generic Inversion Source #
Associated Types type Rep Inversion :: * -> * # Methods from :: Inversion -> Rep Inversion x # to :: Rep Inversion x -> Inversion #
EmitXml Inversion Source #
Methods emitXml :: Inversion -> XmlRep Source #
type Rep Inversion Source #
type Rep Inversion = D1 * (MetaData "Inversion" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Inversion" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "inversionNonNegativeInteger") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NonNegativeInteger)) (S1 * (MetaSel (Just Symbol "inversionDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "inversionDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "inversionRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "inversionRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "inversionFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "inversionFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle)))) ((::) (S1 * (MetaSel (Just Symbol "inversionFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "inversionFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "inversionColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseInversion :: XParse Inversion Source #

mkInversion :: NonNegativeInteger -> Inversion Source #

Smart constructor for Inversion

data Key Source #

key (complex)

The key type represents a key signature. Both traditional and non-traditional key signatures are supported. The optional number attribute refers to staff numbers. If absent, the key signature applies to all staves in the part.

Constructors

Key

Fields

keyNumber :: Maybe StaffNumber
number attribute
keyDefaultX :: Maybe Tenths
default-x attribute
keyDefaultY :: Maybe Tenths
default-y attribute
keyRelativeX :: Maybe Tenths
relative-x attribute
keyRelativeY :: Maybe Tenths
relative-y attribute
keyFontFamily :: Maybe CommaSeparatedText
font-family attribute
keyFontStyle :: Maybe FontStyle
font-style attribute
keyFontSize :: Maybe FontSize
font-size attribute
keyFontWeight :: Maybe FontWeight
font-weight attribute
keyColor :: Maybe Color
color attribute
keyPrintObject :: Maybe YesNo
print-object attribute
keyKey :: ChxKey
keyKeyOctave :: [KeyOctave]
key-octave child element

Instances

Eq Key Source #
Methods (==) :: Key -> Key -> Bool # (/=) :: Key -> Key -> Bool #
Show Key Source #
Methods showsPrec :: Int -> Key -> ShowS # show :: Key -> String # showList :: [Key] -> ShowS #
Generic Key Source #
Associated Types type Rep Key :: * -> * # Methods from :: Key -> Rep Key x # to :: Rep Key x -> Key #
EmitXml Key Source #
Methods emitXml :: Key -> XmlRep Source #
type Rep Key Source #
type Rep Key = D1 * (MetaData "Key" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Key" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "keyNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StaffNumber))) ((::) (S1 * (MetaSel (Just Symbol "keyDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "keyDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) (S1 * (MetaSel (Just Symbol "keyRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "keyRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "keyFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "keyFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) ((::) (S1 * (MetaSel (Just Symbol "keyFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "keyFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "keyColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "keyPrintObject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "keyKey") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ChxKey)) (S1 * (MetaSel (Just Symbol "keyKeyOctave") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [KeyOctave])))))))

parseKey :: XParse Key Source #

mkKey :: ChxKey -> Key Source #

Smart constructor for Key

data KeyOctave Source #

key-octave (complex)

The key-octave element specifies in which octave an element of a key signature appears. The content specifies the octave value using the same values as the display-octave element. The number attribute is a positive integer that refers to the key signature element in left-to-right order. If the cancel attribute is set to yes, then this number refers to an element specified by the cancel element. It is no by default.

Constructors

KeyOctave
Fields keyOctaveOctave :: Octave text content keyOctaveNumber :: PositiveInteger number attribute keyOctaveCancel :: Maybe YesNo cancel attribute

Instances

Eq KeyOctave Source #
Methods (==) :: KeyOctave -> KeyOctave -> Bool # (/=) :: KeyOctave -> KeyOctave -> Bool #
Show KeyOctave Source #
Methods showsPrec :: Int -> KeyOctave -> ShowS # show :: KeyOctave -> String # showList :: [KeyOctave] -> ShowS #
Generic KeyOctave Source #
Associated Types type Rep KeyOctave :: * -> * # Methods from :: KeyOctave -> Rep KeyOctave x # to :: Rep KeyOctave x -> KeyOctave #
EmitXml KeyOctave Source #
Methods emitXml :: KeyOctave -> XmlRep Source #
type Rep KeyOctave Source #
type Rep KeyOctave = D1 * (MetaData "KeyOctave" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "KeyOctave" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "keyOctaveOctave") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Octave)) ((::) (S1 * (MetaSel (Just Symbol "keyOctaveNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveInteger)) (S1 * (MetaSel (Just Symbol "keyOctaveCancel") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))))))

parseKeyOctave :: XParse KeyOctave Source #

mkKeyOctave :: Octave -> PositiveInteger -> KeyOctave Source #

Smart constructor for KeyOctave

data Kind Source #

kind (complex)

Kind indicates the type of chord. Degree elements can then add, subtract, or alter from these starting points

	
The attributes are used to indicate the formatting of the symbol. Since the kind element is the constant in all the harmony-chord groups that can make up a polychord, many formatting attributes are here.
	
The use-symbols attribute is yes if the kind should be represented when possible with harmony symbols rather than letters and numbers. These symbols include:
	
	major: a triangle, like Unicode 25B3
	minor: -, like Unicode 002D
	augmented: +, like Unicode 002B
	diminished: °, like Unicode 00B0
	half-diminished: ø, like Unicode 00F8
	
The text attribute describes how the kind should be spelled if not using symbols; it is ignored if use-symbols is yes. The stack-degrees attribute is yes if the degree elements should be stacked above each other. The parentheses-degrees attribute is yes if all the degrees should be in parentheses. The bracket-degrees attribute is yes if all the degrees should be in a bracket. If not specified, these values are implementation-specific. The alignment attributes are for the entire harmony-chord group of which this kind element is a part.

Constructors

Kind

Fields

kindKindValue :: KindValue
text content
kindUseSymbols :: Maybe YesNo
use-symbols attribute
kindText :: Maybe Token
text attribute
kindStackDegrees :: Maybe YesNo
stack-degrees attribute
kindParenthesesDegrees :: Maybe YesNo
parentheses-degrees attribute
kindBracketDegrees :: Maybe YesNo
bracket-degrees attribute
kindDefaultX :: Maybe Tenths
default-x attribute
kindDefaultY :: Maybe Tenths
default-y attribute
kindRelativeX :: Maybe Tenths
relative-x attribute
kindRelativeY :: Maybe Tenths
relative-y attribute
kindFontFamily :: Maybe CommaSeparatedText
font-family attribute
kindFontStyle :: Maybe FontStyle
font-style attribute
kindFontSize :: Maybe FontSize
font-size attribute
kindFontWeight :: Maybe FontWeight
font-weight attribute
kindColor :: Maybe Color
color attribute
kindHalign :: Maybe LeftCenterRight
halign attribute
kindValign :: Maybe Valign
valign attribute

Instances

Eq Kind Source #
Methods (==) :: Kind -> Kind -> Bool # (/=) :: Kind -> Kind -> Bool #
Show Kind Source #
Methods showsPrec :: Int -> Kind -> ShowS # show :: Kind -> String # showList :: [Kind] -> ShowS #
Generic Kind Source #
Associated Types type Rep Kind :: * -> * # Methods from :: Kind -> Rep Kind x # to :: Rep Kind x -> Kind #
EmitXml Kind Source #
Methods emitXml :: Kind -> XmlRep Source #
type Rep Kind Source #
type Rep Kind = D1 * (MetaData "Kind" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Kind" PrefixI True) ((::) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "kindKindValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * KindValue)) (S1 * (MetaSel (Just Symbol "kindUseSymbols") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "kindText") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) (S1 * (MetaSel (Just Symbol "kindStackDegrees") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "kindParenthesesDegrees") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "kindBracketDegrees") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "kindDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "kindDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "kindRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "kindRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "kindFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "kindFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "kindFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "kindFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight)))) ((::) (S1 * (MetaSel (Just Symbol "kindColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) ((::) (S1 * (MetaSel (Just Symbol "kindHalign") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LeftCenterRight))) (S1 * (MetaSel (Just Symbol "kindValign") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Valign)))))))))

parseKind :: XParse Kind Source #

mkKind :: KindValue -> Kind Source #

Smart constructor for Kind

data Level Source #

level (complex)

The level type is used to specify editorial information for different MusicXML elements. If the reference attribute for the level element is yes, this indicates editorial information that is for display only and should not affect playback. For instance, a modern edition of older music may set reference="yes" on the attributes containing the music's original clef, key, and time signature. It is no by default.

Constructors

Level
Fields levelString :: String text content levelReference :: Maybe YesNo reference attribute levelParentheses :: Maybe YesNo parentheses attribute levelBracket :: Maybe YesNo bracket attribute levelSize :: Maybe SymbolSize size attribute

Instances

Eq Level Source #
Methods (==) :: Level -> Level -> Bool # (/=) :: Level -> Level -> Bool #
Show Level Source #
Methods showsPrec :: Int -> Level -> ShowS # show :: Level -> String # showList :: [Level] -> ShowS #
Generic Level Source #
Associated Types type Rep Level :: * -> * # Methods from :: Level -> Rep Level x # to :: Rep Level x -> Level #
EmitXml Level Source #
Methods emitXml :: Level -> XmlRep Source #
type Rep Level Source #
type Rep Level = D1 * (MetaData "Level" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Level" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "levelString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "levelReference") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "levelParentheses") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) ((::) (S1 * (MetaSel (Just Symbol "levelBracket") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "levelSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe SymbolSize)))))))

parseLevel :: XParse Level Source #

mkLevel :: String -> Level Source #

Smart constructor for Level

data LineWidth Source #

line-width (complex)

The line-width type indicates the width of a line type in tenths. The type attribute defines what type of line is being defined. Values include beam, bracket, dashes, enclosure, ending, extend, heavy barline, leger, light barline, octave shift, pedal, slur middle, slur tip, staff, stem, tie middle, tie tip, tuplet bracket, and wedge. The text content is expressed in tenths.

Constructors

LineWidth
Fields lineWidthTenths :: Tenths text content cmplineWidthType :: LineWidthType type attribute

Instances

Eq LineWidth Source #
Methods (==) :: LineWidth -> LineWidth -> Bool # (/=) :: LineWidth -> LineWidth -> Bool #
Show LineWidth Source #
Methods showsPrec :: Int -> LineWidth -> ShowS # show :: LineWidth -> String # showList :: [LineWidth] -> ShowS #
Generic LineWidth Source #
Associated Types type Rep LineWidth :: * -> * # Methods from :: LineWidth -> Rep LineWidth x # to :: Rep LineWidth x -> LineWidth #
EmitXml LineWidth Source #
Methods emitXml :: LineWidth -> XmlRep Source #
type Rep LineWidth Source #
type Rep LineWidth = D1 * (MetaData "LineWidth" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "LineWidth" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "lineWidthTenths") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Tenths)) (S1 * (MetaSel (Just Symbol "cmplineWidthType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * LineWidthType))))

parseLineWidth :: XParse LineWidth Source #

mkLineWidth :: Tenths -> LineWidthType -> LineWidth Source #

Smart constructor for LineWidth

data Link Source #

link (complex)

The link type serves as an outgoing simple XLink. It is also used to connect a MusicXML score with a MusicXML opus.

Constructors

Link

Fields

linkName :: Maybe Token
name attribute
linkHref :: String
xlink:href attribute
linkType :: Maybe Type
xlink:type attribute
linkRole :: Maybe Token
xlink:role attribute
linkTitle :: Maybe Token
xlink:title attribute
linkShow :: Maybe SmpShow
xlink:show attribute
linkActuate :: Maybe Actuate
xlink:actuate attribute
linkElement :: Maybe NMTOKEN
element attribute
linkPosition :: Maybe PositiveInteger
position attribute
linkDefaultX :: Maybe Tenths
default-x attribute
linkDefaultY :: Maybe Tenths
default-y attribute
linkRelativeX :: Maybe Tenths
relative-x attribute
linkRelativeY :: Maybe Tenths
relative-y attribute

Instances

Eq Link Source #
Methods (==) :: Link -> Link -> Bool # (/=) :: Link -> Link -> Bool #
Show Link Source #
Methods showsPrec :: Int -> Link -> ShowS # show :: Link -> String # showList :: [Link] -> ShowS #
Generic Link Source #
Associated Types type Rep Link :: * -> * # Methods from :: Link -> Rep Link x # to :: Rep Link x -> Link #
EmitXml Link Source #
Methods emitXml :: Link -> XmlRep Source #
type Rep Link Source #
type Rep Link = D1 * (MetaData "Link" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Link" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "linkName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) ((::) (S1 * (MetaSel (Just Symbol "linkHref") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "linkType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Type))))) ((::) (S1 * (MetaSel (Just Symbol "linkRole") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) ((::) (S1 * (MetaSel (Just Symbol "linkTitle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) (S1 * (MetaSel (Just Symbol "linkShow") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe SmpShow)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "linkActuate") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Actuate))) ((::) (S1 * (MetaSel (Just Symbol "linkElement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NMTOKEN))) (S1 * (MetaSel (Just Symbol "linkPosition") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe PositiveInteger))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "linkDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "linkDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "linkRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "linkRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))))))

parseLink :: XParse Link Source #

mkLink :: String -> Link Source #

Smart constructor for Link

data Lyric Source #

lyric (complex)

The lyric type represents text underlays for lyrics, based on Humdrum with support for other formats. Two text elements that are not separated by an elision element are part of the same syllable, but may have different text formatting. The MusicXML 2.0 XSD is more strict than the 2.0 DTD in enforcing this by disallowing a second syllabic element unless preceded by an elision element. The lyric number indicates multiple lines, though a name can be used as well (as in Finale's verse chorus section specification). Justification is center by default; placement is below by default.

Constructors

Lyric

Fields

lyricNumber :: Maybe NMTOKEN
number attribute
lyricName :: Maybe Token
name attribute
lyricJustify :: Maybe LeftCenterRight
justify attribute
lyricDefaultX :: Maybe Tenths
default-x attribute
lyricDefaultY :: Maybe Tenths
default-y attribute
lyricRelativeX :: Maybe Tenths
relative-x attribute
lyricRelativeY :: Maybe Tenths
relative-y attribute
lyricPlacement :: Maybe AboveBelow
placement attribute
lyricColor :: Maybe Color
color attribute
lyricLyric :: ChxLyric
lyricEndLine :: Maybe Empty
end-line child element
lyricEndParagraph :: Maybe Empty
end-paragraph child element
lyricEditorial :: Editorial

Instances

Eq Lyric Source #
Methods (==) :: Lyric -> Lyric -> Bool # (/=) :: Lyric -> Lyric -> Bool #
Show Lyric Source #
Methods showsPrec :: Int -> Lyric -> ShowS # show :: Lyric -> String # showList :: [Lyric] -> ShowS #
Generic Lyric Source #
Associated Types type Rep Lyric :: * -> * # Methods from :: Lyric -> Rep Lyric x # to :: Rep Lyric x -> Lyric #
EmitXml Lyric Source #
Methods emitXml :: Lyric -> XmlRep Source #
type Rep Lyric Source #
type Rep Lyric = D1 * (MetaData "Lyric" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Lyric" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "lyricNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NMTOKEN))) ((::) (S1 * (MetaSel (Just Symbol "lyricName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) (S1 * (MetaSel (Just Symbol "lyricJustify") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LeftCenterRight))))) ((::) (S1 * (MetaSel (Just Symbol "lyricDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "lyricDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "lyricRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "lyricRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "lyricPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow))) (S1 * (MetaSel (Just Symbol "lyricColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "lyricLyric") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ChxLyric)) (S1 * (MetaSel (Just Symbol "lyricEndLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Empty)))) ((::) (S1 * (MetaSel (Just Symbol "lyricEndParagraph") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Empty))) (S1 * (MetaSel (Just Symbol "lyricEditorial") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Editorial)))))))

parseLyric :: XParse Lyric Source #

mkLyric :: ChxLyric -> Editorial -> Lyric Source #

Smart constructor for Lyric

data LyricFont Source #

lyric-font (complex)

The lyric-font type specifies the default font for a particular name and number of lyric.

Constructors

LyricFont
Fields lyricFontNumber :: Maybe NMTOKEN number attribute lyricFontName :: Maybe Token name attribute lyricFontFontFamily :: Maybe CommaSeparatedText font-family attribute lyricFontFontStyle :: Maybe FontStyle font-style attribute lyricFontFontSize :: Maybe FontSize font-size attribute lyricFontFontWeight :: Maybe FontWeight font-weight attribute

Instances

Eq LyricFont Source #
Methods (==) :: LyricFont -> LyricFont -> Bool # (/=) :: LyricFont -> LyricFont -> Bool #
Show LyricFont Source #
Methods showsPrec :: Int -> LyricFont -> ShowS # show :: LyricFont -> String # showList :: [LyricFont] -> ShowS #
Generic LyricFont Source #
Associated Types type Rep LyricFont :: * -> * # Methods from :: LyricFont -> Rep LyricFont x # to :: Rep LyricFont x -> LyricFont #
EmitXml LyricFont Source #
Methods emitXml :: LyricFont -> XmlRep Source #
type Rep LyricFont Source #
type Rep LyricFont = D1 * (MetaData "LyricFont" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "LyricFont" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "lyricFontNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NMTOKEN))) ((::) (S1 * (MetaSel (Just Symbol "lyricFontName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) (S1 * (MetaSel (Just Symbol "lyricFontFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))))) ((::) (S1 * (MetaSel (Just Symbol "lyricFontFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) ((::) (S1 * (MetaSel (Just Symbol "lyricFontFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "lyricFontFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight)))))))

parseLyricFont :: XParse LyricFont Source #

mkLyricFont :: LyricFont Source #

Smart constructor for LyricFont

data LyricLanguage Source #

lyric-language (complex)

The lyric-language type specifies the default language for a particular name and number of lyric.

Constructors

LyricLanguage
Fields lyricLanguageNumber :: Maybe NMTOKEN number attribute lyricLanguageName :: Maybe Token name attribute lyricLanguageLang :: Lang xml:lang attribute

Instances

Eq LyricLanguage Source #
Methods (==) :: LyricLanguage -> LyricLanguage -> Bool # (/=) :: LyricLanguage -> LyricLanguage -> Bool #
Show LyricLanguage Source #
Methods showsPrec :: Int -> LyricLanguage -> ShowS # show :: LyricLanguage -> String # showList :: [LyricLanguage] -> ShowS #
Generic LyricLanguage Source #
Associated Types type Rep LyricLanguage :: * -> * # Methods from :: LyricLanguage -> Rep LyricLanguage x # to :: Rep LyricLanguage x -> LyricLanguage #
EmitXml LyricLanguage Source #
Methods emitXml :: LyricLanguage -> XmlRep Source #
type Rep LyricLanguage Source #
type Rep LyricLanguage = D1 * (MetaData "LyricLanguage" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "LyricLanguage" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "lyricLanguageNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NMTOKEN))) ((::) (S1 * (MetaSel (Just Symbol "lyricLanguageName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) (S1 * (MetaSel (Just Symbol "lyricLanguageLang") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Lang)))))

parseLyricLanguage :: XParse LyricLanguage Source #

mkLyricLanguage :: Lang -> LyricLanguage Source #

Smart constructor for LyricLanguage

data Measure Source #

measure (complex)

Constructors

Measure
Fields measureNumber :: Token number attribute measureImplicit :: Maybe YesNo implicit attribute measureNonControlling :: Maybe YesNo non-controlling attribute measureWidth :: Maybe Tenths width attribute measureMusicData :: MusicData

Instances

Eq Measure Source #
Methods (==) :: Measure -> Measure -> Bool # (/=) :: Measure -> Measure -> Bool #
Show Measure Source #
Methods showsPrec :: Int -> Measure -> ShowS # show :: Measure -> String # showList :: [Measure] -> ShowS #
Generic Measure Source #
Associated Types type Rep Measure :: * -> * # Methods from :: Measure -> Rep Measure x # to :: Rep Measure x -> Measure #
EmitXml Measure Source #
Methods emitXml :: Measure -> XmlRep Source #
type Rep Measure Source #
type Rep Measure = D1 * (MetaData "Measure" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Measure" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "measureNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Token)) (S1 * (MetaSel (Just Symbol "measureImplicit") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "measureNonControlling") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) ((::) (S1 * (MetaSel (Just Symbol "measureWidth") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "measureMusicData") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * MusicData))))))

parseMeasure :: XParse Measure Source #

mkMeasure :: Token -> MusicData -> Measure Source #

Smart constructor for Measure

data CmpMeasure Source #

measure (complex)

Constructors

CmpMeasure
Fields cmpmeasureNumber :: Token number attribute cmpmeasureImplicit :: Maybe YesNo implicit attribute cmpmeasureNonControlling :: Maybe YesNo non-controlling attribute cmpmeasureWidth :: Maybe Tenths width attribute measurePart :: [Part] part child element

Instances

Eq CmpMeasure Source #
Methods (==) :: CmpMeasure -> CmpMeasure -> Bool # (/=) :: CmpMeasure -> CmpMeasure -> Bool #
Show CmpMeasure Source #
Methods showsPrec :: Int -> CmpMeasure -> ShowS # show :: CmpMeasure -> String # showList :: [CmpMeasure] -> ShowS #
Generic CmpMeasure Source #
Associated Types type Rep CmpMeasure :: * -> * # Methods from :: CmpMeasure -> Rep CmpMeasure x # to :: Rep CmpMeasure x -> CmpMeasure #
EmitXml CmpMeasure Source #
Methods emitXml :: CmpMeasure -> XmlRep Source #
type Rep CmpMeasure Source #
type Rep CmpMeasure = D1 * (MetaData "CmpMeasure" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "CmpMeasure" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "cmpmeasureNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Token)) (S1 * (MetaSel (Just Symbol "cmpmeasureImplicit") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "cmpmeasureNonControlling") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) ((::) (S1 * (MetaSel (Just Symbol "cmpmeasureWidth") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "measurePart") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Part]))))))

parseCmpMeasure :: XParse CmpMeasure Source #

mkCmpMeasure :: Token -> CmpMeasure Source #

Smart constructor for CmpMeasure

data MeasureLayout Source #

measure-layout (complex)

The measure-layout type includes the horizontal distance from the previous measure.

Constructors

MeasureLayout
Fields measureLayoutMeasureDistance :: Maybe Tenths measure-distance child element

Instances

Eq MeasureLayout Source #
Methods (==) :: MeasureLayout -> MeasureLayout -> Bool # (/=) :: MeasureLayout -> MeasureLayout -> Bool #
Show MeasureLayout Source #
Methods showsPrec :: Int -> MeasureLayout -> ShowS # show :: MeasureLayout -> String # showList :: [MeasureLayout] -> ShowS #
Generic MeasureLayout Source #
Associated Types type Rep MeasureLayout :: * -> * # Methods from :: MeasureLayout -> Rep MeasureLayout x # to :: Rep MeasureLayout x -> MeasureLayout #
EmitXml MeasureLayout Source #
Methods emitXml :: MeasureLayout -> XmlRep Source #
type Rep MeasureLayout Source #
type Rep MeasureLayout = D1 * (MetaData "MeasureLayout" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "MeasureLayout" PrefixI True) (S1 * (MetaSel (Just Symbol "measureLayoutMeasureDistance") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))

parseMeasureLayout :: XParse MeasureLayout Source #

mkMeasureLayout :: MeasureLayout Source #

Smart constructor for MeasureLayout

data MeasureNumbering Source #

measure-numbering (complex)

The measure-numbering type describes how frequently measure numbers are displayed on this part. The number attribute from the measure element is used for printing. Measures with an implicit attribute set to "yes" never display a measure number, regardless of the measure-numbering setting.

Constructors

MeasureNumbering

Fields

measureNumberingMeasureNumberingValue :: MeasureNumberingValue
text content
measureNumberingDefaultX :: Maybe Tenths
default-x attribute
measureNumberingDefaultY :: Maybe Tenths
default-y attribute
measureNumberingRelativeX :: Maybe Tenths
relative-x attribute
measureNumberingRelativeY :: Maybe Tenths
relative-y attribute
measureNumberingFontFamily :: Maybe CommaSeparatedText
font-family attribute
measureNumberingFontStyle :: Maybe FontStyle
font-style attribute
measureNumberingFontSize :: Maybe FontSize
font-size attribute
measureNumberingFontWeight :: Maybe FontWeight
font-weight attribute
measureNumberingColor :: Maybe Color
color attribute

Instances

Eq MeasureNumbering Source #
Methods (==) :: MeasureNumbering -> MeasureNumbering -> Bool # (/=) :: MeasureNumbering -> MeasureNumbering -> Bool #
Show MeasureNumbering Source #
Methods showsPrec :: Int -> MeasureNumbering -> ShowS # show :: MeasureNumbering -> String # showList :: [MeasureNumbering] -> ShowS #
Generic MeasureNumbering Source #
Associated Types type Rep MeasureNumbering :: * -> * # Methods from :: MeasureNumbering -> Rep MeasureNumbering x # to :: Rep MeasureNumbering x -> MeasureNumbering #
EmitXml MeasureNumbering Source #
Methods emitXml :: MeasureNumbering -> XmlRep Source #
type Rep MeasureNumbering Source #
type Rep MeasureNumbering = D1 * (MetaData "MeasureNumbering" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "MeasureNumbering" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "measureNumberingMeasureNumberingValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * MeasureNumberingValue)) (S1 * (MetaSel (Just Symbol "measureNumberingDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "measureNumberingDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "measureNumberingRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "measureNumberingRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "measureNumberingFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "measureNumberingFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle)))) ((::) (S1 * (MetaSel (Just Symbol "measureNumberingFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "measureNumberingFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "measureNumberingColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseMeasureNumbering :: XParse MeasureNumbering Source #

mkMeasureNumbering :: MeasureNumberingValue -> MeasureNumbering Source #

Smart constructor for MeasureNumbering

data MeasureRepeat Source #

measure-repeat (complex)

The measure-repeat type is used for both single and multiple measure repeats. The text of the element indicates the number of measures to be repeated in a single pattern. The slashes attribute specifies the number of slashes to use in the repeat sign. It is 1 if not specified. Both the start and the stop of the measure-repeat must be specified. The text of the element is ignored when the type is stop.

The measure-repeat element specifies a notation style for repetitions. The actual music being repeated needs to be repeated within the MusicXML file. This element specifies the notation that indicates the repeat.

Constructors

MeasureRepeat
Fields measureRepeatPositiveIntegerOrEmpty :: PositiveIntegerOrEmpty text content measureRepeatType :: StartStop type attribute measureRepeatSlashes :: Maybe PositiveInteger slashes attribute

Instances

Eq MeasureRepeat Source #
Methods (==) :: MeasureRepeat -> MeasureRepeat -> Bool # (/=) :: MeasureRepeat -> MeasureRepeat -> Bool #
Show MeasureRepeat Source #
Methods showsPrec :: Int -> MeasureRepeat -> ShowS # show :: MeasureRepeat -> String # showList :: [MeasureRepeat] -> ShowS #
Generic MeasureRepeat Source #
Associated Types type Rep MeasureRepeat :: * -> * # Methods from :: MeasureRepeat -> Rep MeasureRepeat x # to :: Rep MeasureRepeat x -> MeasureRepeat #
EmitXml MeasureRepeat Source #
Methods emitXml :: MeasureRepeat -> XmlRep Source #
type Rep MeasureRepeat Source #
type Rep MeasureRepeat = D1 * (MetaData "MeasureRepeat" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "MeasureRepeat" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "measureRepeatPositiveIntegerOrEmpty") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveIntegerOrEmpty)) ((::) (S1 * (MetaSel (Just Symbol "measureRepeatType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStop)) (S1 * (MetaSel (Just Symbol "measureRepeatSlashes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe PositiveInteger))))))

parseMeasureRepeat :: XParse MeasureRepeat Source #

mkMeasureRepeat :: PositiveIntegerOrEmpty -> StartStop -> MeasureRepeat Source #

Smart constructor for MeasureRepeat

data MeasureStyle Source #

measure-style (complex)

A measure-style indicates a special way to print partial to multiple measures within a part. This includes multiple rests over several measures, repeats of beats, single, or multiple measures, and use of slash notation.

The multiple-rest and measure-repeat symbols indicate the number of measures covered in the element content. The beat-repeat and slash elements can cover partial measures. All but the multiple-rest element use a type attribute to indicate starting and stopping the use of the style. The optional number attribute specifies the staff number from top to bottom on the system, as with clef.

Constructors

MeasureStyle

Fields

measureStyleNumber :: Maybe StaffNumber
number attribute
measureStyleFontFamily :: Maybe CommaSeparatedText
font-family attribute
measureStyleFontStyle :: Maybe FontStyle
font-style attribute
measureStyleFontSize :: Maybe FontSize
font-size attribute
measureStyleFontWeight :: Maybe FontWeight
font-weight attribute
measureStyleColor :: Maybe Color
color attribute
measureStyleMeasureStyle :: ChxMeasureStyle

Instances

Eq MeasureStyle Source #
Methods (==) :: MeasureStyle -> MeasureStyle -> Bool # (/=) :: MeasureStyle -> MeasureStyle -> Bool #
Show MeasureStyle Source #
Methods showsPrec :: Int -> MeasureStyle -> ShowS # show :: MeasureStyle -> String # showList :: [MeasureStyle] -> ShowS #
Generic MeasureStyle Source #
Associated Types type Rep MeasureStyle :: * -> * # Methods from :: MeasureStyle -> Rep MeasureStyle x # to :: Rep MeasureStyle x -> MeasureStyle #
EmitXml MeasureStyle Source #
Methods emitXml :: MeasureStyle -> XmlRep Source #
type Rep MeasureStyle Source #
type Rep MeasureStyle = D1 * (MetaData "MeasureStyle" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "MeasureStyle" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "measureStyleNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StaffNumber))) ((::) (S1 * (MetaSel (Just Symbol "measureStyleFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "measureStyleFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "measureStyleFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "measureStyleFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight)))) ((::) (S1 * (MetaSel (Just Symbol "measureStyleColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "measureStyleMeasureStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ChxMeasureStyle))))))

parseMeasureStyle :: XParse MeasureStyle Source #

mkMeasureStyle :: ChxMeasureStyle -> MeasureStyle Source #

Smart constructor for MeasureStyle

data Metronome Source #

metronome (complex)

The metronome type represents metronome marks and other metric relationships. The beat-unit group and per-minute element specify regular metronome marks. The metronome-note and metronome-relation elements allow for the specification of more complicated metric relationships, such as swing tempo marks where two eighths are equated to a quarter note / eighth note triplet. The parentheses attribute indicates whether or not to put the metronome mark in parentheses; its value is no if not specified.

Constructors

Metronome

Fields

metronomeParentheses :: Maybe YesNo
parentheses attribute
metronomeDefaultX :: Maybe Tenths
default-x attribute
metronomeDefaultY :: Maybe Tenths
default-y attribute
metronomeRelativeX :: Maybe Tenths
relative-x attribute
metronomeRelativeY :: Maybe Tenths
relative-y attribute
metronomeFontFamily :: Maybe CommaSeparatedText
font-family attribute
metronomeFontStyle :: Maybe FontStyle
font-style attribute
metronomeFontSize :: Maybe FontSize
font-size attribute
metronomeFontWeight :: Maybe FontWeight
font-weight attribute
metronomeColor :: Maybe Color
color attribute
metronomeMetronome :: ChxMetronome

Instances

Eq Metronome Source #
Methods (==) :: Metronome -> Metronome -> Bool # (/=) :: Metronome -> Metronome -> Bool #
Show Metronome Source #
Methods showsPrec :: Int -> Metronome -> ShowS # show :: Metronome -> String # showList :: [Metronome] -> ShowS #
Generic Metronome Source #
Associated Types type Rep Metronome :: * -> * # Methods from :: Metronome -> Rep Metronome x # to :: Rep Metronome x -> Metronome #
EmitXml Metronome Source #
Methods emitXml :: Metronome -> XmlRep Source #
type Rep Metronome Source #
type Rep Metronome = D1 * (MetaData "Metronome" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Metronome" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "metronomeParentheses") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "metronomeDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "metronomeDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "metronomeRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "metronomeRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "metronomeFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) ((::) (S1 * (MetaSel (Just Symbol "metronomeFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "metronomeFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))))) ((::) (S1 * (MetaSel (Just Symbol "metronomeFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) ((::) (S1 * (MetaSel (Just Symbol "metronomeColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "metronomeMetronome") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ChxMetronome)))))))

parseMetronome :: XParse Metronome Source #

mkMetronome :: ChxMetronome -> Metronome Source #

Smart constructor for Metronome

data MetronomeBeam Source #

metronome-beam (complex)

The metronome-beam type works like the beam type in defining metric relationships, but does not include all the attributes available in the beam type.

Constructors

MetronomeBeam
Fields metronomeBeamBeamValue :: BeamValue text content metronomeBeamNumber :: Maybe BeamLevel number attribute

Instances

Eq MetronomeBeam Source #
Methods (==) :: MetronomeBeam -> MetronomeBeam -> Bool # (/=) :: MetronomeBeam -> MetronomeBeam -> Bool #
Show MetronomeBeam Source #
Methods showsPrec :: Int -> MetronomeBeam -> ShowS # show :: MetronomeBeam -> String # showList :: [MetronomeBeam] -> ShowS #
Generic MetronomeBeam Source #
Associated Types type Rep MetronomeBeam :: * -> * # Methods from :: MetronomeBeam -> Rep MetronomeBeam x # to :: Rep MetronomeBeam x -> MetronomeBeam #
EmitXml MetronomeBeam Source #
Methods emitXml :: MetronomeBeam -> XmlRep Source #
type Rep MetronomeBeam Source #
type Rep MetronomeBeam = D1 * (MetaData "MetronomeBeam" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "MetronomeBeam" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "metronomeBeamBeamValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * BeamValue)) (S1 * (MetaSel (Just Symbol "metronomeBeamNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe BeamLevel)))))

parseMetronomeBeam :: XParse MetronomeBeam Source #

mkMetronomeBeam :: BeamValue -> MetronomeBeam Source #

Smart constructor for MetronomeBeam

data MetronomeNote Source #

metronome-note (complex)

The metronome-note type defines the appearance of a note within a metric relationship mark.

Constructors

MetronomeNote
Fields metronomeNoteMetronomeType :: NoteTypeValue metronome-type child element metronomeNoteMetronomeDot :: [Empty] metronome-dot child element metronomeNoteMetronomeBeam :: [MetronomeBeam] metronome-beam child element metronomeNoteMetronomeTuplet :: Maybe MetronomeTuplet metronome-tuplet child element

Instances

Eq MetronomeNote Source #
Methods (==) :: MetronomeNote -> MetronomeNote -> Bool # (/=) :: MetronomeNote -> MetronomeNote -> Bool #
Show MetronomeNote Source #
Methods showsPrec :: Int -> MetronomeNote -> ShowS # show :: MetronomeNote -> String # showList :: [MetronomeNote] -> ShowS #
Generic MetronomeNote Source #
Associated Types type Rep MetronomeNote :: * -> * # Methods from :: MetronomeNote -> Rep MetronomeNote x # to :: Rep MetronomeNote x -> MetronomeNote #
EmitXml MetronomeNote Source #
Methods emitXml :: MetronomeNote -> XmlRep Source #
type Rep MetronomeNote Source #
type Rep MetronomeNote = D1 * (MetaData "MetronomeNote" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "MetronomeNote" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "metronomeNoteMetronomeType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NoteTypeValue)) (S1 * (MetaSel (Just Symbol "metronomeNoteMetronomeDot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Empty]))) ((::) (S1 * (MetaSel (Just Symbol "metronomeNoteMetronomeBeam") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [MetronomeBeam])) (S1 * (MetaSel (Just Symbol "metronomeNoteMetronomeTuplet") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe MetronomeTuplet))))))

parseMetronomeNote :: XParse MetronomeNote Source #

mkMetronomeNote :: NoteTypeValue -> MetronomeNote Source #

Smart constructor for MetronomeNote

data MetronomeTuplet Source #

metronome-tuplet (complex)

The metronome-tuplet type uses the same element structure as the time-modification element along with some attributes from the tuplet element.

Constructors

MetronomeTuplet
Fields metronomeTupletTimeModification :: MetronomeTuplet metronomeTupletType :: StartStop type attribute metronomeTupletBracket :: Maybe YesNo bracket attribute metronomeTupletShowNumber :: Maybe ShowTuplet show-number attribute

Instances

Eq MetronomeTuplet Source #
Methods (==) :: MetronomeTuplet -> MetronomeTuplet -> Bool # (/=) :: MetronomeTuplet -> MetronomeTuplet -> Bool #
Show MetronomeTuplet Source #
Methods showsPrec :: Int -> MetronomeTuplet -> ShowS # show :: MetronomeTuplet -> String # showList :: [MetronomeTuplet] -> ShowS #
Generic MetronomeTuplet Source #
Associated Types type Rep MetronomeTuplet :: * -> * # Methods from :: MetronomeTuplet -> Rep MetronomeTuplet x # to :: Rep MetronomeTuplet x -> MetronomeTuplet #
EmitXml MetronomeTuplet Source #
Methods emitXml :: MetronomeTuplet -> XmlRep Source #
type Rep MetronomeTuplet Source #
type Rep MetronomeTuplet = D1 * (MetaData "MetronomeTuplet" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "MetronomeTuplet" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "metronomeTupletTimeModification") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * MetronomeTuplet)) (S1 * (MetaSel (Just Symbol "metronomeTupletType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStop))) ((::) (S1 * (MetaSel (Just Symbol "metronomeTupletBracket") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "metronomeTupletShowNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe ShowTuplet))))))

parseMetronomeTuplet :: XParse MetronomeTuplet Source #

mkMetronomeTuplet :: MetronomeTuplet -> StartStop -> MetronomeTuplet Source #

Smart constructor for MetronomeTuplet

data MidiDevice Source #

midi-device (complex)

The midi-device type corresponds to the DeviceName meta event in Standard MIDI Files. The optional port attribute is a number from 1 to 16 that can be used with the unofficial MIDI port (or cable) meta event.

Constructors

MidiDevice
Fields midiDeviceString :: String text content midiDevicePort :: Maybe Midi16 port attribute

Instances

Eq MidiDevice Source #
Methods (==) :: MidiDevice -> MidiDevice -> Bool # (/=) :: MidiDevice -> MidiDevice -> Bool #
Show MidiDevice Source #
Methods showsPrec :: Int -> MidiDevice -> ShowS # show :: MidiDevice -> String # showList :: [MidiDevice] -> ShowS #
Generic MidiDevice Source #
Associated Types type Rep MidiDevice :: * -> * # Methods from :: MidiDevice -> Rep MidiDevice x # to :: Rep MidiDevice x -> MidiDevice #
EmitXml MidiDevice Source #
Methods emitXml :: MidiDevice -> XmlRep Source #
type Rep MidiDevice Source #
type Rep MidiDevice = D1 * (MetaData "MidiDevice" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "MidiDevice" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "midiDeviceString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "midiDevicePort") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Midi16)))))

parseMidiDevice :: XParse MidiDevice Source #

mkMidiDevice :: String -> MidiDevice Source #

Smart constructor for MidiDevice

data MidiInstrument Source #

midi-instrument (complex)

The midi-instrument type defines MIDI 1.0 instrument playback. The midi-instrument element can be a part of either the score-instrument element at the start of a part, or the sound element within a part. The id attribute refers to the score-instrument affected by the change.

Constructors

MidiInstrument

Fields

midiInstrumentId :: IDREF
id attribute
midiInstrumentMidiChannel :: Maybe Midi16
midi-channel child element
midiInstrumentMidiName :: Maybe String
midi-name child element
midiInstrumentMidiBank :: Maybe Midi16384
midi-bank child element
midiInstrumentMidiProgram :: Maybe Midi128
midi-program child element
midiInstrumentMidiUnpitched :: Maybe Midi128
midi-unpitched child element
midiInstrumentVolume :: Maybe Percent
volume child element
midiInstrumentPan :: Maybe RotationDegrees
pan child element
midiInstrumentElevation :: Maybe RotationDegrees
elevation child element

Instances

Eq MidiInstrument Source #
Methods (==) :: MidiInstrument -> MidiInstrument -> Bool # (/=) :: MidiInstrument -> MidiInstrument -> Bool #
Show MidiInstrument Source #
Methods showsPrec :: Int -> MidiInstrument -> ShowS # show :: MidiInstrument -> String # showList :: [MidiInstrument] -> ShowS #
Generic MidiInstrument Source #
Associated Types type Rep MidiInstrument :: * -> * # Methods from :: MidiInstrument -> Rep MidiInstrument x # to :: Rep MidiInstrument x -> MidiInstrument #
EmitXml MidiInstrument Source #
Methods emitXml :: MidiInstrument -> XmlRep Source #
type Rep MidiInstrument Source #
type Rep MidiInstrument = D1 * (MetaData "MidiInstrument" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "MidiInstrument" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "midiInstrumentId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * IDREF)) (S1 * (MetaSel (Just Symbol "midiInstrumentMidiChannel") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Midi16)))) ((::) (S1 * (MetaSel (Just Symbol "midiInstrumentMidiName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe String))) (S1 * (MetaSel (Just Symbol "midiInstrumentMidiBank") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Midi16384))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "midiInstrumentMidiProgram") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Midi128))) (S1 * (MetaSel (Just Symbol "midiInstrumentMidiUnpitched") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Midi128)))) ((::) (S1 * (MetaSel (Just Symbol "midiInstrumentVolume") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Percent))) ((::) (S1 * (MetaSel (Just Symbol "midiInstrumentPan") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe RotationDegrees))) (S1 * (MetaSel (Just Symbol "midiInstrumentElevation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe RotationDegrees))))))))

parseMidiInstrument :: XParse MidiInstrument Source #

mkMidiInstrument :: IDREF -> MidiInstrument Source #

Smart constructor for MidiInstrument

data Miscellaneous Source #

miscellaneous (complex)

If a program has other metadata not yet supported in the MusicXML format, it can go in the miscellaneous element. The miscellaneous type puts each separate part of metadata into its own miscellaneous-field type.

Constructors

Miscellaneous
Fields miscellaneousMiscellaneousField :: [MiscellaneousField] miscellaneous-field child element

Instances

Eq Miscellaneous Source #
Methods (==) :: Miscellaneous -> Miscellaneous -> Bool # (/=) :: Miscellaneous -> Miscellaneous -> Bool #
Show Miscellaneous Source #
Methods showsPrec :: Int -> Miscellaneous -> ShowS # show :: Miscellaneous -> String # showList :: [Miscellaneous] -> ShowS #
Generic Miscellaneous Source #
Associated Types type Rep Miscellaneous :: * -> * # Methods from :: Miscellaneous -> Rep Miscellaneous x # to :: Rep Miscellaneous x -> Miscellaneous #
EmitXml Miscellaneous Source #
Methods emitXml :: Miscellaneous -> XmlRep Source #
type Rep Miscellaneous Source #
type Rep Miscellaneous = D1 * (MetaData "Miscellaneous" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Miscellaneous" PrefixI True) (S1 * (MetaSel (Just Symbol "miscellaneousMiscellaneousField") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [MiscellaneousField])))

parseMiscellaneous :: XParse Miscellaneous Source #

mkMiscellaneous :: Miscellaneous Source #

Smart constructor for Miscellaneous

data MiscellaneousField Source #

miscellaneous-field (complex)

If a program has other metadata not yet supported in the MusicXML format, each type of metadata can go in a miscellaneous-field element. The required name attribute indicates the type of metadata the element content represents.

Constructors

MiscellaneousField
Fields miscellaneousFieldString :: String text content miscellaneousFieldName :: Token name attribute

Instances

Eq MiscellaneousField Source #
Methods (==) :: MiscellaneousField -> MiscellaneousField -> Bool # (/=) :: MiscellaneousField -> MiscellaneousField -> Bool #
Show MiscellaneousField Source #
Methods showsPrec :: Int -> MiscellaneousField -> ShowS # show :: MiscellaneousField -> String # showList :: [MiscellaneousField] -> ShowS #
Generic MiscellaneousField Source #
Associated Types type Rep MiscellaneousField :: * -> * # Methods from :: MiscellaneousField -> Rep MiscellaneousField x # to :: Rep MiscellaneousField x -> MiscellaneousField #
EmitXml MiscellaneousField Source #
Methods emitXml :: MiscellaneousField -> XmlRep Source #
type Rep MiscellaneousField Source #
type Rep MiscellaneousField = D1 * (MetaData "MiscellaneousField" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "MiscellaneousField" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "miscellaneousFieldString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "miscellaneousFieldName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Token))))

parseMiscellaneousField :: XParse MiscellaneousField Source #

mkMiscellaneousField :: String -> Token -> MiscellaneousField Source #

Smart constructor for MiscellaneousField

data Mordent Source #

mordent (complex)

The mordent type is used for both represents the mordent sign with the vertical line and the inverted-mordent sign without the line. The long attribute is "no" by default.

Constructors

Mordent
Fields mordentEmptyTrillSound :: Mordent mordentLong :: Maybe YesNo long attribute

Instances

Eq Mordent Source #
Methods (==) :: Mordent -> Mordent -> Bool # (/=) :: Mordent -> Mordent -> Bool #
Show Mordent Source #
Methods showsPrec :: Int -> Mordent -> ShowS # show :: Mordent -> String # showList :: [Mordent] -> ShowS #
Generic Mordent Source #
Associated Types type Rep Mordent :: * -> * # Methods from :: Mordent -> Rep Mordent x # to :: Rep Mordent x -> Mordent #
EmitXml Mordent Source #
Methods emitXml :: Mordent -> XmlRep Source #
type Rep Mordent Source #
type Rep Mordent = D1 * (MetaData "Mordent" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Mordent" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "mordentEmptyTrillSound") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Mordent)) (S1 * (MetaSel (Just Symbol "mordentLong") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))))

parseMordent :: XParse Mordent Source #

mkMordent :: Mordent -> Mordent Source #

Smart constructor for Mordent

data MultipleRest Source #

multiple-rest (complex)

The text of the multiple-rest type indicates the number of measures in the multiple rest. Multiple rests may use the 1-bar 2-bar 4-bar rest symbols, or a single shape. The use-symbols attribute indicates which to use; it is no if not specified. The element text is ignored when the type is stop.

Constructors

MultipleRest
Fields multipleRestPositiveIntegerOrEmpty :: PositiveIntegerOrEmpty text content multipleRestUseSymbols :: Maybe YesNo use-symbols attribute

Instances

Eq MultipleRest Source #
Methods (==) :: MultipleRest -> MultipleRest -> Bool # (/=) :: MultipleRest -> MultipleRest -> Bool #
Show MultipleRest Source #
Methods showsPrec :: Int -> MultipleRest -> ShowS # show :: MultipleRest -> String # showList :: [MultipleRest] -> ShowS #
Generic MultipleRest Source #
Associated Types type Rep MultipleRest :: * -> * # Methods from :: MultipleRest -> Rep MultipleRest x # to :: Rep MultipleRest x -> MultipleRest #
EmitXml MultipleRest Source #
Methods emitXml :: MultipleRest -> XmlRep Source #
type Rep MultipleRest Source #
type Rep MultipleRest = D1 * (MetaData "MultipleRest" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "MultipleRest" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "multipleRestPositiveIntegerOrEmpty") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveIntegerOrEmpty)) (S1 * (MetaSel (Just Symbol "multipleRestUseSymbols") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))))

parseMultipleRest :: XParse MultipleRest Source #

mkMultipleRest :: PositiveIntegerOrEmpty -> MultipleRest Source #

Smart constructor for MultipleRest

data NameDisplay Source #

name-display (complex)

The name-display type is used for exact formatting of multi-font text in part and group names to the left of the system. The print-object attribute can be used to determine what, if anything, is printed at the start of each system. Enclosure for the display-text element is none by default. Language for the display-text element is Italian ("it") by default.

Constructors

NameDisplay
Fields nameDisplayPrintObject :: Maybe YesNo print-object attribute nameDisplayNameDisplay :: [ChxNameDisplay]

Instances

Eq NameDisplay Source #
Methods (==) :: NameDisplay -> NameDisplay -> Bool # (/=) :: NameDisplay -> NameDisplay -> Bool #
Show NameDisplay Source #
Methods showsPrec :: Int -> NameDisplay -> ShowS # show :: NameDisplay -> String # showList :: [NameDisplay] -> ShowS #
Generic NameDisplay Source #
Associated Types type Rep NameDisplay :: * -> * # Methods from :: NameDisplay -> Rep NameDisplay x # to :: Rep NameDisplay x -> NameDisplay #
EmitXml NameDisplay Source #
Methods emitXml :: NameDisplay -> XmlRep Source #
type Rep NameDisplay Source #
type Rep NameDisplay = D1 * (MetaData "NameDisplay" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "NameDisplay" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "nameDisplayPrintObject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "nameDisplayNameDisplay") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [ChxNameDisplay]))))

parseNameDisplay :: XParse NameDisplay Source #

mkNameDisplay :: NameDisplay Source #

Smart constructor for NameDisplay

data NonArpeggiate Source #

non-arpeggiate (complex)

The non-arpeggiate type indicates that this note is at the top or bottom of a bracket indicating to not arpeggiate these notes. Since this does not involve playback, it is only used on the top or bottom notes, not on each note as for the arpeggiate type.

Constructors

NonArpeggiate

Fields

nonArpeggiateType :: TopBottom
type attribute
nonArpeggiateNumber :: Maybe NumberLevel
number attribute
nonArpeggiateDefaultX :: Maybe Tenths
default-x attribute
nonArpeggiateDefaultY :: Maybe Tenths
default-y attribute
nonArpeggiateRelativeX :: Maybe Tenths
relative-x attribute
nonArpeggiateRelativeY :: Maybe Tenths
relative-y attribute
nonArpeggiatePlacement :: Maybe AboveBelow
placement attribute
nonArpeggiateColor :: Maybe Color
color attribute

Instances

Eq NonArpeggiate Source #
Methods (==) :: NonArpeggiate -> NonArpeggiate -> Bool # (/=) :: NonArpeggiate -> NonArpeggiate -> Bool #
Show NonArpeggiate Source #
Methods showsPrec :: Int -> NonArpeggiate -> ShowS # show :: NonArpeggiate -> String # showList :: [NonArpeggiate] -> ShowS #
Generic NonArpeggiate Source #
Associated Types type Rep NonArpeggiate :: * -> * # Methods from :: NonArpeggiate -> Rep NonArpeggiate x # to :: Rep NonArpeggiate x -> NonArpeggiate #
EmitXml NonArpeggiate Source #
Methods emitXml :: NonArpeggiate -> XmlRep Source #
type Rep NonArpeggiate Source #
type Rep NonArpeggiate = D1 * (MetaData "NonArpeggiate" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "NonArpeggiate" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "nonArpeggiateType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * TopBottom)) (S1 * (MetaSel (Just Symbol "nonArpeggiateNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberLevel)))) ((::) (S1 * (MetaSel (Just Symbol "nonArpeggiateDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "nonArpeggiateDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "nonArpeggiateRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "nonArpeggiateRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "nonArpeggiatePlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow))) (S1 * (MetaSel (Just Symbol "nonArpeggiateColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))))

parseNonArpeggiate :: XParse NonArpeggiate Source #

mkNonArpeggiate :: TopBottom -> NonArpeggiate Source #

Smart constructor for NonArpeggiate

data Notations Source #

notations (complex)

Notations refer to musical notations, not XML notations. Multiple notations are allowed in order to represent multiple editorial levels. The set of notations may be refined and expanded over time, especially to handle more instrument-specific technical notations.

Constructors

Notations
Fields notationsEditorial :: Editorial notationsNotations :: [ChxNotations]

Instances

Eq Notations Source #
Methods (==) :: Notations -> Notations -> Bool # (/=) :: Notations -> Notations -> Bool #
Show Notations Source #
Methods showsPrec :: Int -> Notations -> ShowS # show :: Notations -> String # showList :: [Notations] -> ShowS #
Generic Notations Source #
Associated Types type Rep Notations :: * -> * # Methods from :: Notations -> Rep Notations x # to :: Rep Notations x -> Notations #
EmitXml Notations Source #
Methods emitXml :: Notations -> XmlRep Source #
type Rep Notations Source #
type Rep Notations = D1 * (MetaData "Notations" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Notations" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "notationsEditorial") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Editorial)) (S1 * (MetaSel (Just Symbol "notationsNotations") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [ChxNotations]))))

parseNotations :: XParse Notations Source #

mkNotations :: Editorial -> Notations Source #

Smart constructor for Notations

data Note Source #

note (complex)

Notes are the most common type of MusicXML data. The MusicXML format keeps the MuseData distinction between elements used for sound information and elements used for notation information (e.g., tie is used for sound, tied for notation). Thus grace notes do not have a duration element. Cue notes have a duration element, as do forward elements, but no tie elements. Having these two types of information available can make interchange considerably easier, as some programs handle one type of information much more readily than the other.

The dynamics and end-dynamics attributes correspond to MIDI 1.0's Note On and Note Off velocities, respectively. They are expressed in terms of percentages of the default forte value (90 for MIDI 1.0). The attack and release attributes are used to alter the staring and stopping time of the note from when it would otherwise occur based on the flow of durations - information that is specific to a performance. They are expressed in terms of divisions, either positive or negative. A note that starts a tie should not have a release attribute, and a note that stops a tie should not have an attack attribute. If a note is played only one time through a repeat, the time-only attribute shows which time to play the note. The pizzicato attribute is used when just this note is sounded pizzicato, vs. the pizzicato element which changes overall playback between pizzicato and arco.

Constructors

Note

Fields

noteDynamics :: Maybe NonNegativeDecimal
dynamics attribute
noteEndDynamics :: Maybe NonNegativeDecimal
end-dynamics attribute
noteAttack :: Maybe Divisions
attack attribute
noteRelease :: Maybe Divisions
release attribute
noteTimeOnly :: Maybe Token
time-only attribute
notePizzicato :: Maybe YesNo
pizzicato attribute
noteDefaultX :: Maybe Tenths
default-x attribute
noteDefaultY :: Maybe Tenths
default-y attribute
noteRelativeX :: Maybe Tenths
relative-x attribute
noteRelativeY :: Maybe Tenths
relative-y attribute
noteFontFamily :: Maybe CommaSeparatedText
font-family attribute
noteFontStyle :: Maybe FontStyle
font-style attribute
noteFontSize :: Maybe FontSize
font-size attribute
noteFontWeight :: Maybe FontWeight
font-weight attribute
noteColor :: Maybe Color
color attribute
notePrintDot :: Maybe YesNo
print-dot attribute
notePrintLyric :: Maybe YesNo
print-lyric attribute
notePrintObject :: Maybe YesNo
print-object attribute
notePrintSpacing :: Maybe YesNo
print-spacing attribute
noteNote :: ChxNote
noteInstrument :: Maybe Instrument
instrument child element
noteEditorialVoice :: EditorialVoice
noteType :: Maybe NoteType
type child element
noteDot :: [EmptyPlacement]
dot child element
noteAccidental :: Maybe Accidental
accidental child element
noteTimeModification :: Maybe TimeModification
time-modification child element
noteStem :: Maybe Stem
stem child element
noteNotehead :: Maybe Notehead
notehead child element
noteStaff :: Maybe Staff
noteBeam :: [Beam]
beam child element
noteNotations :: [Notations]
notations child element
noteLyric :: [Lyric]
lyric child element

Instances

Eq Note Source #
Methods (==) :: Note -> Note -> Bool # (/=) :: Note -> Note -> Bool #
Show Note Source #
Methods showsPrec :: Int -> Note -> ShowS # show :: Note -> String # showList :: [Note] -> ShowS #
Generic Note Source #
Associated Types type Rep Note :: * -> * # Methods from :: Note -> Rep Note x # to :: Rep Note x -> Note #
EmitXml Note Source #
Methods emitXml :: Note -> XmlRep Source #
type Rep Note Source #
type Rep Note = D1 * (MetaData "Note" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Note" PrefixI True) ((::) ((::) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "noteDynamics") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NonNegativeDecimal))) (S1 * (MetaSel (Just Symbol "noteEndDynamics") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NonNegativeDecimal)))) ((::) (S1 * (MetaSel (Just Symbol "noteAttack") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Divisions))) (S1 * (MetaSel (Just Symbol "noteRelease") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Divisions))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "noteTimeOnly") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) (S1 * (MetaSel (Just Symbol "notePizzicato") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "noteDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "noteDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "noteRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "noteRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "noteFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "noteFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "noteFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "noteFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight)))) ((::) (S1 * (MetaSel (Just Symbol "noteColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "notePrintDot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))))))) ((::) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "notePrintLyric") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "notePrintObject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "notePrintSpacing") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "noteNote") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ChxNote)))) ((::) ((::) (S1 * (MetaSel (Just Symbol "noteInstrument") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Instrument))) (S1 * (MetaSel (Just Symbol "noteEditorialVoice") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EditorialVoice))) ((::) (S1 * (MetaSel (Just Symbol "noteType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NoteType))) (S1 * (MetaSel (Just Symbol "noteDot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [EmptyPlacement]))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "noteAccidental") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Accidental))) (S1 * (MetaSel (Just Symbol "noteTimeModification") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TimeModification)))) ((::) (S1 * (MetaSel (Just Symbol "noteStem") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Stem))) (S1 * (MetaSel (Just Symbol "noteNotehead") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Notehead))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "noteStaff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Staff))) (S1 * (MetaSel (Just Symbol "noteBeam") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Beam]))) ((::) (S1 * (MetaSel (Just Symbol "noteNotations") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Notations])) (S1 * (MetaSel (Just Symbol "noteLyric") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Lyric]))))))))

parseNote :: XParse Note Source #

mkNote :: ChxNote -> EditorialVoice -> Note Source #

Smart constructor for Note

data NoteSize Source #

note-size (complex)

The note-size type indicates the percentage of the regular note size to use for notes with a cue and large size as defined in the type element. The grace type is used for notes of cue size that that include a grace element. The cue type is used for all other notes with cue size, whether defined explicitly or implicitly via a cue element. The large type is used for notes of large size. The text content represent the numeric percentage. A value of 100 would be identical to the size of a regular note as defined by the music font.

Constructors

NoteSize
Fields noteSizeNonNegativeDecimal :: NonNegativeDecimal text content noteSizeType :: NoteSizeType type attribute

Instances

Eq NoteSize Source #
Methods (==) :: NoteSize -> NoteSize -> Bool # (/=) :: NoteSize -> NoteSize -> Bool #
Show NoteSize Source #
Methods showsPrec :: Int -> NoteSize -> ShowS # show :: NoteSize -> String # showList :: [NoteSize] -> ShowS #
Generic NoteSize Source #
Associated Types type Rep NoteSize :: * -> * # Methods from :: NoteSize -> Rep NoteSize x # to :: Rep NoteSize x -> NoteSize #
EmitXml NoteSize Source #
Methods emitXml :: NoteSize -> XmlRep Source #
type Rep NoteSize Source #
type Rep NoteSize = D1 * (MetaData "NoteSize" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "NoteSize" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "noteSizeNonNegativeDecimal") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NonNegativeDecimal)) (S1 * (MetaSel (Just Symbol "noteSizeType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NoteSizeType))))

parseNoteSize :: XParse NoteSize Source #

mkNoteSize :: NonNegativeDecimal -> NoteSizeType -> NoteSize Source #

Smart constructor for NoteSize

data NoteType Source #

note-type (complex)

The note-type type indicates the graphic note type. Values range from 256th to long. The size attribute indicates full, cue, or large size, with full the default for regular notes and cue the default for cue and grace notes.

Constructors

NoteType
Fields noteTypeNoteTypeValue :: NoteTypeValue text content noteTypeSize :: Maybe SymbolSize size attribute

Instances

Eq NoteType Source #
Methods (==) :: NoteType -> NoteType -> Bool # (/=) :: NoteType -> NoteType -> Bool #
Show NoteType Source #
Methods showsPrec :: Int -> NoteType -> ShowS # show :: NoteType -> String # showList :: [NoteType] -> ShowS #
Generic NoteType Source #
Associated Types type Rep NoteType :: * -> * # Methods from :: NoteType -> Rep NoteType x # to :: Rep NoteType x -> NoteType #
EmitXml NoteType Source #
Methods emitXml :: NoteType -> XmlRep Source #
type Rep NoteType Source #
type Rep NoteType = D1 * (MetaData "NoteType" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "NoteType" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "noteTypeNoteTypeValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NoteTypeValue)) (S1 * (MetaSel (Just Symbol "noteTypeSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe SymbolSize)))))

parseNoteType :: XParse NoteType Source #

mkNoteType :: NoteTypeValue -> NoteType Source #

Smart constructor for NoteType

data Notehead Source #

notehead (complex)

The notehead element indicates shapes other than the open and closed ovals associated with note durations.

For the enclosed shapes, the default is to be hollow for half notes and longer, and filled otherwise. The filled attribute can be set to change this if needed.

If the parentheses attribute is set to yes, the notehead is parenthesized. It is no by default.

Constructors

Notehead

Fields

noteheadNoteheadValue :: NoteheadValue
text content
noteheadFilled :: Maybe YesNo
filled attribute
noteheadParentheses :: Maybe YesNo
parentheses attribute
noteheadFontFamily :: Maybe CommaSeparatedText
font-family attribute
noteheadFontStyle :: Maybe FontStyle
font-style attribute
noteheadFontSize :: Maybe FontSize
font-size attribute
noteheadFontWeight :: Maybe FontWeight
font-weight attribute
noteheadColor :: Maybe Color
color attribute

Instances

Eq Notehead Source #
Methods (==) :: Notehead -> Notehead -> Bool # (/=) :: Notehead -> Notehead -> Bool #
Show Notehead Source #
Methods showsPrec :: Int -> Notehead -> ShowS # show :: Notehead -> String # showList :: [Notehead] -> ShowS #
Generic Notehead Source #
Associated Types type Rep Notehead :: * -> * # Methods from :: Notehead -> Rep Notehead x # to :: Rep Notehead x -> Notehead #
EmitXml Notehead Source #
Methods emitXml :: Notehead -> XmlRep Source #
type Rep Notehead Source #
type Rep Notehead = D1 * (MetaData "Notehead" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Notehead" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "noteheadNoteheadValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NoteheadValue)) (S1 * (MetaSel (Just Symbol "noteheadFilled") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "noteheadParentheses") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "noteheadFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "noteheadFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "noteheadFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize)))) ((::) (S1 * (MetaSel (Just Symbol "noteheadFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "noteheadColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))))

parseNotehead :: XParse Notehead Source #

mkNotehead :: NoteheadValue -> Notehead Source #

Smart constructor for Notehead

data OctaveShift Source #

octave-shift (complex)

The octave shift type indicates where notes are shifted up or down from their true pitched values because of printing difficulty. Thus a treble clef line noted with 8va will be indicated with an octave-shift down from the pitch data indicated in the notes. A size of 8 indicates one octave; a size of 15 indicates two octaves.

Constructors

OctaveShift

Fields

octaveShiftType :: UpDownStop
type attribute
octaveShiftNumber :: Maybe NumberLevel
number attribute
octaveShiftSize :: Maybe PositiveInteger
size attribute
octaveShiftDefaultX :: Maybe Tenths
default-x attribute
octaveShiftDefaultY :: Maybe Tenths
default-y attribute
octaveShiftRelativeX :: Maybe Tenths
relative-x attribute
octaveShiftRelativeY :: Maybe Tenths
relative-y attribute
octaveShiftFontFamily :: Maybe CommaSeparatedText
font-family attribute
octaveShiftFontStyle :: Maybe FontStyle
font-style attribute
octaveShiftFontSize :: Maybe FontSize
font-size attribute
octaveShiftFontWeight :: Maybe FontWeight
font-weight attribute
octaveShiftColor :: Maybe Color
color attribute

Instances

Eq OctaveShift Source #
Methods (==) :: OctaveShift -> OctaveShift -> Bool # (/=) :: OctaveShift -> OctaveShift -> Bool #
Show OctaveShift Source #
Methods showsPrec :: Int -> OctaveShift -> ShowS # show :: OctaveShift -> String # showList :: [OctaveShift] -> ShowS #
Generic OctaveShift Source #
Associated Types type Rep OctaveShift :: * -> * # Methods from :: OctaveShift -> Rep OctaveShift x # to :: Rep OctaveShift x -> OctaveShift #
EmitXml OctaveShift Source #
Methods emitXml :: OctaveShift -> XmlRep Source #
type Rep OctaveShift Source #
type Rep OctaveShift = D1 * (MetaData "OctaveShift" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "OctaveShift" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "octaveShiftType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * UpDownStop)) ((::) (S1 * (MetaSel (Just Symbol "octaveShiftNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberLevel))) (S1 * (MetaSel (Just Symbol "octaveShiftSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe PositiveInteger))))) ((::) (S1 * (MetaSel (Just Symbol "octaveShiftDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "octaveShiftDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "octaveShiftRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "octaveShiftRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "octaveShiftFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "octaveShiftFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) (S1 * (MetaSel (Just Symbol "octaveShiftFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "octaveShiftFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "octaveShiftColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseOctaveShift :: XParse OctaveShift Source #

mkOctaveShift :: UpDownStop -> OctaveShift Source #

Smart constructor for OctaveShift

data Offset Source #

offset (complex)

An offset is represented in terms of divisions, and indicates where the direction will appear relative to the current musical location. This affects the visual appearance of the direction. If the sound attribute is "yes", then the offset affects playback too. If the sound attribute is "no", then any sound associated with the direction takes effect at the current location. The sound attribute is "no" by default for compatibility with earlier versions of the MusicXML format. If an element within a direction includes a default-x attribute, the offset value will be ignored when determining the appearance of that element.

Constructors

Offset
Fields offsetDivisions :: Divisions text content offsetSound :: Maybe YesNo sound attribute

Instances

Eq Offset Source #
Methods (==) :: Offset -> Offset -> Bool # (/=) :: Offset -> Offset -> Bool #
Show Offset Source #
Methods showsPrec :: Int -> Offset -> ShowS # show :: Offset -> String # showList :: [Offset] -> ShowS #
Generic Offset Source #
Associated Types type Rep Offset :: * -> * # Methods from :: Offset -> Rep Offset x # to :: Rep Offset x -> Offset #
EmitXml Offset Source #
Methods emitXml :: Offset -> XmlRep Source #
type Rep Offset Source #
type Rep Offset = D1 * (MetaData "Offset" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Offset" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "offsetDivisions") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Divisions)) (S1 * (MetaSel (Just Symbol "offsetSound") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))))

parseOffset :: XParse Offset Source #

mkOffset :: Divisions -> Offset Source #

Smart constructor for Offset

data Opus Source #

opus (complex)

The opus type represents a link to a MusicXML opus document that composes multiple MusicXML scores into a collection.

Constructors

Opus
Fields opusHref :: String xlink:href attribute opusType :: Maybe Type xlink:type attribute opusRole :: Maybe Token xlink:role attribute opusTitle :: Maybe Token xlink:title attribute opusShow :: Maybe SmpShow xlink:show attribute opusActuate :: Maybe Actuate xlink:actuate attribute

Instances

Eq Opus Source #
Methods (==) :: Opus -> Opus -> Bool # (/=) :: Opus -> Opus -> Bool #
Show Opus Source #
Methods showsPrec :: Int -> Opus -> ShowS # show :: Opus -> String # showList :: [Opus] -> ShowS #
Generic Opus Source #
Associated Types type Rep Opus :: * -> * # Methods from :: Opus -> Rep Opus x # to :: Rep Opus x -> Opus #
EmitXml Opus Source #
Methods emitXml :: Opus -> XmlRep Source #
type Rep Opus Source #
type Rep Opus = D1 * (MetaData "Opus" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Opus" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "opusHref") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) ((::) (S1 * (MetaSel (Just Symbol "opusType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Type))) (S1 * (MetaSel (Just Symbol "opusRole") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))))) ((::) (S1 * (MetaSel (Just Symbol "opusTitle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) ((::) (S1 * (MetaSel (Just Symbol "opusShow") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe SmpShow))) (S1 * (MetaSel (Just Symbol "opusActuate") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Actuate)))))))

parseOpus :: XParse Opus Source #

mkOpus :: String -> Opus Source #

Smart constructor for Opus

data Ornaments Source #

ornaments (complex)

Ornaments can be any of several types, followed optionally by accidentals. The accidental-mark element's content is represented the same as an accidental element, but with a different name to reflect the different musical meaning.

Constructors

Ornaments
Fields ornamentsOrnaments :: [SeqOrnaments]

Instances

Eq Ornaments Source #
Methods (==) :: Ornaments -> Ornaments -> Bool # (/=) :: Ornaments -> Ornaments -> Bool #
Show Ornaments Source #
Methods showsPrec :: Int -> Ornaments -> ShowS # show :: Ornaments -> String # showList :: [Ornaments] -> ShowS #
Generic Ornaments Source #
Associated Types type Rep Ornaments :: * -> * # Methods from :: Ornaments -> Rep Ornaments x # to :: Rep Ornaments x -> Ornaments #
EmitXml Ornaments Source #
Methods emitXml :: Ornaments -> XmlRep Source #
type Rep Ornaments Source #
type Rep Ornaments = D1 * (MetaData "Ornaments" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Ornaments" PrefixI True) (S1 * (MetaSel (Just Symbol "ornamentsOrnaments") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [SeqOrnaments])))

parseOrnaments :: XParse Ornaments Source #

mkOrnaments :: Ornaments Source #

Smart constructor for Ornaments

data OtherAppearance Source #

other-appearance (complex)

The other-appearance type is used to define any graphical settings not yet in the current version of the MusicXML format. This allows extended representation, though without application interoperability.

Constructors

OtherAppearance
Fields otherAppearanceString :: String text content otherAppearanceType :: Token type attribute

Instances

Eq OtherAppearance Source #
Methods (==) :: OtherAppearance -> OtherAppearance -> Bool # (/=) :: OtherAppearance -> OtherAppearance -> Bool #
Show OtherAppearance Source #
Methods showsPrec :: Int -> OtherAppearance -> ShowS # show :: OtherAppearance -> String # showList :: [OtherAppearance] -> ShowS #
Generic OtherAppearance Source #
Associated Types type Rep OtherAppearance :: * -> * # Methods from :: OtherAppearance -> Rep OtherAppearance x # to :: Rep OtherAppearance x -> OtherAppearance #
EmitXml OtherAppearance Source #
Methods emitXml :: OtherAppearance -> XmlRep Source #
type Rep OtherAppearance Source #
type Rep OtherAppearance = D1 * (MetaData "OtherAppearance" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "OtherAppearance" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "otherAppearanceString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "otherAppearanceType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Token))))

parseOtherAppearance :: XParse OtherAppearance Source #

mkOtherAppearance :: String -> Token -> OtherAppearance Source #

Smart constructor for OtherAppearance

data OtherDirection Source #

other-direction (complex)

The other-direction type is used to define any direction symbols not yet in the current version of the MusicXML format. This allows extended representation, though without application interoperability.

Constructors

OtherDirection

Fields

otherDirectionString :: String
text content
otherDirectionPrintObject :: Maybe YesNo
print-object attribute
otherDirectionDefaultX :: Maybe Tenths
default-x attribute
otherDirectionDefaultY :: Maybe Tenths
default-y attribute
otherDirectionRelativeX :: Maybe Tenths
relative-x attribute
otherDirectionRelativeY :: Maybe Tenths
relative-y attribute
otherDirectionFontFamily :: Maybe CommaSeparatedText
font-family attribute
otherDirectionFontStyle :: Maybe FontStyle
font-style attribute
otherDirectionFontSize :: Maybe FontSize
font-size attribute
otherDirectionFontWeight :: Maybe FontWeight
font-weight attribute
otherDirectionColor :: Maybe Color
color attribute

Instances

Eq OtherDirection Source #
Methods (==) :: OtherDirection -> OtherDirection -> Bool # (/=) :: OtherDirection -> OtherDirection -> Bool #
Show OtherDirection Source #
Methods showsPrec :: Int -> OtherDirection -> ShowS # show :: OtherDirection -> String # showList :: [OtherDirection] -> ShowS #
Generic OtherDirection Source #
Associated Types type Rep OtherDirection :: * -> * # Methods from :: OtherDirection -> Rep OtherDirection x # to :: Rep OtherDirection x -> OtherDirection #
EmitXml OtherDirection Source #
Methods emitXml :: OtherDirection -> XmlRep Source #
type Rep OtherDirection Source #
type Rep OtherDirection = D1 * (MetaData "OtherDirection" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "OtherDirection" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "otherDirectionString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "otherDirectionPrintObject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "otherDirectionDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "otherDirectionDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "otherDirectionRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "otherDirectionRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "otherDirectionFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "otherDirectionFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) (S1 * (MetaSel (Just Symbol "otherDirectionFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "otherDirectionFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "otherDirectionColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseOtherDirection :: XParse OtherDirection Source #

mkOtherDirection :: String -> OtherDirection Source #

Smart constructor for OtherDirection

data OtherNotation Source #

other-notation (complex)

The other-notation type is used to define any notations not yet in the MusicXML format. This allows extended representation, though without application interoperability. It handles notations where more specific extension elements such as other-dynamics and other-technical are not appropriate.

Constructors

OtherNotation

Fields

otherNotationString :: String
text content
otherNotationType :: StartStopSingle
type attribute
otherNotationNumber :: Maybe NumberLevel
number attribute
otherNotationPrintObject :: Maybe YesNo
print-object attribute
otherNotationDefaultX :: Maybe Tenths
default-x attribute
otherNotationDefaultY :: Maybe Tenths
default-y attribute
otherNotationRelativeX :: Maybe Tenths
relative-x attribute
otherNotationRelativeY :: Maybe Tenths
relative-y attribute
otherNotationFontFamily :: Maybe CommaSeparatedText
font-family attribute
otherNotationFontStyle :: Maybe FontStyle
font-style attribute
otherNotationFontSize :: Maybe FontSize
font-size attribute
otherNotationFontWeight :: Maybe FontWeight
font-weight attribute
otherNotationColor :: Maybe Color
color attribute
otherNotationPlacement :: Maybe AboveBelow
placement attribute

Instances

Eq OtherNotation Source #
Methods (==) :: OtherNotation -> OtherNotation -> Bool # (/=) :: OtherNotation -> OtherNotation -> Bool #
Show OtherNotation Source #
Methods showsPrec :: Int -> OtherNotation -> ShowS # show :: OtherNotation -> String # showList :: [OtherNotation] -> ShowS #
Generic OtherNotation Source #
Associated Types type Rep OtherNotation :: * -> * # Methods from :: OtherNotation -> Rep OtherNotation x # to :: Rep OtherNotation x -> OtherNotation #
EmitXml OtherNotation Source #
Methods emitXml :: OtherNotation -> XmlRep Source #
type Rep OtherNotation Source #
type Rep OtherNotation = D1 * (MetaData "OtherNotation" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "OtherNotation" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "otherNotationString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) ((::) (S1 * (MetaSel (Just Symbol "otherNotationType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStopSingle)) (S1 * (MetaSel (Just Symbol "otherNotationNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberLevel))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "otherNotationPrintObject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "otherNotationDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "otherNotationDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "otherNotationRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "otherNotationRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "otherNotationFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "otherNotationFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "otherNotationFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "otherNotationFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight)))) ((::) (S1 * (MetaSel (Just Symbol "otherNotationColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "otherNotationPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow))))))))

parseOtherNotation :: XParse OtherNotation Source #

mkOtherNotation :: String -> StartStopSingle -> OtherNotation Source #

Smart constructor for OtherNotation

data PageLayout Source #

page-layout (complex)

Page layout can be defined both in score-wide defaults and in the print element. Page margins are specified either for both even and odd pages, or via separate odd and even page number values. The type is not needed when used as part of a print element. If omitted when used in the defaults element, "both" is the default.

Constructors

PageLayout
Fields pageLayoutPageLayout :: Maybe SeqPageLayout pageLayoutPageMargins :: [PageMargins] page-margins child element

Instances

Eq PageLayout Source #
Methods (==) :: PageLayout -> PageLayout -> Bool # (/=) :: PageLayout -> PageLayout -> Bool #
Show PageLayout Source #
Methods showsPrec :: Int -> PageLayout -> ShowS # show :: PageLayout -> String # showList :: [PageLayout] -> ShowS #
Generic PageLayout Source #
Associated Types type Rep PageLayout :: * -> * # Methods from :: PageLayout -> Rep PageLayout x # to :: Rep PageLayout x -> PageLayout #
EmitXml PageLayout Source #
Methods emitXml :: PageLayout -> XmlRep Source #
type Rep PageLayout Source #
type Rep PageLayout = D1 * (MetaData "PageLayout" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "PageLayout" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "pageLayoutPageLayout") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe SeqPageLayout))) (S1 * (MetaSel (Just Symbol "pageLayoutPageMargins") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [PageMargins]))))

parsePageLayout :: XParse PageLayout Source #

mkPageLayout :: PageLayout Source #

Smart constructor for PageLayout

data PageMargins Source #

page-margins (complex)

Page margins are specified either for both even and odd pages, or via separate odd and even page number values. The type attribute is not needed when used as part of a print element. If omitted when the page-margins type is used in the defaults element, "both" is the default value.

Constructors

PageMargins
Fields pageMarginsType :: Maybe MarginType type attribute pageMarginsAllMargins :: AllMargins

Instances

Eq PageMargins Source #
Methods (==) :: PageMargins -> PageMargins -> Bool # (/=) :: PageMargins -> PageMargins -> Bool #
Show PageMargins Source #
Methods showsPrec :: Int -> PageMargins -> ShowS # show :: PageMargins -> String # showList :: [PageMargins] -> ShowS #
Generic PageMargins Source #
Associated Types type Rep PageMargins :: * -> * # Methods from :: PageMargins -> Rep PageMargins x # to :: Rep PageMargins x -> PageMargins #
EmitXml PageMargins Source #
Methods emitXml :: PageMargins -> XmlRep Source #
type Rep PageMargins Source #
type Rep PageMargins = D1 * (MetaData "PageMargins" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "PageMargins" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "pageMarginsType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe MarginType))) (S1 * (MetaSel (Just Symbol "pageMarginsAllMargins") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * AllMargins))))

parsePageMargins :: XParse PageMargins Source #

mkPageMargins :: AllMargins -> PageMargins Source #

Smart constructor for PageMargins

data CmpPart Source #

part (complex)

Constructors

CmpPart
Fields partId :: IDREF id attribute partMeasure :: [Measure] measure child element

Instances

Eq CmpPart Source #
Methods (==) :: CmpPart -> CmpPart -> Bool # (/=) :: CmpPart -> CmpPart -> Bool #
Show CmpPart Source #
Methods showsPrec :: Int -> CmpPart -> ShowS # show :: CmpPart -> String # showList :: [CmpPart] -> ShowS #
Generic CmpPart Source #
Associated Types type Rep CmpPart :: * -> * # Methods from :: CmpPart -> Rep CmpPart x # to :: Rep CmpPart x -> CmpPart #
EmitXml CmpPart Source #
Methods emitXml :: CmpPart -> XmlRep Source #
type Rep CmpPart Source #
type Rep CmpPart = D1 * (MetaData "CmpPart" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "CmpPart" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "partId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * IDREF)) (S1 * (MetaSel (Just Symbol "partMeasure") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Measure]))))

parseCmpPart :: XParse CmpPart Source #

mkCmpPart :: IDREF -> CmpPart Source #

Smart constructor for CmpPart

data Part Source #

part (complex)

Constructors

Part
Fields cmppartId :: IDREF id attribute partMusicData :: MusicData

Instances

Eq Part Source #
Methods (==) :: Part -> Part -> Bool # (/=) :: Part -> Part -> Bool #
Show Part Source #
Methods showsPrec :: Int -> Part -> ShowS # show :: Part -> String # showList :: [Part] -> ShowS #
Generic Part Source #
Associated Types type Rep Part :: * -> * # Methods from :: Part -> Rep Part x # to :: Rep Part x -> Part #
EmitXml Part Source #
Methods emitXml :: Part -> XmlRep Source #
type Rep Part Source #
type Rep Part = D1 * (MetaData "Part" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Part" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "cmppartId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * IDREF)) (S1 * (MetaSel (Just Symbol "partMusicData") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * MusicData))))

parsePart :: XParse Part Source #

mkPart :: IDREF -> MusicData -> Part Source #

Smart constructor for Part

data PartGroup Source #

part-group (complex)

The part-group element indicates groupings of parts in the score, usually indicated by braces and brackets. Braces that are used for multi-staff parts should be defined in the attributes element for that part. The part-group start element appears before the first score-part in the group. The part-group stop element appears after the last score-part in the group.

The number attribute is used to distinguish overlapping and nested part-groups, not the sequence of groups. As with parts, groups can have a name and abbreviation. Values for the child elements are ignored at the stop of a group.

A part-group element is not needed for a single multi-staff part. By default, multi-staff parts include a brace symbol and (if appropriate given the bar-style) common barlines. The symbol formatting for a multi-staff part can be more fully specified using the part-symbol element.

Constructors

PartGroup

Fields

partGroupType :: StartStop
type attribute
partGroupNumber :: Maybe Token
number attribute
partGroupGroupName :: Maybe GroupName
group-name child element
partGroupGroupNameDisplay :: Maybe NameDisplay
group-name-display child element
partGroupGroupAbbreviation :: Maybe GroupName
group-abbreviation child element
partGroupGroupAbbreviationDisplay :: Maybe NameDisplay
group-abbreviation-display child element
partGroupGroupSymbol :: Maybe GroupSymbol
group-symbol child element
partGroupGroupBarline :: Maybe GroupBarline
group-barline child element
partGroupGroupTime :: Maybe Empty
group-time child element
partGroupEditorial :: Editorial

Instances

Eq PartGroup Source #
Methods (==) :: PartGroup -> PartGroup -> Bool # (/=) :: PartGroup -> PartGroup -> Bool #
Show PartGroup Source #
Methods showsPrec :: Int -> PartGroup -> ShowS # show :: PartGroup -> String # showList :: [PartGroup] -> ShowS #
Generic PartGroup Source #
Associated Types type Rep PartGroup :: * -> * # Methods from :: PartGroup -> Rep PartGroup x # to :: Rep PartGroup x -> PartGroup #
EmitXml PartGroup Source #
Methods emitXml :: PartGroup -> XmlRep Source #
type Rep PartGroup Source #
type Rep PartGroup = D1 * (MetaData "PartGroup" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "PartGroup" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "partGroupType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStop)) (S1 * (MetaSel (Just Symbol "partGroupNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token)))) ((::) (S1 * (MetaSel (Just Symbol "partGroupGroupName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe GroupName))) ((::) (S1 * (MetaSel (Just Symbol "partGroupGroupNameDisplay") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NameDisplay))) (S1 * (MetaSel (Just Symbol "partGroupGroupAbbreviation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe GroupName)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "partGroupGroupAbbreviationDisplay") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NameDisplay))) (S1 * (MetaSel (Just Symbol "partGroupGroupSymbol") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe GroupSymbol)))) ((::) (S1 * (MetaSel (Just Symbol "partGroupGroupBarline") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe GroupBarline))) ((::) (S1 * (MetaSel (Just Symbol "partGroupGroupTime") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Empty))) (S1 * (MetaSel (Just Symbol "partGroupEditorial") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Editorial)))))))

parsePartGroup :: XParse PartGroup Source #

mkPartGroup :: StartStop -> Editorial -> PartGroup Source #

Smart constructor for PartGroup

data PartList Source #

part-list (complex)

The part-list identifies the different musical parts in this movement. Each part has an ID that is used later within the musical data. Since parts may be encoded separately and combined later, identification elements are present at both the score and score-part levels. There must be at least one score-part, combined as desired with part-group elements that indicate braces and brackets. Parts are ordered from top to bottom in a score based on the order in which they appear in the part-list.

Constructors

PartList
Fields partListPartGroup :: [GrpPartGroup] partListScorePart :: ScorePart partListPartList :: [ChxPartList]

Instances

Eq PartList Source #
Methods (==) :: PartList -> PartList -> Bool # (/=) :: PartList -> PartList -> Bool #
Show PartList Source #
Methods showsPrec :: Int -> PartList -> ShowS # show :: PartList -> String # showList :: [PartList] -> ShowS #
Generic PartList Source #
Associated Types type Rep PartList :: * -> * # Methods from :: PartList -> Rep PartList x # to :: Rep PartList x -> PartList #
EmitXml PartList Source #
Methods emitXml :: PartList -> XmlRep Source #
type Rep PartList Source #
type Rep PartList = D1 * (MetaData "PartList" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "PartList" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "partListPartGroup") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [GrpPartGroup])) ((::) (S1 * (MetaSel (Just Symbol "partListScorePart") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ScorePart)) (S1 * (MetaSel (Just Symbol "partListPartList") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [ChxPartList])))))

parsePartList :: XParse PartList Source #

mkPartList :: ScorePart -> PartList Source #

Smart constructor for PartList

data PartName Source #

part-name (complex)

The part-name type describes the name or abbreviation of a score-part element. Formatting attributes for the part-name element are deprecated in Version 2.0 in favor of the new part-name-display and part-abbreviation-display elements.

Constructors

PartName

Fields

partNameString :: String
text content
partNameDefaultX :: Maybe Tenths
default-x attribute
partNameDefaultY :: Maybe Tenths
default-y attribute
partNameRelativeX :: Maybe Tenths
relative-x attribute
partNameRelativeY :: Maybe Tenths
relative-y attribute
partNameFontFamily :: Maybe CommaSeparatedText
font-family attribute
partNameFontStyle :: Maybe FontStyle
font-style attribute
partNameFontSize :: Maybe FontSize
font-size attribute
partNameFontWeight :: Maybe FontWeight
font-weight attribute
partNameColor :: Maybe Color
color attribute
partNamePrintObject :: Maybe YesNo
print-object attribute
partNameJustify :: Maybe LeftCenterRight
justify attribute

Instances

Eq PartName Source #
Methods (==) :: PartName -> PartName -> Bool # (/=) :: PartName -> PartName -> Bool #
Show PartName Source #
Methods showsPrec :: Int -> PartName -> ShowS # show :: PartName -> String # showList :: [PartName] -> ShowS #
Generic PartName Source #
Associated Types type Rep PartName :: * -> * # Methods from :: PartName -> Rep PartName x # to :: Rep PartName x -> PartName #
EmitXml PartName Source #
Methods emitXml :: PartName -> XmlRep Source #
type Rep PartName Source #
type Rep PartName = D1 * (MetaData "PartName" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "PartName" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "partNameString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) ((::) (S1 * (MetaSel (Just Symbol "partNameDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "partNameDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) (S1 * (MetaSel (Just Symbol "partNameRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "partNameRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "partNameFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "partNameFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) ((::) (S1 * (MetaSel (Just Symbol "partNameFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "partNameFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))))) ((::) (S1 * (MetaSel (Just Symbol "partNameColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) ((::) (S1 * (MetaSel (Just Symbol "partNamePrintObject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "partNameJustify") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LeftCenterRight))))))))

parsePartName :: XParse PartName Source #

mkPartName :: String -> PartName Source #

Smart constructor for PartName

data PartSymbol Source #

part-symbol (complex)

The part-symbol element indicates how a symbol for a multi-staff part is indicated in the score. Values include none, brace, line, and bracket; brace is the default. The top-staff and bottom-staff elements are used when the brace does not extend across the entire part. For example, in a 3-staff organ part, the top-staff will typically be 1 for the right hand, while the bottom-staff will typically be 2 for the left hand. Staff 3 for the pedals is usually outside the brace.

Constructors

PartSymbol

Fields

partSymbolGroupSymbolValue :: GroupSymbolValue
text content
partSymbolTopStaff :: Maybe StaffNumber
top-staff attribute
partSymbolBottomStaff :: Maybe StaffNumber
bottom-staff attribute
partSymbolDefaultX :: Maybe Tenths
default-x attribute
partSymbolDefaultY :: Maybe Tenths
default-y attribute
partSymbolRelativeX :: Maybe Tenths
relative-x attribute
partSymbolRelativeY :: Maybe Tenths
relative-y attribute
partSymbolColor :: Maybe Color
color attribute

Instances

Eq PartSymbol Source #
Methods (==) :: PartSymbol -> PartSymbol -> Bool # (/=) :: PartSymbol -> PartSymbol -> Bool #
Show PartSymbol Source #
Methods showsPrec :: Int -> PartSymbol -> ShowS # show :: PartSymbol -> String # showList :: [PartSymbol] -> ShowS #
Generic PartSymbol Source #
Associated Types type Rep PartSymbol :: * -> * # Methods from :: PartSymbol -> Rep PartSymbol x # to :: Rep PartSymbol x -> PartSymbol #
EmitXml PartSymbol Source #
Methods emitXml :: PartSymbol -> XmlRep Source #
type Rep PartSymbol Source #
type Rep PartSymbol = D1 * (MetaData "PartSymbol" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "PartSymbol" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "partSymbolGroupSymbolValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * GroupSymbolValue)) (S1 * (MetaSel (Just Symbol "partSymbolTopStaff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StaffNumber)))) ((::) (S1 * (MetaSel (Just Symbol "partSymbolBottomStaff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StaffNumber))) (S1 * (MetaSel (Just Symbol "partSymbolDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "partSymbolDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "partSymbolRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "partSymbolRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "partSymbolColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))))

parsePartSymbol :: XParse PartSymbol Source #

mkPartSymbol :: GroupSymbolValue -> PartSymbol Source #

Smart constructor for PartSymbol

data Pedal Source #

pedal (complex)

The pedal type represents piano pedal marks. The line attribute is yes if pedal lines are used, no if Ped and * signs are used. The change type is used with line set to yes.

Constructors

Pedal

Fields

pedalType :: StartStopChange
type attribute
pedalLine :: Maybe YesNo
line attribute
pedalDefaultX :: Maybe Tenths
default-x attribute
pedalDefaultY :: Maybe Tenths
default-y attribute
pedalRelativeX :: Maybe Tenths
relative-x attribute
pedalRelativeY :: Maybe Tenths
relative-y attribute
pedalFontFamily :: Maybe CommaSeparatedText
font-family attribute
pedalFontStyle :: Maybe FontStyle
font-style attribute
pedalFontSize :: Maybe FontSize
font-size attribute
pedalFontWeight :: Maybe FontWeight
font-weight attribute
pedalColor :: Maybe Color
color attribute

Instances

Eq Pedal Source #
Methods (==) :: Pedal -> Pedal -> Bool # (/=) :: Pedal -> Pedal -> Bool #
Show Pedal Source #
Methods showsPrec :: Int -> Pedal -> ShowS # show :: Pedal -> String # showList :: [Pedal] -> ShowS #
Generic Pedal Source #
Associated Types type Rep Pedal :: * -> * # Methods from :: Pedal -> Rep Pedal x # to :: Rep Pedal x -> Pedal #
EmitXml Pedal Source #
Methods emitXml :: Pedal -> XmlRep Source #
type Rep Pedal Source #
type Rep Pedal = D1 * (MetaData "Pedal" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Pedal" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "pedalType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStopChange)) (S1 * (MetaSel (Just Symbol "pedalLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "pedalDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "pedalDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "pedalRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "pedalRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "pedalFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "pedalFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) (S1 * (MetaSel (Just Symbol "pedalFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "pedalFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "pedalColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parsePedal :: XParse Pedal Source #

mkPedal :: StartStopChange -> Pedal Source #

Smart constructor for Pedal

data PedalTuning Source #

pedal-tuning (complex)

The pedal-tuning type specifies the tuning of a single harp pedal.

Constructors

PedalTuning
Fields pedalTuningPedalStep :: Step pedal-step child element pedalTuningPedalAlter :: Semitones pedal-alter child element

Instances

Eq PedalTuning Source #
Methods (==) :: PedalTuning -> PedalTuning -> Bool # (/=) :: PedalTuning -> PedalTuning -> Bool #
Show PedalTuning Source #
Methods showsPrec :: Int -> PedalTuning -> ShowS # show :: PedalTuning -> String # showList :: [PedalTuning] -> ShowS #
Generic PedalTuning Source #
Associated Types type Rep PedalTuning :: * -> * # Methods from :: PedalTuning -> Rep PedalTuning x # to :: Rep PedalTuning x -> PedalTuning #
EmitXml PedalTuning Source #
Methods emitXml :: PedalTuning -> XmlRep Source #
type Rep PedalTuning Source #
type Rep PedalTuning = D1 * (MetaData "PedalTuning" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "PedalTuning" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "pedalTuningPedalStep") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Step)) (S1 * (MetaSel (Just Symbol "pedalTuningPedalAlter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Semitones))))

parsePedalTuning :: XParse PedalTuning Source #

mkPedalTuning :: Step -> Semitones -> PedalTuning Source #

Smart constructor for PedalTuning

data PerMinute Source #

per-minute (complex)

The per-minute type can be a number, or a text description including numbers. If a font is specified, it overrides the font specified for the overall metronome element. This allows separate specification of a music font for the beat-unit and a text font for the numeric value, in cases where a single metronome font is not used.

Constructors

PerMinute
Fields perMinuteString :: String text content perMinuteFontFamily :: Maybe CommaSeparatedText font-family attribute perMinuteFontStyle :: Maybe FontStyle font-style attribute perMinuteFontSize :: Maybe FontSize font-size attribute perMinuteFontWeight :: Maybe FontWeight font-weight attribute

Instances

Eq PerMinute Source #
Methods (==) :: PerMinute -> PerMinute -> Bool # (/=) :: PerMinute -> PerMinute -> Bool #
Show PerMinute Source #
Methods showsPrec :: Int -> PerMinute -> ShowS # show :: PerMinute -> String # showList :: [PerMinute] -> ShowS #
Generic PerMinute Source #
Associated Types type Rep PerMinute :: * -> * # Methods from :: PerMinute -> Rep PerMinute x # to :: Rep PerMinute x -> PerMinute #
EmitXml PerMinute Source #
Methods emitXml :: PerMinute -> XmlRep Source #
type Rep PerMinute Source #
type Rep PerMinute = D1 * (MetaData "PerMinute" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "PerMinute" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "perMinuteString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "perMinuteFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText)))) ((::) (S1 * (MetaSel (Just Symbol "perMinuteFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) ((::) (S1 * (MetaSel (Just Symbol "perMinuteFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "perMinuteFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight)))))))

parsePerMinute :: XParse PerMinute Source #

mkPerMinute :: String -> PerMinute Source #

Smart constructor for PerMinute

data Pitch Source #

pitch (complex)

Pitch is represented as a combination of the step of the diatonic scale, the chromatic alteration, and the octave.

Constructors

Pitch
Fields pitchStep :: Step step child element pitchAlter :: Maybe Semitones alter child element pitchOctave :: Octave octave child element

Instances

Eq Pitch Source #
Methods (==) :: Pitch -> Pitch -> Bool # (/=) :: Pitch -> Pitch -> Bool #
Show Pitch Source #
Methods showsPrec :: Int -> Pitch -> ShowS # show :: Pitch -> String # showList :: [Pitch] -> ShowS #
Generic Pitch Source #
Associated Types type Rep Pitch :: * -> * # Methods from :: Pitch -> Rep Pitch x # to :: Rep Pitch x -> Pitch #
EmitXml Pitch Source #
Methods emitXml :: Pitch -> XmlRep Source #
type Rep Pitch Source #
type Rep Pitch = D1 * (MetaData "Pitch" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Pitch" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "pitchStep") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Step)) ((::) (S1 * (MetaSel (Just Symbol "pitchAlter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Semitones))) (S1 * (MetaSel (Just Symbol "pitchOctave") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Octave)))))

parsePitch :: XParse Pitch Source #

mkPitch :: Step -> Octave -> Pitch Source #

Smart constructor for Pitch

data PlacementText Source #

placement-text (complex)

The placement-text type represents a text element with print-style and placement attribute groups.

Constructors

PlacementText

Fields

placementTextString :: String
text content
placementTextDefaultX :: Maybe Tenths
default-x attribute
placementTextDefaultY :: Maybe Tenths
default-y attribute
placementTextRelativeX :: Maybe Tenths
relative-x attribute
placementTextRelativeY :: Maybe Tenths
relative-y attribute
placementTextFontFamily :: Maybe CommaSeparatedText
font-family attribute
placementTextFontStyle :: Maybe FontStyle
font-style attribute
placementTextFontSize :: Maybe FontSize
font-size attribute
placementTextFontWeight :: Maybe FontWeight
font-weight attribute
placementTextColor :: Maybe Color
color attribute
placementTextPlacement :: Maybe AboveBelow
placement attribute

Instances

Eq PlacementText Source #
Methods (==) :: PlacementText -> PlacementText -> Bool # (/=) :: PlacementText -> PlacementText -> Bool #
Show PlacementText Source #
Methods showsPrec :: Int -> PlacementText -> ShowS # show :: PlacementText -> String # showList :: [PlacementText] -> ShowS #
Generic PlacementText Source #
Associated Types type Rep PlacementText :: * -> * # Methods from :: PlacementText -> Rep PlacementText x # to :: Rep PlacementText x -> PlacementText #
EmitXml PlacementText Source #
Methods emitXml :: PlacementText -> XmlRep Source #
type Rep PlacementText Source #
type Rep PlacementText = D1 * (MetaData "PlacementText" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "PlacementText" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "placementTextString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "placementTextDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "placementTextDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "placementTextRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "placementTextRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "placementTextFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) ((::) (S1 * (MetaSel (Just Symbol "placementTextFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "placementTextFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))))) ((::) (S1 * (MetaSel (Just Symbol "placementTextFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) ((::) (S1 * (MetaSel (Just Symbol "placementTextColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "placementTextPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow))))))))

parsePlacementText :: XParse PlacementText Source #

mkPlacementText :: String -> PlacementText Source #

Smart constructor for PlacementText

data Print Source #

print (complex)

The print type contains general printing parameters, including the layout elements defined in the layout.mod file. The part-name-display and part-abbreviation-display elements used in the score.mod file may also be used here to change how a part name or abbreviation is displayed over the course of a piece. They take effect when the current measure or a succeeding measure starts a new system.

Layout elements in a print statement only apply to the current page, system, staff, or measure. Music that follows continues to take the default values from the layout included in the defaults element.

Constructors

Print

Fields

printStaffSpacing :: Maybe Tenths
staff-spacing attribute
printNewSystem :: Maybe YesNo
new-system attribute
printNewPage :: Maybe YesNo
new-page attribute
printBlankPage :: Maybe PositiveInteger
blank-page attribute
printPageNumber :: Maybe Token
page-number attribute
printLayout :: Layout
printMeasureLayout :: Maybe MeasureLayout
measure-layout child element
printMeasureNumbering :: Maybe MeasureNumbering
measure-numbering child element
printPartNameDisplay :: Maybe NameDisplay
part-name-display child element
printPartAbbreviationDisplay :: Maybe NameDisplay
part-abbreviation-display child element

Instances

Eq Print Source #
Methods (==) :: Print -> Print -> Bool # (/=) :: Print -> Print -> Bool #
Show Print Source #
Methods showsPrec :: Int -> Print -> ShowS # show :: Print -> String # showList :: [Print] -> ShowS #
Generic Print Source #
Associated Types type Rep Print :: * -> * # Methods from :: Print -> Rep Print x # to :: Rep Print x -> Print #
EmitXml Print Source #
Methods emitXml :: Print -> XmlRep Source #
type Rep Print Source #
type Rep Print = D1 * (MetaData "Print" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Print" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "printStaffSpacing") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "printNewSystem") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "printNewPage") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) ((::) (S1 * (MetaSel (Just Symbol "printBlankPage") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe PositiveInteger))) (S1 * (MetaSel (Just Symbol "printPageNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "printLayout") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Layout)) (S1 * (MetaSel (Just Symbol "printMeasureLayout") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe MeasureLayout)))) ((::) (S1 * (MetaSel (Just Symbol "printMeasureNumbering") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe MeasureNumbering))) ((::) (S1 * (MetaSel (Just Symbol "printPartNameDisplay") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NameDisplay))) (S1 * (MetaSel (Just Symbol "printPartAbbreviationDisplay") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NameDisplay))))))))

parsePrint :: XParse Print Source #

mkPrint :: Layout -> Print Source #

Smart constructor for Print

data Rehearsal Source #

rehearsal (complex)

The rehearsal type specifies a rehearsal mark. Language is Italian ("it") by default. Enclosure is square by default.

Constructors

Rehearsal

Fields

rehearsalString :: String
text content
rehearsalLang :: Maybe Lang
xml:lang attribute
rehearsalEnclosure :: Maybe RehearsalEnclosure
enclosure attribute
rehearsalDefaultX :: Maybe Tenths
default-x attribute
rehearsalDefaultY :: Maybe Tenths
default-y attribute
rehearsalRelativeX :: Maybe Tenths
relative-x attribute
rehearsalRelativeY :: Maybe Tenths
relative-y attribute
rehearsalFontFamily :: Maybe CommaSeparatedText
font-family attribute
rehearsalFontStyle :: Maybe FontStyle
font-style attribute
rehearsalFontSize :: Maybe FontSize
font-size attribute
rehearsalFontWeight :: Maybe FontWeight
font-weight attribute
rehearsalColor :: Maybe Color
color attribute
rehearsalUnderline :: Maybe NumberOfLines
underline attribute
rehearsalOverline :: Maybe NumberOfLines
overline attribute
rehearsalLineThrough :: Maybe NumberOfLines
line-through attribute
rehearsalDir :: Maybe TextDirection
dir attribute
rehearsalRotation :: Maybe RotationDegrees
rotation attribute

Instances

Eq Rehearsal Source #
Methods (==) :: Rehearsal -> Rehearsal -> Bool # (/=) :: Rehearsal -> Rehearsal -> Bool #
Show Rehearsal Source #
Methods showsPrec :: Int -> Rehearsal -> ShowS # show :: Rehearsal -> String # showList :: [Rehearsal] -> ShowS #
Generic Rehearsal Source #
Associated Types type Rep Rehearsal :: * -> * # Methods from :: Rehearsal -> Rep Rehearsal x # to :: Rep Rehearsal x -> Rehearsal #
EmitXml Rehearsal Source #
Methods emitXml :: Rehearsal -> XmlRep Source #
type Rep Rehearsal Source #
type Rep Rehearsal = D1 * (MetaData "Rehearsal" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Rehearsal" PrefixI True) ((::) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "rehearsalString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "rehearsalLang") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Lang)))) ((::) (S1 * (MetaSel (Just Symbol "rehearsalEnclosure") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe RehearsalEnclosure))) (S1 * (MetaSel (Just Symbol "rehearsalDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "rehearsalDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "rehearsalRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "rehearsalRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "rehearsalFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText)))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "rehearsalFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "rehearsalFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize)))) ((::) (S1 * (MetaSel (Just Symbol "rehearsalFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "rehearsalColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "rehearsalUnderline") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOfLines))) (S1 * (MetaSel (Just Symbol "rehearsalOverline") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOfLines)))) ((::) (S1 * (MetaSel (Just Symbol "rehearsalLineThrough") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOfLines))) ((::) (S1 * (MetaSel (Just Symbol "rehearsalDir") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TextDirection))) (S1 * (MetaSel (Just Symbol "rehearsalRotation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe RotationDegrees)))))))))

parseRehearsal :: XParse Rehearsal Source #

mkRehearsal :: String -> Rehearsal Source #

Smart constructor for Rehearsal

data Repeat Source #

repeat (complex)

The repeat type represents repeat marks. The start of the repeat has a forward direction while the end of the repeat has a backward direction. Backward repeats that are not part of an ending can use the times attribute to indicate the number of times the repeated section is played.

Constructors

Repeat
Fields repeatDirection :: BackwardForward direction attribute repeatTimes :: Maybe NonNegativeInteger times attribute

Instances

Eq Repeat Source #
Methods (==) :: Repeat -> Repeat -> Bool # (/=) :: Repeat -> Repeat -> Bool #
Show Repeat Source #
Methods showsPrec :: Int -> Repeat -> ShowS # show :: Repeat -> String # showList :: [Repeat] -> ShowS #
Generic Repeat Source #
Associated Types type Rep Repeat :: * -> * # Methods from :: Repeat -> Rep Repeat x # to :: Rep Repeat x -> Repeat #
EmitXml Repeat Source #
Methods emitXml :: Repeat -> XmlRep Source #
type Rep Repeat Source #
type Rep Repeat = D1 * (MetaData "Repeat" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Repeat" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "repeatDirection") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * BackwardForward)) (S1 * (MetaSel (Just Symbol "repeatTimes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NonNegativeInteger)))))

parseRepeat :: XParse Repeat Source #

mkRepeat :: BackwardForward -> Repeat Source #

Smart constructor for Repeat

data Root Source #

root (complex)

The root type indicates a pitch like C, D, E vs. a function indication like I, II, III. It is used with chord symbols in popular music. The root element has a root-step and optional root-alter element similar to the step and alter elements, but renamed to distinguish the different musical meanings.

Constructors

Root
Fields rootRootStep :: RootStep root-step child element rootRootAlter :: Maybe RootAlter root-alter child element

Instances

Eq Root Source #
Methods (==) :: Root -> Root -> Bool # (/=) :: Root -> Root -> Bool #
Show Root Source #
Methods showsPrec :: Int -> Root -> ShowS # show :: Root -> String # showList :: [Root] -> ShowS #
Generic Root Source #
Associated Types type Rep Root :: * -> * # Methods from :: Root -> Rep Root x # to :: Rep Root x -> Root #
EmitXml Root Source #
Methods emitXml :: Root -> XmlRep Source #
type Rep Root Source #
type Rep Root = D1 * (MetaData "Root" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Root" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "rootRootStep") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * RootStep)) (S1 * (MetaSel (Just Symbol "rootRootAlter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe RootAlter)))))

parseRoot :: XParse Root Source #

mkRoot :: RootStep -> Root Source #

Smart constructor for Root

data RootAlter Source #

root-alter (complex)

The root-alter type represents the chromatic alteration of the root of the current chord within the harmony element. In some chord styles, the text for the root-step element may include root-alter information. In that case, the print-object attribute of the root-alter element can be set to no. The location attribute indicates whether the alteration should appear to the left or the right of the root-step; it is right by default.

Constructors

RootAlter

Fields

rootAlterSemitones :: Semitones
text content
rootAlterLocation :: Maybe LeftRight
location attribute
rootAlterPrintObject :: Maybe YesNo
print-object attribute
rootAlterDefaultX :: Maybe Tenths
default-x attribute
rootAlterDefaultY :: Maybe Tenths
default-y attribute
rootAlterRelativeX :: Maybe Tenths
relative-x attribute
rootAlterRelativeY :: Maybe Tenths
relative-y attribute
rootAlterFontFamily :: Maybe CommaSeparatedText
font-family attribute
rootAlterFontStyle :: Maybe FontStyle
font-style attribute
rootAlterFontSize :: Maybe FontSize
font-size attribute
rootAlterFontWeight :: Maybe FontWeight
font-weight attribute
rootAlterColor :: Maybe Color
color attribute

Instances

Eq RootAlter Source #
Methods (==) :: RootAlter -> RootAlter -> Bool # (/=) :: RootAlter -> RootAlter -> Bool #
Show RootAlter Source #
Methods showsPrec :: Int -> RootAlter -> ShowS # show :: RootAlter -> String # showList :: [RootAlter] -> ShowS #
Generic RootAlter Source #
Associated Types type Rep RootAlter :: * -> * # Methods from :: RootAlter -> Rep RootAlter x # to :: Rep RootAlter x -> RootAlter #
EmitXml RootAlter Source #
Methods emitXml :: RootAlter -> XmlRep Source #
type Rep RootAlter Source #
type Rep RootAlter = D1 * (MetaData "RootAlter" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "RootAlter" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "rootAlterSemitones") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Semitones)) ((::) (S1 * (MetaSel (Just Symbol "rootAlterLocation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LeftRight))) (S1 * (MetaSel (Just Symbol "rootAlterPrintObject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))))) ((::) (S1 * (MetaSel (Just Symbol "rootAlterDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "rootAlterDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "rootAlterRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "rootAlterRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "rootAlterFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "rootAlterFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) (S1 * (MetaSel (Just Symbol "rootAlterFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "rootAlterFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "rootAlterColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseRootAlter :: XParse RootAlter Source #

mkRootAlter :: Semitones -> RootAlter Source #

Smart constructor for RootAlter

data RootStep Source #

root-step (complex)

The root-step type represents the pitch step of the root of the current chord within the harmony element. The text attribute indicates how the root should appear on the page if not using the element contents.

Constructors

RootStep

Fields

rootStepStep :: Step
text content
rootStepText :: Maybe Token
text attribute
rootStepDefaultX :: Maybe Tenths
default-x attribute
rootStepDefaultY :: Maybe Tenths
default-y attribute
rootStepRelativeX :: Maybe Tenths
relative-x attribute
rootStepRelativeY :: Maybe Tenths
relative-y attribute
rootStepFontFamily :: Maybe CommaSeparatedText
font-family attribute
rootStepFontStyle :: Maybe FontStyle
font-style attribute
rootStepFontSize :: Maybe FontSize
font-size attribute
rootStepFontWeight :: Maybe FontWeight
font-weight attribute
rootStepColor :: Maybe Color
color attribute

Instances

Eq RootStep Source #
Methods (==) :: RootStep -> RootStep -> Bool # (/=) :: RootStep -> RootStep -> Bool #
Show RootStep Source #
Methods showsPrec :: Int -> RootStep -> ShowS # show :: RootStep -> String # showList :: [RootStep] -> ShowS #
Generic RootStep Source #
Associated Types type Rep RootStep :: * -> * # Methods from :: RootStep -> Rep RootStep x # to :: Rep RootStep x -> RootStep #
EmitXml RootStep Source #
Methods emitXml :: RootStep -> XmlRep Source #
type Rep RootStep Source #
type Rep RootStep = D1 * (MetaData "RootStep" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "RootStep" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "rootStepStep") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Step)) (S1 * (MetaSel (Just Symbol "rootStepText") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token)))) ((::) (S1 * (MetaSel (Just Symbol "rootStepDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "rootStepDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "rootStepRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "rootStepRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "rootStepFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "rootStepFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) (S1 * (MetaSel (Just Symbol "rootStepFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "rootStepFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "rootStepColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseRootStep :: XParse RootStep Source #

mkRootStep :: Step -> RootStep Source #

Smart constructor for RootStep

data Scaling Source #

scaling (complex)

Margins, page sizes, and distances are all measured in tenths to keep MusicXML data in a consistent coordinate system as much as possible. The translation to absolute units is done with the scaling type, which specifies how many millimeters are equal to how many tenths. For a staff height of 7 mm, millimeters would be set to 7 while tenths is set to 40. The ability to set a formula rather than a single scaling factor helps avoid roundoff errors.

Constructors

Scaling
Fields scalingMillimeters :: Millimeters millimeters child element scalingTenths :: Tenths tenths child element

Instances

Eq Scaling Source #
Methods (==) :: Scaling -> Scaling -> Bool # (/=) :: Scaling -> Scaling -> Bool #
Show Scaling Source #
Methods showsPrec :: Int -> Scaling -> ShowS # show :: Scaling -> String # showList :: [Scaling] -> ShowS #
Generic Scaling Source #
Associated Types type Rep Scaling :: * -> * # Methods from :: Scaling -> Rep Scaling x # to :: Rep Scaling x -> Scaling #
EmitXml Scaling Source #
Methods emitXml :: Scaling -> XmlRep Source #
type Rep Scaling Source #
type Rep Scaling = D1 * (MetaData "Scaling" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Scaling" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "scalingMillimeters") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Millimeters)) (S1 * (MetaSel (Just Symbol "scalingTenths") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Tenths))))

parseScaling :: XParse Scaling Source #

mkScaling :: Millimeters -> Tenths -> Scaling Source #

Smart constructor for Scaling

data Scordatura Source #

scordatura (complex)

Scordatura string tunings are represented by a series of accord elements, similar to the staff-tuning elements. Strings are numbered from high to low.

Constructors

Scordatura
Fields scordaturaAccord :: [Accord] accord child element

Instances

Eq Scordatura Source #
Methods (==) :: Scordatura -> Scordatura -> Bool # (/=) :: Scordatura -> Scordatura -> Bool #
Show Scordatura Source #
Methods showsPrec :: Int -> Scordatura -> ShowS # show :: Scordatura -> String # showList :: [Scordatura] -> ShowS #
Generic Scordatura Source #
Associated Types type Rep Scordatura :: * -> * # Methods from :: Scordatura -> Rep Scordatura x # to :: Rep Scordatura x -> Scordatura #
EmitXml Scordatura Source #
Methods emitXml :: Scordatura -> XmlRep Source #
type Rep Scordatura Source #
type Rep Scordatura = D1 * (MetaData "Scordatura" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Scordatura" PrefixI True) (S1 * (MetaSel (Just Symbol "scordaturaAccord") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Accord])))

parseScordatura :: XParse Scordatura Source #

mkScordatura :: Scordatura Source #

Smart constructor for Scordatura

data ScoreInstrument Source #

score-instrument (complex)

The score-instrument type represents a single instrument within a score-part. As with the score-part type, each score-instrument has a required ID attribute, a name, and an optional abbreviation.

A score-instrument type is also required if the score specifies MIDI 1.0 channels, banks, or programs. An initial midi-instrument assignment can also be made here. MusicXML software should be able to automatically assign reasonable channels and instruments without these elements in simple cases, such as where part names match General MIDI instrument names.

Constructors

ScoreInstrument
Fields scoreInstrumentId :: ID id attribute scoreInstrumentInstrumentName :: String instrument-name child element scoreInstrumentInstrumentAbbreviation :: Maybe String instrument-abbreviation child element scoreInstrumentScoreInstrument :: Maybe ChxScoreInstrument

Instances

Eq ScoreInstrument Source #
Methods (==) :: ScoreInstrument -> ScoreInstrument -> Bool # (/=) :: ScoreInstrument -> ScoreInstrument -> Bool #
Show ScoreInstrument Source #
Methods showsPrec :: Int -> ScoreInstrument -> ShowS # show :: ScoreInstrument -> String # showList :: [ScoreInstrument] -> ShowS #
Generic ScoreInstrument Source #
Associated Types type Rep ScoreInstrument :: * -> * # Methods from :: ScoreInstrument -> Rep ScoreInstrument x # to :: Rep ScoreInstrument x -> ScoreInstrument #
EmitXml ScoreInstrument Source #
Methods emitXml :: ScoreInstrument -> XmlRep Source #
type Rep ScoreInstrument Source #
type Rep ScoreInstrument = D1 * (MetaData "ScoreInstrument" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "ScoreInstrument" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "scoreInstrumentId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ID)) (S1 * (MetaSel (Just Symbol "scoreInstrumentInstrumentName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String))) ((::) (S1 * (MetaSel (Just Symbol "scoreInstrumentInstrumentAbbreviation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe String))) (S1 * (MetaSel (Just Symbol "scoreInstrumentScoreInstrument") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe ChxScoreInstrument))))))

parseScoreInstrument :: XParse ScoreInstrument Source #

mkScoreInstrument :: ID -> String -> ScoreInstrument Source #

Smart constructor for ScoreInstrument

data CmpScorePart Source #

score-part (complex)

Each MusicXML part corresponds to a track in a Standard MIDI Format 1 file. The score-instrument elements are used when there are multiple instruments per track. The midi-device element is used to make a MIDI device or port assignment for the given track. Initial midi-instrument assignments may be made here as well.

Constructors

CmpScorePart

Fields

scorePartId :: ID
id attribute
scorePartIdentification :: Maybe Identification
identification child element
scorePartPartName :: PartName
part-name child element
scorePartPartNameDisplay :: Maybe NameDisplay
part-name-display child element
scorePartPartAbbreviation :: Maybe PartName
part-abbreviation child element
scorePartPartAbbreviationDisplay :: Maybe NameDisplay
part-abbreviation-display child element
scorePartGroup :: [String]
group child element
scorePartScoreInstrument :: [ScoreInstrument]
score-instrument child element
scorePartMidiDevice :: Maybe MidiDevice
midi-device child element
scorePartMidiInstrument :: [MidiInstrument]
midi-instrument child element

Instances

Eq CmpScorePart Source #
Methods (==) :: CmpScorePart -> CmpScorePart -> Bool # (/=) :: CmpScorePart -> CmpScorePart -> Bool #
Show CmpScorePart Source #
Methods showsPrec :: Int -> CmpScorePart -> ShowS # show :: CmpScorePart -> String # showList :: [CmpScorePart] -> ShowS #
Generic CmpScorePart Source #
Associated Types type Rep CmpScorePart :: * -> * # Methods from :: CmpScorePart -> Rep CmpScorePart x # to :: Rep CmpScorePart x -> CmpScorePart #
EmitXml CmpScorePart Source #
Methods emitXml :: CmpScorePart -> XmlRep Source #
type Rep CmpScorePart Source #
type Rep CmpScorePart = D1 * (MetaData "CmpScorePart" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "CmpScorePart" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "scorePartId") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ID)) (S1 * (MetaSel (Just Symbol "scorePartIdentification") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Identification)))) ((::) (S1 * (MetaSel (Just Symbol "scorePartPartName") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PartName)) ((::) (S1 * (MetaSel (Just Symbol "scorePartPartNameDisplay") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NameDisplay))) (S1 * (MetaSel (Just Symbol "scorePartPartAbbreviation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe PartName)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "scorePartPartAbbreviationDisplay") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NameDisplay))) (S1 * (MetaSel (Just Symbol "scorePartGroup") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [String]))) ((::) (S1 * (MetaSel (Just Symbol "scorePartScoreInstrument") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [ScoreInstrument])) ((::) (S1 * (MetaSel (Just Symbol "scorePartMidiDevice") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe MidiDevice))) (S1 * (MetaSel (Just Symbol "scorePartMidiInstrument") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [MidiInstrument])))))))

parseCmpScorePart :: XParse CmpScorePart Source #

mkCmpScorePart :: ID -> PartName -> CmpScorePart Source #

Smart constructor for CmpScorePart

data ScorePartwise Source #

score-partwise (complex)

Constructors

ScorePartwise
Fields scorePartwiseVersion :: Maybe Token version attribute scorePartwiseScoreHeader :: ScoreHeader scorePartwisePart :: [CmpPart] part child element

Instances

Eq ScorePartwise Source #
Methods (==) :: ScorePartwise -> ScorePartwise -> Bool # (/=) :: ScorePartwise -> ScorePartwise -> Bool #
Show ScorePartwise Source #
Methods showsPrec :: Int -> ScorePartwise -> ShowS # show :: ScorePartwise -> String # showList :: [ScorePartwise] -> ShowS #
Generic ScorePartwise Source #
Associated Types type Rep ScorePartwise :: * -> * # Methods from :: ScorePartwise -> Rep ScorePartwise x # to :: Rep ScorePartwise x -> ScorePartwise #
EmitXml ScorePartwise Source #
Methods emitXml :: ScorePartwise -> XmlRep Source #
type Rep ScorePartwise Source #
type Rep ScorePartwise = D1 * (MetaData "ScorePartwise" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "ScorePartwise" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "scorePartwiseVersion") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) ((::) (S1 * (MetaSel (Just Symbol "scorePartwiseScoreHeader") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ScoreHeader)) (S1 * (MetaSel (Just Symbol "scorePartwisePart") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [CmpPart])))))

parseScorePartwise :: XParse ScorePartwise Source #

mkScorePartwise :: ScoreHeader -> ScorePartwise Source #

Smart constructor for ScorePartwise

data ScoreTimewise Source #

score-timewise (complex)

Constructors

ScoreTimewise
Fields scoreTimewiseVersion :: Maybe Token version attribute scoreTimewiseScoreHeader :: ScoreHeader scoreTimewiseMeasure :: [CmpMeasure] measure child element

Instances

Eq ScoreTimewise Source #
Methods (==) :: ScoreTimewise -> ScoreTimewise -> Bool # (/=) :: ScoreTimewise -> ScoreTimewise -> Bool #
Show ScoreTimewise Source #
Methods showsPrec :: Int -> ScoreTimewise -> ShowS # show :: ScoreTimewise -> String # showList :: [ScoreTimewise] -> ShowS #
Generic ScoreTimewise Source #
Associated Types type Rep ScoreTimewise :: * -> * # Methods from :: ScoreTimewise -> Rep ScoreTimewise x # to :: Rep ScoreTimewise x -> ScoreTimewise #
EmitXml ScoreTimewise Source #
Methods emitXml :: ScoreTimewise -> XmlRep Source #
type Rep ScoreTimewise Source #
type Rep ScoreTimewise = D1 * (MetaData "ScoreTimewise" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "ScoreTimewise" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "scoreTimewiseVersion") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) ((::) (S1 * (MetaSel (Just Symbol "scoreTimewiseScoreHeader") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ScoreHeader)) (S1 * (MetaSel (Just Symbol "scoreTimewiseMeasure") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [CmpMeasure])))))

parseScoreTimewise :: XParse ScoreTimewise Source #

mkScoreTimewise :: ScoreHeader -> ScoreTimewise Source #

Smart constructor for ScoreTimewise

data CmpSlash Source #

slash (complex)

The slash type is used to indicate that slash notation is to be used. If the slash is on every beat, use-stems is no (the default). To indicate rhythms but not pitches, use-stems is set to yes. The type attribute indicates whether this is the start or stop of a slash notation style. The use-dots attribute works as for the beat-repeat element, and only has effect if use-stems is no.

Constructors

CmpSlash
Fields slashType :: StartStop type attribute slashUseDots :: Maybe YesNo use-dots attribute slashUseStems :: Maybe YesNo use-stems attribute slashSlash :: Maybe Slash

Instances

Eq CmpSlash Source #
Methods (==) :: CmpSlash -> CmpSlash -> Bool # (/=) :: CmpSlash -> CmpSlash -> Bool #
Show CmpSlash Source #
Methods showsPrec :: Int -> CmpSlash -> ShowS # show :: CmpSlash -> String # showList :: [CmpSlash] -> ShowS #
Generic CmpSlash Source #
Associated Types type Rep CmpSlash :: * -> * # Methods from :: CmpSlash -> Rep CmpSlash x # to :: Rep CmpSlash x -> CmpSlash #
EmitXml CmpSlash Source #
Methods emitXml :: CmpSlash -> XmlRep Source #
type Rep CmpSlash Source #
type Rep CmpSlash = D1 * (MetaData "CmpSlash" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "CmpSlash" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "slashType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStop)) (S1 * (MetaSel (Just Symbol "slashUseDots") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "slashUseStems") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "slashSlash") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Slash))))))

parseCmpSlash :: XParse CmpSlash Source #

mkCmpSlash :: StartStop -> CmpSlash Source #

Smart constructor for CmpSlash

data Slide Source #

slide (complex)

Glissando and slide types both indicate rapidly moving from one pitch to the other so that individual notes are not discerned. The distinction is similar to that between NIFF's glissando and portamento elements. A slide is continuous between two notes and defaults to a solid line. The optional text for a is printed alongside the line.

Constructors

Slide

Fields

slideString :: String
text content
slideType :: StartStop
type attribute
slideNumber :: Maybe NumberLevel
number attribute
slideLineType :: Maybe LineType
line-type attribute
slideDefaultX :: Maybe Tenths
default-x attribute
slideDefaultY :: Maybe Tenths
default-y attribute
slideRelativeX :: Maybe Tenths
relative-x attribute
slideRelativeY :: Maybe Tenths
relative-y attribute
slideFontFamily :: Maybe CommaSeparatedText
font-family attribute
slideFontStyle :: Maybe FontStyle
font-style attribute
slideFontSize :: Maybe FontSize
font-size attribute
slideFontWeight :: Maybe FontWeight
font-weight attribute
slideColor :: Maybe Color
color attribute
slideAccelerate :: Maybe YesNo
accelerate attribute
slideBeats :: Maybe TrillBeats
beats attribute
slideFirstBeat :: Maybe Percent
first-beat attribute
slideLastBeat :: Maybe Percent
last-beat attribute

Instances

Eq Slide Source #
Methods (==) :: Slide -> Slide -> Bool # (/=) :: Slide -> Slide -> Bool #
Show Slide Source #
Methods showsPrec :: Int -> Slide -> ShowS # show :: Slide -> String # showList :: [Slide] -> ShowS #
Generic Slide Source #
Associated Types type Rep Slide :: * -> * # Methods from :: Slide -> Rep Slide x # to :: Rep Slide x -> Slide #
EmitXml Slide Source #
Methods emitXml :: Slide -> XmlRep Source #
type Rep Slide Source #
type Rep Slide = D1 * (MetaData "Slide" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Slide" PrefixI True) ((::) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "slideString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "slideType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStop))) ((::) (S1 * (MetaSel (Just Symbol "slideNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberLevel))) (S1 * (MetaSel (Just Symbol "slideLineType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LineType))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "slideDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "slideDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "slideRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "slideRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "slideFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "slideFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle)))) ((::) (S1 * (MetaSel (Just Symbol "slideFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "slideFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "slideColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "slideAccelerate") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo)))) ((::) (S1 * (MetaSel (Just Symbol "slideBeats") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TrillBeats))) ((::) (S1 * (MetaSel (Just Symbol "slideFirstBeat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Percent))) (S1 * (MetaSel (Just Symbol "slideLastBeat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Percent)))))))))

parseSlide :: XParse Slide Source #

mkSlide :: String -> StartStop -> Slide Source #

Smart constructor for Slide

data Slur Source #

slur (complex)

Slur types are empty. Most slurs are represented with two elements: one with a start type, and one with a stop type. Slurs can add more elements using a continue type. This is typically used to specify the formatting of cross-system slurs, or to specify the shape of very complex slurs.

Constructors

Slur

Fields

slurType :: StartStopContinue
type attribute
slurNumber :: Maybe NumberLevel
number attribute
slurLineType :: Maybe LineType
line-type attribute
slurDefaultX :: Maybe Tenths
default-x attribute
slurDefaultY :: Maybe Tenths
default-y attribute
slurRelativeX :: Maybe Tenths
relative-x attribute
slurRelativeY :: Maybe Tenths
relative-y attribute
slurPlacement :: Maybe AboveBelow
placement attribute
slurOrientation :: Maybe OverUnder
orientation attribute
slurBezierOffset :: Maybe Divisions
bezier-offset attribute
slurBezierOffset2 :: Maybe Divisions
bezier-offset2 attribute
slurBezierX :: Maybe Tenths
bezier-x attribute
slurBezierY :: Maybe Tenths
bezier-y attribute
slurBezierX2 :: Maybe Tenths
bezier-x2 attribute
slurBezierY2 :: Maybe Tenths
bezier-y2 attribute
slurColor :: Maybe Color
color attribute

Instances

Eq Slur Source #
Methods (==) :: Slur -> Slur -> Bool # (/=) :: Slur -> Slur -> Bool #
Show Slur Source #
Methods showsPrec :: Int -> Slur -> ShowS # show :: Slur -> String # showList :: [Slur] -> ShowS #
Generic Slur Source #
Associated Types type Rep Slur :: * -> * # Methods from :: Slur -> Rep Slur x # to :: Rep Slur x -> Slur #
EmitXml Slur Source #
Methods emitXml :: Slur -> XmlRep Source #
type Rep Slur Source #
type Rep Slur = D1 * (MetaData "Slur" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Slur" PrefixI True) ((::) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "slurType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStopContinue)) (S1 * (MetaSel (Just Symbol "slurNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberLevel)))) ((::) (S1 * (MetaSel (Just Symbol "slurLineType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LineType))) (S1 * (MetaSel (Just Symbol "slurDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "slurDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "slurRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "slurRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "slurPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow)))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "slurOrientation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe OverUnder))) (S1 * (MetaSel (Just Symbol "slurBezierOffset") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Divisions)))) ((::) (S1 * (MetaSel (Just Symbol "slurBezierOffset2") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Divisions))) (S1 * (MetaSel (Just Symbol "slurBezierX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "slurBezierY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "slurBezierX2") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "slurBezierY2") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "slurColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseSlur :: XParse Slur Source #

mkSlur :: StartStopContinue -> Slur Source #

Smart constructor for Slur

data Sound Source #

sound (complex)

The sound element contains general playback parameters. They can stand alone within a part/measure, or be a component element within a direction.

Tempo is expressed in quarter notes per minute. If 0, the sound-generating program should prompt the user at the time of compiling a sound (MIDI) file.

Dynamics (or MIDI velocity) are expressed as a percentage of the default forte value (90 for MIDI 1.0).

Dacapo indicates to go back to the beginning of the movement. When used it always has the value "yes".

Segno and dalsegno are used for backwards jumps to a segno sign; coda and tocoda are used for forward jumps to a coda sign. If there are multiple jumps, the value of these parameters can be used to name and distinguish them. If segno or coda is used, the divisions attribute can also be used to indicate the number of divisions per quarter note. Otherwise sound and MIDI generating programs may have to recompute this.

By default, a dalsegno or dacapo attribute indicates that the jump should occur the first time through, while a tocoda attribute indicates the jump should occur the second time through. The time that jumps occur can be changed by using the time-only attribute.

Forward-repeat is used when a forward repeat sign is implied, and usually follows a bar line. When used it always has the value of "yes".

The fine attribute follows the final note or rest in a movement with a da capo or dal segno direction. If numeric, the value represents the actual duration of the final note or rest, which can be ambiguous in written notation and different among parts and voices. The value may also be "yes" to indicate no change to the final duration.

If the sound element applies only one time through a repeat, the time-only attribute indicates which time to apply the sound element.

Pizzicato in a sound element effects all following notes. Yes indicates pizzicato, no indicates arco.

The pan and elevation attributes are deprecated in Version 2.0. The pan and elevation elements in the midi-instrument element should be used instead. The meaning of the pan and elevation attributes is the same as for the pan and elevation elements. If both are present, the mid-instrument elements take priority.

The damper-pedal, soft-pedal, and sostenuto-pedal attributes effect playback of the three common piano pedals and their MIDI controller equivalents. The yes value indicates the pedal is depressed; no indicates the pedal is released. A numeric value from 0 to 100 may also be used for half pedaling. This value is the percentage that the pedal is depressed. A value of 0 is equivalent to no, and a value of 100 is equivalent to yes.

MIDI instruments are changed using the midi-instrument element.

The offset element is used to indicate that the sound takes place offset from the current score position. If the sound element is a child of a direction element, the sound offset element overrides the direction offset element if both elements are present. Note that the offset reflects the intended musical position for the change in sound. It should not be used to compensate for latency issues in particular hardware configurations.

Constructors

Sound

Fields

soundTempo :: Maybe NonNegativeDecimal
tempo attribute
soundDynamics :: Maybe NonNegativeDecimal
dynamics attribute
soundDacapo :: Maybe YesNo
dacapo attribute
soundSegno :: Maybe Token
segno attribute
soundDalsegno :: Maybe Token
dalsegno attribute
soundCoda :: Maybe Token
coda attribute
soundTocoda :: Maybe Token
tocoda attribute
soundDivisions :: Maybe Divisions
divisions attribute
soundForwardRepeat :: Maybe YesNo
forward-repeat attribute
soundFine :: Maybe Token
fine attribute
soundTimeOnly :: Maybe Token
time-only attribute
soundPizzicato :: Maybe YesNo
pizzicato attribute
soundPan :: Maybe RotationDegrees
pan attribute
soundElevation :: Maybe RotationDegrees
elevation attribute
soundDamperPedal :: Maybe YesNoNumber
damper-pedal attribute
soundSoftPedal :: Maybe YesNoNumber
soft-pedal attribute
soundSostenutoPedal :: Maybe YesNoNumber
sostenuto-pedal attribute
soundMidiInstrument :: [MidiInstrument]
midi-instrument child element
soundOffset :: Maybe Offset
offset child element

Instances

Eq Sound Source #
Methods (==) :: Sound -> Sound -> Bool # (/=) :: Sound -> Sound -> Bool #
Show Sound Source #
Methods showsPrec :: Int -> Sound -> ShowS # show :: Sound -> String # showList :: [Sound] -> ShowS #
Generic Sound Source #
Associated Types type Rep Sound :: * -> * # Methods from :: Sound -> Rep Sound x # to :: Rep Sound x -> Sound #
EmitXml Sound Source #
Methods emitXml :: Sound -> XmlRep Source #
type Rep Sound Source #
type Rep Sound = D1 * (MetaData "Sound" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Sound" PrefixI True) ((::) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "soundTempo") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NonNegativeDecimal))) (S1 * (MetaSel (Just Symbol "soundDynamics") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NonNegativeDecimal)))) ((::) (S1 * (MetaSel (Just Symbol "soundDacapo") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "soundSegno") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "soundDalsegno") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) (S1 * (MetaSel (Just Symbol "soundCoda") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token)))) ((::) (S1 * (MetaSel (Just Symbol "soundTocoda") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) ((::) (S1 * (MetaSel (Just Symbol "soundDivisions") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Divisions))) (S1 * (MetaSel (Just Symbol "soundForwardRepeat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "soundFine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))) (S1 * (MetaSel (Just Symbol "soundTimeOnly") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token)))) ((::) (S1 * (MetaSel (Just Symbol "soundPizzicato") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) ((::) (S1 * (MetaSel (Just Symbol "soundPan") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe RotationDegrees))) (S1 * (MetaSel (Just Symbol "soundElevation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe RotationDegrees)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "soundDamperPedal") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNoNumber))) (S1 * (MetaSel (Just Symbol "soundSoftPedal") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNoNumber)))) ((::) (S1 * (MetaSel (Just Symbol "soundSostenutoPedal") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNoNumber))) ((::) (S1 * (MetaSel (Just Symbol "soundMidiInstrument") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [MidiInstrument])) (S1 * (MetaSel (Just Symbol "soundOffset") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Offset)))))))))

parseSound :: XParse Sound Source #

mkSound :: Sound Source #

Smart constructor for Sound

data StaffDetails Source #

staff-details (complex)

The staff-details element is used to indicate different types of staves. The optional number attribute specifies the staff number from top to bottom on the system, as with clef. The print-object attribute is used to indicate when a staff is not printed in a part, usually in large scores where empty parts are omitted. It is yes by default. If print-spacing is yes while print-object is no, the score is printed in cutaway format where vertical space is left for the empty part.

Constructors

StaffDetails

Fields

staffDetailsNumber :: Maybe StaffNumber
number attribute
staffDetailsShowFrets :: Maybe ShowFrets
show-frets attribute
staffDetailsPrintObject :: Maybe YesNo
print-object attribute
staffDetailsPrintSpacing :: Maybe YesNo
print-spacing attribute
staffDetailsStaffType :: Maybe StaffType
staff-type child element
staffDetailsStaffLines :: Maybe NonNegativeInteger
staff-lines child element
staffDetailsStaffTuning :: [StaffTuning]
staff-tuning child element
staffDetailsCapo :: Maybe NonNegativeInteger
capo child element
staffDetailsStaffSize :: Maybe NonNegativeDecimal
staff-size child element

Instances

Eq StaffDetails Source #
Methods (==) :: StaffDetails -> StaffDetails -> Bool # (/=) :: StaffDetails -> StaffDetails -> Bool #
Show StaffDetails Source #
Methods showsPrec :: Int -> StaffDetails -> ShowS # show :: StaffDetails -> String # showList :: [StaffDetails] -> ShowS #
Generic StaffDetails Source #
Associated Types type Rep StaffDetails :: * -> * # Methods from :: StaffDetails -> Rep StaffDetails x # to :: Rep StaffDetails x -> StaffDetails #
EmitXml StaffDetails Source #
Methods emitXml :: StaffDetails -> XmlRep Source #
type Rep StaffDetails Source #
type Rep StaffDetails = D1 * (MetaData "StaffDetails" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "StaffDetails" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "staffDetailsNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StaffNumber))) (S1 * (MetaSel (Just Symbol "staffDetailsShowFrets") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe ShowFrets)))) ((::) (S1 * (MetaSel (Just Symbol "staffDetailsPrintObject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "staffDetailsPrintSpacing") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "staffDetailsStaffType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StaffType))) (S1 * (MetaSel (Just Symbol "staffDetailsStaffLines") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NonNegativeInteger)))) ((::) (S1 * (MetaSel (Just Symbol "staffDetailsStaffTuning") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [StaffTuning])) ((::) (S1 * (MetaSel (Just Symbol "staffDetailsCapo") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NonNegativeInteger))) (S1 * (MetaSel (Just Symbol "staffDetailsStaffSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NonNegativeDecimal))))))))

parseStaffDetails :: XParse StaffDetails Source #

mkStaffDetails :: StaffDetails Source #

Smart constructor for StaffDetails

data StaffLayout Source #

staff-layout (complex)

Staff layout includes the vertical distance from the bottom line of the previous staff in this system to the top line of the staff specified by the number attribute. The optional number attribute refers to staff numbers within the part, from top to bottom on the system. A value of 1 is assumed if not present. When used in the defaults element, the values apply to all parts. This value is ignored for the first staff in a system.

Constructors

StaffLayout
Fields staffLayoutNumber :: Maybe StaffNumber number attribute staffLayoutStaffDistance :: Maybe Tenths staff-distance child element

Instances

Eq StaffLayout Source #
Methods (==) :: StaffLayout -> StaffLayout -> Bool # (/=) :: StaffLayout -> StaffLayout -> Bool #
Show StaffLayout Source #
Methods showsPrec :: Int -> StaffLayout -> ShowS # show :: StaffLayout -> String # showList :: [StaffLayout] -> ShowS #
Generic StaffLayout Source #
Associated Types type Rep StaffLayout :: * -> * # Methods from :: StaffLayout -> Rep StaffLayout x # to :: Rep StaffLayout x -> StaffLayout #
EmitXml StaffLayout Source #
Methods emitXml :: StaffLayout -> XmlRep Source #
type Rep StaffLayout Source #
type Rep StaffLayout = D1 * (MetaData "StaffLayout" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "StaffLayout" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "staffLayoutNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StaffNumber))) (S1 * (MetaSel (Just Symbol "staffLayoutStaffDistance") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))

parseStaffLayout :: XParse StaffLayout Source #

mkStaffLayout :: StaffLayout Source #

Smart constructor for StaffLayout

data StaffTuning Source #

staff-tuning (complex)

The staff-tuning type specifies the open, non-capo tuning of the lines on a tablature staff.

Constructors

StaffTuning
Fields staffTuningLine :: Maybe StaffLine line attribute staffTuningTuning :: Tuning

Instances

Eq StaffTuning Source #
Methods (==) :: StaffTuning -> StaffTuning -> Bool # (/=) :: StaffTuning -> StaffTuning -> Bool #
Show StaffTuning Source #
Methods showsPrec :: Int -> StaffTuning -> ShowS # show :: StaffTuning -> String # showList :: [StaffTuning] -> ShowS #
Generic StaffTuning Source #
Associated Types type Rep StaffTuning :: * -> * # Methods from :: StaffTuning -> Rep StaffTuning x # to :: Rep StaffTuning x -> StaffTuning #
EmitXml StaffTuning Source #
Methods emitXml :: StaffTuning -> XmlRep Source #
type Rep StaffTuning Source #
type Rep StaffTuning = D1 * (MetaData "StaffTuning" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "StaffTuning" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "staffTuningLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StaffLine))) (S1 * (MetaSel (Just Symbol "staffTuningTuning") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Tuning))))

parseStaffTuning :: XParse StaffTuning Source #

mkStaffTuning :: Tuning -> StaffTuning Source #

Smart constructor for StaffTuning

data Stem Source #

stem (complex)

Stems can be down, up, none, or double. For down and up stems, the position attributes can be used to specify stem length. The relative values specify the end of the stem relative to the program default. Default values specify an absolute end stem position. Negative values of relative-y that would flip a stem instead of shortening it are ignored.

Constructors

Stem
Fields stemStemValue :: StemValue text content stemDefaultX :: Maybe Tenths default-x attribute stemDefaultY :: Maybe Tenths default-y attribute stemRelativeX :: Maybe Tenths relative-x attribute stemRelativeY :: Maybe Tenths relative-y attribute stemColor :: Maybe Color color attribute

Instances

Eq Stem Source #
Methods (==) :: Stem -> Stem -> Bool # (/=) :: Stem -> Stem -> Bool #
Show Stem Source #
Methods showsPrec :: Int -> Stem -> ShowS # show :: Stem -> String # showList :: [Stem] -> ShowS #
Generic Stem Source #
Associated Types type Rep Stem :: * -> * # Methods from :: Stem -> Rep Stem x # to :: Rep Stem x -> Stem #
EmitXml Stem Source #
Methods emitXml :: Stem -> XmlRep Source #
type Rep Stem Source #
type Rep Stem = D1 * (MetaData "Stem" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Stem" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "stemStemValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StemValue)) ((::) (S1 * (MetaSel (Just Symbol "stemDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "stemDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) (S1 * (MetaSel (Just Symbol "stemRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "stemRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "stemColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))))

parseStem :: XParse Stem Source #

mkStem :: StemValue -> Stem Source #

Smart constructor for Stem

data CmpString Source #

string (complex)

The string type is used with tablature notation, regular notation (where it is often circled), and chord diagrams. String numbers start with 1 for the highest string.

Constructors

CmpString

Fields

stringStringNumber :: StringNumber
text content
stringDefaultX :: Maybe Tenths
default-x attribute
stringDefaultY :: Maybe Tenths
default-y attribute
stringRelativeX :: Maybe Tenths
relative-x attribute
stringRelativeY :: Maybe Tenths
relative-y attribute
stringFontFamily :: Maybe CommaSeparatedText
font-family attribute
stringFontStyle :: Maybe FontStyle
font-style attribute
stringFontSize :: Maybe FontSize
font-size attribute
stringFontWeight :: Maybe FontWeight
font-weight attribute
stringColor :: Maybe Color
color attribute
stringPlacement :: Maybe AboveBelow
placement attribute

Instances

Eq CmpString Source #
Methods (==) :: CmpString -> CmpString -> Bool # (/=) :: CmpString -> CmpString -> Bool #
Show CmpString Source #
Methods showsPrec :: Int -> CmpString -> ShowS # show :: CmpString -> String # showList :: [CmpString] -> ShowS #
Generic CmpString Source #
Associated Types type Rep CmpString :: * -> * # Methods from :: CmpString -> Rep CmpString x # to :: Rep CmpString x -> CmpString #
EmitXml CmpString Source #
Methods emitXml :: CmpString -> XmlRep Source #
type Rep CmpString Source #
type Rep CmpString = D1 * (MetaData "CmpString" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "CmpString" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "stringStringNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StringNumber)) (S1 * (MetaSel (Just Symbol "stringDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "stringDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "stringRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "stringRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "stringFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) ((::) (S1 * (MetaSel (Just Symbol "stringFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "stringFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))))) ((::) (S1 * (MetaSel (Just Symbol "stringFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) ((::) (S1 * (MetaSel (Just Symbol "stringColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "stringPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow))))))))

parseCmpString :: XParse CmpString Source #

mkCmpString :: StringNumber -> CmpString Source #

Smart constructor for CmpString

data StrongAccent Source #

strong-accent (complex)

The strong-accent type indicates a vertical accent mark. The type attribute indicates if the point of the accent is down or up.

Constructors

StrongAccent
Fields strongAccentEmptyPlacement :: StrongAccent strongAccentType :: Maybe UpDown type attribute

Instances

Eq StrongAccent Source #
Methods (==) :: StrongAccent -> StrongAccent -> Bool # (/=) :: StrongAccent -> StrongAccent -> Bool #
Show StrongAccent Source #
Methods showsPrec :: Int -> StrongAccent -> ShowS # show :: StrongAccent -> String # showList :: [StrongAccent] -> ShowS #
Generic StrongAccent Source #
Associated Types type Rep StrongAccent :: * -> * # Methods from :: StrongAccent -> Rep StrongAccent x # to :: Rep StrongAccent x -> StrongAccent #
EmitXml StrongAccent Source #
Methods emitXml :: StrongAccent -> XmlRep Source #
type Rep StrongAccent Source #
type Rep StrongAccent = D1 * (MetaData "StrongAccent" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "StrongAccent" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "strongAccentEmptyPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StrongAccent)) (S1 * (MetaSel (Just Symbol "strongAccentType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe UpDown)))))

parseStrongAccent :: XParse StrongAccent Source #

mkStrongAccent :: StrongAccent -> StrongAccent Source #

Smart constructor for StrongAccent

data StyleText Source #

style-text (complex)

The style-text type represents a text element with a print-style attribute group.

Constructors

StyleText

Fields

styleTextString :: String
text content
styleTextDefaultX :: Maybe Tenths
default-x attribute
styleTextDefaultY :: Maybe Tenths
default-y attribute
styleTextRelativeX :: Maybe Tenths
relative-x attribute
styleTextRelativeY :: Maybe Tenths
relative-y attribute
styleTextFontFamily :: Maybe CommaSeparatedText
font-family attribute
styleTextFontStyle :: Maybe FontStyle
font-style attribute
styleTextFontSize :: Maybe FontSize
font-size attribute
styleTextFontWeight :: Maybe FontWeight
font-weight attribute
styleTextColor :: Maybe Color
color attribute

Instances

Eq StyleText Source #
Methods (==) :: StyleText -> StyleText -> Bool # (/=) :: StyleText -> StyleText -> Bool #
Show StyleText Source #
Methods showsPrec :: Int -> StyleText -> ShowS # show :: StyleText -> String # showList :: [StyleText] -> ShowS #
Generic StyleText Source #
Associated Types type Rep StyleText :: * -> * # Methods from :: StyleText -> Rep StyleText x # to :: Rep StyleText x -> StyleText #
EmitXml StyleText Source #
Methods emitXml :: StyleText -> XmlRep Source #
type Rep StyleText Source #
type Rep StyleText = D1 * (MetaData "StyleText" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "StyleText" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "styleTextString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "styleTextDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "styleTextDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "styleTextRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "styleTextRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "styleTextFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "styleTextFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle)))) ((::) (S1 * (MetaSel (Just Symbol "styleTextFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "styleTextFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "styleTextColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseStyleText :: XParse StyleText Source #

mkStyleText :: String -> StyleText Source #

Smart constructor for StyleText

data Supports Source #

supports (complex)

The supports type indicates if a MusicXML encoding supports a particular MusicXML element. This is recommended for elements like beam, stem, and accidental, where the absence of an element is ambiguous if you do not know if the encoding supports that element. For Version 2.0, the supports element is expanded to allow programs to indicate support for particular attributes or particular values. This lets applications communicate, for example, that all system and/or page breaks are contained in the MusicXML file.

Constructors

Supports
Fields supportsType :: YesNo type attribute supportsElement :: NMTOKEN element attribute supportsAttribute :: Maybe NMTOKEN attribute attribute supportsValue :: Maybe Token value attribute

Instances

Eq Supports Source #
Methods (==) :: Supports -> Supports -> Bool # (/=) :: Supports -> Supports -> Bool #
Show Supports Source #
Methods showsPrec :: Int -> Supports -> ShowS # show :: Supports -> String # showList :: [Supports] -> ShowS #
Generic Supports Source #
Associated Types type Rep Supports :: * -> * # Methods from :: Supports -> Rep Supports x # to :: Rep Supports x -> Supports #
EmitXml Supports Source #
Methods emitXml :: Supports -> XmlRep Source #
type Rep Supports Source #
type Rep Supports = D1 * (MetaData "Supports" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Supports" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "supportsType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * YesNo)) (S1 * (MetaSel (Just Symbol "supportsElement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NMTOKEN))) ((::) (S1 * (MetaSel (Just Symbol "supportsAttribute") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NMTOKEN))) (S1 * (MetaSel (Just Symbol "supportsValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token))))))

parseSupports :: XParse Supports Source #

mkSupports :: YesNo -> NMTOKEN -> Supports Source #

Smart constructor for Supports

data SystemLayout Source #

system-layout (complex)

System layout includes left and right margins and the vertical distance from the previous system. The system distance is measured from the bottom line of the previous system to the top line of the current system. It is ignored for the first system on a page. The top system distance is measured from the page's top margin to the top line of the first system. It is ignored for all but the first system on a page.

Sometimes the sum of measure widths in a system may not equal the system width specified by the layout elements due to roundoff or other errors. The behavior when reading MusicXML files in these cases is application-dependent. For instance, applications may find that the system layout data is more reliable than the sum of the measure widths, and adjust the measure widths accordingly.

Constructors

SystemLayout
Fields systemLayoutSystemMargins :: Maybe SystemMargins system-margins child element systemLayoutSystemDistance :: Maybe Tenths system-distance child element systemLayoutTopSystemDistance :: Maybe Tenths top-system-distance child element

Instances

Eq SystemLayout Source #
Methods (==) :: SystemLayout -> SystemLayout -> Bool # (/=) :: SystemLayout -> SystemLayout -> Bool #
Show SystemLayout Source #
Methods showsPrec :: Int -> SystemLayout -> ShowS # show :: SystemLayout -> String # showList :: [SystemLayout] -> ShowS #
Generic SystemLayout Source #
Associated Types type Rep SystemLayout :: * -> * # Methods from :: SystemLayout -> Rep SystemLayout x # to :: Rep SystemLayout x -> SystemLayout #
EmitXml SystemLayout Source #
Methods emitXml :: SystemLayout -> XmlRep Source #
type Rep SystemLayout Source #
type Rep SystemLayout = D1 * (MetaData "SystemLayout" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "SystemLayout" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "systemLayoutSystemMargins") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe SystemMargins))) ((::) (S1 * (MetaSel (Just Symbol "systemLayoutSystemDistance") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "systemLayoutTopSystemDistance") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))))

parseSystemLayout :: XParse SystemLayout Source #

mkSystemLayout :: SystemLayout Source #

Smart constructor for SystemLayout

data SystemMargins Source #

system-margins (complex)

System margins are relative to the page margins. Positive values indent and negative values reduce the margin size.

Constructors

SystemMargins
Fields systemMarginsLeftRightMargins :: LeftRightMargins

Instances

Eq SystemMargins Source #
Methods (==) :: SystemMargins -> SystemMargins -> Bool # (/=) :: SystemMargins -> SystemMargins -> Bool #
Show SystemMargins Source #
Methods showsPrec :: Int -> SystemMargins -> ShowS # show :: SystemMargins -> String # showList :: [SystemMargins] -> ShowS #
Generic SystemMargins Source #
Associated Types type Rep SystemMargins :: * -> * # Methods from :: SystemMargins -> Rep SystemMargins x # to :: Rep SystemMargins x -> SystemMargins #
EmitXml SystemMargins Source #
Methods emitXml :: SystemMargins -> XmlRep Source #
type Rep SystemMargins Source #
type Rep SystemMargins = D1 * (MetaData "SystemMargins" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "SystemMargins" PrefixI True) (S1 * (MetaSel (Just Symbol "systemMarginsLeftRightMargins") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * LeftRightMargins)))

parseSystemMargins :: XParse SystemMargins Source #

mkSystemMargins :: LeftRightMargins -> SystemMargins Source #

Smart constructor for SystemMargins

data Technical Source #

technical (complex)

Technical indications give performance information for individual instruments.

Constructors

Technical
Fields technicalTechnical :: [ChxTechnical]

Instances

Eq Technical Source #
Methods (==) :: Technical -> Technical -> Bool # (/=) :: Technical -> Technical -> Bool #
Show Technical Source #
Methods showsPrec :: Int -> Technical -> ShowS # show :: Technical -> String # showList :: [Technical] -> ShowS #
Generic Technical Source #
Associated Types type Rep Technical :: * -> * # Methods from :: Technical -> Rep Technical x # to :: Rep Technical x -> Technical #
EmitXml Technical Source #
Methods emitXml :: Technical -> XmlRep Source #
type Rep Technical Source #
type Rep Technical = D1 * (MetaData "Technical" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Technical" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalTechnical") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [ChxTechnical])))

parseTechnical :: XParse Technical Source #

mkTechnical :: Technical Source #

Smart constructor for Technical

data TextElementData Source #

text-element-data (complex)

The text-element-data type represents a syllable or portion of a syllable for lyric text underlay. A hyphen in the string content should only be used for an actual hyphenated word. Language names for text elements come from ISO 639, with optional country subcodes from ISO 3166.

Constructors

TextElementData

Fields

textElementDataString :: String
text content
textElementDataLang :: Maybe Lang
xml:lang attribute
textElementDataFontFamily :: Maybe CommaSeparatedText
font-family attribute
textElementDataFontStyle :: Maybe FontStyle
font-style attribute
textElementDataFontSize :: Maybe FontSize
font-size attribute
textElementDataFontWeight :: Maybe FontWeight
font-weight attribute
textElementDataColor :: Maybe Color
color attribute
textElementDataUnderline :: Maybe NumberOfLines
underline attribute
textElementDataOverline :: Maybe NumberOfLines
overline attribute
textElementDataLineThrough :: Maybe NumberOfLines
line-through attribute
textElementDataRotation :: Maybe RotationDegrees
rotation attribute
textElementDataLetterSpacing :: Maybe NumberOrNormal
letter-spacing attribute
textElementDataDir :: Maybe TextDirection
dir attribute

Instances

Eq TextElementData Source #
Methods (==) :: TextElementData -> TextElementData -> Bool # (/=) :: TextElementData -> TextElementData -> Bool #
Show TextElementData Source #
Methods showsPrec :: Int -> TextElementData -> ShowS # show :: TextElementData -> String # showList :: [TextElementData] -> ShowS #
Generic TextElementData Source #
Associated Types type Rep TextElementData :: * -> * # Methods from :: TextElementData -> Rep TextElementData x # to :: Rep TextElementData x -> TextElementData #
EmitXml TextElementData Source #
Methods emitXml :: TextElementData -> XmlRep Source #
type Rep TextElementData Source #
type Rep TextElementData = D1 * (MetaData "TextElementData" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "TextElementData" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "textElementDataString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) ((::) (S1 * (MetaSel (Just Symbol "textElementDataLang") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Lang))) (S1 * (MetaSel (Just Symbol "textElementDataFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))))) ((::) (S1 * (MetaSel (Just Symbol "textElementDataFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) ((::) (S1 * (MetaSel (Just Symbol "textElementDataFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) (S1 * (MetaSel (Just Symbol "textElementDataFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "textElementDataColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) ((::) (S1 * (MetaSel (Just Symbol "textElementDataUnderline") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOfLines))) (S1 * (MetaSel (Just Symbol "textElementDataOverline") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOfLines))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "textElementDataLineThrough") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOfLines))) (S1 * (MetaSel (Just Symbol "textElementDataRotation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe RotationDegrees)))) ((::) (S1 * (MetaSel (Just Symbol "textElementDataLetterSpacing") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberOrNormal))) (S1 * (MetaSel (Just Symbol "textElementDataDir") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TextDirection))))))))

parseTextElementData :: XParse TextElementData Source #

mkTextElementData :: String -> TextElementData Source #

Smart constructor for TextElementData

data Tie Source #

tie (complex)

The tie element indicates that a tie begins or ends with this note. The tie element indicates sound; the tied element indicates notation.

Constructors

Tie
Fields tieType :: StartStop type attribute

Instances

Eq Tie Source #
Methods (==) :: Tie -> Tie -> Bool # (/=) :: Tie -> Tie -> Bool #
Show Tie Source #
Methods showsPrec :: Int -> Tie -> ShowS # show :: Tie -> String # showList :: [Tie] -> ShowS #
Generic Tie Source #
Associated Types type Rep Tie :: * -> * # Methods from :: Tie -> Rep Tie x # to :: Rep Tie x -> Tie #
EmitXml Tie Source #
Methods emitXml :: Tie -> XmlRep Source #
type Rep Tie Source #
type Rep Tie = D1 * (MetaData "Tie" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Tie" PrefixI True) (S1 * (MetaSel (Just Symbol "tieType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStop)))

parseTie :: XParse Tie Source #

mkTie :: StartStop -> Tie Source #

Smart constructor for Tie

data Tied Source #

tied (complex)

The tied type represents the notated tie. The tie element represents the tie sound.

Constructors

Tied

Fields

tiedType :: StartStop
type attribute
tiedNumber :: Maybe NumberLevel
number attribute
tiedLineType :: Maybe LineType
line-type attribute
tiedDefaultX :: Maybe Tenths
default-x attribute
tiedDefaultY :: Maybe Tenths
default-y attribute
tiedRelativeX :: Maybe Tenths
relative-x attribute
tiedRelativeY :: Maybe Tenths
relative-y attribute
tiedPlacement :: Maybe AboveBelow
placement attribute
tiedOrientation :: Maybe OverUnder
orientation attribute
tiedBezierOffset :: Maybe Divisions
bezier-offset attribute
tiedBezierOffset2 :: Maybe Divisions
bezier-offset2 attribute
tiedBezierX :: Maybe Tenths
bezier-x attribute
tiedBezierY :: Maybe Tenths
bezier-y attribute
tiedBezierX2 :: Maybe Tenths
bezier-x2 attribute
tiedBezierY2 :: Maybe Tenths
bezier-y2 attribute
tiedColor :: Maybe Color
color attribute

Instances

Eq Tied Source #
Methods (==) :: Tied -> Tied -> Bool # (/=) :: Tied -> Tied -> Bool #
Show Tied Source #
Methods showsPrec :: Int -> Tied -> ShowS # show :: Tied -> String # showList :: [Tied] -> ShowS #
Generic Tied Source #
Associated Types type Rep Tied :: * -> * # Methods from :: Tied -> Rep Tied x # to :: Rep Tied x -> Tied #
EmitXml Tied Source #
Methods emitXml :: Tied -> XmlRep Source #
type Rep Tied Source #
type Rep Tied = D1 * (MetaData "Tied" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Tied" PrefixI True) ((::) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "tiedType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStop)) (S1 * (MetaSel (Just Symbol "tiedNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberLevel)))) ((::) (S1 * (MetaSel (Just Symbol "tiedLineType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LineType))) (S1 * (MetaSel (Just Symbol "tiedDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "tiedDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "tiedRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "tiedRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "tiedPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow)))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "tiedOrientation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe OverUnder))) (S1 * (MetaSel (Just Symbol "tiedBezierOffset") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Divisions)))) ((::) (S1 * (MetaSel (Just Symbol "tiedBezierOffset2") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Divisions))) (S1 * (MetaSel (Just Symbol "tiedBezierX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "tiedBezierY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "tiedBezierX2") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "tiedBezierY2") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "tiedColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))))))))

parseTied :: XParse Tied Source #

mkTied :: StartStop -> Tied Source #

Smart constructor for Tied

data Time Source #

time (complex)

Time signatures are represented by the beats element for the numerator and the beat-type element for the denominator. The symbol attribute is used indicate common and cut time symbols as well as a single number display. Multiple pairs of beat and beat-type elements are used for composite time signatures with multiple denominators, such as 24 + 38. A composite such as 3+28 requires only one beatbeat-type pair.

The print-object attribute allows a time signature to be specified but not printed, as is the case for excerpts from the middle of a score. The value is "yes" if not present. The optional number attribute refers to staff numbers within the part. If absent, the time signature applies to all staves in the part.

Constructors

Time

Fields

timeNumber :: Maybe StaffNumber
number attribute
timeSymbol :: Maybe TimeSymbol
symbol attribute
timeDefaultX :: Maybe Tenths
default-x attribute
timeDefaultY :: Maybe Tenths
default-y attribute
timeRelativeX :: Maybe Tenths
relative-x attribute
timeRelativeY :: Maybe Tenths
relative-y attribute
timeFontFamily :: Maybe CommaSeparatedText
font-family attribute
timeFontStyle :: Maybe FontStyle
font-style attribute
timeFontSize :: Maybe FontSize
font-size attribute
timeFontWeight :: Maybe FontWeight
font-weight attribute
timeColor :: Maybe Color
color attribute
timePrintObject :: Maybe YesNo
print-object attribute
timeTime :: ChxTime

Instances

Eq Time Source #
Methods (==) :: Time -> Time -> Bool # (/=) :: Time -> Time -> Bool #
Show Time Source #
Methods showsPrec :: Int -> Time -> ShowS # show :: Time -> String # showList :: [Time] -> ShowS #
Generic Time Source #
Associated Types type Rep Time :: * -> * # Methods from :: Time -> Rep Time x # to :: Rep Time x -> Time #
EmitXml Time Source #
Methods emitXml :: Time -> XmlRep Source #
type Rep Time Source #
type Rep Time = D1 * (MetaData "Time" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Time" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "timeNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StaffNumber))) ((::) (S1 * (MetaSel (Just Symbol "timeSymbol") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TimeSymbol))) (S1 * (MetaSel (Just Symbol "timeDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) (S1 * (MetaSel (Just Symbol "timeDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "timeRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "timeRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "timeFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) ((::) (S1 * (MetaSel (Just Symbol "timeFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "timeFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "timeFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "timeColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))) ((::) (S1 * (MetaSel (Just Symbol "timePrintObject") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "timeTime") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ChxTime)))))))

parseTime :: XParse Time Source #

mkTime :: ChxTime -> Time Source #

Smart constructor for Time

data TimeModification Source #

time-modification (complex)

The time-modification type represents tuplets and other durational changes.

Constructors

TimeModification
Fields timeModificationActualNotes :: NonNegativeInteger actual-notes child element timeModificationNormalNotes :: NonNegativeInteger normal-notes child element timeModificationTimeModification :: Maybe SeqTimeModification

Instances

Eq TimeModification Source #
Methods (==) :: TimeModification -> TimeModification -> Bool # (/=) :: TimeModification -> TimeModification -> Bool #
Show TimeModification Source #
Methods showsPrec :: Int -> TimeModification -> ShowS # show :: TimeModification -> String # showList :: [TimeModification] -> ShowS #
Generic TimeModification Source #
Associated Types type Rep TimeModification :: * -> * # Methods from :: TimeModification -> Rep TimeModification x # to :: Rep TimeModification x -> TimeModification #
EmitXml TimeModification Source #
Methods emitXml :: TimeModification -> XmlRep Source #
type Rep TimeModification Source #
type Rep TimeModification = D1 * (MetaData "TimeModification" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "TimeModification" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "timeModificationActualNotes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NonNegativeInteger)) ((::) (S1 * (MetaSel (Just Symbol "timeModificationNormalNotes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NonNegativeInteger)) (S1 * (MetaSel (Just Symbol "timeModificationTimeModification") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe SeqTimeModification))))))

parseTimeModification :: XParse TimeModification Source #

mkTimeModification :: NonNegativeInteger -> NonNegativeInteger -> TimeModification Source #

Smart constructor for TimeModification

data Transpose Source #

transpose (complex)

The transpose type represents what must be added to a written pitch to get a correct sounding pitch.

Constructors

Transpose
Fields transposeDiatonic :: Maybe Int diatonic child element transposeChromatic :: Semitones chromatic child element transposeOctaveChange :: Maybe Int octave-change child element transposeDouble :: Maybe Empty double child element

Instances

Eq Transpose Source #
Methods (==) :: Transpose -> Transpose -> Bool # (/=) :: Transpose -> Transpose -> Bool #
Show Transpose Source #
Methods showsPrec :: Int -> Transpose -> ShowS # show :: Transpose -> String # showList :: [Transpose] -> ShowS #
Generic Transpose Source #
Associated Types type Rep Transpose :: * -> * # Methods from :: Transpose -> Rep Transpose x # to :: Rep Transpose x -> Transpose #
EmitXml Transpose Source #
Methods emitXml :: Transpose -> XmlRep Source #
type Rep Transpose Source #
type Rep Transpose = D1 * (MetaData "Transpose" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Transpose" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "transposeDiatonic") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Int))) (S1 * (MetaSel (Just Symbol "transposeChromatic") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Semitones))) ((::) (S1 * (MetaSel (Just Symbol "transposeOctaveChange") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Int))) (S1 * (MetaSel (Just Symbol "transposeDouble") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Empty))))))

parseTranspose :: XParse Transpose Source #

mkTranspose :: Semitones -> Transpose Source #

Smart constructor for Transpose

data Tremolo Source #

tremolo (complex)

While using repeater beams was the original method for indicating tremolos, often playback and display are not well-enough integrated in an application to make that feasible. The tremolo ornament can be used to indicate either single-note or double-note tremolos. Single-note tremolos use the single type, while double-note tremolos use the start and stop types. The default is "single" for compatibility with Version 1.1. The text of the element indicates the number of tremolo marks and is an integer from 0 to 6. Note that the number of attached beams is not included in this value, but is represented separately using the beam element.

Constructors

Tremolo

Fields

tremoloTremoloMarks :: TremoloMarks
text content
tremoloType :: Maybe StartStopSingle
type attribute
tremoloDefaultX :: Maybe Tenths
default-x attribute
tremoloDefaultY :: Maybe Tenths
default-y attribute
tremoloRelativeX :: Maybe Tenths
relative-x attribute
tremoloRelativeY :: Maybe Tenths
relative-y attribute
tremoloFontFamily :: Maybe CommaSeparatedText
font-family attribute
tremoloFontStyle :: Maybe FontStyle
font-style attribute
tremoloFontSize :: Maybe FontSize
font-size attribute
tremoloFontWeight :: Maybe FontWeight
font-weight attribute
tremoloColor :: Maybe Color
color attribute
tremoloPlacement :: Maybe AboveBelow
placement attribute

Instances

Eq Tremolo Source #
Methods (==) :: Tremolo -> Tremolo -> Bool # (/=) :: Tremolo -> Tremolo -> Bool #
Show Tremolo Source #
Methods showsPrec :: Int -> Tremolo -> ShowS # show :: Tremolo -> String # showList :: [Tremolo] -> ShowS #
Generic Tremolo Source #
Associated Types type Rep Tremolo :: * -> * # Methods from :: Tremolo -> Rep Tremolo x # to :: Rep Tremolo x -> Tremolo #
EmitXml Tremolo Source #
Methods emitXml :: Tremolo -> XmlRep Source #
type Rep Tremolo Source #
type Rep Tremolo = D1 * (MetaData "Tremolo" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Tremolo" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "tremoloTremoloMarks") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * TremoloMarks)) ((::) (S1 * (MetaSel (Just Symbol "tremoloType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StartStopSingle))) (S1 * (MetaSel (Just Symbol "tremoloDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) (S1 * (MetaSel (Just Symbol "tremoloDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "tremoloRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "tremoloRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "tremoloFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) ((::) (S1 * (MetaSel (Just Symbol "tremoloFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))) (S1 * (MetaSel (Just Symbol "tremoloFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))))) ((::) (S1 * (MetaSel (Just Symbol "tremoloFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) ((::) (S1 * (MetaSel (Just Symbol "tremoloColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "tremoloPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow))))))))

parseTremolo :: XParse Tremolo Source #

mkTremolo :: TremoloMarks -> Tremolo Source #

Smart constructor for Tremolo

data Tuplet Source #

tuplet (complex)

A tuplet element is present when a tuplet is to be displayed graphically, in addition to the sound data provided by the time-modification elements. The number attribute is used to distinguish nested tuplets. The bracket attribute is used to indicate the presence of a bracket. If unspecified, the results are implementation-dependent. The line-shape attribute is used to specify whether the bracket is straight or in the older curved or slurred style. It is straight by default.

Whereas a time-modification element shows how the cumulative, sounding effect of tuplets compare to the written note type, the tuplet element describes how each tuplet is displayed.

The show-number attribute is used to display either the number of actual notes, the number of both actual and normal notes, or neither. It is actual by default. The show-type attribute is used to display either the actual type, both the actual and normal types, or neither. It is none by default.

Constructors

Tuplet

Fields

tupletType :: StartStop
type attribute
tupletNumber :: Maybe NumberLevel
number attribute
tupletBracket :: Maybe YesNo
bracket attribute
tupletShowNumber :: Maybe ShowTuplet
show-number attribute
tupletShowType :: Maybe ShowTuplet
show-type attribute
tupletLineShape :: Maybe LineShape
line-shape attribute
tupletDefaultX :: Maybe Tenths
default-x attribute
tupletDefaultY :: Maybe Tenths
default-y attribute
tupletRelativeX :: Maybe Tenths
relative-x attribute
tupletRelativeY :: Maybe Tenths
relative-y attribute
tupletPlacement :: Maybe AboveBelow
placement attribute
tupletTupletActual :: Maybe TupletPortion
tuplet-actual child element
tupletTupletNormal :: Maybe TupletPortion
tuplet-normal child element

Instances

Eq Tuplet Source #
Methods (==) :: Tuplet -> Tuplet -> Bool # (/=) :: Tuplet -> Tuplet -> Bool #
Show Tuplet Source #
Methods showsPrec :: Int -> Tuplet -> ShowS # show :: Tuplet -> String # showList :: [Tuplet] -> ShowS #
Generic Tuplet Source #
Associated Types type Rep Tuplet :: * -> * # Methods from :: Tuplet -> Rep Tuplet x # to :: Rep Tuplet x -> Tuplet #
EmitXml Tuplet Source #
Methods emitXml :: Tuplet -> XmlRep Source #
type Rep Tuplet Source #
type Rep Tuplet = D1 * (MetaData "Tuplet" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Tuplet" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "tupletType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStop)) ((::) (S1 * (MetaSel (Just Symbol "tupletNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberLevel))) (S1 * (MetaSel (Just Symbol "tupletBracket") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))))) ((::) (S1 * (MetaSel (Just Symbol "tupletShowNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe ShowTuplet))) ((::) (S1 * (MetaSel (Just Symbol "tupletShowType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe ShowTuplet))) (S1 * (MetaSel (Just Symbol "tupletLineShape") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe LineShape)))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "tupletDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) ((::) (S1 * (MetaSel (Just Symbol "tupletDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "tupletRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "tupletRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "tupletPlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow)))) ((::) (S1 * (MetaSel (Just Symbol "tupletTupletActual") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TupletPortion))) (S1 * (MetaSel (Just Symbol "tupletTupletNormal") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TupletPortion))))))))

parseTuplet :: XParse Tuplet Source #

mkTuplet :: StartStop -> Tuplet Source #

Smart constructor for Tuplet

data TupletDot Source #

tuplet-dot (complex)

The tuplet-dot type is used to specify dotted normal tuplet types.

Constructors

TupletDot
Fields tupletDotFontFamily :: Maybe CommaSeparatedText font-family attribute tupletDotFontStyle :: Maybe FontStyle font-style attribute tupletDotFontSize :: Maybe FontSize font-size attribute tupletDotFontWeight :: Maybe FontWeight font-weight attribute tupletDotColor :: Maybe Color color attribute

Instances

Eq TupletDot Source #
Methods (==) :: TupletDot -> TupletDot -> Bool # (/=) :: TupletDot -> TupletDot -> Bool #
Show TupletDot Source #
Methods showsPrec :: Int -> TupletDot -> ShowS # show :: TupletDot -> String # showList :: [TupletDot] -> ShowS #
Generic TupletDot Source #
Associated Types type Rep TupletDot :: * -> * # Methods from :: TupletDot -> Rep TupletDot x # to :: Rep TupletDot x -> TupletDot #
EmitXml TupletDot Source #
Methods emitXml :: TupletDot -> XmlRep Source #
type Rep TupletDot Source #
type Rep TupletDot = D1 * (MetaData "TupletDot" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "TupletDot" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "tupletDotFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "tupletDotFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle)))) ((::) (S1 * (MetaSel (Just Symbol "tupletDotFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "tupletDotFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "tupletDotColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))))

parseTupletDot :: XParse TupletDot Source #

mkTupletDot :: TupletDot Source #

Smart constructor for TupletDot

data TupletNumber Source #

tuplet-number (complex)

The tuplet-number type indicates the number of notes for this portion of the tuplet.

Constructors

TupletNumber
Fields tupletNumberNonNegativeInteger :: NonNegativeInteger text content tupletNumberFontFamily :: Maybe CommaSeparatedText font-family attribute tupletNumberFontStyle :: Maybe FontStyle font-style attribute tupletNumberFontSize :: Maybe FontSize font-size attribute tupletNumberFontWeight :: Maybe FontWeight font-weight attribute tupletNumberColor :: Maybe Color color attribute

Instances

Eq TupletNumber Source #
Methods (==) :: TupletNumber -> TupletNumber -> Bool # (/=) :: TupletNumber -> TupletNumber -> Bool #
Show TupletNumber Source #
Methods showsPrec :: Int -> TupletNumber -> ShowS # show :: TupletNumber -> String # showList :: [TupletNumber] -> ShowS #
Generic TupletNumber Source #
Associated Types type Rep TupletNumber :: * -> * # Methods from :: TupletNumber -> Rep TupletNumber x # to :: Rep TupletNumber x -> TupletNumber #
EmitXml TupletNumber Source #
Methods emitXml :: TupletNumber -> XmlRep Source #
type Rep TupletNumber Source #
type Rep TupletNumber = D1 * (MetaData "TupletNumber" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "TupletNumber" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "tupletNumberNonNegativeInteger") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NonNegativeInteger)) ((::) (S1 * (MetaSel (Just Symbol "tupletNumberFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "tupletNumberFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) (S1 * (MetaSel (Just Symbol "tupletNumberFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "tupletNumberFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "tupletNumberColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))))

parseTupletNumber :: XParse TupletNumber Source #

mkTupletNumber :: NonNegativeInteger -> TupletNumber Source #

Smart constructor for TupletNumber

data TupletPortion Source #

tuplet-portion (complex)

The tuplet-portion type provides optional full control over tuplet specifications. It allows the number and note type (including dots) to be set for the actual and normal portions of a single tuplet. If any of these elements are absent, their values are based on the time-modification element.

Constructors

TupletPortion
Fields tupletPortionTupletNumber :: Maybe TupletNumber tuplet-number child element tupletPortionTupletType :: Maybe TupletType tuplet-type child element tupletPortionTupletDot :: [TupletDot] tuplet-dot child element

Instances

Eq TupletPortion Source #
Methods (==) :: TupletPortion -> TupletPortion -> Bool # (/=) :: TupletPortion -> TupletPortion -> Bool #
Show TupletPortion Source #
Methods showsPrec :: Int -> TupletPortion -> ShowS # show :: TupletPortion -> String # showList :: [TupletPortion] -> ShowS #
Generic TupletPortion Source #
Associated Types type Rep TupletPortion :: * -> * # Methods from :: TupletPortion -> Rep TupletPortion x # to :: Rep TupletPortion x -> TupletPortion #
EmitXml TupletPortion Source #
Methods emitXml :: TupletPortion -> XmlRep Source #
type Rep TupletPortion Source #
type Rep TupletPortion = D1 * (MetaData "TupletPortion" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "TupletPortion" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "tupletPortionTupletNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TupletNumber))) ((::) (S1 * (MetaSel (Just Symbol "tupletPortionTupletType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TupletType))) (S1 * (MetaSel (Just Symbol "tupletPortionTupletDot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [TupletDot])))))

parseTupletPortion :: XParse TupletPortion Source #

mkTupletPortion :: TupletPortion Source #

Smart constructor for TupletPortion

data TupletType Source #

tuplet-type (complex)

The tuplet-type type indicates the graphical note type of the notes for this portion of the tuplet.

Constructors

TupletType
Fields tupletTypeNoteTypeValue :: NoteTypeValue text content tupletTypeFontFamily :: Maybe CommaSeparatedText font-family attribute tupletTypeFontStyle :: Maybe FontStyle font-style attribute tupletTypeFontSize :: Maybe FontSize font-size attribute tupletTypeFontWeight :: Maybe FontWeight font-weight attribute tupletTypeColor :: Maybe Color color attribute

Instances

Eq TupletType Source #
Methods (==) :: TupletType -> TupletType -> Bool # (/=) :: TupletType -> TupletType -> Bool #
Show TupletType Source #
Methods showsPrec :: Int -> TupletType -> ShowS # show :: TupletType -> String # showList :: [TupletType] -> ShowS #
Generic TupletType Source #
Associated Types type Rep TupletType :: * -> * # Methods from :: TupletType -> Rep TupletType x # to :: Rep TupletType x -> TupletType #
EmitXml TupletType Source #
Methods emitXml :: TupletType -> XmlRep Source #
type Rep TupletType Source #
type Rep TupletType = D1 * (MetaData "TupletType" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "TupletType" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "tupletTypeNoteTypeValue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NoteTypeValue)) ((::) (S1 * (MetaSel (Just Symbol "tupletTypeFontFamily") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe CommaSeparatedText))) (S1 * (MetaSel (Just Symbol "tupletTypeFontStyle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontStyle))))) ((::) (S1 * (MetaSel (Just Symbol "tupletTypeFontSize") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontSize))) ((::) (S1 * (MetaSel (Just Symbol "tupletTypeFontWeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe FontWeight))) (S1 * (MetaSel (Just Symbol "tupletTypeColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))))

parseTupletType :: XParse TupletType Source #

mkTupletType :: NoteTypeValue -> TupletType Source #

Smart constructor for TupletType

data TypedText Source #

typed-text (complex)

The typed-text type represents a text element with a type attributes.

Constructors

TypedText
Fields typedTextString :: String text content typedTextType :: Maybe Token type attribute

Instances

Eq TypedText Source #
Methods (==) :: TypedText -> TypedText -> Bool # (/=) :: TypedText -> TypedText -> Bool #
Show TypedText Source #
Methods showsPrec :: Int -> TypedText -> ShowS # show :: TypedText -> String # showList :: [TypedText] -> ShowS #
Generic TypedText Source #
Associated Types type Rep TypedText :: * -> * # Methods from :: TypedText -> Rep TypedText x # to :: Rep TypedText x -> TypedText #
EmitXml TypedText Source #
Methods emitXml :: TypedText -> XmlRep Source #
type Rep TypedText Source #
type Rep TypedText = D1 * (MetaData "TypedText" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "TypedText" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "typedTextString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "typedTextType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Token)))))

parseTypedText :: XParse TypedText Source #

mkTypedText :: String -> TypedText Source #

Smart constructor for TypedText

data WavyLine Source #

wavy-line (complex)

Wavy lines are one way to indicate trills. When used with a measure element, they should always have type="continue" set.

Constructors

WavyLine

Fields

wavyLineType :: StartStopContinue
type attribute
wavyLineNumber :: Maybe NumberLevel
number attribute
wavyLineDefaultX :: Maybe Tenths
default-x attribute
wavyLineDefaultY :: Maybe Tenths
default-y attribute
wavyLineRelativeX :: Maybe Tenths
relative-x attribute
wavyLineRelativeY :: Maybe Tenths
relative-y attribute
wavyLinePlacement :: Maybe AboveBelow
placement attribute
wavyLineColor :: Maybe Color
color attribute
wavyLineStartNote :: Maybe StartNote
start-note attribute
wavyLineTrillStep :: Maybe TrillStep
trill-step attribute
wavyLineTwoNoteTurn :: Maybe TwoNoteTurn
two-note-turn attribute
wavyLineAccelerate :: Maybe YesNo
accelerate attribute
wavyLineBeats :: Maybe TrillBeats
beats attribute
wavyLineSecondBeat :: Maybe Percent
second-beat attribute
wavyLineLastBeat :: Maybe Percent
last-beat attribute

Instances

Eq WavyLine Source #
Methods (==) :: WavyLine -> WavyLine -> Bool # (/=) :: WavyLine -> WavyLine -> Bool #
Show WavyLine Source #
Methods showsPrec :: Int -> WavyLine -> ShowS # show :: WavyLine -> String # showList :: [WavyLine] -> ShowS #
Generic WavyLine Source #
Associated Types type Rep WavyLine :: * -> * # Methods from :: WavyLine -> Rep WavyLine x # to :: Rep WavyLine x -> WavyLine #
EmitXml WavyLine Source #
Methods emitXml :: WavyLine -> XmlRep Source #
type Rep WavyLine Source #
type Rep WavyLine = D1 * (MetaData "WavyLine" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "WavyLine" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "wavyLineType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StartStopContinue)) ((::) (S1 * (MetaSel (Just Symbol "wavyLineNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberLevel))) (S1 * (MetaSel (Just Symbol "wavyLineDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "wavyLineDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "wavyLineRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "wavyLineRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "wavyLinePlacement") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe AboveBelow)))))) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "wavyLineColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color))) (S1 * (MetaSel (Just Symbol "wavyLineStartNote") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe StartNote)))) ((::) (S1 * (MetaSel (Just Symbol "wavyLineTrillStep") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TrillStep))) (S1 * (MetaSel (Just Symbol "wavyLineTwoNoteTurn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TwoNoteTurn))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "wavyLineAccelerate") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe YesNo))) (S1 * (MetaSel (Just Symbol "wavyLineBeats") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe TrillBeats)))) ((::) (S1 * (MetaSel (Just Symbol "wavyLineSecondBeat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Percent))) (S1 * (MetaSel (Just Symbol "wavyLineLastBeat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Percent))))))))

parseWavyLine :: XParse WavyLine Source #

mkWavyLine :: StartStopContinue -> WavyLine Source #

Smart constructor for WavyLine

data Wedge Source #

wedge (complex)

The wedge type represents crescendo and diminuendo wedge symbols. The type attribute is crescendo for the start of a wedge that is closed at the left side, and diminuendo for the start of a wedge that is closed on the right side. Spread values are measured in tenths; those at the start of a crescendo wedge or end of a diminuendo wedge are ignored.

Constructors

Wedge

Fields

wedgeType :: WedgeType
type attribute
wedgeNumber :: Maybe NumberLevel
number attribute
wedgeSpread :: Maybe Tenths
spread attribute
wedgeDefaultX :: Maybe Tenths
default-x attribute
wedgeDefaultY :: Maybe Tenths
default-y attribute
wedgeRelativeX :: Maybe Tenths
relative-x attribute
wedgeRelativeY :: Maybe Tenths
relative-y attribute
wedgeColor :: Maybe Color
color attribute

Instances

Eq Wedge Source #
Methods (==) :: Wedge -> Wedge -> Bool # (/=) :: Wedge -> Wedge -> Bool #
Show Wedge Source #
Methods showsPrec :: Int -> Wedge -> ShowS # show :: Wedge -> String # showList :: [Wedge] -> ShowS #
Generic Wedge Source #
Associated Types type Rep Wedge :: * -> * # Methods from :: Wedge -> Rep Wedge x # to :: Rep Wedge x -> Wedge #
EmitXml Wedge Source #
Methods emitXml :: Wedge -> XmlRep Source #
type Rep Wedge Source #
type Rep Wedge = D1 * (MetaData "Wedge" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Wedge" PrefixI True) ((::) ((::) ((::) (S1 * (MetaSel (Just Symbol "wedgeType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * WedgeType)) (S1 * (MetaSel (Just Symbol "wedgeNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe NumberLevel)))) ((::) (S1 * (MetaSel (Just Symbol "wedgeSpread") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "wedgeDefaultX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "wedgeDefaultY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "wedgeRelativeX") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths)))) ((::) (S1 * (MetaSel (Just Symbol "wedgeRelativeY") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Tenths))) (S1 * (MetaSel (Just Symbol "wedgeColor") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Color)))))))

parseWedge :: XParse Wedge Source #

mkWedge :: WedgeType -> Wedge Source #

Smart constructor for Wedge

data Work Source #

work (complex)

Works are optionally identified by number and title. The work type also may indicate a link to the opus document that composes multiple scores into a collection.

Constructors

Work
Fields workWorkNumber :: Maybe String work-number child element workWorkTitle :: Maybe String work-title child element workOpus :: Maybe Opus opus child element

Instances

Eq Work Source #
Methods (==) :: Work -> Work -> Bool # (/=) :: Work -> Work -> Bool #
Show Work Source #
Methods showsPrec :: Int -> Work -> ShowS # show :: Work -> String # showList :: [Work] -> ShowS #
Generic Work Source #
Associated Types type Rep Work :: * -> * # Methods from :: Work -> Rep Work x # to :: Rep Work x -> Work #
EmitXml Work Source #
Methods emitXml :: Work -> XmlRep Source #
type Rep Work Source #
type Rep Work = D1 * (MetaData "Work" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Work" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "workWorkNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe String))) ((::) (S1 * (MetaSel (Just Symbol "workWorkTitle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe String))) (S1 * (MetaSel (Just Symbol "workOpus") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Opus))))))

parseWork :: XParse Work Source #

mkWork :: Work Source #

Smart constructor for Work

data ChxArticulations Source #

articulations (choice)

Constructors

ArticulationsAccent
Fields articulationsAccent :: EmptyPlacement accent child element
ArticulationsStrongAccent
Fields articulationsStrongAccent :: StrongAccent strong-accent child element
ArticulationsStaccato
Fields articulationsStaccato :: EmptyPlacement staccato child element
ArticulationsTenuto
Fields articulationsTenuto :: EmptyPlacement tenuto child element
ArticulationsDetachedLegato
Fields articulationsDetachedLegato :: EmptyPlacement detached-legato child element
ArticulationsStaccatissimo
Fields articulationsStaccatissimo :: EmptyPlacement staccatissimo child element
ArticulationsSpiccato
Fields articulationsSpiccato :: EmptyPlacement spiccato child element
ArticulationsScoop
Fields articulationsScoop :: EmptyLine scoop child element
ArticulationsPlop
Fields articulationsPlop :: EmptyLine plop child element
ArticulationsDoit
Fields articulationsDoit :: EmptyLine doit child element
ArticulationsFalloff
Fields articulationsFalloff :: EmptyLine falloff child element
ArticulationsBreathMark
Fields articulationsBreathMark :: EmptyPlacement breath-mark child element
ArticulationsCaesura
Fields articulationsCaesura :: EmptyPlacement caesura child element
ArticulationsStress
Fields articulationsStress :: EmptyPlacement stress child element
ArticulationsUnstress
Fields articulationsUnstress :: EmptyPlacement unstress child element
ArticulationsOtherArticulation
Fields articulationsOtherArticulation :: PlacementText other-articulation child element

Instances

Eq ChxArticulations Source #
Methods (==) :: ChxArticulations -> ChxArticulations -> Bool # (/=) :: ChxArticulations -> ChxArticulations -> Bool #
Show ChxArticulations Source #
Methods showsPrec :: Int -> ChxArticulations -> ShowS # show :: ChxArticulations -> String # showList :: [ChxArticulations] -> ShowS #
Generic ChxArticulations Source #
Associated Types type Rep ChxArticulations :: * -> * # Methods from :: ChxArticulations -> Rep ChxArticulations x # to :: Rep ChxArticulations x -> ChxArticulations #
EmitXml ChxArticulations Source #
Methods emitXml :: ChxArticulations -> XmlRep Source #
type Rep ChxArticulations Source #
type Rep ChxArticulations = D1 * (MetaData "ChxArticulations" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "ArticulationsAccent" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsAccent") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement))) (C1 * (MetaCons "ArticulationsStrongAccent" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsStrongAccent") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StrongAccent)))) ((:+:) * (C1 * (MetaCons "ArticulationsStaccato" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsStaccato") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement))) (C1 * (MetaCons "ArticulationsTenuto" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsTenuto") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement))))) ((:+:) * ((:+:) * (C1 * (MetaCons "ArticulationsDetachedLegato" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsDetachedLegato") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement))) (C1 * (MetaCons "ArticulationsStaccatissimo" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsStaccatissimo") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement)))) ((:+:) * (C1 * (MetaCons "ArticulationsSpiccato" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsSpiccato") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement))) (C1 * (MetaCons "ArticulationsScoop" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsScoop") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyLine)))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "ArticulationsPlop" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsPlop") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyLine))) (C1 * (MetaCons "ArticulationsDoit" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsDoit") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyLine)))) ((:+:) * (C1 * (MetaCons "ArticulationsFalloff" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsFalloff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyLine))) (C1 * (MetaCons "ArticulationsBreathMark" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsBreathMark") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement))))) ((:+:) * ((:+:) * (C1 * (MetaCons "ArticulationsCaesura" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsCaesura") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement))) (C1 * (MetaCons "ArticulationsStress" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsStress") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement)))) ((:+:) * (C1 * (MetaCons "ArticulationsUnstress" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsUnstress") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement))) (C1 * (MetaCons "ArticulationsOtherArticulation" PrefixI True) (S1 * (MetaSel (Just Symbol "articulationsOtherArticulation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PlacementText)))))))

parseChxArticulations :: XParse ChxArticulations Source #

mkArticulationsAccent :: EmptyPlacement -> ChxArticulations Source #

Smart constructor for ArticulationsAccent

mkArticulationsStrongAccent :: StrongAccent -> ChxArticulations Source #

Smart constructor for ArticulationsStrongAccent

mkArticulationsStaccato :: EmptyPlacement -> ChxArticulations Source #

Smart constructor for ArticulationsStaccato

mkArticulationsTenuto :: EmptyPlacement -> ChxArticulations Source #

Smart constructor for ArticulationsTenuto

mkArticulationsDetachedLegato :: EmptyPlacement -> ChxArticulations Source #

Smart constructor for ArticulationsDetachedLegato

mkArticulationsStaccatissimo :: EmptyPlacement -> ChxArticulations Source #

Smart constructor for ArticulationsStaccatissimo

mkArticulationsSpiccato :: EmptyPlacement -> ChxArticulations Source #

Smart constructor for ArticulationsSpiccato

mkArticulationsScoop :: EmptyLine -> ChxArticulations Source #

Smart constructor for ArticulationsScoop

mkArticulationsPlop :: EmptyLine -> ChxArticulations Source #

Smart constructor for ArticulationsPlop

mkArticulationsDoit :: EmptyLine -> ChxArticulations Source #

Smart constructor for ArticulationsDoit

mkArticulationsFalloff :: EmptyLine -> ChxArticulations Source #

Smart constructor for ArticulationsFalloff

mkArticulationsBreathMark :: EmptyPlacement -> ChxArticulations Source #

Smart constructor for ArticulationsBreathMark

mkArticulationsCaesura :: EmptyPlacement -> ChxArticulations Source #

Smart constructor for ArticulationsCaesura

mkArticulationsStress :: EmptyPlacement -> ChxArticulations Source #

Smart constructor for ArticulationsStress

mkArticulationsUnstress :: EmptyPlacement -> ChxArticulations Source #

Smart constructor for ArticulationsUnstress

mkArticulationsOtherArticulation :: PlacementText -> ChxArticulations Source #

Smart constructor for ArticulationsOtherArticulation

data ChxBend Source #

bend (choice)

Constructors

BendPreBend
Fields bendPreBend :: Empty pre-bend child element
BendRelease
Fields bendRelease :: Empty release child element

Instances

Eq ChxBend Source #
Methods (==) :: ChxBend -> ChxBend -> Bool # (/=) :: ChxBend -> ChxBend -> Bool #
Show ChxBend Source #
Methods showsPrec :: Int -> ChxBend -> ShowS # show :: ChxBend -> String # showList :: [ChxBend] -> ShowS #
Generic ChxBend Source #
Associated Types type Rep ChxBend :: * -> * # Methods from :: ChxBend -> Rep ChxBend x # to :: Rep ChxBend x -> ChxBend #
EmitXml ChxBend Source #
Methods emitXml :: ChxBend -> XmlRep Source #
type Rep ChxBend Source #
type Rep ChxBend = D1 * (MetaData "ChxBend" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "BendPreBend" PrefixI True) (S1 * (MetaSel (Just Symbol "bendPreBend") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) (C1 * (MetaCons "BendRelease" PrefixI True) (S1 * (MetaSel (Just Symbol "bendRelease") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))))

parseChxBend :: XParse ChxBend Source #

mkBendPreBend :: Empty -> ChxBend Source #

Smart constructor for BendPreBend

mkBendRelease :: Empty -> ChxBend Source #

Smart constructor for BendRelease

data ChxCredit Source #

credit (choice)

Constructors

CreditCreditImage
Fields creditCreditImage :: Image credit-image child element
CreditCreditWords
Fields creditCreditWords :: FormattedText credit-words child element chxcreditCredit :: [SeqCredit]

Instances

Eq ChxCredit Source #
Methods (==) :: ChxCredit -> ChxCredit -> Bool # (/=) :: ChxCredit -> ChxCredit -> Bool #
Show ChxCredit Source #
Methods showsPrec :: Int -> ChxCredit -> ShowS # show :: ChxCredit -> String # showList :: [ChxCredit] -> ShowS #
Generic ChxCredit Source #
Associated Types type Rep ChxCredit :: * -> * # Methods from :: ChxCredit -> Rep ChxCredit x # to :: Rep ChxCredit x -> ChxCredit #
EmitXml ChxCredit Source #
Methods emitXml :: ChxCredit -> XmlRep Source #
type Rep ChxCredit Source #
type Rep ChxCredit = D1 * (MetaData "ChxCredit" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "CreditCreditImage" PrefixI True) (S1 * (MetaSel (Just Symbol "creditCreditImage") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Image))) (C1 * (MetaCons "CreditCreditWords" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "creditCreditWords") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * FormattedText)) (S1 * (MetaSel (Just Symbol "chxcreditCredit") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [SeqCredit])))))

parseChxCredit :: XParse ChxCredit Source #

mkCreditCreditImage :: Image -> ChxCredit Source #

Smart constructor for CreditCreditImage

mkCreditCreditWords :: FormattedText -> ChxCredit Source #

Smart constructor for CreditCreditWords

data ChxDirectionType Source #

direction-type (choice)

Constructors

DirectionTypeRehearsal
Fields directionTypeRehearsal :: [Rehearsal] rehearsal child element
DirectionTypeSegno
Fields directionTypeSegno :: [EmptyPrintStyle] segno child element
DirectionTypeWords
Fields directionTypeWords :: [FormattedText] words child element
DirectionTypeCoda
Fields directionTypeCoda :: [EmptyPrintStyle] coda child element
DirectionTypeWedge
Fields directionTypeWedge :: Wedge wedge child element
DirectionTypeDynamics
Fields directionTypeDynamics :: [Dynamics] dynamics child element
DirectionTypeDashes
Fields directionTypeDashes :: Dashes dashes child element
DirectionTypeBracket
Fields directionTypeBracket :: Bracket bracket child element
DirectionTypePedal
Fields directionTypePedal :: Pedal pedal child element
DirectionTypeMetronome
Fields directionTypeMetronome :: Metronome metronome child element
DirectionTypeOctaveShift
Fields directionTypeOctaveShift :: OctaveShift octave-shift child element
DirectionTypeHarpPedals
Fields directionTypeHarpPedals :: HarpPedals harp-pedals child element
DirectionTypeDamp
Fields directionTypeDamp :: EmptyPrintStyle damp child element
DirectionTypeDampAll
Fields directionTypeDampAll :: EmptyPrintStyle damp-all child element
DirectionTypeEyeglasses
Fields directionTypeEyeglasses :: EmptyPrintStyle eyeglasses child element
DirectionTypeScordatura
Fields directionTypeScordatura :: Scordatura scordatura child element
DirectionTypeImage
Fields directionTypeImage :: Image image child element
DirectionTypeAccordionRegistration
Fields directionTypeAccordionRegistration :: AccordionRegistration accordion-registration child element
DirectionTypeOtherDirection
Fields directionTypeOtherDirection :: OtherDirection other-direction child element

Instances

Eq ChxDirectionType Source #
Methods (==) :: ChxDirectionType -> ChxDirectionType -> Bool # (/=) :: ChxDirectionType -> ChxDirectionType -> Bool #
Show ChxDirectionType Source #
Methods showsPrec :: Int -> ChxDirectionType -> ShowS # show :: ChxDirectionType -> String # showList :: [ChxDirectionType] -> ShowS #
Generic ChxDirectionType Source #
Associated Types type Rep ChxDirectionType :: * -> * # Methods from :: ChxDirectionType -> Rep ChxDirectionType x # to :: Rep ChxDirectionType x -> ChxDirectionType #
EmitXml ChxDirectionType Source #
Methods emitXml :: ChxDirectionType -> XmlRep Source #
type Rep ChxDirectionType Source #
type Rep ChxDirectionType = D1 * (MetaData "ChxDirectionType" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "DirectionTypeRehearsal" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeRehearsal") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Rehearsal]))) (C1 * (MetaCons "DirectionTypeSegno" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeSegno") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [EmptyPrintStyle])))) ((:+:) * (C1 * (MetaCons "DirectionTypeWords" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeWords") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [FormattedText]))) (C1 * (MetaCons "DirectionTypeCoda" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeCoda") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [EmptyPrintStyle]))))) ((:+:) * ((:+:) * (C1 * (MetaCons "DirectionTypeWedge" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeWedge") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Wedge))) (C1 * (MetaCons "DirectionTypeDynamics" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeDynamics") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Dynamics])))) ((:+:) * (C1 * (MetaCons "DirectionTypeDashes" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeDashes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Dashes))) ((:+:) * (C1 * (MetaCons "DirectionTypeBracket" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeBracket") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Bracket))) (C1 * (MetaCons "DirectionTypePedal" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypePedal") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pedal))))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "DirectionTypeMetronome" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeMetronome") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Metronome))) (C1 * (MetaCons "DirectionTypeOctaveShift" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeOctaveShift") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * OctaveShift)))) ((:+:) * (C1 * (MetaCons "DirectionTypeHarpPedals" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeHarpPedals") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * HarpPedals))) ((:+:) * (C1 * (MetaCons "DirectionTypeDamp" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeDamp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPrintStyle))) (C1 * (MetaCons "DirectionTypeDampAll" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeDampAll") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPrintStyle)))))) ((:+:) * ((:+:) * (C1 * (MetaCons "DirectionTypeEyeglasses" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeEyeglasses") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPrintStyle))) (C1 * (MetaCons "DirectionTypeScordatura" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeScordatura") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Scordatura)))) ((:+:) * (C1 * (MetaCons "DirectionTypeImage" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeImage") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Image))) ((:+:) * (C1 * (MetaCons "DirectionTypeAccordionRegistration" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeAccordionRegistration") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * AccordionRegistration))) (C1 * (MetaCons "DirectionTypeOtherDirection" PrefixI True) (S1 * (MetaSel (Just Symbol "directionTypeOtherDirection") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * OtherDirection))))))))

parseChxDirectionType :: XParse ChxDirectionType Source #

mkDirectionTypeRehearsal :: ChxDirectionType Source #

Smart constructor for DirectionTypeRehearsal

mkDirectionTypeSegno :: ChxDirectionType Source #

Smart constructor for DirectionTypeSegno

mkDirectionTypeWords :: ChxDirectionType Source #

Smart constructor for DirectionTypeWords

mkDirectionTypeCoda :: ChxDirectionType Source #

Smart constructor for DirectionTypeCoda

mkDirectionTypeWedge :: Wedge -> ChxDirectionType Source #

Smart constructor for DirectionTypeWedge

mkDirectionTypeDynamics :: ChxDirectionType Source #

Smart constructor for DirectionTypeDynamics

mkDirectionTypeDashes :: Dashes -> ChxDirectionType Source #

Smart constructor for DirectionTypeDashes

mkDirectionTypeBracket :: Bracket -> ChxDirectionType Source #

Smart constructor for DirectionTypeBracket

mkDirectionTypePedal :: Pedal -> ChxDirectionType Source #

Smart constructor for DirectionTypePedal

mkDirectionTypeMetronome :: Metronome -> ChxDirectionType Source #

Smart constructor for DirectionTypeMetronome

mkDirectionTypeOctaveShift :: OctaveShift -> ChxDirectionType Source #

Smart constructor for DirectionTypeOctaveShift

mkDirectionTypeHarpPedals :: HarpPedals -> ChxDirectionType Source #

Smart constructor for DirectionTypeHarpPedals

mkDirectionTypeDamp :: EmptyPrintStyle -> ChxDirectionType Source #

Smart constructor for DirectionTypeDamp

mkDirectionTypeDampAll :: EmptyPrintStyle -> ChxDirectionType Source #

Smart constructor for DirectionTypeDampAll

mkDirectionTypeEyeglasses :: EmptyPrintStyle -> ChxDirectionType Source #

Smart constructor for DirectionTypeEyeglasses

mkDirectionTypeScordatura :: Scordatura -> ChxDirectionType Source #

Smart constructor for DirectionTypeScordatura

mkDirectionTypeImage :: Image -> ChxDirectionType Source #

Smart constructor for DirectionTypeImage

mkDirectionTypeAccordionRegistration :: AccordionRegistration -> ChxDirectionType Source #

Smart constructor for DirectionTypeAccordionRegistration

mkDirectionTypeOtherDirection :: OtherDirection -> ChxDirectionType Source #

Smart constructor for DirectionTypeOtherDirection

data ChxDynamics Source #

dynamics (choice)

Constructors

DynamicsP
Fields dynamicsP :: Empty p child element
DynamicsPp
Fields dynamicsPp :: Empty pp child element
DynamicsPpp
Fields dynamicsPpp :: Empty ppp child element
DynamicsPppp
Fields dynamicsPppp :: Empty pppp child element
DynamicsPpppp
Fields dynamicsPpppp :: Empty ppppp child element
DynamicsPppppp
Fields dynamicsPppppp :: Empty pppppp child element
DynamicsF
Fields dynamicsF :: Empty f child element
DynamicsFf
Fields dynamicsFf :: Empty ff child element
DynamicsFff
Fields dynamicsFff :: Empty fff child element
DynamicsFfff
Fields dynamicsFfff :: Empty ffff child element
DynamicsFffff
Fields dynamicsFffff :: Empty fffff child element
DynamicsFfffff
Fields dynamicsFfffff :: Empty ffffff child element
DynamicsMp
Fields dynamicsMp :: Empty mp child element
DynamicsMf
Fields dynamicsMf :: Empty mf child element
DynamicsSf
Fields dynamicsSf :: Empty sf child element
DynamicsSfp
Fields dynamicsSfp :: Empty sfp child element
DynamicsSfpp
Fields dynamicsSfpp :: Empty sfpp child element
DynamicsFp
Fields dynamicsFp :: Empty fp child element
DynamicsRf
Fields dynamicsRf :: Empty rf child element
DynamicsRfz
Fields dynamicsRfz :: Empty rfz child element
DynamicsSfz
Fields dynamicsSfz :: Empty sfz child element
DynamicsSffz
Fields dynamicsSffz :: Empty sffz child element
DynamicsFz
Fields dynamicsFz :: Empty fz child element
DynamicsOtherDynamics
Fields dynamicsOtherDynamics :: String other-dynamics child element

Instances

Eq ChxDynamics Source #
Methods (==) :: ChxDynamics -> ChxDynamics -> Bool # (/=) :: ChxDynamics -> ChxDynamics -> Bool #
Show ChxDynamics Source #
Methods showsPrec :: Int -> ChxDynamics -> ShowS # show :: ChxDynamics -> String # showList :: [ChxDynamics] -> ShowS #
Generic ChxDynamics Source #
Associated Types type Rep ChxDynamics :: * -> * # Methods from :: ChxDynamics -> Rep ChxDynamics x # to :: Rep ChxDynamics x -> ChxDynamics #
EmitXml ChxDynamics Source #
Methods emitXml :: ChxDynamics -> XmlRep Source #
type Rep ChxDynamics Source #
type Rep ChxDynamics = D1 * (MetaData "ChxDynamics" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "DynamicsP" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsP") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) ((:+:) * (C1 * (MetaCons "DynamicsPp" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsPp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) (C1 * (MetaCons "DynamicsPpp" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsPpp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))))) ((:+:) * (C1 * (MetaCons "DynamicsPppp" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsPppp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) ((:+:) * (C1 * (MetaCons "DynamicsPpppp" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsPpppp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) (C1 * (MetaCons "DynamicsPppppp" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsPppppp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty)))))) ((:+:) * ((:+:) * (C1 * (MetaCons "DynamicsF" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsF") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) ((:+:) * (C1 * (MetaCons "DynamicsFf" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsFf") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) (C1 * (MetaCons "DynamicsFff" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsFff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))))) ((:+:) * (C1 * (MetaCons "DynamicsFfff" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsFfff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) ((:+:) * (C1 * (MetaCons "DynamicsFffff" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsFffff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) (C1 * (MetaCons "DynamicsFfffff" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsFfffff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "DynamicsMp" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsMp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) ((:+:) * (C1 * (MetaCons "DynamicsMf" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsMf") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) (C1 * (MetaCons "DynamicsSf" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsSf") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))))) ((:+:) * (C1 * (MetaCons "DynamicsSfp" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsSfp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) ((:+:) * (C1 * (MetaCons "DynamicsSfpp" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsSfpp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) (C1 * (MetaCons "DynamicsFp" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsFp") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty)))))) ((:+:) * ((:+:) * (C1 * (MetaCons "DynamicsRf" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsRf") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) ((:+:) * (C1 * (MetaCons "DynamicsRfz" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsRfz") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) (C1 * (MetaCons "DynamicsSfz" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsSfz") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))))) ((:+:) * (C1 * (MetaCons "DynamicsSffz" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsSffz") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) ((:+:) * (C1 * (MetaCons "DynamicsFz" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsFz") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) (C1 * (MetaCons "DynamicsOtherDynamics" PrefixI True) (S1 * (MetaSel (Just Symbol "dynamicsOtherDynamics") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String))))))))

parseChxDynamics :: XParse ChxDynamics Source #

mkDynamicsP :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsP

mkDynamicsPp :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsPp

mkDynamicsPpp :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsPpp

mkDynamicsPppp :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsPppp

mkDynamicsPpppp :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsPpppp

mkDynamicsPppppp :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsPppppp

mkDynamicsF :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsF

mkDynamicsFf :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsFf

mkDynamicsFff :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsFff

mkDynamicsFfff :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsFfff

mkDynamicsFffff :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsFffff

mkDynamicsFfffff :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsFfffff

mkDynamicsMp :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsMp

mkDynamicsMf :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsMf

mkDynamicsSf :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsSf

mkDynamicsSfp :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsSfp

mkDynamicsSfpp :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsSfpp

mkDynamicsFp :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsFp

mkDynamicsRf :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsRf

mkDynamicsRfz :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsRfz

mkDynamicsSfz :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsSfz

mkDynamicsSffz :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsSffz

mkDynamicsFz :: Empty -> ChxDynamics Source #

Smart constructor for DynamicsFz

mkDynamicsOtherDynamics :: String -> ChxDynamics Source #

Smart constructor for DynamicsOtherDynamics

data ChxEncoding Source #

encoding (choice)

Constructors

EncodingEncodingDate
Fields encodingEncodingDate :: YyyyMmDd encoding-date child element
EncodingEncoder
Fields encodingEncoder :: TypedText encoder child element
EncodingSoftware
Fields encodingSoftware :: String software child element
EncodingEncodingDescription
Fields encodingEncodingDescription :: String encoding-description child element
EncodingSupports
Fields encodingSupports :: Supports supports child element

Instances

Eq ChxEncoding Source #
Methods (==) :: ChxEncoding -> ChxEncoding -> Bool # (/=) :: ChxEncoding -> ChxEncoding -> Bool #
Show ChxEncoding Source #
Methods showsPrec :: Int -> ChxEncoding -> ShowS # show :: ChxEncoding -> String # showList :: [ChxEncoding] -> ShowS #
Generic ChxEncoding Source #
Associated Types type Rep ChxEncoding :: * -> * # Methods from :: ChxEncoding -> Rep ChxEncoding x # to :: Rep ChxEncoding x -> ChxEncoding #
EmitXml ChxEncoding Source #
Methods emitXml :: ChxEncoding -> XmlRep Source #
type Rep ChxEncoding Source #
type Rep ChxEncoding = D1 * (MetaData "ChxEncoding" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "EncodingEncodingDate" PrefixI True) (S1 * (MetaSel (Just Symbol "encodingEncodingDate") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * YyyyMmDd))) (C1 * (MetaCons "EncodingEncoder" PrefixI True) (S1 * (MetaSel (Just Symbol "encodingEncoder") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * TypedText)))) ((:+:) * (C1 * (MetaCons "EncodingSoftware" PrefixI True) (S1 * (MetaSel (Just Symbol "encodingSoftware") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String))) ((:+:) * (C1 * (MetaCons "EncodingEncodingDescription" PrefixI True) (S1 * (MetaSel (Just Symbol "encodingEncodingDescription") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String))) (C1 * (MetaCons "EncodingSupports" PrefixI True) (S1 * (MetaSel (Just Symbol "encodingSupports") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Supports))))))

parseChxEncoding :: XParse ChxEncoding Source #

mkEncodingEncodingDate :: YyyyMmDd -> ChxEncoding Source #

Smart constructor for EncodingEncodingDate

mkEncodingEncoder :: TypedText -> ChxEncoding Source #

Smart constructor for EncodingEncoder

mkEncodingSoftware :: String -> ChxEncoding Source #

Smart constructor for EncodingSoftware

mkEncodingEncodingDescription :: String -> ChxEncoding Source #

Smart constructor for EncodingEncodingDescription

mkEncodingSupports :: Supports -> ChxEncoding Source #

Smart constructor for EncodingSupports

data FullNote Source #

full-note (choice)

Constructors

FullNotePitch
Fields fullNotePitch :: Pitch pitch child element
FullNoteUnpitched
Fields fullNoteUnpitched :: DisplayStepOctave unpitched child element
FullNoteRest
Fields fullNoteRest :: DisplayStepOctave rest child element

Instances

Eq FullNote Source #
Methods (==) :: FullNote -> FullNote -> Bool # (/=) :: FullNote -> FullNote -> Bool #
Show FullNote Source #
Methods showsPrec :: Int -> FullNote -> ShowS # show :: FullNote -> String # showList :: [FullNote] -> ShowS #
Generic FullNote Source #
Associated Types type Rep FullNote :: * -> * # Methods from :: FullNote -> Rep FullNote x # to :: Rep FullNote x -> FullNote #
EmitXml FullNote Source #
Methods emitXml :: FullNote -> XmlRep Source #
type Rep FullNote Source #
type Rep FullNote = D1 * (MetaData "FullNote" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "FullNotePitch" PrefixI True) (S1 * (MetaSel (Just Symbol "fullNotePitch") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Pitch))) ((:+:) * (C1 * (MetaCons "FullNoteUnpitched" PrefixI True) (S1 * (MetaSel (Just Symbol "fullNoteUnpitched") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * DisplayStepOctave))) (C1 * (MetaCons "FullNoteRest" PrefixI True) (S1 * (MetaSel (Just Symbol "fullNoteRest") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * DisplayStepOctave)))))

parseFullNote :: XParse FullNote Source #

mkFullNotePitch :: Pitch -> FullNote Source #

Smart constructor for FullNotePitch

mkFullNoteUnpitched :: DisplayStepOctave -> FullNote Source #

Smart constructor for FullNoteUnpitched

mkFullNoteRest :: DisplayStepOctave -> FullNote Source #

Smart constructor for FullNoteRest

data ChxHarmonic Source #

harmonic (choice)

Constructors

HarmonicNatural
Fields harmonicNatural :: Empty natural child element
HarmonicArtificial
Fields harmonicArtificial :: Empty artificial child element

Instances

Eq ChxHarmonic Source #
Methods (==) :: ChxHarmonic -> ChxHarmonic -> Bool # (/=) :: ChxHarmonic -> ChxHarmonic -> Bool #
Show ChxHarmonic Source #
Methods showsPrec :: Int -> ChxHarmonic -> ShowS # show :: ChxHarmonic -> String # showList :: [ChxHarmonic] -> ShowS #
Generic ChxHarmonic Source #
Associated Types type Rep ChxHarmonic :: * -> * # Methods from :: ChxHarmonic -> Rep ChxHarmonic x # to :: Rep ChxHarmonic x -> ChxHarmonic #
EmitXml ChxHarmonic Source #
Methods emitXml :: ChxHarmonic -> XmlRep Source #
type Rep ChxHarmonic Source #
type Rep ChxHarmonic = D1 * (MetaData "ChxHarmonic" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "HarmonicNatural" PrefixI True) (S1 * (MetaSel (Just Symbol "harmonicNatural") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) (C1 * (MetaCons "HarmonicArtificial" PrefixI True) (S1 * (MetaSel (Just Symbol "harmonicArtificial") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))))

parseChxHarmonic :: XParse ChxHarmonic Source #

mkHarmonicNatural :: Empty -> ChxHarmonic Source #

Smart constructor for HarmonicNatural

mkHarmonicArtificial :: Empty -> ChxHarmonic Source #

Smart constructor for HarmonicArtificial

data ChxHarmonic1 Source #

harmonic (choice)

Constructors

HarmonicBasePitch
Fields harmonicBasePitch :: Empty base-pitch child element
HarmonicTouchingPitch
Fields harmonicTouchingPitch :: Empty touching-pitch child element
HarmonicSoundingPitch
Fields harmonicSoundingPitch :: Empty sounding-pitch child element

Instances

Eq ChxHarmonic1 Source #
Methods (==) :: ChxHarmonic1 -> ChxHarmonic1 -> Bool # (/=) :: ChxHarmonic1 -> ChxHarmonic1 -> Bool #
Show ChxHarmonic1 Source #
Methods showsPrec :: Int -> ChxHarmonic1 -> ShowS # show :: ChxHarmonic1 -> String # showList :: [ChxHarmonic1] -> ShowS #
Generic ChxHarmonic1 Source #
Associated Types type Rep ChxHarmonic1 :: * -> * # Methods from :: ChxHarmonic1 -> Rep ChxHarmonic1 x # to :: Rep ChxHarmonic1 x -> ChxHarmonic1 #
EmitXml ChxHarmonic1 Source #
Methods emitXml :: ChxHarmonic1 -> XmlRep Source #
type Rep ChxHarmonic1 Source #
type Rep ChxHarmonic1 = D1 * (MetaData "ChxHarmonic1" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "HarmonicBasePitch" PrefixI True) (S1 * (MetaSel (Just Symbol "harmonicBasePitch") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) ((:+:) * (C1 * (MetaCons "HarmonicTouchingPitch" PrefixI True) (S1 * (MetaSel (Just Symbol "harmonicTouchingPitch") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) (C1 * (MetaCons "HarmonicSoundingPitch" PrefixI True) (S1 * (MetaSel (Just Symbol "harmonicSoundingPitch") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty)))))

parseChxHarmonic1 :: XParse ChxHarmonic1 Source #

mkHarmonicBasePitch :: Empty -> ChxHarmonic1 Source #

Smart constructor for HarmonicBasePitch

mkHarmonicTouchingPitch :: Empty -> ChxHarmonic1 Source #

Smart constructor for HarmonicTouchingPitch

mkHarmonicSoundingPitch :: Empty -> ChxHarmonic1 Source #

Smart constructor for HarmonicSoundingPitch

data ChxHarmonyChord Source #

harmony-chord (choice)

Constructors

HarmonyChordRoot
Fields harmonyChordRoot :: Root root child element
HarmonyChordFunction
Fields harmonyChordFunction :: StyleText function child element

Instances

Eq ChxHarmonyChord Source #
Methods (==) :: ChxHarmonyChord -> ChxHarmonyChord -> Bool # (/=) :: ChxHarmonyChord -> ChxHarmonyChord -> Bool #
Show ChxHarmonyChord Source #
Methods showsPrec :: Int -> ChxHarmonyChord -> ShowS # show :: ChxHarmonyChord -> String # showList :: [ChxHarmonyChord] -> ShowS #
Generic ChxHarmonyChord Source #
Associated Types type Rep ChxHarmonyChord :: * -> * # Methods from :: ChxHarmonyChord -> Rep ChxHarmonyChord x # to :: Rep ChxHarmonyChord x -> ChxHarmonyChord #
EmitXml ChxHarmonyChord Source #
Methods emitXml :: ChxHarmonyChord -> XmlRep Source #
type Rep ChxHarmonyChord Source #
type Rep ChxHarmonyChord = D1 * (MetaData "ChxHarmonyChord" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "HarmonyChordRoot" PrefixI True) (S1 * (MetaSel (Just Symbol "harmonyChordRoot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Root))) (C1 * (MetaCons "HarmonyChordFunction" PrefixI True) (S1 * (MetaSel (Just Symbol "harmonyChordFunction") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * StyleText))))

parseChxHarmonyChord :: XParse ChxHarmonyChord Source #

mkHarmonyChordRoot :: Root -> ChxHarmonyChord Source #

Smart constructor for HarmonyChordRoot

mkHarmonyChordFunction :: StyleText -> ChxHarmonyChord Source #

Smart constructor for HarmonyChordFunction

data ChxKey Source #

key (choice)

Constructors

KeyTraditionalKey
Fields keyTraditionalKey :: TraditionalKey
KeyNonTraditionalKey
Fields keyNonTraditionalKey :: [NonTraditionalKey]

Instances

Eq ChxKey Source #
Methods (==) :: ChxKey -> ChxKey -> Bool # (/=) :: ChxKey -> ChxKey -> Bool #
Show ChxKey Source #
Methods showsPrec :: Int -> ChxKey -> ShowS # show :: ChxKey -> String # showList :: [ChxKey] -> ShowS #
Generic ChxKey Source #
Associated Types type Rep ChxKey :: * -> * # Methods from :: ChxKey -> Rep ChxKey x # to :: Rep ChxKey x -> ChxKey #
EmitXml ChxKey Source #
Methods emitXml :: ChxKey -> XmlRep Source #
type Rep ChxKey Source #
type Rep ChxKey = D1 * (MetaData "ChxKey" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "KeyTraditionalKey" PrefixI True) (S1 * (MetaSel (Just Symbol "keyTraditionalKey") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * TraditionalKey))) (C1 * (MetaCons "KeyNonTraditionalKey" PrefixI True) (S1 * (MetaSel (Just Symbol "keyNonTraditionalKey") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [NonTraditionalKey]))))

parseChxKey :: XParse ChxKey Source #

mkKeyTraditionalKey :: TraditionalKey -> ChxKey Source #

Smart constructor for KeyTraditionalKey

mkKeyNonTraditionalKey :: ChxKey Source #

Smart constructor for KeyNonTraditionalKey

data ChxLyric Source #

lyric (choice)

Constructors

LyricSyllabic
Fields lyricSyllabic :: Maybe Syllabic syllabic child element lyricText :: TextElementData text child element chxlyricLyric :: [SeqLyric] lyricExtend :: Maybe Extend extend child element
LyricExtend
Fields lyricExtend1 :: Extend extend child element
LyricLaughing
Fields lyricLaughing :: Empty laughing child element
LyricHumming
Fields lyricHumming :: Empty humming child element

Instances

Eq ChxLyric Source #
Methods (==) :: ChxLyric -> ChxLyric -> Bool # (/=) :: ChxLyric -> ChxLyric -> Bool #
Show ChxLyric Source #
Methods showsPrec :: Int -> ChxLyric -> ShowS # show :: ChxLyric -> String # showList :: [ChxLyric] -> ShowS #
Generic ChxLyric Source #
Associated Types type Rep ChxLyric :: * -> * # Methods from :: ChxLyric -> Rep ChxLyric x # to :: Rep ChxLyric x -> ChxLyric #
EmitXml ChxLyric Source #
Methods emitXml :: ChxLyric -> XmlRep Source #
type Rep ChxLyric Source #
type Rep ChxLyric = D1 * (MetaData "ChxLyric" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "LyricSyllabic" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "lyricSyllabic") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Syllabic))) (S1 * (MetaSel (Just Symbol "lyricText") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * TextElementData))) ((::) (S1 * (MetaSel (Just Symbol "chxlyricLyric") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [SeqLyric])) (S1 * (MetaSel (Just Symbol "lyricExtend") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Extend)))))) (C1 * (MetaCons "LyricExtend" PrefixI True) (S1 * (MetaSel (Just Symbol "lyricExtend1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Extend)))) ((:+:) * (C1 * (MetaCons "LyricLaughing" PrefixI True) (S1 * (MetaSel (Just Symbol "lyricLaughing") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) (C1 * (MetaCons "LyricHumming" PrefixI True) (S1 * (MetaSel (Just Symbol "lyricHumming") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty)))))

parseChxLyric :: XParse ChxLyric Source #

mkLyricSyllabic :: TextElementData -> ChxLyric Source #

Smart constructor for LyricSyllabic

mkLyricExtend :: Extend -> ChxLyric Source #

Smart constructor for LyricExtend

mkLyricLaughing :: Empty -> ChxLyric Source #

Smart constructor for LyricLaughing

mkLyricHumming :: Empty -> ChxLyric Source #

Smart constructor for LyricHumming

data ChxMeasureStyle Source #

measure-style (choice)

Constructors

MeasureStyleMultipleRest
Fields measureStyleMultipleRest :: MultipleRest multiple-rest child element
MeasureStyleMeasureRepeat
Fields measureStyleMeasureRepeat :: MeasureRepeat measure-repeat child element
MeasureStyleBeatRepeat
Fields measureStyleBeatRepeat :: BeatRepeat beat-repeat child element
MeasureStyleSlash
Fields measureStyleSlash :: CmpSlash slash child element

Instances

Eq ChxMeasureStyle Source #
Methods (==) :: ChxMeasureStyle -> ChxMeasureStyle -> Bool # (/=) :: ChxMeasureStyle -> ChxMeasureStyle -> Bool #
Show ChxMeasureStyle Source #
Methods showsPrec :: Int -> ChxMeasureStyle -> ShowS # show :: ChxMeasureStyle -> String # showList :: [ChxMeasureStyle] -> ShowS #
Generic ChxMeasureStyle Source #
Associated Types type Rep ChxMeasureStyle :: * -> * # Methods from :: ChxMeasureStyle -> Rep ChxMeasureStyle x # to :: Rep ChxMeasureStyle x -> ChxMeasureStyle #
EmitXml ChxMeasureStyle Source #
Methods emitXml :: ChxMeasureStyle -> XmlRep Source #
type Rep ChxMeasureStyle Source #
type Rep ChxMeasureStyle = D1 * (MetaData "ChxMeasureStyle" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * (C1 * (MetaCons "MeasureStyleMultipleRest" PrefixI True) (S1 * (MetaSel (Just Symbol "measureStyleMultipleRest") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * MultipleRest))) (C1 * (MetaCons "MeasureStyleMeasureRepeat" PrefixI True) (S1 * (MetaSel (Just Symbol "measureStyleMeasureRepeat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * MeasureRepeat)))) ((:+:) * (C1 * (MetaCons "MeasureStyleBeatRepeat" PrefixI True) (S1 * (MetaSel (Just Symbol "measureStyleBeatRepeat") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * BeatRepeat))) (C1 * (MetaCons "MeasureStyleSlash" PrefixI True) (S1 * (MetaSel (Just Symbol "measureStyleSlash") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * CmpSlash)))))

parseChxMeasureStyle :: XParse ChxMeasureStyle Source #

mkMeasureStyleMultipleRest :: MultipleRest -> ChxMeasureStyle Source #

Smart constructor for MeasureStyleMultipleRest

mkMeasureStyleMeasureRepeat :: MeasureRepeat -> ChxMeasureStyle Source #

Smart constructor for MeasureStyleMeasureRepeat

mkMeasureStyleBeatRepeat :: BeatRepeat -> ChxMeasureStyle Source #

Smart constructor for MeasureStyleBeatRepeat

mkMeasureStyleSlash :: CmpSlash -> ChxMeasureStyle Source #

Smart constructor for MeasureStyleSlash

data ChxMetronome0 Source #

metronome (choice)

Constructors

MetronomePerMinute
Fields metronomePerMinute :: PerMinute per-minute child element
MetronomeBeatUnit
Fields metronomeBeatUnit :: BeatUnit

Instances

Eq ChxMetronome0 Source #
Methods (==) :: ChxMetronome0 -> ChxMetronome0 -> Bool # (/=) :: ChxMetronome0 -> ChxMetronome0 -> Bool #
Show ChxMetronome0 Source #
Methods showsPrec :: Int -> ChxMetronome0 -> ShowS # show :: ChxMetronome0 -> String # showList :: [ChxMetronome0] -> ShowS #
Generic ChxMetronome0 Source #
Associated Types type Rep ChxMetronome0 :: * -> * # Methods from :: ChxMetronome0 -> Rep ChxMetronome0 x # to :: Rep ChxMetronome0 x -> ChxMetronome0 #
EmitXml ChxMetronome0 Source #
Methods emitXml :: ChxMetronome0 -> XmlRep Source #
type Rep ChxMetronome0 Source #
type Rep ChxMetronome0 = D1 * (MetaData "ChxMetronome0" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "MetronomePerMinute" PrefixI True) (S1 * (MetaSel (Just Symbol "metronomePerMinute") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PerMinute))) (C1 * (MetaCons "MetronomeBeatUnit" PrefixI True) (S1 * (MetaSel (Just Symbol "metronomeBeatUnit") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * BeatUnit))))

parseChxMetronome0 :: XParse ChxMetronome0 Source #

mkMetronomePerMinute :: PerMinute -> ChxMetronome0 Source #

Smart constructor for MetronomePerMinute

mkMetronomeBeatUnit :: BeatUnit -> ChxMetronome0 Source #

Smart constructor for MetronomeBeatUnit

data ChxMetronome Source #

metronome (choice)

Constructors

ChxMetronomeBeatUnit
Fields chxmetronomeBeatUnit :: BeatUnit chxmetronomeMetronome :: ChxMetronome0
MetronomeMetronomeNote
Fields metronomeMetronomeNote :: [MetronomeNote] metronome-note child element metronomeMetronome1 :: Maybe SeqMetronome

Instances

Eq ChxMetronome Source #
Methods (==) :: ChxMetronome -> ChxMetronome -> Bool # (/=) :: ChxMetronome -> ChxMetronome -> Bool #
Show ChxMetronome Source #
Methods showsPrec :: Int -> ChxMetronome -> ShowS # show :: ChxMetronome -> String # showList :: [ChxMetronome] -> ShowS #
Generic ChxMetronome Source #
Associated Types type Rep ChxMetronome :: * -> * # Methods from :: ChxMetronome -> Rep ChxMetronome x # to :: Rep ChxMetronome x -> ChxMetronome #
EmitXml ChxMetronome Source #
Methods emitXml :: ChxMetronome -> XmlRep Source #
type Rep ChxMetronome Source #
type Rep ChxMetronome = D1 * (MetaData "ChxMetronome" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "ChxMetronomeBeatUnit" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "chxmetronomeBeatUnit") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * BeatUnit)) (S1 * (MetaSel (Just Symbol "chxmetronomeMetronome") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ChxMetronome0)))) (C1 * (MetaCons "MetronomeMetronomeNote" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "metronomeMetronomeNote") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [MetronomeNote])) (S1 * (MetaSel (Just Symbol "metronomeMetronome1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe SeqMetronome))))))

parseChxMetronome :: XParse ChxMetronome Source #

mkChxMetronomeBeatUnit :: BeatUnit -> ChxMetronome0 -> ChxMetronome Source #

Smart constructor for ChxMetronomeBeatUnit

mkMetronomeMetronomeNote :: ChxMetronome Source #

Smart constructor for MetronomeMetronomeNote

data ChxMusicData Source #

music-data (choice)

Constructors

MusicDataNote
Fields musicDataNote :: Note note child element
MusicDataBackup
Fields musicDataBackup :: Backup backup child element
MusicDataForward
Fields musicDataForward :: Forward forward child element
MusicDataDirection
Fields musicDataDirection :: Direction direction child element
MusicDataAttributes
Fields musicDataAttributes :: Attributes attributes child element
MusicDataHarmony
Fields musicDataHarmony :: Harmony harmony child element
MusicDataFiguredBass
Fields musicDataFiguredBass :: FiguredBass figured-bass child element
MusicDataPrint
Fields musicDataPrint :: Print print child element
MusicDataSound
Fields musicDataSound :: Sound sound child element
MusicDataBarline
Fields musicDataBarline :: Barline barline child element
MusicDataGrouping
Fields musicDataGrouping :: Grouping grouping child element
MusicDataLink
Fields musicDataLink :: Link link child element
MusicDataBookmark
Fields musicDataBookmark :: Bookmark bookmark child element

Instances

Eq ChxMusicData Source #
Methods (==) :: ChxMusicData -> ChxMusicData -> Bool # (/=) :: ChxMusicData -> ChxMusicData -> Bool #
Show ChxMusicData Source #
Methods showsPrec :: Int -> ChxMusicData -> ShowS # show :: ChxMusicData -> String # showList :: [ChxMusicData] -> ShowS #
Generic ChxMusicData Source #
Associated Types type Rep ChxMusicData :: * -> * # Methods from :: ChxMusicData -> Rep ChxMusicData x # to :: Rep ChxMusicData x -> ChxMusicData #
EmitXml ChxMusicData Source #
Methods emitXml :: ChxMusicData -> XmlRep Source #
type Rep ChxMusicData Source #
type Rep ChxMusicData = D1 * (MetaData "ChxMusicData" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "MusicDataNote" PrefixI True) (S1 * (MetaSel (Just Symbol "musicDataNote") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Note))) ((:+:) * (C1 * (MetaCons "MusicDataBackup" PrefixI True) (S1 * (MetaSel (Just Symbol "musicDataBackup") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Backup))) (C1 * (MetaCons "MusicDataForward" PrefixI True) (S1 * (MetaSel (Just Symbol "musicDataForward") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Forward))))) ((:+:) * (C1 * (MetaCons "MusicDataDirection" PrefixI True) (S1 * (MetaSel (Just Symbol "musicDataDirection") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Direction))) ((:+:) * (C1 * (MetaCons "MusicDataAttributes" PrefixI True) (S1 * (MetaSel (Just Symbol "musicDataAttributes") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Attributes))) (C1 * (MetaCons "MusicDataHarmony" PrefixI True) (S1 * (MetaSel (Just Symbol "musicDataHarmony") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Harmony)))))) ((:+:) * ((:+:) * (C1 * (MetaCons "MusicDataFiguredBass" PrefixI True) (S1 * (MetaSel (Just Symbol "musicDataFiguredBass") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * FiguredBass))) ((:+:) * (C1 * (MetaCons "MusicDataPrint" PrefixI True) (S1 * (MetaSel (Just Symbol "musicDataPrint") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Print))) (C1 * (MetaCons "MusicDataSound" PrefixI True) (S1 * (MetaSel (Just Symbol "musicDataSound") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Sound))))) ((:+:) * ((:+:) * (C1 * (MetaCons "MusicDataBarline" PrefixI True) (S1 * (MetaSel (Just Symbol "musicDataBarline") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Barline))) (C1 * (MetaCons "MusicDataGrouping" PrefixI True) (S1 * (MetaSel (Just Symbol "musicDataGrouping") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Grouping)))) ((:+:) * (C1 * (MetaCons "MusicDataLink" PrefixI True) (S1 * (MetaSel (Just Symbol "musicDataLink") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Link))) (C1 * (MetaCons "MusicDataBookmark" PrefixI True) (S1 * (MetaSel (Just Symbol "musicDataBookmark") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Bookmark)))))))

parseChxMusicData :: XParse ChxMusicData Source #

mkMusicDataNote :: Note -> ChxMusicData Source #

Smart constructor for MusicDataNote

mkMusicDataBackup :: Backup -> ChxMusicData Source #

Smart constructor for MusicDataBackup

mkMusicDataForward :: Forward -> ChxMusicData Source #

Smart constructor for MusicDataForward

mkMusicDataDirection :: Direction -> ChxMusicData Source #

Smart constructor for MusicDataDirection

mkMusicDataAttributes :: Attributes -> ChxMusicData Source #

Smart constructor for MusicDataAttributes

mkMusicDataHarmony :: Harmony -> ChxMusicData Source #

Smart constructor for MusicDataHarmony

mkMusicDataFiguredBass :: FiguredBass -> ChxMusicData Source #

Smart constructor for MusicDataFiguredBass

mkMusicDataPrint :: Print -> ChxMusicData Source #

Smart constructor for MusicDataPrint

mkMusicDataSound :: Sound -> ChxMusicData Source #

Smart constructor for MusicDataSound

mkMusicDataBarline :: Barline -> ChxMusicData Source #

Smart constructor for MusicDataBarline

mkMusicDataGrouping :: Grouping -> ChxMusicData Source #

Smart constructor for MusicDataGrouping

mkMusicDataLink :: Link -> ChxMusicData Source #

Smart constructor for MusicDataLink

mkMusicDataBookmark :: Bookmark -> ChxMusicData Source #

Smart constructor for MusicDataBookmark

data ChxNameDisplay Source #

name-display (choice)

Constructors

NameDisplayDisplayText
Fields nameDisplayDisplayText :: FormattedText display-text child element
NameDisplayAccidentalText
Fields nameDisplayAccidentalText :: AccidentalText accidental-text child element

Instances

Eq ChxNameDisplay Source #
Methods (==) :: ChxNameDisplay -> ChxNameDisplay -> Bool # (/=) :: ChxNameDisplay -> ChxNameDisplay -> Bool #
Show ChxNameDisplay Source #
Methods showsPrec :: Int -> ChxNameDisplay -> ShowS # show :: ChxNameDisplay -> String # showList :: [ChxNameDisplay] -> ShowS #
Generic ChxNameDisplay Source #
Associated Types type Rep ChxNameDisplay :: * -> * # Methods from :: ChxNameDisplay -> Rep ChxNameDisplay x # to :: Rep ChxNameDisplay x -> ChxNameDisplay #
EmitXml ChxNameDisplay Source #
Methods emitXml :: ChxNameDisplay -> XmlRep Source #
type Rep ChxNameDisplay Source #
type Rep ChxNameDisplay = D1 * (MetaData "ChxNameDisplay" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "NameDisplayDisplayText" PrefixI True) (S1 * (MetaSel (Just Symbol "nameDisplayDisplayText") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * FormattedText))) (C1 * (MetaCons "NameDisplayAccidentalText" PrefixI True) (S1 * (MetaSel (Just Symbol "nameDisplayAccidentalText") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * AccidentalText))))

parseChxNameDisplay :: XParse ChxNameDisplay Source #

mkNameDisplayDisplayText :: FormattedText -> ChxNameDisplay Source #

Smart constructor for NameDisplayDisplayText

mkNameDisplayAccidentalText :: AccidentalText -> ChxNameDisplay Source #

Smart constructor for NameDisplayAccidentalText

data ChxNotations Source #

notations (choice)

Constructors

NotationsTied
Fields notationsTied :: Tied tied child element
NotationsSlur
Fields notationsSlur :: Slur slur child element
NotationsTuplet
Fields notationsTuplet :: Tuplet tuplet child element
NotationsGlissando
Fields notationsGlissando :: Glissando glissando child element
NotationsSlide
Fields notationsSlide :: Slide slide child element
NotationsOrnaments
Fields notationsOrnaments :: Ornaments ornaments child element
NotationsTechnical
Fields notationsTechnical :: Technical technical child element
NotationsArticulations
Fields notationsArticulations :: Articulations articulations child element
NotationsDynamics
Fields notationsDynamics :: Dynamics dynamics child element
NotationsFermata
Fields notationsFermata :: Fermata fermata child element
NotationsArpeggiate
Fields notationsArpeggiate :: Arpeggiate arpeggiate child element
NotationsNonArpeggiate
Fields notationsNonArpeggiate :: NonArpeggiate non-arpeggiate child element
NotationsAccidentalMark
Fields notationsAccidentalMark :: AccidentalMark accidental-mark child element
NotationsOtherNotation
Fields notationsOtherNotation :: OtherNotation other-notation child element

Instances

Eq ChxNotations Source #
Methods (==) :: ChxNotations -> ChxNotations -> Bool # (/=) :: ChxNotations -> ChxNotations -> Bool #
Show ChxNotations Source #
Methods showsPrec :: Int -> ChxNotations -> ShowS # show :: ChxNotations -> String # showList :: [ChxNotations] -> ShowS #
Generic ChxNotations Source #
Associated Types type Rep ChxNotations :: * -> * # Methods from :: ChxNotations -> Rep ChxNotations x # to :: Rep ChxNotations x -> ChxNotations #
EmitXml ChxNotations Source #
Methods emitXml :: ChxNotations -> XmlRep Source #
type Rep ChxNotations Source #
type Rep ChxNotations = D1 * (MetaData "ChxNotations" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "NotationsTied" PrefixI True) (S1 * (MetaSel (Just Symbol "notationsTied") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Tied))) ((:+:) * (C1 * (MetaCons "NotationsSlur" PrefixI True) (S1 * (MetaSel (Just Symbol "notationsSlur") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Slur))) (C1 * (MetaCons "NotationsTuplet" PrefixI True) (S1 * (MetaSel (Just Symbol "notationsTuplet") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Tuplet))))) ((:+:) * ((:+:) * (C1 * (MetaCons "NotationsGlissando" PrefixI True) (S1 * (MetaSel (Just Symbol "notationsGlissando") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Glissando))) (C1 * (MetaCons "NotationsSlide" PrefixI True) (S1 * (MetaSel (Just Symbol "notationsSlide") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Slide)))) ((:+:) * (C1 * (MetaCons "NotationsOrnaments" PrefixI True) (S1 * (MetaSel (Just Symbol "notationsOrnaments") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Ornaments))) (C1 * (MetaCons "NotationsTechnical" PrefixI True) (S1 * (MetaSel (Just Symbol "notationsTechnical") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Technical)))))) ((:+:) * ((:+:) * (C1 * (MetaCons "NotationsArticulations" PrefixI True) (S1 * (MetaSel (Just Symbol "notationsArticulations") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Articulations))) ((:+:) * (C1 * (MetaCons "NotationsDynamics" PrefixI True) (S1 * (MetaSel (Just Symbol "notationsDynamics") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Dynamics))) (C1 * (MetaCons "NotationsFermata" PrefixI True) (S1 * (MetaSel (Just Symbol "notationsFermata") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Fermata))))) ((:+:) * ((:+:) * (C1 * (MetaCons "NotationsArpeggiate" PrefixI True) (S1 * (MetaSel (Just Symbol "notationsArpeggiate") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Arpeggiate))) (C1 * (MetaCons "NotationsNonArpeggiate" PrefixI True) (S1 * (MetaSel (Just Symbol "notationsNonArpeggiate") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NonArpeggiate)))) ((:+:) * (C1 * (MetaCons "NotationsAccidentalMark" PrefixI True) (S1 * (MetaSel (Just Symbol "notationsAccidentalMark") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * AccidentalMark))) (C1 * (MetaCons "NotationsOtherNotation" PrefixI True) (S1 * (MetaSel (Just Symbol "notationsOtherNotation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * OtherNotation)))))))

parseChxNotations :: XParse ChxNotations Source #

mkNotationsTied :: Tied -> ChxNotations Source #

Smart constructor for NotationsTied

mkNotationsSlur :: Slur -> ChxNotations Source #

Smart constructor for NotationsSlur

mkNotationsTuplet :: Tuplet -> ChxNotations Source #

Smart constructor for NotationsTuplet

mkNotationsGlissando :: Glissando -> ChxNotations Source #

Smart constructor for NotationsGlissando

mkNotationsSlide :: Slide -> ChxNotations Source #

Smart constructor for NotationsSlide

mkNotationsOrnaments :: Ornaments -> ChxNotations Source #

Smart constructor for NotationsOrnaments

mkNotationsTechnical :: Technical -> ChxNotations Source #

Smart constructor for NotationsTechnical

mkNotationsArticulations :: Articulations -> ChxNotations Source #

Smart constructor for NotationsArticulations

mkNotationsDynamics :: Dynamics -> ChxNotations Source #

Smart constructor for NotationsDynamics

mkNotationsFermata :: Fermata -> ChxNotations Source #

Smart constructor for NotationsFermata

mkNotationsArpeggiate :: Arpeggiate -> ChxNotations Source #

Smart constructor for NotationsArpeggiate

mkNotationsNonArpeggiate :: NonArpeggiate -> ChxNotations Source #

Smart constructor for NotationsNonArpeggiate

mkNotationsAccidentalMark :: AccidentalMark -> ChxNotations Source #

Smart constructor for NotationsAccidentalMark

mkNotationsOtherNotation :: OtherNotation -> ChxNotations Source #

Smart constructor for NotationsOtherNotation

data ChxNote Source #

note (choice)

Constructors

NoteGrace
Fields noteGrace :: Grace grace child element noteFullNote :: GrpFullNote noteTie :: [Tie] tie child element
NoteCue
Fields noteCue :: Empty cue child element noteFullNote1 :: GrpFullNote noteDuration :: Duration
NoteFullNote
Fields noteFullNote2 :: GrpFullNote noteDuration1 :: Duration noteTie1 :: [Tie] tie child element

Instances

Eq ChxNote Source #
Methods (==) :: ChxNote -> ChxNote -> Bool # (/=) :: ChxNote -> ChxNote -> Bool #
Show ChxNote Source #
Methods showsPrec :: Int -> ChxNote -> ShowS # show :: ChxNote -> String # showList :: [ChxNote] -> ShowS #
Generic ChxNote Source #
Associated Types type Rep ChxNote :: * -> * # Methods from :: ChxNote -> Rep ChxNote x # to :: Rep ChxNote x -> ChxNote #
EmitXml ChxNote Source #
Methods emitXml :: ChxNote -> XmlRep Source #
type Rep ChxNote Source #
type Rep ChxNote = D1 * (MetaData "ChxNote" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "NoteGrace" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "noteGrace") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Grace)) ((::) (S1 * (MetaSel (Just Symbol "noteFullNote") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * GrpFullNote)) (S1 * (MetaSel (Just Symbol "noteTie") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Tie]))))) ((:+:) * (C1 * (MetaCons "NoteCue" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "noteCue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty)) ((::) (S1 * (MetaSel (Just Symbol "noteFullNote1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * GrpFullNote)) (S1 * (MetaSel (Just Symbol "noteDuration") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Duration))))) (C1 * (MetaCons "NoteFullNote" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "noteFullNote2") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * GrpFullNote)) ((::) (S1 * (MetaSel (Just Symbol "noteDuration1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Duration)) (S1 * (MetaSel (Just Symbol "noteTie1") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Tie])))))))

parseChxNote :: XParse ChxNote Source #

mkNoteGrace :: Grace -> GrpFullNote -> ChxNote Source #

Smart constructor for NoteGrace

mkNoteCue :: Empty -> GrpFullNote -> Duration -> ChxNote Source #

Smart constructor for NoteCue

mkNoteFullNote :: GrpFullNote -> Duration -> ChxNote Source #

Smart constructor for NoteFullNote

data ChxOrnaments Source #

ornaments (choice)

Constructors

OrnamentsTrillMark
Fields ornamentsTrillMark :: EmptyTrillSound trill-mark child element
OrnamentsTurn
Fields ornamentsTurn :: EmptyTrillSound turn child element
OrnamentsDelayedTurn
Fields ornamentsDelayedTurn :: EmptyTrillSound delayed-turn child element
OrnamentsInvertedTurn
Fields ornamentsInvertedTurn :: EmptyTrillSound inverted-turn child element
OrnamentsShake
Fields ornamentsShake :: EmptyTrillSound shake child element
OrnamentsWavyLine
Fields ornamentsWavyLine :: WavyLine wavy-line child element
OrnamentsMordent
Fields ornamentsMordent :: Mordent mordent child element
OrnamentsInvertedMordent
Fields ornamentsInvertedMordent :: Mordent inverted-mordent child element
OrnamentsSchleifer
Fields ornamentsSchleifer :: EmptyPlacement schleifer child element
OrnamentsTremolo
Fields ornamentsTremolo :: Tremolo tremolo child element
OrnamentsOtherOrnament
Fields ornamentsOtherOrnament :: PlacementText other-ornament child element

Instances

Eq ChxOrnaments Source #
Methods (==) :: ChxOrnaments -> ChxOrnaments -> Bool # (/=) :: ChxOrnaments -> ChxOrnaments -> Bool #
Show ChxOrnaments Source #
Methods showsPrec :: Int -> ChxOrnaments -> ShowS # show :: ChxOrnaments -> String # showList :: [ChxOrnaments] -> ShowS #
Generic ChxOrnaments Source #
Associated Types type Rep ChxOrnaments :: * -> * # Methods from :: ChxOrnaments -> Rep ChxOrnaments x # to :: Rep ChxOrnaments x -> ChxOrnaments #
EmitXml ChxOrnaments Source #
Methods emitXml :: ChxOrnaments -> XmlRep Source #
type Rep ChxOrnaments Source #
type Rep ChxOrnaments = D1 * (MetaData "ChxOrnaments" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "OrnamentsTrillMark" PrefixI True) (S1 * (MetaSel (Just Symbol "ornamentsTrillMark") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyTrillSound))) (C1 * (MetaCons "OrnamentsTurn" PrefixI True) (S1 * (MetaSel (Just Symbol "ornamentsTurn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyTrillSound)))) ((:+:) * (C1 * (MetaCons "OrnamentsDelayedTurn" PrefixI True) (S1 * (MetaSel (Just Symbol "ornamentsDelayedTurn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyTrillSound))) ((:+:) * (C1 * (MetaCons "OrnamentsInvertedTurn" PrefixI True) (S1 * (MetaSel (Just Symbol "ornamentsInvertedTurn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyTrillSound))) (C1 * (MetaCons "OrnamentsShake" PrefixI True) (S1 * (MetaSel (Just Symbol "ornamentsShake") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyTrillSound)))))) ((:+:) * ((:+:) * (C1 * (MetaCons "OrnamentsWavyLine" PrefixI True) (S1 * (MetaSel (Just Symbol "ornamentsWavyLine") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * WavyLine))) ((:+:) * (C1 * (MetaCons "OrnamentsMordent" PrefixI True) (S1 * (MetaSel (Just Symbol "ornamentsMordent") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Mordent))) (C1 * (MetaCons "OrnamentsInvertedMordent" PrefixI True) (S1 * (MetaSel (Just Symbol "ornamentsInvertedMordent") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Mordent))))) ((:+:) * (C1 * (MetaCons "OrnamentsSchleifer" PrefixI True) (S1 * (MetaSel (Just Symbol "ornamentsSchleifer") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement))) ((:+:) * (C1 * (MetaCons "OrnamentsTremolo" PrefixI True) (S1 * (MetaSel (Just Symbol "ornamentsTremolo") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Tremolo))) (C1 * (MetaCons "OrnamentsOtherOrnament" PrefixI True) (S1 * (MetaSel (Just Symbol "ornamentsOtherOrnament") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PlacementText)))))))

parseChxOrnaments :: XParse ChxOrnaments Source #

mkOrnamentsTrillMark :: EmptyTrillSound -> ChxOrnaments Source #

Smart constructor for OrnamentsTrillMark

mkOrnamentsTurn :: EmptyTrillSound -> ChxOrnaments Source #

Smart constructor for OrnamentsTurn

mkOrnamentsDelayedTurn :: EmptyTrillSound -> ChxOrnaments Source #

Smart constructor for OrnamentsDelayedTurn

mkOrnamentsInvertedTurn :: EmptyTrillSound -> ChxOrnaments Source #

Smart constructor for OrnamentsInvertedTurn

mkOrnamentsShake :: EmptyTrillSound -> ChxOrnaments Source #

Smart constructor for OrnamentsShake

mkOrnamentsWavyLine :: WavyLine -> ChxOrnaments Source #

Smart constructor for OrnamentsWavyLine

mkOrnamentsMordent :: Mordent -> ChxOrnaments Source #

Smart constructor for OrnamentsMordent

mkOrnamentsInvertedMordent :: Mordent -> ChxOrnaments Source #

Smart constructor for OrnamentsInvertedMordent

mkOrnamentsSchleifer :: EmptyPlacement -> ChxOrnaments Source #

Smart constructor for OrnamentsSchleifer

mkOrnamentsTremolo :: Tremolo -> ChxOrnaments Source #

Smart constructor for OrnamentsTremolo

mkOrnamentsOtherOrnament :: PlacementText -> ChxOrnaments Source #

Smart constructor for OrnamentsOtherOrnament

data ChxPartList Source #

part-list (choice)

Constructors

PartListPartGroup
Fields chxpartListPartGroup :: GrpPartGroup
PartListScorePart
Fields chxpartListScorePart :: ScorePart

Instances

Eq ChxPartList Source #
Methods (==) :: ChxPartList -> ChxPartList -> Bool # (/=) :: ChxPartList -> ChxPartList -> Bool #
Show ChxPartList Source #
Methods showsPrec :: Int -> ChxPartList -> ShowS # show :: ChxPartList -> String # showList :: [ChxPartList] -> ShowS #
Generic ChxPartList Source #
Associated Types type Rep ChxPartList :: * -> * # Methods from :: ChxPartList -> Rep ChxPartList x # to :: Rep ChxPartList x -> ChxPartList #
EmitXml ChxPartList Source #
Methods emitXml :: ChxPartList -> XmlRep Source #
type Rep ChxPartList Source #
type Rep ChxPartList = D1 * (MetaData "ChxPartList" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "PartListPartGroup" PrefixI True) (S1 * (MetaSel (Just Symbol "chxpartListPartGroup") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * GrpPartGroup))) (C1 * (MetaCons "PartListScorePart" PrefixI True) (S1 * (MetaSel (Just Symbol "chxpartListScorePart") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ScorePart))))

parseChxPartList :: XParse ChxPartList Source #

mkPartListPartGroup :: GrpPartGroup -> ChxPartList Source #

Smart constructor for PartListPartGroup

mkPartListScorePart :: ScorePart -> ChxPartList Source #

Smart constructor for PartListScorePart

data ChxScoreInstrument Source #

score-instrument (choice)

Constructors

ScoreInstrumentSolo
Fields scoreInstrumentSolo :: Empty solo child element
ScoreInstrumentEnsemble
Fields scoreInstrumentEnsemble :: PositiveIntegerOrEmpty ensemble child element

Instances

Eq ChxScoreInstrument Source #
Methods (==) :: ChxScoreInstrument -> ChxScoreInstrument -> Bool # (/=) :: ChxScoreInstrument -> ChxScoreInstrument -> Bool #
Show ChxScoreInstrument Source #
Methods showsPrec :: Int -> ChxScoreInstrument -> ShowS # show :: ChxScoreInstrument -> String # showList :: [ChxScoreInstrument] -> ShowS #
Generic ChxScoreInstrument Source #
Associated Types type Rep ChxScoreInstrument :: * -> * # Methods from :: ChxScoreInstrument -> Rep ChxScoreInstrument x # to :: Rep ChxScoreInstrument x -> ChxScoreInstrument #
EmitXml ChxScoreInstrument Source #
Methods emitXml :: ChxScoreInstrument -> XmlRep Source #
type Rep ChxScoreInstrument Source #
type Rep ChxScoreInstrument = D1 * (MetaData "ChxScoreInstrument" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "ScoreInstrumentSolo" PrefixI True) (S1 * (MetaSel (Just Symbol "scoreInstrumentSolo") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))) (C1 * (MetaCons "ScoreInstrumentEnsemble" PrefixI True) (S1 * (MetaSel (Just Symbol "scoreInstrumentEnsemble") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveIntegerOrEmpty))))

parseChxScoreInstrument :: XParse ChxScoreInstrument Source #

mkScoreInstrumentSolo :: Empty -> ChxScoreInstrument Source #

Smart constructor for ScoreInstrumentSolo

mkScoreInstrumentEnsemble :: PositiveIntegerOrEmpty -> ChxScoreInstrument Source #

Smart constructor for ScoreInstrumentEnsemble

data ChxTechnical Source #

technical (choice)

Constructors

TechnicalUpBow
Fields technicalUpBow :: EmptyPlacement up-bow child element
TechnicalDownBow
Fields technicalDownBow :: EmptyPlacement down-bow child element
TechnicalHarmonic
Fields technicalHarmonic :: Harmonic harmonic child element
TechnicalOpenString
Fields technicalOpenString :: EmptyPlacement open-string child element
TechnicalThumbPosition
Fields technicalThumbPosition :: EmptyPlacement thumb-position child element
TechnicalFingering
Fields technicalFingering :: Fingering fingering child element
TechnicalPluck
Fields technicalPluck :: PlacementText pluck child element
TechnicalDoubleTongue
Fields technicalDoubleTongue :: EmptyPlacement double-tongue child element
TechnicalTripleTongue
Fields technicalTripleTongue :: EmptyPlacement triple-tongue child element
TechnicalStopped
Fields technicalStopped :: EmptyPlacement stopped child element
TechnicalSnapPizzicato
Fields technicalSnapPizzicato :: EmptyPlacement snap-pizzicato child element
TechnicalFret
Fields technicalFret :: Fret fret child element
TechnicalString
Fields technicalString :: CmpString string child element
TechnicalHammerOn
Fields technicalHammerOn :: HammerOnPullOff hammer-on child element
TechnicalPullOff
Fields technicalPullOff :: HammerOnPullOff pull-off child element
TechnicalBend
Fields technicalBend :: Bend bend child element
TechnicalTap
Fields technicalTap :: PlacementText tap child element
TechnicalHeel
Fields technicalHeel :: HeelToe heel child element
TechnicalToe
Fields technicalToe :: HeelToe toe child element
TechnicalFingernails
Fields technicalFingernails :: EmptyPlacement fingernails child element
TechnicalOtherTechnical
Fields technicalOtherTechnical :: PlacementText other-technical child element

Instances

Eq ChxTechnical Source #
Methods (==) :: ChxTechnical -> ChxTechnical -> Bool # (/=) :: ChxTechnical -> ChxTechnical -> Bool #
Show ChxTechnical Source #
Methods showsPrec :: Int -> ChxTechnical -> ShowS # show :: ChxTechnical -> String # showList :: [ChxTechnical] -> ShowS #
Generic ChxTechnical Source #
Associated Types type Rep ChxTechnical :: * -> * # Methods from :: ChxTechnical -> Rep ChxTechnical x # to :: Rep ChxTechnical x -> ChxTechnical #
EmitXml ChxTechnical Source #
Methods emitXml :: ChxTechnical -> XmlRep Source #
type Rep ChxTechnical Source #
type Rep ChxTechnical = D1 * (MetaData "ChxTechnical" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "TechnicalUpBow" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalUpBow") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement))) (C1 * (MetaCons "TechnicalDownBow" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalDownBow") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement)))) ((:+:) * (C1 * (MetaCons "TechnicalHarmonic" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalHarmonic") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Harmonic))) ((:+:) * (C1 * (MetaCons "TechnicalOpenString" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalOpenString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement))) (C1 * (MetaCons "TechnicalThumbPosition" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalThumbPosition") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement)))))) ((:+:) * ((:+:) * (C1 * (MetaCons "TechnicalFingering" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalFingering") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Fingering))) (C1 * (MetaCons "TechnicalPluck" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalPluck") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PlacementText)))) ((:+:) * (C1 * (MetaCons "TechnicalDoubleTongue" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalDoubleTongue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement))) ((:+:) * (C1 * (MetaCons "TechnicalTripleTongue" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalTripleTongue") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement))) (C1 * (MetaCons "TechnicalStopped" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalStopped") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement))))))) ((:+:) * ((:+:) * ((:+:) * (C1 * (MetaCons "TechnicalSnapPizzicato" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalSnapPizzicato") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement))) (C1 * (MetaCons "TechnicalFret" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalFret") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Fret)))) ((:+:) * (C1 * (MetaCons "TechnicalString" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalString") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * CmpString))) ((:+:) * (C1 * (MetaCons "TechnicalHammerOn" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalHammerOn") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * HammerOnPullOff))) (C1 * (MetaCons "TechnicalPullOff" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalPullOff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * HammerOnPullOff)))))) ((:+:) * ((:+:) * (C1 * (MetaCons "TechnicalBend" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalBend") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Bend))) ((:+:) * (C1 * (MetaCons "TechnicalTap" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalTap") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PlacementText))) (C1 * (MetaCons "TechnicalHeel" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalHeel") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * HeelToe))))) ((:+:) * (C1 * (MetaCons "TechnicalToe" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalToe") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * HeelToe))) ((:+:) * (C1 * (MetaCons "TechnicalFingernails" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalFingernails") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * EmptyPlacement))) (C1 * (MetaCons "TechnicalOtherTechnical" PrefixI True) (S1 * (MetaSel (Just Symbol "technicalOtherTechnical") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PlacementText))))))))

parseChxTechnical :: XParse ChxTechnical Source #

mkTechnicalUpBow :: EmptyPlacement -> ChxTechnical Source #

Smart constructor for TechnicalUpBow

mkTechnicalDownBow :: EmptyPlacement -> ChxTechnical Source #

Smart constructor for TechnicalDownBow

mkTechnicalHarmonic :: Harmonic -> ChxTechnical Source #

Smart constructor for TechnicalHarmonic

mkTechnicalOpenString :: EmptyPlacement -> ChxTechnical Source #

Smart constructor for TechnicalOpenString

mkTechnicalThumbPosition :: EmptyPlacement -> ChxTechnical Source #

Smart constructor for TechnicalThumbPosition

mkTechnicalFingering :: Fingering -> ChxTechnical Source #

Smart constructor for TechnicalFingering

mkTechnicalPluck :: PlacementText -> ChxTechnical Source #

Smart constructor for TechnicalPluck

mkTechnicalDoubleTongue :: EmptyPlacement -> ChxTechnical Source #

Smart constructor for TechnicalDoubleTongue

mkTechnicalTripleTongue :: EmptyPlacement -> ChxTechnical Source #

Smart constructor for TechnicalTripleTongue

mkTechnicalStopped :: EmptyPlacement -> ChxTechnical Source #

Smart constructor for TechnicalStopped

mkTechnicalSnapPizzicato :: EmptyPlacement -> ChxTechnical Source #

Smart constructor for TechnicalSnapPizzicato

mkTechnicalFret :: Fret -> ChxTechnical Source #

Smart constructor for TechnicalFret

mkTechnicalString :: CmpString -> ChxTechnical Source #

Smart constructor for TechnicalString

mkTechnicalHammerOn :: HammerOnPullOff -> ChxTechnical Source #

Smart constructor for TechnicalHammerOn

mkTechnicalPullOff :: HammerOnPullOff -> ChxTechnical Source #

Smart constructor for TechnicalPullOff

mkTechnicalBend :: Bend -> ChxTechnical Source #

Smart constructor for TechnicalBend

mkTechnicalTap :: PlacementText -> ChxTechnical Source #

Smart constructor for TechnicalTap

mkTechnicalHeel :: HeelToe -> ChxTechnical Source #

Smart constructor for TechnicalHeel

mkTechnicalToe :: HeelToe -> ChxTechnical Source #

Smart constructor for TechnicalToe

mkTechnicalFingernails :: EmptyPlacement -> ChxTechnical Source #

Smart constructor for TechnicalFingernails

mkTechnicalOtherTechnical :: PlacementText -> ChxTechnical Source #

Smart constructor for TechnicalOtherTechnical

data ChxTime Source #

time (choice)

Constructors

TimeTime
Fields chxtimeTime :: [SeqTime]
TimeSenzaMisura
Fields timeSenzaMisura :: Empty senza-misura child element

Instances

Eq ChxTime Source #
Methods (==) :: ChxTime -> ChxTime -> Bool # (/=) :: ChxTime -> ChxTime -> Bool #
Show ChxTime Source #
Methods showsPrec :: Int -> ChxTime -> ShowS # show :: ChxTime -> String # showList :: [ChxTime] -> ShowS #
Generic ChxTime Source #
Associated Types type Rep ChxTime :: * -> * # Methods from :: ChxTime -> Rep ChxTime x # to :: Rep ChxTime x -> ChxTime #
EmitXml ChxTime Source #
Methods emitXml :: ChxTime -> XmlRep Source #
type Rep ChxTime Source #
type Rep ChxTime = D1 * (MetaData "ChxTime" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) ((:+:) * (C1 * (MetaCons "TimeTime" PrefixI True) (S1 * (MetaSel (Just Symbol "chxtimeTime") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [SeqTime]))) (C1 * (MetaCons "TimeSenzaMisura" PrefixI True) (S1 * (MetaSel (Just Symbol "timeSenzaMisura") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Empty))))

parseChxTime :: XParse ChxTime Source #

mkTimeTime :: ChxTime Source #

Smart constructor for TimeTime

mkTimeSenzaMisura :: Empty -> ChxTime Source #

Smart constructor for TimeSenzaMisura

data SeqCredit Source #

credit (sequence)

Constructors

SeqCredit
Fields seqcreditLink :: [Link] link child element seqcreditBookmark :: [Bookmark] bookmark child element seqcreditCreditWords :: FormattedText credit-words child element

Instances

Eq SeqCredit Source #
Methods (==) :: SeqCredit -> SeqCredit -> Bool # (/=) :: SeqCredit -> SeqCredit -> Bool #
Show SeqCredit Source #
Methods showsPrec :: Int -> SeqCredit -> ShowS # show :: SeqCredit -> String # showList :: [SeqCredit] -> ShowS #
Generic SeqCredit Source #
Associated Types type Rep SeqCredit :: * -> * # Methods from :: SeqCredit -> Rep SeqCredit x # to :: Rep SeqCredit x -> SeqCredit #
EmitXml SeqCredit Source #
Methods emitXml :: SeqCredit -> XmlRep Source #
type Rep SeqCredit Source #
type Rep SeqCredit = D1 * (MetaData "SeqCredit" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "SeqCredit" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "seqcreditLink") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Link])) ((::) (S1 * (MetaSel (Just Symbol "seqcreditBookmark") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Bookmark])) (S1 * (MetaSel (Just Symbol "seqcreditCreditWords") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * FormattedText)))))

parseSeqCredit :: XParse SeqCredit Source #

mkSeqCredit :: FormattedText -> SeqCredit Source #

Smart constructor for SeqCredit

data SeqDisplayStepOctave Source #

display-step-octave (sequence)

Constructors

SeqDisplayStepOctave
Fields displayStepOctaveDisplayStep :: Step display-step child element displayStepOctaveDisplayOctave :: Octave display-octave child element

Instances

Eq SeqDisplayStepOctave Source #
Methods (==) :: SeqDisplayStepOctave -> SeqDisplayStepOctave -> Bool # (/=) :: SeqDisplayStepOctave -> SeqDisplayStepOctave -> Bool #
Show SeqDisplayStepOctave Source #
Methods showsPrec :: Int -> SeqDisplayStepOctave -> ShowS # show :: SeqDisplayStepOctave -> String # showList :: [SeqDisplayStepOctave] -> ShowS #
Generic SeqDisplayStepOctave Source #
Associated Types type Rep SeqDisplayStepOctave :: * -> * # Methods from :: SeqDisplayStepOctave -> Rep SeqDisplayStepOctave x # to :: Rep SeqDisplayStepOctave x -> SeqDisplayStepOctave #
EmitXml SeqDisplayStepOctave Source #
Methods emitXml :: SeqDisplayStepOctave -> XmlRep Source #
type Rep SeqDisplayStepOctave Source #
type Rep SeqDisplayStepOctave = D1 * (MetaData "SeqDisplayStepOctave" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "SeqDisplayStepOctave" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "displayStepOctaveDisplayStep") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Step)) (S1 * (MetaSel (Just Symbol "displayStepOctaveDisplayOctave") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Octave))))

parseSeqDisplayStepOctave :: XParse SeqDisplayStepOctave Source #

mkSeqDisplayStepOctave :: Step -> Octave -> SeqDisplayStepOctave Source #

Smart constructor for SeqDisplayStepOctave

data SeqLyric0 Source #

lyric (sequence)

Constructors

SeqLyric0
Fields lyricElision :: Elision elision child element seqlyricSyllabic :: Maybe Syllabic syllabic child element

Instances

Eq SeqLyric0 Source #
Methods (==) :: SeqLyric0 -> SeqLyric0 -> Bool # (/=) :: SeqLyric0 -> SeqLyric0 -> Bool #
Show SeqLyric0 Source #
Methods showsPrec :: Int -> SeqLyric0 -> ShowS # show :: SeqLyric0 -> String # showList :: [SeqLyric0] -> ShowS #
Generic SeqLyric0 Source #
Associated Types type Rep SeqLyric0 :: * -> * # Methods from :: SeqLyric0 -> Rep SeqLyric0 x # to :: Rep SeqLyric0 x -> SeqLyric0 #
EmitXml SeqLyric0 Source #
Methods emitXml :: SeqLyric0 -> XmlRep Source #
type Rep SeqLyric0 Source #
type Rep SeqLyric0 = D1 * (MetaData "SeqLyric0" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "SeqLyric0" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "lyricElision") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Elision)) (S1 * (MetaSel (Just Symbol "seqlyricSyllabic") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Syllabic)))))

parseSeqLyric0 :: XParse SeqLyric0 Source #

mkSeqLyric0 :: Elision -> SeqLyric0 Source #

Smart constructor for SeqLyric0

data SeqLyric Source #

lyric (sequence)

Constructors

SeqLyric
Fields seqlyricLyric :: Maybe SeqLyric0 seqlyricText :: TextElementData text child element

Instances

Eq SeqLyric Source #
Methods (==) :: SeqLyric -> SeqLyric -> Bool # (/=) :: SeqLyric -> SeqLyric -> Bool #
Show SeqLyric Source #
Methods showsPrec :: Int -> SeqLyric -> ShowS # show :: SeqLyric -> String # showList :: [SeqLyric] -> ShowS #
Generic SeqLyric Source #
Associated Types type Rep SeqLyric :: * -> * # Methods from :: SeqLyric -> Rep SeqLyric x # to :: Rep SeqLyric x -> SeqLyric #
EmitXml SeqLyric Source #
Methods emitXml :: SeqLyric -> XmlRep Source #
type Rep SeqLyric Source #
type Rep SeqLyric = D1 * (MetaData "SeqLyric" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "SeqLyric" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "seqlyricLyric") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe SeqLyric0))) (S1 * (MetaSel (Just Symbol "seqlyricText") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * TextElementData))))

parseSeqLyric :: XParse SeqLyric Source #

mkSeqLyric :: TextElementData -> SeqLyric Source #

Smart constructor for SeqLyric

data SeqMetronome Source #

metronome (sequence)

Constructors

SeqMetronome
Fields metronomeMetronomeRelation :: String metronome-relation child element seqmetronomeMetronomeNote :: [MetronomeNote] metronome-note child element

Instances

Eq SeqMetronome Source #
Methods (==) :: SeqMetronome -> SeqMetronome -> Bool # (/=) :: SeqMetronome -> SeqMetronome -> Bool #
Show SeqMetronome Source #
Methods showsPrec :: Int -> SeqMetronome -> ShowS # show :: SeqMetronome -> String # showList :: [SeqMetronome] -> ShowS #
Generic SeqMetronome Source #
Associated Types type Rep SeqMetronome :: * -> * # Methods from :: SeqMetronome -> Rep SeqMetronome x # to :: Rep SeqMetronome x -> SeqMetronome #
EmitXml SeqMetronome Source #
Methods emitXml :: SeqMetronome -> XmlRep Source #
type Rep SeqMetronome Source #
type Rep SeqMetronome = D1 * (MetaData "SeqMetronome" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "SeqMetronome" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "metronomeMetronomeRelation") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "seqmetronomeMetronomeNote") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [MetronomeNote]))))

parseSeqMetronome :: XParse SeqMetronome Source #

mkSeqMetronome :: String -> SeqMetronome Source #

Smart constructor for SeqMetronome

data SeqMetronomeTuplet Source #

metronome-tuplet (sequence)

Constructors

SeqMetronomeTuplet
Fields metronomeTupletNormalType :: NoteTypeValue normal-type child element metronomeTupletNormalDot :: [Empty] normal-dot child element

Instances

Eq SeqMetronomeTuplet Source #
Methods (==) :: SeqMetronomeTuplet -> SeqMetronomeTuplet -> Bool # (/=) :: SeqMetronomeTuplet -> SeqMetronomeTuplet -> Bool #
Show SeqMetronomeTuplet Source #
Methods showsPrec :: Int -> SeqMetronomeTuplet -> ShowS # show :: SeqMetronomeTuplet -> String # showList :: [SeqMetronomeTuplet] -> ShowS #
Generic SeqMetronomeTuplet Source #
Associated Types type Rep SeqMetronomeTuplet :: * -> * # Methods from :: SeqMetronomeTuplet -> Rep SeqMetronomeTuplet x # to :: Rep SeqMetronomeTuplet x -> SeqMetronomeTuplet #
EmitXml SeqMetronomeTuplet Source #
Methods emitXml :: SeqMetronomeTuplet -> XmlRep Source #
type Rep SeqMetronomeTuplet Source #
type Rep SeqMetronomeTuplet = D1 * (MetaData "SeqMetronomeTuplet" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "SeqMetronomeTuplet" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "metronomeTupletNormalType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NoteTypeValue)) (S1 * (MetaSel (Just Symbol "metronomeTupletNormalDot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Empty]))))

parseSeqMetronomeTuplet :: XParse SeqMetronomeTuplet Source #

mkSeqMetronomeTuplet :: NoteTypeValue -> SeqMetronomeTuplet Source #

Smart constructor for SeqMetronomeTuplet

data SeqOrnaments Source #

ornaments (sequence)

Constructors

SeqOrnaments
Fields seqornamentsOrnaments :: ChxOrnaments ornamentsAccidentalMark :: [AccidentalMark] accidental-mark child element

Instances

Eq SeqOrnaments Source #
Methods (==) :: SeqOrnaments -> SeqOrnaments -> Bool # (/=) :: SeqOrnaments -> SeqOrnaments -> Bool #
Show SeqOrnaments Source #
Methods showsPrec :: Int -> SeqOrnaments -> ShowS # show :: SeqOrnaments -> String # showList :: [SeqOrnaments] -> ShowS #
Generic SeqOrnaments Source #
Associated Types type Rep SeqOrnaments :: * -> * # Methods from :: SeqOrnaments -> Rep SeqOrnaments x # to :: Rep SeqOrnaments x -> SeqOrnaments #
EmitXml SeqOrnaments Source #
Methods emitXml :: SeqOrnaments -> XmlRep Source #
type Rep SeqOrnaments Source #
type Rep SeqOrnaments = D1 * (MetaData "SeqOrnaments" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "SeqOrnaments" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "seqornamentsOrnaments") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ChxOrnaments)) (S1 * (MetaSel (Just Symbol "ornamentsAccidentalMark") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [AccidentalMark]))))

parseSeqOrnaments :: XParse SeqOrnaments Source #

mkSeqOrnaments :: ChxOrnaments -> SeqOrnaments Source #

Smart constructor for SeqOrnaments

data SeqPageLayout Source #

page-layout (sequence)

Constructors

SeqPageLayout
Fields pageLayoutPageHeight :: Tenths page-height child element pageLayoutPageWidth :: Tenths page-width child element

Instances

Eq SeqPageLayout Source #
Methods (==) :: SeqPageLayout -> SeqPageLayout -> Bool # (/=) :: SeqPageLayout -> SeqPageLayout -> Bool #
Show SeqPageLayout Source #
Methods showsPrec :: Int -> SeqPageLayout -> ShowS # show :: SeqPageLayout -> String # showList :: [SeqPageLayout] -> ShowS #
Generic SeqPageLayout Source #
Associated Types type Rep SeqPageLayout :: * -> * # Methods from :: SeqPageLayout -> Rep SeqPageLayout x # to :: Rep SeqPageLayout x -> SeqPageLayout #
EmitXml SeqPageLayout Source #
Methods emitXml :: SeqPageLayout -> XmlRep Source #
type Rep SeqPageLayout Source #
type Rep SeqPageLayout = D1 * (MetaData "SeqPageLayout" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "SeqPageLayout" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "pageLayoutPageHeight") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Tenths)) (S1 * (MetaSel (Just Symbol "pageLayoutPageWidth") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Tenths))))

parseSeqPageLayout :: XParse SeqPageLayout Source #

mkSeqPageLayout :: Tenths -> Tenths -> SeqPageLayout Source #

Smart constructor for SeqPageLayout

data SeqTime Source #

time (sequence)

Constructors

SeqTime
Fields timeBeats :: String beats child element timeBeatType :: String beat-type child element

Instances

Eq SeqTime Source #
Methods (==) :: SeqTime -> SeqTime -> Bool # (/=) :: SeqTime -> SeqTime -> Bool #
Show SeqTime Source #
Methods showsPrec :: Int -> SeqTime -> ShowS # show :: SeqTime -> String # showList :: [SeqTime] -> ShowS #
Generic SeqTime Source #
Associated Types type Rep SeqTime :: * -> * # Methods from :: SeqTime -> Rep SeqTime x # to :: Rep SeqTime x -> SeqTime #
EmitXml SeqTime Source #
Methods emitXml :: SeqTime -> XmlRep Source #
type Rep SeqTime Source #
type Rep SeqTime = D1 * (MetaData "SeqTime" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "SeqTime" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "timeBeats") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)) (S1 * (MetaSel (Just Symbol "timeBeatType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String))))

parseSeqTime :: XParse SeqTime Source #

mkSeqTime :: String -> String -> SeqTime Source #

Smart constructor for SeqTime

data SeqTimeModification Source #

time-modification (sequence)

Constructors

SeqTimeModification
Fields timeModificationNormalType :: NoteTypeValue normal-type child element timeModificationNormalDot :: [Empty] normal-dot child element

Instances

Eq SeqTimeModification Source #
Methods (==) :: SeqTimeModification -> SeqTimeModification -> Bool # (/=) :: SeqTimeModification -> SeqTimeModification -> Bool #
Show SeqTimeModification Source #
Methods showsPrec :: Int -> SeqTimeModification -> ShowS # show :: SeqTimeModification -> String # showList :: [SeqTimeModification] -> ShowS #
Generic SeqTimeModification Source #
Associated Types type Rep SeqTimeModification :: * -> * # Methods from :: SeqTimeModification -> Rep SeqTimeModification x # to :: Rep SeqTimeModification x -> SeqTimeModification #
EmitXml SeqTimeModification Source #
Methods emitXml :: SeqTimeModification -> XmlRep Source #
type Rep SeqTimeModification Source #
type Rep SeqTimeModification = D1 * (MetaData "SeqTimeModification" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "SeqTimeModification" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "timeModificationNormalType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NoteTypeValue)) (S1 * (MetaSel (Just Symbol "timeModificationNormalDot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Empty]))))

parseSeqTimeModification :: XParse SeqTimeModification Source #

mkSeqTimeModification :: NoteTypeValue -> SeqTimeModification Source #

Smart constructor for SeqTimeModification

data AllMargins Source #

all-margins (group)

Constructors

AllMargins
Fields allMarginsLeftRightMargins :: LeftRightMargins allMarginsTopMargin :: Tenths top-margin child element allMarginsBottomMargin :: Tenths bottom-margin child element

Instances

Eq AllMargins Source #
Methods (==) :: AllMargins -> AllMargins -> Bool # (/=) :: AllMargins -> AllMargins -> Bool #
Show AllMargins Source #
Methods showsPrec :: Int -> AllMargins -> ShowS # show :: AllMargins -> String # showList :: [AllMargins] -> ShowS #
Generic AllMargins Source #
Associated Types type Rep AllMargins :: * -> * # Methods from :: AllMargins -> Rep AllMargins x # to :: Rep AllMargins x -> AllMargins #
EmitXml AllMargins Source #
Methods emitXml :: AllMargins -> XmlRep Source #
type Rep AllMargins Source #
type Rep AllMargins = D1 * (MetaData "AllMargins" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "AllMargins" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "allMarginsLeftRightMargins") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * LeftRightMargins)) ((::) (S1 * (MetaSel (Just Symbol "allMarginsTopMargin") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Tenths)) (S1 * (MetaSel (Just Symbol "allMarginsBottomMargin") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Tenths)))))

parseAllMargins :: XParse AllMargins Source #

mkAllMargins :: LeftRightMargins -> Tenths -> Tenths -> AllMargins Source #

Smart constructor for AllMargins

data BeatUnit Source #

beat-unit (group)

Constructors

BeatUnit
Fields beatUnitBeatUnit :: NoteTypeValue beat-unit child element beatUnitBeatUnitDot :: [Empty] beat-unit-dot child element

Instances

Eq BeatUnit Source #
Methods (==) :: BeatUnit -> BeatUnit -> Bool # (/=) :: BeatUnit -> BeatUnit -> Bool #
Show BeatUnit Source #
Methods showsPrec :: Int -> BeatUnit -> ShowS # show :: BeatUnit -> String # showList :: [BeatUnit] -> ShowS #
Generic BeatUnit Source #
Associated Types type Rep BeatUnit :: * -> * # Methods from :: BeatUnit -> Rep BeatUnit x # to :: Rep BeatUnit x -> BeatUnit #
EmitXml BeatUnit Source #
Methods emitXml :: BeatUnit -> XmlRep Source #
type Rep BeatUnit Source #
type Rep BeatUnit = D1 * (MetaData "BeatUnit" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "BeatUnit" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "beatUnitBeatUnit") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NoteTypeValue)) (S1 * (MetaSel (Just Symbol "beatUnitBeatUnitDot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Empty]))))

parseBeatUnit :: XParse BeatUnit Source #

mkBeatUnit :: NoteTypeValue -> BeatUnit Source #

Smart constructor for BeatUnit

data Duration Source #

duration (group)

Constructors

Duration
Fields durationDuration :: PositiveDivisions duration child element

Instances

Eq Duration Source #
Methods (==) :: Duration -> Duration -> Bool # (/=) :: Duration -> Duration -> Bool #
Show Duration Source #
Methods showsPrec :: Int -> Duration -> ShowS # show :: Duration -> String # showList :: [Duration] -> ShowS #
Generic Duration Source #
Associated Types type Rep Duration :: * -> * # Methods from :: Duration -> Rep Duration x # to :: Rep Duration x -> Duration #
EmitXml Duration Source #
Methods emitXml :: Duration -> XmlRep Source #
type Rep Duration Source #
type Rep Duration = D1 * (MetaData "Duration" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Duration" PrefixI True) (S1 * (MetaSel (Just Symbol "durationDuration") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveDivisions)))

parseDuration :: XParse Duration Source #

mkDuration :: PositiveDivisions -> Duration Source #

Smart constructor for Duration

data Editorial Source #

editorial (group)

Constructors

Editorial
Fields editorialFootnote :: Maybe Footnote editorialLevel :: Maybe GrpLevel

Instances

Eq Editorial Source #
Methods (==) :: Editorial -> Editorial -> Bool # (/=) :: Editorial -> Editorial -> Bool #
Show Editorial Source #
Methods showsPrec :: Int -> Editorial -> ShowS # show :: Editorial -> String # showList :: [Editorial] -> ShowS #
Generic Editorial Source #
Associated Types type Rep Editorial :: * -> * # Methods from :: Editorial -> Rep Editorial x # to :: Rep Editorial x -> Editorial #
EmitXml Editorial Source #
Methods emitXml :: Editorial -> XmlRep Source #
type Rep Editorial Source #
type Rep Editorial = D1 * (MetaData "Editorial" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Editorial" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "editorialFootnote") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Footnote))) (S1 * (MetaSel (Just Symbol "editorialLevel") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe GrpLevel)))))

parseEditorial :: XParse Editorial Source #

mkEditorial :: Editorial Source #

Smart constructor for Editorial

data EditorialVoice Source #

editorial-voice (group)

Constructors

EditorialVoice
Fields editorialVoiceFootnote :: Maybe Footnote editorialVoiceLevel :: Maybe GrpLevel editorialVoiceVoice :: Maybe Voice

Instances

Eq EditorialVoice Source #
Methods (==) :: EditorialVoice -> EditorialVoice -> Bool # (/=) :: EditorialVoice -> EditorialVoice -> Bool #
Show EditorialVoice Source #
Methods showsPrec :: Int -> EditorialVoice -> ShowS # show :: EditorialVoice -> String # showList :: [EditorialVoice] -> ShowS #
Generic EditorialVoice Source #
Associated Types type Rep EditorialVoice :: * -> * # Methods from :: EditorialVoice -> Rep EditorialVoice x # to :: Rep EditorialVoice x -> EditorialVoice #
EmitXml EditorialVoice Source #
Methods emitXml :: EditorialVoice -> XmlRep Source #
type Rep EditorialVoice Source #
type Rep EditorialVoice = D1 * (MetaData "EditorialVoice" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "EditorialVoice" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "editorialVoiceFootnote") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Footnote))) ((::) (S1 * (MetaSel (Just Symbol "editorialVoiceLevel") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe GrpLevel))) (S1 * (MetaSel (Just Symbol "editorialVoiceVoice") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Voice))))))

parseEditorialVoice :: XParse EditorialVoice Source #

mkEditorialVoice :: EditorialVoice Source #

Smart constructor for EditorialVoice

data EditorialVoiceDirection Source #

editorial-voice-direction (group)

Constructors

EditorialVoiceDirection
Fields editorialVoiceDirectionFootnote :: Maybe Footnote editorialVoiceDirectionLevel :: Maybe GrpLevel editorialVoiceDirectionVoice :: Maybe Voice

Instances

Eq EditorialVoiceDirection Source #
Methods (==) :: EditorialVoiceDirection -> EditorialVoiceDirection -> Bool # (/=) :: EditorialVoiceDirection -> EditorialVoiceDirection -> Bool #
Show EditorialVoiceDirection Source #
Methods showsPrec :: Int -> EditorialVoiceDirection -> ShowS # show :: EditorialVoiceDirection -> String # showList :: [EditorialVoiceDirection] -> ShowS #
Generic EditorialVoiceDirection Source #
Associated Types type Rep EditorialVoiceDirection :: * -> * # Methods from :: EditorialVoiceDirection -> Rep EditorialVoiceDirection x # to :: Rep EditorialVoiceDirection x -> EditorialVoiceDirection #
EmitXml EditorialVoiceDirection Source #
Methods emitXml :: EditorialVoiceDirection -> XmlRep Source #
type Rep EditorialVoiceDirection Source #
type Rep EditorialVoiceDirection = D1 * (MetaData "EditorialVoiceDirection" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "EditorialVoiceDirection" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "editorialVoiceDirectionFootnote") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Footnote))) ((::) (S1 * (MetaSel (Just Symbol "editorialVoiceDirectionLevel") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe GrpLevel))) (S1 * (MetaSel (Just Symbol "editorialVoiceDirectionVoice") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Voice))))))

parseEditorialVoiceDirection :: XParse EditorialVoiceDirection Source #

mkEditorialVoiceDirection :: EditorialVoiceDirection Source #

Smart constructor for EditorialVoiceDirection

data Footnote Source #

footnote (group)

Constructors

Footnote
Fields footnoteFootnote :: FormattedText footnote child element

Instances

Eq Footnote Source #
Methods (==) :: Footnote -> Footnote -> Bool # (/=) :: Footnote -> Footnote -> Bool #
Show Footnote Source #
Methods showsPrec :: Int -> Footnote -> ShowS # show :: Footnote -> String # showList :: [Footnote] -> ShowS #
Generic Footnote Source #
Associated Types type Rep Footnote :: * -> * # Methods from :: Footnote -> Rep Footnote x # to :: Rep Footnote x -> Footnote #
EmitXml Footnote Source #
Methods emitXml :: Footnote -> XmlRep Source #
type Rep Footnote Source #
type Rep Footnote = D1 * (MetaData "Footnote" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Footnote" PrefixI True) (S1 * (MetaSel (Just Symbol "footnoteFootnote") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * FormattedText)))

parseFootnote :: XParse Footnote Source #

mkFootnote :: FormattedText -> Footnote Source #

Smart constructor for Footnote

data GrpFullNote Source #

full-note (group)

Constructors

GrpFullNote
Fields fullNoteChord :: Maybe Empty chord child element fullNoteFullNote :: FullNote

Instances

Eq GrpFullNote Source #
Methods (==) :: GrpFullNote -> GrpFullNote -> Bool # (/=) :: GrpFullNote -> GrpFullNote -> Bool #
Show GrpFullNote Source #
Methods showsPrec :: Int -> GrpFullNote -> ShowS # show :: GrpFullNote -> String # showList :: [GrpFullNote] -> ShowS #
Generic GrpFullNote Source #
Associated Types type Rep GrpFullNote :: * -> * # Methods from :: GrpFullNote -> Rep GrpFullNote x # to :: Rep GrpFullNote x -> GrpFullNote #
EmitXml GrpFullNote Source #
Methods emitXml :: GrpFullNote -> XmlRep Source #
type Rep GrpFullNote Source #
type Rep GrpFullNote = D1 * (MetaData "GrpFullNote" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "GrpFullNote" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "fullNoteChord") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Empty))) (S1 * (MetaSel (Just Symbol "fullNoteFullNote") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * FullNote))))

parseGrpFullNote :: XParse GrpFullNote Source #

mkGrpFullNote :: FullNote -> GrpFullNote Source #

Smart constructor for GrpFullNote

data HarmonyChord Source #

harmony-chord (group)

Constructors

HarmonyChord
Fields harmonyChordHarmonyChord :: ChxHarmonyChord harmonyChordKind :: Kind kind child element harmonyChordInversion :: Maybe Inversion inversion child element harmonyChordBass :: Maybe Bass bass child element harmonyChordDegree :: [Degree] degree child element

Instances

Eq HarmonyChord Source #
Methods (==) :: HarmonyChord -> HarmonyChord -> Bool # (/=) :: HarmonyChord -> HarmonyChord -> Bool #
Show HarmonyChord Source #
Methods showsPrec :: Int -> HarmonyChord -> ShowS # show :: HarmonyChord -> String # showList :: [HarmonyChord] -> ShowS #
Generic HarmonyChord Source #
Associated Types type Rep HarmonyChord :: * -> * # Methods from :: HarmonyChord -> Rep HarmonyChord x # to :: Rep HarmonyChord x -> HarmonyChord #
EmitXml HarmonyChord Source #
Methods emitXml :: HarmonyChord -> XmlRep Source #
type Rep HarmonyChord Source #
type Rep HarmonyChord = D1 * (MetaData "HarmonyChord" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "HarmonyChord" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "harmonyChordHarmonyChord") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * ChxHarmonyChord)) (S1 * (MetaSel (Just Symbol "harmonyChordKind") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Kind))) ((::) (S1 * (MetaSel (Just Symbol "harmonyChordInversion") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Inversion))) ((::) (S1 * (MetaSel (Just Symbol "harmonyChordBass") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Bass))) (S1 * (MetaSel (Just Symbol "harmonyChordDegree") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Degree]))))))

parseHarmonyChord :: XParse HarmonyChord Source #

mkHarmonyChord :: ChxHarmonyChord -> Kind -> HarmonyChord Source #

Smart constructor for HarmonyChord

data Layout Source #

layout (group)

Constructors

Layout
Fields layoutPageLayout :: Maybe PageLayout page-layout child element layoutSystemLayout :: Maybe SystemLayout system-layout child element layoutStaffLayout :: [StaffLayout] staff-layout child element

Instances

Eq Layout Source #
Methods (==) :: Layout -> Layout -> Bool # (/=) :: Layout -> Layout -> Bool #
Show Layout Source #
Methods showsPrec :: Int -> Layout -> ShowS # show :: Layout -> String # showList :: [Layout] -> ShowS #
Generic Layout Source #
Associated Types type Rep Layout :: * -> * # Methods from :: Layout -> Rep Layout x # to :: Rep Layout x -> Layout #
EmitXml Layout Source #
Methods emitXml :: Layout -> XmlRep Source #
type Rep Layout Source #
type Rep Layout = D1 * (MetaData "Layout" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Layout" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "layoutPageLayout") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe PageLayout))) ((::) (S1 * (MetaSel (Just Symbol "layoutSystemLayout") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe SystemLayout))) (S1 * (MetaSel (Just Symbol "layoutStaffLayout") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [StaffLayout])))))

parseLayout :: XParse Layout Source #

mkLayout :: Layout Source #

Smart constructor for Layout

data LeftRightMargins Source #

left-right-margins (group)

Constructors

LeftRightMargins
Fields leftRightMarginsLeftMargin :: Tenths left-margin child element leftRightMarginsRightMargin :: Tenths right-margin child element

Instances

Eq LeftRightMargins Source #
Methods (==) :: LeftRightMargins -> LeftRightMargins -> Bool # (/=) :: LeftRightMargins -> LeftRightMargins -> Bool #
Show LeftRightMargins Source #
Methods showsPrec :: Int -> LeftRightMargins -> ShowS # show :: LeftRightMargins -> String # showList :: [LeftRightMargins] -> ShowS #
Generic LeftRightMargins Source #
Associated Types type Rep LeftRightMargins :: * -> * # Methods from :: LeftRightMargins -> Rep LeftRightMargins x # to :: Rep LeftRightMargins x -> LeftRightMargins #
EmitXml LeftRightMargins Source #
Methods emitXml :: LeftRightMargins -> XmlRep Source #
type Rep LeftRightMargins Source #
type Rep LeftRightMargins = D1 * (MetaData "LeftRightMargins" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "LeftRightMargins" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "leftRightMarginsLeftMargin") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Tenths)) (S1 * (MetaSel (Just Symbol "leftRightMarginsRightMargin") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Tenths))))

parseLeftRightMargins :: XParse LeftRightMargins Source #

mkLeftRightMargins :: Tenths -> Tenths -> LeftRightMargins Source #

Smart constructor for LeftRightMargins

data GrpLevel Source #

level (group)

Constructors

GrpLevel
Fields levelLevel :: Level level child element

Instances

Eq GrpLevel Source #
Methods (==) :: GrpLevel -> GrpLevel -> Bool # (/=) :: GrpLevel -> GrpLevel -> Bool #
Show GrpLevel Source #
Methods showsPrec :: Int -> GrpLevel -> ShowS # show :: GrpLevel -> String # showList :: [GrpLevel] -> ShowS #
Generic GrpLevel Source #
Associated Types type Rep GrpLevel :: * -> * # Methods from :: GrpLevel -> Rep GrpLevel x # to :: Rep GrpLevel x -> GrpLevel #
EmitXml GrpLevel Source #
Methods emitXml :: GrpLevel -> XmlRep Source #
type Rep GrpLevel Source #
type Rep GrpLevel = D1 * (MetaData "GrpLevel" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "GrpLevel" PrefixI True) (S1 * (MetaSel (Just Symbol "levelLevel") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Level)))

parseGrpLevel :: XParse GrpLevel Source #

mkGrpLevel :: Level -> GrpLevel Source #

Smart constructor for GrpLevel

data MusicData Source #

music-data (group)

Constructors

MusicData
Fields musicDataMusicData :: [ChxMusicData]

Instances

Eq MusicData Source #
Methods (==) :: MusicData -> MusicData -> Bool # (/=) :: MusicData -> MusicData -> Bool #
Show MusicData Source #
Methods showsPrec :: Int -> MusicData -> ShowS # show :: MusicData -> String # showList :: [MusicData] -> ShowS #
Generic MusicData Source #
Associated Types type Rep MusicData :: * -> * # Methods from :: MusicData -> Rep MusicData x # to :: Rep MusicData x -> MusicData #
EmitXml MusicData Source #
Methods emitXml :: MusicData -> XmlRep Source #
type Rep MusicData Source #
type Rep MusicData = D1 * (MetaData "MusicData" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "MusicData" PrefixI True) (S1 * (MetaSel (Just Symbol "musicDataMusicData") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [ChxMusicData])))

parseMusicData :: XParse MusicData Source #

mkMusicData :: MusicData Source #

Smart constructor for MusicData

data NonTraditionalKey Source #

non-traditional-key (group)

Constructors

NonTraditionalKey
Fields nonTraditionalKeyKeyStep :: Step key-step child element nonTraditionalKeyKeyAlter :: Semitones key-alter child element

Instances

Eq NonTraditionalKey Source #
Methods (==) :: NonTraditionalKey -> NonTraditionalKey -> Bool # (/=) :: NonTraditionalKey -> NonTraditionalKey -> Bool #
Show NonTraditionalKey Source #
Methods showsPrec :: Int -> NonTraditionalKey -> ShowS # show :: NonTraditionalKey -> String # showList :: [NonTraditionalKey] -> ShowS #
Generic NonTraditionalKey Source #
Associated Types type Rep NonTraditionalKey :: * -> * # Methods from :: NonTraditionalKey -> Rep NonTraditionalKey x # to :: Rep NonTraditionalKey x -> NonTraditionalKey #
EmitXml NonTraditionalKey Source #
Methods emitXml :: NonTraditionalKey -> XmlRep Source #
type Rep NonTraditionalKey Source #
type Rep NonTraditionalKey = D1 * (MetaData "NonTraditionalKey" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "NonTraditionalKey" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "nonTraditionalKeyKeyStep") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Step)) (S1 * (MetaSel (Just Symbol "nonTraditionalKeyKeyAlter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Semitones))))

parseNonTraditionalKey :: XParse NonTraditionalKey Source #

mkNonTraditionalKey :: Step -> Semitones -> NonTraditionalKey Source #

Smart constructor for NonTraditionalKey

data GrpPartGroup Source #

part-group (group)

Constructors

GrpPartGroup
Fields partGroupPartGroup :: PartGroup part-group child element

Instances

Eq GrpPartGroup Source #
Methods (==) :: GrpPartGroup -> GrpPartGroup -> Bool # (/=) :: GrpPartGroup -> GrpPartGroup -> Bool #
Show GrpPartGroup Source #
Methods showsPrec :: Int -> GrpPartGroup -> ShowS # show :: GrpPartGroup -> String # showList :: [GrpPartGroup] -> ShowS #
Generic GrpPartGroup Source #
Associated Types type Rep GrpPartGroup :: * -> * # Methods from :: GrpPartGroup -> Rep GrpPartGroup x # to :: Rep GrpPartGroup x -> GrpPartGroup #
EmitXml GrpPartGroup Source #
Methods emitXml :: GrpPartGroup -> XmlRep Source #
type Rep GrpPartGroup Source #
type Rep GrpPartGroup = D1 * (MetaData "GrpPartGroup" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "GrpPartGroup" PrefixI True) (S1 * (MetaSel (Just Symbol "partGroupPartGroup") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PartGroup)))

parseGrpPartGroup :: XParse GrpPartGroup Source #

mkGrpPartGroup :: PartGroup -> GrpPartGroup Source #

Smart constructor for GrpPartGroup

data ScoreHeader Source #

score-header (group)

Constructors

ScoreHeader

Fields

scoreHeaderWork :: Maybe Work
work child element
scoreHeaderMovementNumber :: Maybe String
movement-number child element
scoreHeaderMovementTitle :: Maybe String
movement-title child element
scoreHeaderIdentification :: Maybe Identification
identification child element
scoreHeaderDefaults :: Maybe Defaults
defaults child element
scoreHeaderCredit :: [Credit]
credit child element
scoreHeaderPartList :: PartList
part-list child element

Instances

Eq ScoreHeader Source #
Methods (==) :: ScoreHeader -> ScoreHeader -> Bool # (/=) :: ScoreHeader -> ScoreHeader -> Bool #
Show ScoreHeader Source #
Methods showsPrec :: Int -> ScoreHeader -> ShowS # show :: ScoreHeader -> String # showList :: [ScoreHeader] -> ShowS #
Generic ScoreHeader Source #
Associated Types type Rep ScoreHeader :: * -> * # Methods from :: ScoreHeader -> Rep ScoreHeader x # to :: Rep ScoreHeader x -> ScoreHeader #
EmitXml ScoreHeader Source #
Methods emitXml :: ScoreHeader -> XmlRep Source #
type Rep ScoreHeader Source #
type Rep ScoreHeader = D1 * (MetaData "ScoreHeader" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "ScoreHeader" PrefixI True) ((::) ((::) (S1 * (MetaSel (Just Symbol "scoreHeaderWork") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Work))) ((::) (S1 * (MetaSel (Just Symbol "scoreHeaderMovementNumber") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe String))) (S1 * (MetaSel (Just Symbol "scoreHeaderMovementTitle") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe String))))) ((::) ((::) (S1 * (MetaSel (Just Symbol "scoreHeaderIdentification") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Identification))) (S1 * (MetaSel (Just Symbol "scoreHeaderDefaults") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Defaults)))) ((::) (S1 * (MetaSel (Just Symbol "scoreHeaderCredit") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Credit])) (S1 * (MetaSel (Just Symbol "scoreHeaderPartList") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PartList))))))

parseScoreHeader :: XParse ScoreHeader Source #

mkScoreHeader :: PartList -> ScoreHeader Source #

Smart constructor for ScoreHeader

data ScorePart Source #

score-part (group)

Constructors

ScorePart
Fields scorePartScorePart :: CmpScorePart score-part child element

Instances

Eq ScorePart Source #
Methods (==) :: ScorePart -> ScorePart -> Bool # (/=) :: ScorePart -> ScorePart -> Bool #
Show ScorePart Source #
Methods showsPrec :: Int -> ScorePart -> ShowS # show :: ScorePart -> String # showList :: [ScorePart] -> ShowS #
Generic ScorePart Source #
Associated Types type Rep ScorePart :: * -> * # Methods from :: ScorePart -> Rep ScorePart x # to :: Rep ScorePart x -> ScorePart #
EmitXml ScorePart Source #
Methods emitXml :: ScorePart -> XmlRep Source #
type Rep ScorePart Source #
type Rep ScorePart = D1 * (MetaData "ScorePart" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "ScorePart" PrefixI True) (S1 * (MetaSel (Just Symbol "scorePartScorePart") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * CmpScorePart)))

parseScorePart :: XParse ScorePart Source #

mkScorePart :: CmpScorePart -> ScorePart Source #

Smart constructor for ScorePart

data Slash Source #

slash (group)

Constructors

Slash
Fields slashSlashType :: NoteTypeValue slash-type child element slashSlashDot :: [Empty] slash-dot child element

Instances

Eq Slash Source #
Methods (==) :: Slash -> Slash -> Bool # (/=) :: Slash -> Slash -> Bool #
Show Slash Source #
Methods showsPrec :: Int -> Slash -> ShowS # show :: Slash -> String # showList :: [Slash] -> ShowS #
Generic Slash Source #
Associated Types type Rep Slash :: * -> * # Methods from :: Slash -> Rep Slash x # to :: Rep Slash x -> Slash #
EmitXml Slash Source #
Methods emitXml :: Slash -> XmlRep Source #
type Rep Slash Source #
type Rep Slash = D1 * (MetaData "Slash" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Slash" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "slashSlashType") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * NoteTypeValue)) (S1 * (MetaSel (Just Symbol "slashSlashDot") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * [Empty]))))

parseSlash :: XParse Slash Source #

mkSlash :: NoteTypeValue -> Slash Source #

Smart constructor for Slash

data Staff Source #

staff (group)

Constructors

Staff
Fields staffStaff :: PositiveInteger staff child element

Instances

Eq Staff Source #
Methods (==) :: Staff -> Staff -> Bool # (/=) :: Staff -> Staff -> Bool #
Show Staff Source #
Methods showsPrec :: Int -> Staff -> ShowS # show :: Staff -> String # showList :: [Staff] -> ShowS #
Generic Staff Source #
Associated Types type Rep Staff :: * -> * # Methods from :: Staff -> Rep Staff x # to :: Rep Staff x -> Staff #
EmitXml Staff Source #
Methods emitXml :: Staff -> XmlRep Source #
type Rep Staff Source #
type Rep Staff = D1 * (MetaData "Staff" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Staff" PrefixI True) (S1 * (MetaSel (Just Symbol "staffStaff") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * PositiveInteger)))

parseStaff :: XParse Staff Source #

mkStaff :: PositiveInteger -> Staff Source #

Smart constructor for Staff

data TraditionalKey Source #

traditional-key (group)

Constructors

TraditionalKey
Fields traditionalKeyCancel :: Maybe Cancel cancel child element traditionalKeyFifths :: Fifths fifths child element traditionalKeyMode :: Maybe Mode mode child element

Instances

Eq TraditionalKey Source #
Methods (==) :: TraditionalKey -> TraditionalKey -> Bool # (/=) :: TraditionalKey -> TraditionalKey -> Bool #
Show TraditionalKey Source #
Methods showsPrec :: Int -> TraditionalKey -> ShowS # show :: TraditionalKey -> String # showList :: [TraditionalKey] -> ShowS #
Generic TraditionalKey Source #
Associated Types type Rep TraditionalKey :: * -> * # Methods from :: TraditionalKey -> Rep TraditionalKey x # to :: Rep TraditionalKey x -> TraditionalKey #
EmitXml TraditionalKey Source #
Methods emitXml :: TraditionalKey -> XmlRep Source #
type Rep TraditionalKey Source #
type Rep TraditionalKey = D1 * (MetaData "TraditionalKey" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "TraditionalKey" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "traditionalKeyCancel") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Cancel))) ((::) (S1 * (MetaSel (Just Symbol "traditionalKeyFifths") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Fifths)) (S1 * (MetaSel (Just Symbol "traditionalKeyMode") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Mode))))))

parseTraditionalKey :: XParse TraditionalKey Source #

mkTraditionalKey :: Fifths -> TraditionalKey Source #

Smart constructor for TraditionalKey

data Tuning Source #

tuning (group)

Constructors

Tuning
Fields tuningTuningStep :: Step tuning-step child element tuningTuningAlter :: Maybe Semitones tuning-alter child element tuningTuningOctave :: Octave tuning-octave child element

Instances

Eq Tuning Source #
Methods (==) :: Tuning -> Tuning -> Bool # (/=) :: Tuning -> Tuning -> Bool #
Show Tuning Source #
Methods showsPrec :: Int -> Tuning -> ShowS # show :: Tuning -> String # showList :: [Tuning] -> ShowS #
Generic Tuning Source #
Associated Types type Rep Tuning :: * -> * # Methods from :: Tuning -> Rep Tuning x # to :: Rep Tuning x -> Tuning #
EmitXml Tuning Source #
Methods emitXml :: Tuning -> XmlRep Source #
type Rep Tuning Source #
type Rep Tuning = D1 * (MetaData "Tuning" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Tuning" PrefixI True) ((::) (S1 * (MetaSel (Just Symbol "tuningTuningStep") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Step)) ((::) (S1 * (MetaSel (Just Symbol "tuningTuningAlter") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * (Maybe Semitones))) (S1 * (MetaSel (Just Symbol "tuningTuningOctave") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Octave)))))

parseTuning :: XParse Tuning Source #

mkTuning :: Step -> Octave -> Tuning Source #

Smart constructor for Tuning

data Voice Source #

voice (group)

Constructors

Voice
Fields voiceVoice :: String voice child element

Instances

Eq Voice Source #
Methods (==) :: Voice -> Voice -> Bool # (/=) :: Voice -> Voice -> Bool #
Show Voice Source #
Methods showsPrec :: Int -> Voice -> ShowS # show :: Voice -> String # showList :: [Voice] -> ShowS #
Generic Voice Source #
Associated Types type Rep Voice :: * -> * # Methods from :: Voice -> Rep Voice x # to :: Rep Voice x -> Voice #
EmitXml Voice Source #
Methods emitXml :: Voice -> XmlRep Source #
type Rep Voice Source #
type Rep Voice = D1 * (MetaData "Voice" "Fadno.MusicXml.MusicXml20" "fadno-xml-1.1.1-Dcfp5nXbYFYCBmngx9xJB4" False) (C1 * (MetaCons "Voice" PrefixI True) (S1 * (MetaSel (Just Symbol "voiceVoice") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * String)))

parseVoice :: XParse Voice Source #

mkVoice :: String -> Voice Source #

Smart constructor for Voice