| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
Fadno.MusicXml.MusicXml31
Synopsis
- newtype ID = ID {}
- parseID :: String -> XParse ID
- newtype IDREF = IDREF {}
- parseIDREF :: String -> XParse IDREF
- newtype NCName = NCName {}
- parseNCName :: String -> XParse NCName
- newtype NMTOKEN = NMTOKEN {}
- parseNMTOKEN :: String -> XParse NMTOKEN
- newtype Name = Name {}
- parseName :: String -> XParse Name
- data AboveBelow
- parseAboveBelow :: String -> XParse AboveBelow
- data AccidentalValue
- = AccidentalValueSharp
- | AccidentalValueNatural
- | AccidentalValueFlat
- | AccidentalValueDoubleSharp
- | AccidentalValueSharpSharp
- | AccidentalValueFlatFlat
- | AccidentalValueNaturalSharp
- | AccidentalValueNaturalFlat
- | AccidentalValueQuarterFlat
- | AccidentalValueQuarterSharp
- | AccidentalValueThreeQuartersFlat
- | AccidentalValueThreeQuartersSharp
- | AccidentalValueSharpDown
- | AccidentalValueSharpUp
- | AccidentalValueNaturalDown
- | AccidentalValueNaturalUp
- | AccidentalValueFlatDown
- | AccidentalValueFlatUp
- | AccidentalValueDoubleSharpDown
- | AccidentalValueDoubleSharpUp
- | AccidentalValueFlatFlatDown
- | AccidentalValueFlatFlatUp
- | AccidentalValueArrowDown
- | AccidentalValueArrowUp
- | AccidentalValueTripleSharp
- | AccidentalValueTripleFlat
- | AccidentalValueSlashQuarterSharp
- | AccidentalValueSlashSharp
- | AccidentalValueSlashFlat
- | AccidentalValueDoubleSlashFlat
- | AccidentalValueSharp1
- | AccidentalValueSharp2
- | AccidentalValueSharp3
- | AccidentalValueSharp5
- | AccidentalValueFlat1
- | AccidentalValueFlat2
- | AccidentalValueFlat3
- | AccidentalValueFlat4
- | AccidentalValueSori
- | AccidentalValueKoron
- | AccidentalValueOther
- parseAccidentalValue :: String -> XParse AccidentalValue
- newtype AccordionMiddle = AccordionMiddle {}
- parseAccordionMiddle :: String -> XParse AccordionMiddle
- data Actuate
- parseActuate :: String -> XParse Actuate
- data ArrowDirection
- = ArrowDirectionLeft
- | ArrowDirectionUp
- | ArrowDirectionRight
- | ArrowDirectionDown
- | ArrowDirectionNorthwest
- | ArrowDirectionNortheast
- | ArrowDirectionSoutheast
- | ArrowDirectionSouthwest
- | ArrowDirectionLeftRight
- | ArrowDirectionUpDown
- | ArrowDirectionNorthwestSoutheast
- | ArrowDirectionNortheastSouthwest
- | ArrowDirectionOther
- parseArrowDirection :: String -> XParse ArrowDirection
- data ArrowStyle
- parseArrowStyle :: String -> XParse ArrowStyle
- data BackwardForward
- parseBackwardForward :: String -> XParse BackwardForward
- data BarStyle
- parseBarStyle :: String -> XParse BarStyle
- newtype BeamLevel = BeamLevel {}
- parseBeamLevel :: String -> XParse BeamLevel
- data BeamValue
- parseBeamValue :: String -> XParse BeamValue
- data BeaterValue
- = BeaterValueBow
- | BeaterValueChimeHammer
- | BeaterValueCoin
- | BeaterValueDrumStick
- | BeaterValueFinger
- | BeaterValueFingernail
- | BeaterValueFist
- | BeaterValueGuiroScraper
- | BeaterValueHammer
- | BeaterValueHand
- | BeaterValueJazzStick
- | BeaterValueKnittingNeedle
- | BeaterValueMetalHammer
- | BeaterValueSlideBrushOnGong
- | BeaterValueSnareStick
- | BeaterValueSpoonMallet
- | BeaterValueSuperball
- | BeaterValueTriangleBeater
- | BeaterValueTriangleBeaterPlain
- | BeaterValueWireBrush
- parseBeaterValue :: String -> XParse BeaterValue
- data BreathMarkValue
- parseBreathMarkValue :: String -> XParse BreathMarkValue
- data CaesuraValue
- parseCaesuraValue :: String -> XParse CaesuraValue
- data CancelLocation
- parseCancelLocation :: String -> XParse CancelLocation
- data CircularArrow
- parseCircularArrow :: String -> XParse CircularArrow
- data ClefSign
- parseClefSign :: String -> XParse ClefSign
- newtype Color = Color {}
- parseColor :: String -> XParse Color
- newtype CommaSeparatedText = CommaSeparatedText {}
- parseCommaSeparatedText :: String -> XParse CommaSeparatedText
- data CssFontSize
- parseCssFontSize :: String -> XParse CssFontSize
- data DegreeSymbolValue
- parseDegreeSymbolValue :: String -> XParse DegreeSymbolValue
- data DegreeTypeValue
- parseDegreeTypeValue :: String -> XParse DegreeTypeValue
- newtype DistanceType = DistanceType {}
- parseDistanceType :: String -> XParse DistanceType
- newtype Divisions = Divisions {}
- parseDivisions :: String -> XParse Divisions
- data Effect
- parseEffect :: String -> XParse Effect
- data EnclosureShape
- = EnclosureShapeRectangle
- | EnclosureShapeSquare
- | EnclosureShapeOval
- | EnclosureShapeCircle
- | EnclosureShapeBracket
- | EnclosureShapeTriangle
- | EnclosureShapeDiamond
- | EnclosureShapePentagon
- | EnclosureShapeHexagon
- | EnclosureShapeHeptagon
- | EnclosureShapeOctagon
- | EnclosureShapeNonagon
- | EnclosureShapeDecagon
- | EnclosureShapeNone
- parseEnclosureShape :: String -> XParse EnclosureShape
- newtype EndingNumber = EndingNumber {}
- parseEndingNumber :: String -> XParse EndingNumber
- data Fan
- parseFan :: String -> XParse Fan
- data FermataShape
- parseFermataShape :: String -> XParse FermataShape
- newtype Fifths = Fifths {}
- parseFifths :: String -> XParse Fifths
- data FontSize
- = FontSizeDecimal { }
- | FontSizeCssFontSize { }
- parseFontSize :: String -> XParse FontSize
- data FontStyle
- parseFontStyle :: String -> XParse FontStyle
- data FontWeight
- parseFontWeight :: String -> XParse FontWeight
- data GlassValue
- parseGlassValue :: String -> XParse GlassValue
- newtype GlyphType = GlyphType {}
- parseGlyphType :: String -> XParse GlyphType
- data GroupBarlineValue
- parseGroupBarlineValue :: String -> XParse GroupBarlineValue
- data GroupSymbolValue
- parseGroupSymbolValue :: String -> XParse GroupSymbolValue
- data HandbellValue
- parseHandbellValue :: String -> XParse HandbellValue
- data HarmonClosedLocation
- parseHarmonClosedLocation :: String -> XParse HarmonClosedLocation
- data HarmonClosedValue
- parseHarmonClosedValue :: String -> XParse HarmonClosedValue
- data HarmonyType
- parseHarmonyType :: String -> XParse HarmonyType
- data HoleClosedLocation
- parseHoleClosedLocation :: String -> XParse HoleClosedLocation
- data HoleClosedValue
- parseHoleClosedValue :: String -> XParse HoleClosedValue
- data KindValue
- = KindValueMajor
- | KindValueMinor
- | KindValueAugmented
- | KindValueDiminished
- | KindValueDominant
- | KindValueMajorSeventh
- | KindValueMinorSeventh
- | KindValueDiminishedSeventh
- | KindValueAugmentedSeventh
- | KindValueHalfDiminished
- | KindValueMajorMinor
- | KindValueMajorSixth
- | KindValueMinorSixth
- | KindValueDominantNinth
- | KindValueMajorNinth
- | KindValueMinorNinth
- | KindValueDominant11th
- | KindValueMajor11th
- | KindValueMinor11th
- | KindValueDominant13th
- | KindValueMajor13th
- | KindValueMinor13th
- | KindValueSuspendedSecond
- | KindValueSuspendedFourth
- | KindValueNeapolitan
- | KindValueItalian
- | KindValueFrench
- | KindValueGerman
- | KindValuePedal
- | KindValuePower
- | KindValueTristan
- | KindValueOther
- | KindValueNone
- parseKindValue :: String -> XParse KindValue
- data Lang
- parseLang :: String -> XParse Lang
- newtype Language = Language {}
- parseLanguage :: String -> XParse Language
- data LeftCenterRight
- parseLeftCenterRight :: String -> XParse LeftCenterRight
- data LeftRight
- parseLeftRight :: String -> XParse LeftRight
- data LineEnd
- parseLineEnd :: String -> XParse LineEnd
- data LineLength
- parseLineLength :: String -> XParse LineLength
- data LineShape
- parseLineShape :: String -> XParse LineShape
- data LineType
- parseLineType :: String -> XParse LineType
- newtype LineWidthType = LineWidthType {}
- parseLineWidthType :: String -> XParse LineWidthType
- data MarginType
- parseMarginType :: String -> XParse MarginType
- data MeasureNumberingValue
- parseMeasureNumberingValue :: String -> XParse MeasureNumberingValue
- newtype MeasureText = MeasureText {
- measureText :: Token
- parseMeasureText :: String -> XParse MeasureText
- data Membrane
- = MembraneBassDrum
- | MembraneBassDrumOnSide
- | MembraneBongos
- | MembraneChineseTomtom
- | MembraneCongaDrum
- | MembraneCuica
- | MembraneGobletDrum
- | MembraneIndoAmericanTomtom
- | MembraneJapaneseTomtom
- | MembraneMilitaryDrum
- | MembraneSnareDrum
- | MembraneSnareDrumSnaresOff
- | MembraneTabla
- | MembraneTambourine
- | MembraneTenorDrum
- | MembraneTimbales
- | MembraneTomtom
- parseMembrane :: String -> XParse Membrane
- data Metal
- = MetalAgogo
- | MetalAlmglocken
- | MetalBell
- | MetalBellPlate
- | MetalBellTree
- | MetalBrakeDrum
- | MetalCencerro
- | MetalChainRattle
- | MetalChineseCymbal
- | MetalCowbell
- | MetalCrashCymbals
- | MetalCrotale
- | MetalCymbalTongs
- | MetalDomedGong
- | MetalFingerCymbals
- | MetalFlexatone
- | MetalGong
- | MetalHiHat
- | MetalHighHatCymbals
- | MetalHandbell
- | MetalJawHarp
- | MetalJingleBells
- | MetalMusicalSaw
- | MetalShellBells
- | MetalSistrum
- | MetalSizzleCymbal
- | MetalSleighBells
- | MetalSuspendedCymbal
- | MetalTamTam
- | MetalTamTamWithBeater
- | MetalTriangle
- | MetalVietnameseHat
- parseMetal :: String -> XParse Metal
- newtype Midi128 = Midi128 {}
- parseMidi128 :: String -> XParse Midi128
- newtype Midi16 = Midi16 {}
- parseMidi16 :: String -> XParse Midi16
- newtype Midi16384 = Midi16384 {}
- parseMidi16384 :: String -> XParse Midi16384
- newtype Millimeters = Millimeters {}
- parseMillimeters :: String -> XParse Millimeters
- newtype Mode = Mode {}
- parseMode :: String -> XParse Mode
- data Mute
- parseMute :: String -> XParse Mute
- newtype NonNegativeDecimal = NonNegativeDecimal {}
- parseNonNegativeDecimal :: String -> XParse NonNegativeDecimal
- newtype NonNegativeInteger = NonNegativeInteger {}
- parseNonNegativeInteger :: String -> XParse NonNegativeInteger
- newtype NormalizedString = NormalizedString {}
- parseNormalizedString :: String -> XParse NormalizedString
- data NoteSizeType
- parseNoteSizeType :: String -> XParse NoteSizeType
- data NoteTypeValue
- parseNoteTypeValue :: String -> XParse NoteTypeValue
- data NoteheadValue
- = NoteheadValueSlash
- | NoteheadValueTriangle
- | NoteheadValueDiamond
- | NoteheadValueSquare
- | NoteheadValueCross
- | NoteheadValueX
- | NoteheadValueCircleX
- | NoteheadValueInvertedTriangle
- | NoteheadValueArrowDown
- | NoteheadValueArrowUp
- | NoteheadValueCircled
- | NoteheadValueSlashed
- | NoteheadValueBackSlashed
- | NoteheadValueNormal
- | NoteheadValueCluster
- | NoteheadValueCircleDot
- | NoteheadValueLeftTriangle
- | NoteheadValueRectangle
- | NoteheadValueNone
- | NoteheadValueDo
- | NoteheadValueRe
- | NoteheadValueMi
- | NoteheadValueFa
- | NoteheadValueFaUp
- | NoteheadValueSo
- | NoteheadValueLa
- | NoteheadValueTi
- | NoteheadValueOther
- parseNoteheadValue :: String -> XParse NoteheadValue
- newtype NumberLevel = NumberLevel {}
- parseNumberLevel :: String -> XParse NumberLevel
- newtype NumberOfLines = NumberOfLines {}
- parseNumberOfLines :: String -> XParse NumberOfLines
- data NumberOrNormal
- parseNumberOrNormal :: String -> XParse NumberOrNormal
- newtype Octave = Octave {}
- parseOctave :: String -> XParse Octave
- data OnOff
- parseOnOff :: String -> XParse OnOff
- data OverUnder
- parseOverUnder :: String -> XParse OverUnder
- data PedalType
- parsePedalType :: String -> XParse PedalType
- newtype Percent = Percent {}
- parsePercent :: String -> XParse Percent
- data PitchedValue
- parsePitchedValue :: String -> XParse PitchedValue
- newtype PositiveDivisions = PositiveDivisions {}
- parsePositiveDivisions :: String -> XParse PositiveDivisions
- data PositiveIntegerOrEmpty
- parsePositiveIntegerOrEmpty :: String -> XParse PositiveIntegerOrEmpty
- newtype PositiveInteger = PositiveInteger {}
- parsePositiveInteger :: String -> XParse PositiveInteger
- data PrincipalVoiceSymbol
- parsePrincipalVoiceSymbol :: String -> XParse PrincipalVoiceSymbol
- data RightLeftMiddle
- parseRightLeftMiddle :: String -> XParse RightLeftMiddle
- newtype RotationDegrees = RotationDegrees {}
- parseRotationDegrees :: String -> XParse RotationDegrees
- data SemiPitched
- parseSemiPitched :: String -> XParse SemiPitched
- newtype Semitones = Semitones {}
- parseSemitones :: String -> XParse Semitones
- data SmpShow
- parseSmpShow :: String -> XParse SmpShow
- data ShowFrets
- parseShowFrets :: String -> XParse ShowFrets
- data ShowTuplet
- parseShowTuplet :: String -> XParse ShowTuplet
- newtype SmuflAccidentalGlyphName = SmuflAccidentalGlyphName {}
- parseSmuflAccidentalGlyphName :: String -> XParse SmuflAccidentalGlyphName
- newtype SmuflCodaGlyphName = SmuflCodaGlyphName {}
- parseSmuflCodaGlyphName :: String -> XParse SmuflCodaGlyphName
- newtype SmuflGlyphName = SmuflGlyphName {}
- parseSmuflGlyphName :: String -> XParse SmuflGlyphName
- newtype SmuflLyricsGlyphName = SmuflLyricsGlyphName {}
- parseSmuflLyricsGlyphName :: String -> XParse SmuflLyricsGlyphName
- newtype SmuflPictogramGlyphName = SmuflPictogramGlyphName {}
- parseSmuflPictogramGlyphName :: String -> XParse SmuflPictogramGlyphName
- newtype SmuflSegnoGlyphName = SmuflSegnoGlyphName {}
- parseSmuflSegnoGlyphName :: String -> XParse SmuflSegnoGlyphName
- data Space
- parseSpace :: String -> XParse Space
- data StaffDivideSymbol
- parseStaffDivideSymbol :: String -> XParse StaffDivideSymbol
- newtype StaffLine = StaffLine {}
- parseStaffLine :: String -> XParse StaffLine
- newtype StaffNumber = StaffNumber {}
- parseStaffNumber :: String -> XParse StaffNumber
- data StaffType
- parseStaffType :: String -> XParse StaffType
- data StartNote
- parseStartNote :: String -> XParse StartNote
- data StartStop
- parseStartStop :: String -> XParse StartStop
- data StartStopContinue
- parseStartStopContinue :: String -> XParse StartStopContinue
- data StartStopDiscontinue
- parseStartStopDiscontinue :: String -> XParse StartStopDiscontinue
- data StartStopSingle
- parseStartStopSingle :: String -> XParse StartStopSingle
- data StemValue
- parseStemValue :: String -> XParse StemValue
- data Step
- parseStep :: String -> XParse Step
- data StickLocation
- parseStickLocation :: String -> XParse StickLocation
- data StickMaterial
- parseStickMaterial :: String -> XParse StickMaterial
- data StickType
- parseStickType :: String -> XParse StickType
- newtype StringNumber = StringNumber {}
- parseStringNumber :: String -> XParse StringNumber
- data Syllabic
- parseSyllabic :: String -> XParse Syllabic
- data SymbolSize
- parseSymbolSize :: String -> XParse SymbolSize
- data TapHand
- parseTapHand :: String -> XParse TapHand
- newtype Tenths = Tenths {}
- parseTenths :: String -> XParse Tenths
- data TextDirection
- parseTextDirection :: String -> XParse TextDirection
- data TiedType
- parseTiedType :: String -> XParse TiedType
- newtype TimeOnly = TimeOnly {}
- parseTimeOnly :: String -> XParse TimeOnly
- data TimeRelation
- parseTimeRelation :: String -> XParse TimeRelation
- data TimeSeparator
- parseTimeSeparator :: String -> XParse TimeSeparator
- data TimeSymbol
- parseTimeSymbol :: String -> XParse TimeSymbol
- data TipDirection
- parseTipDirection :: String -> XParse TipDirection
- newtype Token = Token {}
- parseToken :: String -> XParse Token
- data TopBottom
- parseTopBottom :: String -> XParse TopBottom
- newtype TremoloMarks = TremoloMarks {
- tremoloMarks :: Int
- parseTremoloMarks :: String -> XParse TremoloMarks
- data TremoloType
- parseTremoloType :: String -> XParse TremoloType
- newtype TrillBeats = TrillBeats {}
- parseTrillBeats :: String -> XParse TrillBeats
- data TrillStep
- parseTrillStep :: String -> XParse TrillStep
- data TwoNoteTurn
- parseTwoNoteTurn :: String -> XParse TwoNoteTurn
- data Type = TypeSimple
- parseType :: String -> XParse Type
- data UpDown
- parseUpDown :: String -> XParse UpDown
- data UpDownStopContinue
- parseUpDownStopContinue :: String -> XParse UpDownStopContinue
- data UprightInverted
- parseUprightInverted :: String -> XParse UprightInverted
- data Valign
- parseValign :: String -> XParse Valign
- data ValignImage
- parseValignImage :: String -> XParse ValignImage
- data WedgeType
- parseWedgeType :: String -> XParse WedgeType
- data Winged
- parseWinged :: String -> XParse Winged
- data Wood
- = WoodBambooScraper
- | WoodBoardClapper
- | WoodCabasa
- | WoodCastanets
- | WoodCastanetsWithHandle
- | WoodClaves
- | WoodFootballRattle
- | WoodGuiro
- | WoodLogDrum
- | WoodMaraca
- | WoodMaracas
- | WoodQuijada
- | WoodRainstick
- | WoodRatchet
- | WoodRecoReco
- | WoodSandpaperBlocks
- | WoodSlitDrum
- | WoodTempleBlock
- | WoodVibraslap
- | WoodWhip
- | WoodWoodBlock
- parseWood :: String -> XParse Wood
- data YesNo
- parseYesNo :: String -> XParse YesNo
- data YesNoNumber
- = YesNoNumberYesNo { }
- | YesNoNumberDecimal { }
- parseYesNoNumber :: String -> XParse YesNoNumber
- newtype YyyyMmDd = YyyyMmDd {}
- parseYyyyMmDd :: String -> XParse YyyyMmDd
- data SumLang = SumLang
- parseSumLang :: String -> XParse SumLang
- data SumNumberOrNormal = NumberOrNormalNormal
- parseSumNumberOrNormal :: String -> XParse SumNumberOrNormal
- data SumPositiveIntegerOrEmpty = SumPositiveIntegerOrEmpty
- parseSumPositiveIntegerOrEmpty :: String -> XParse SumPositiveIntegerOrEmpty
- data Accidental = Accidental {
- accidentalAccidentalValue :: AccidentalValue
- accidentalCautionary :: Maybe YesNo
- accidentalEditorial :: Maybe YesNo
- accidentalSmufl :: Maybe SmuflAccidentalGlyphName
- accidentalParentheses :: Maybe YesNo
- accidentalBracket :: Maybe YesNo
- accidentalSize :: Maybe SymbolSize
- accidentalDefaultX :: Maybe Tenths
- accidentalDefaultY :: Maybe Tenths
- accidentalRelativeX :: Maybe Tenths
- accidentalRelativeY :: Maybe Tenths
- accidentalFontFamily :: Maybe CommaSeparatedText
- accidentalFontStyle :: Maybe FontStyle
- accidentalFontSize :: Maybe FontSize
- accidentalFontWeight :: Maybe FontWeight
- accidentalColor :: Maybe Color
- parseAccidental :: XParse Accidental
- mkAccidental :: AccidentalValue -> Accidental
- data AccidentalMark = AccidentalMark {
- accidentalMarkAccidentalValue :: AccidentalValue
- accidentalMarkSmufl :: Maybe SmuflAccidentalGlyphName
- accidentalMarkParentheses :: Maybe YesNo
- accidentalMarkBracket :: Maybe YesNo
- accidentalMarkSize :: Maybe SymbolSize
- accidentalMarkDefaultX :: Maybe Tenths
- accidentalMarkDefaultY :: Maybe Tenths
- accidentalMarkRelativeX :: Maybe Tenths
- accidentalMarkRelativeY :: Maybe Tenths
- accidentalMarkFontFamily :: Maybe CommaSeparatedText
- accidentalMarkFontStyle :: Maybe FontStyle
- accidentalMarkFontSize :: Maybe FontSize
- accidentalMarkFontWeight :: Maybe FontWeight
- accidentalMarkColor :: Maybe Color
- accidentalMarkPlacement :: Maybe AboveBelow
- accidentalMarkId :: Maybe ID
- parseAccidentalMark :: XParse AccidentalMark
- mkAccidentalMark :: AccidentalValue -> AccidentalMark
- data AccidentalText = AccidentalText {
- accidentalTextAccidentalValue :: AccidentalValue
- accidentalTextSmufl :: Maybe SmuflAccidentalGlyphName
- accidentalTextLang :: Maybe Lang
- accidentalTextSpace :: Maybe Space
- accidentalTextJustify :: Maybe LeftCenterRight
- accidentalTextDefaultX :: Maybe Tenths
- accidentalTextDefaultY :: Maybe Tenths
- accidentalTextRelativeX :: Maybe Tenths
- accidentalTextRelativeY :: Maybe Tenths
- accidentalTextFontFamily :: Maybe CommaSeparatedText
- accidentalTextFontStyle :: Maybe FontStyle
- accidentalTextFontSize :: Maybe FontSize
- accidentalTextFontWeight :: Maybe FontWeight
- accidentalTextColor :: Maybe Color
- accidentalTextHalign :: Maybe LeftCenterRight
- accidentalTextValign :: Maybe Valign
- accidentalTextUnderline :: Maybe NumberOfLines
- accidentalTextOverline :: Maybe NumberOfLines
- accidentalTextLineThrough :: Maybe NumberOfLines
- accidentalTextRotation :: Maybe RotationDegrees
- accidentalTextLetterSpacing :: Maybe NumberOrNormal
- accidentalTextLineHeight :: Maybe NumberOrNormal
- accidentalTextDir :: Maybe TextDirection
- accidentalTextEnclosure :: Maybe EnclosureShape
- parseAccidentalText :: XParse AccidentalText
- mkAccidentalText :: AccidentalValue -> AccidentalText
- data Accord = Accord {}
- parseAccord :: XParse Accord
- mkAccord :: Tuning -> Accord
- data AccordionRegistration = AccordionRegistration {
- accordionRegistrationDefaultX :: Maybe Tenths
- accordionRegistrationDefaultY :: Maybe Tenths
- accordionRegistrationRelativeX :: Maybe Tenths
- accordionRegistrationRelativeY :: Maybe Tenths
- accordionRegistrationFontFamily :: Maybe CommaSeparatedText
- accordionRegistrationFontStyle :: Maybe FontStyle
- accordionRegistrationFontSize :: Maybe FontSize
- accordionRegistrationFontWeight :: Maybe FontWeight
- accordionRegistrationColor :: Maybe Color
- accordionRegistrationHalign :: Maybe LeftCenterRight
- accordionRegistrationValign :: Maybe Valign
- accordionRegistrationId :: Maybe ID
- accordionRegistrationAccordionHigh :: Maybe Empty
- accordionRegistrationAccordionMiddle :: Maybe AccordionMiddle
- accordionRegistrationAccordionLow :: Maybe Empty
- parseAccordionRegistration :: XParse AccordionRegistration
- mkAccordionRegistration :: AccordionRegistration
- data Appearance = Appearance {}
- parseAppearance :: XParse Appearance
- mkAppearance :: Appearance
- data Arpeggiate = Arpeggiate {
- arpeggiateNumber :: Maybe NumberLevel
- arpeggiateDirection :: Maybe UpDown
- arpeggiateDefaultX :: Maybe Tenths
- arpeggiateDefaultY :: Maybe Tenths
- arpeggiateRelativeX :: Maybe Tenths
- arpeggiateRelativeY :: Maybe Tenths
- arpeggiatePlacement :: Maybe AboveBelow
- arpeggiateColor :: Maybe Color
- arpeggiateId :: Maybe ID
- parseArpeggiate :: XParse Arpeggiate
- mkArpeggiate :: Arpeggiate
- data Arrow = Arrow {
- arrowDefaultX :: Maybe Tenths
- arrowDefaultY :: Maybe Tenths
- arrowRelativeX :: Maybe Tenths
- arrowRelativeY :: Maybe Tenths
- arrowFontFamily :: Maybe CommaSeparatedText
- arrowFontStyle :: Maybe FontStyle
- arrowFontSize :: Maybe FontSize
- arrowFontWeight :: Maybe FontWeight
- arrowColor :: Maybe Color
- arrowPlacement :: Maybe AboveBelow
- arrowSmufl :: Maybe SmuflGlyphName
- arrowArrow :: ChxArrow
- parseArrow :: XParse Arrow
- mkArrow :: ChxArrow -> Arrow
- data Articulations = Articulations {}
- parseArticulations :: XParse Articulations
- mkArticulations :: Articulations
- data Attributes = Attributes {
- attributesEditorial :: Editorial
- attributesDivisions :: Maybe PositiveDivisions
- attributesKey :: [Key]
- attributesTime :: [Time]
- attributesStaves :: Maybe NonNegativeInteger
- attributesPartSymbol :: Maybe PartSymbol
- attributesInstruments :: Maybe NonNegativeInteger
- attributesClef :: [Clef]
- attributesStaffDetails :: [StaffDetails]
- attributesTranspose :: [Transpose]
- attributesDirective :: [Directive]
- attributesMeasureStyle :: [MeasureStyle]
- parseAttributes :: XParse Attributes
- mkAttributes :: Editorial -> Attributes
- data Backup = Backup {}
- parseBackup :: XParse Backup
- mkBackup :: Duration -> Editorial -> Backup
- data BarStyleColor = BarStyleColor {}
- parseBarStyleColor :: XParse BarStyleColor
- mkBarStyleColor :: BarStyle -> BarStyleColor
- data Barline = Barline {
- barlineLocation :: Maybe RightLeftMiddle
- barlineSegno :: Maybe Token
- barlineCoda :: Maybe Token
- barlineDivisions :: Maybe Divisions
- barlineId :: Maybe ID
- barlineBarStyle :: Maybe BarStyleColor
- barlineEditorial :: Editorial
- barlineWavyLine :: Maybe WavyLine
- barlineSegno1 :: Maybe Segno
- barlineCoda1 :: Maybe Coda
- barlineFermata :: [Fermata]
- barlineEnding :: Maybe Ending
- barlineRepeat :: Maybe Repeat
- parseBarline :: XParse Barline
- mkBarline :: Editorial -> Barline
- data Barre = Barre {}
- parseBarre :: XParse Barre
- mkBarre :: StartStop -> Barre
- data Bass = Bass {}
- parseBass :: XParse Bass
- mkBass :: BassStep -> Bass
- data BassAlter = BassAlter {
- bassAlterSemitones :: Semitones
- bassAlterLocation :: Maybe LeftRight
- bassAlterPrintObject :: Maybe YesNo
- bassAlterDefaultX :: Maybe Tenths
- bassAlterDefaultY :: Maybe Tenths
- bassAlterRelativeX :: Maybe Tenths
- bassAlterRelativeY :: Maybe Tenths
- bassAlterFontFamily :: Maybe CommaSeparatedText
- bassAlterFontStyle :: Maybe FontStyle
- bassAlterFontSize :: Maybe FontSize
- bassAlterFontWeight :: Maybe FontWeight
- bassAlterColor :: Maybe Color
- parseBassAlter :: XParse BassAlter
- mkBassAlter :: Semitones -> BassAlter
- data BassStep = BassStep {
- bassStepStep :: Step
- bassStepText :: Maybe Token
- bassStepDefaultX :: Maybe Tenths
- bassStepDefaultY :: Maybe Tenths
- bassStepRelativeX :: Maybe Tenths
- bassStepRelativeY :: Maybe Tenths
- bassStepFontFamily :: Maybe CommaSeparatedText
- bassStepFontStyle :: Maybe FontStyle
- bassStepFontSize :: Maybe FontSize
- bassStepFontWeight :: Maybe FontWeight
- bassStepColor :: Maybe Color
- parseBassStep :: XParse BassStep
- mkBassStep :: Step -> BassStep
- data Beam = Beam {}
- parseBeam :: XParse Beam
- mkBeam :: BeamValue -> Beam
- data BeatRepeat = BeatRepeat {}
- parseBeatRepeat :: XParse BeatRepeat
- mkBeatRepeat :: StartStop -> BeatRepeat
- data BeatUnitTied = BeatUnitTied {}
- parseBeatUnitTied :: XParse BeatUnitTied
- mkBeatUnitTied :: BeatUnit -> BeatUnitTied
- data Beater = Beater {}
- parseBeater :: XParse Beater
- mkBeater :: BeaterValue -> Beater
- data Bend = Bend {
- bendDefaultX :: Maybe Tenths
- bendDefaultY :: Maybe Tenths
- bendRelativeX :: Maybe Tenths
- bendRelativeY :: Maybe Tenths
- bendFontFamily :: Maybe CommaSeparatedText
- bendFontStyle :: Maybe FontStyle
- bendFontSize :: Maybe FontSize
- bendFontWeight :: Maybe FontWeight
- bendColor :: Maybe Color
- bendAccelerate :: Maybe YesNo
- bendBeats :: Maybe TrillBeats
- bendFirstBeat :: Maybe Percent
- bendLastBeat :: Maybe Percent
- bendBendAlter :: Semitones
- bendBend :: Maybe ChxBend
- bendWithBar :: Maybe PlacementText
- parseBend :: XParse Bend
- mkBend :: Semitones -> Bend
- data Bookmark = Bookmark {}
- parseBookmark :: XParse Bookmark
- mkBookmark :: ID -> Bookmark
- data Bracket = Bracket {
- bracketType :: StartStopContinue
- bracketNumber :: Maybe NumberLevel
- bracketLineEnd :: LineEnd
- bracketEndLength :: Maybe Tenths
- bracketLineType :: Maybe LineType
- bracketDashLength :: Maybe Tenths
- bracketSpaceLength :: Maybe Tenths
- bracketDefaultX :: Maybe Tenths
- bracketDefaultY :: Maybe Tenths
- bracketRelativeX :: Maybe Tenths
- bracketRelativeY :: Maybe Tenths
- bracketColor :: Maybe Color
- bracketId :: Maybe ID
- parseBracket :: XParse Bracket
- mkBracket :: StartStopContinue -> LineEnd -> Bracket
- data BreathMark = BreathMark {
- breathMarkBreathMarkValue :: BreathMarkValue
- breathMarkDefaultX :: Maybe Tenths
- breathMarkDefaultY :: Maybe Tenths
- breathMarkRelativeX :: Maybe Tenths
- breathMarkRelativeY :: Maybe Tenths
- breathMarkFontFamily :: Maybe CommaSeparatedText
- breathMarkFontStyle :: Maybe FontStyle
- breathMarkFontSize :: Maybe FontSize
- breathMarkFontWeight :: Maybe FontWeight
- breathMarkColor :: Maybe Color
- breathMarkPlacement :: Maybe AboveBelow
- parseBreathMark :: XParse BreathMark
- mkBreathMark :: BreathMarkValue -> BreathMark
- data Caesura = Caesura {
- caesuraCaesuraValue :: CaesuraValue
- caesuraDefaultX :: Maybe Tenths
- caesuraDefaultY :: Maybe Tenths
- caesuraRelativeX :: Maybe Tenths
- caesuraRelativeY :: Maybe Tenths
- caesuraFontFamily :: Maybe CommaSeparatedText
- caesuraFontStyle :: Maybe FontStyle
- caesuraFontSize :: Maybe FontSize
- caesuraFontWeight :: Maybe FontWeight
- caesuraColor :: Maybe Color
- caesuraPlacement :: Maybe AboveBelow
- parseCaesura :: XParse Caesura
- mkCaesura :: CaesuraValue -> Caesura
- data Cancel = Cancel {}
- parseCancel :: XParse Cancel
- mkCancel :: Fifths -> Cancel
- data Clef = Clef {
- clefNumber :: Maybe StaffNumber
- clefAdditional :: Maybe YesNo
- clefSize :: Maybe SymbolSize
- clefAfterBarline :: Maybe YesNo
- clefDefaultX :: Maybe Tenths
- clefDefaultY :: Maybe Tenths
- clefRelativeX :: Maybe Tenths
- clefRelativeY :: Maybe Tenths
- clefFontFamily :: Maybe CommaSeparatedText
- clefFontStyle :: Maybe FontStyle
- clefFontSize :: Maybe FontSize
- clefFontWeight :: Maybe FontWeight
- clefColor :: Maybe Color
- clefPrintObject :: Maybe YesNo
- clefId :: Maybe ID
- clefSign :: ClefSign
- clefLine :: Maybe StaffLine
- clefClefOctaveChange :: Maybe Int
- parseClef :: XParse Clef
- mkClef :: ClefSign -> Clef
- data Coda = Coda {
- codaSmufl :: Maybe SmuflCodaGlyphName
- codaDefaultX :: Maybe Tenths
- codaDefaultY :: Maybe Tenths
- codaRelativeX :: Maybe Tenths
- codaRelativeY :: Maybe Tenths
- codaFontFamily :: Maybe CommaSeparatedText
- codaFontStyle :: Maybe FontStyle
- codaFontSize :: Maybe FontSize
- codaFontWeight :: Maybe FontWeight
- codaColor :: Maybe Color
- codaHalign :: Maybe LeftCenterRight
- codaValign :: Maybe Valign
- codaId :: Maybe ID
- parseCoda :: XParse Coda
- mkCoda :: Coda
- data Credit = Credit {
- creditPage :: Maybe PositiveInteger
- creditId :: Maybe ID
- creditCreditType :: [String]
- creditLink :: [Link]
- creditBookmark :: [Bookmark]
- creditCredit :: ChxCredit
- parseCredit :: XParse Credit
- mkCredit :: ChxCredit -> Credit
- data Dashes = Dashes {}
- parseDashes :: XParse Dashes
- mkDashes :: StartStopContinue -> Dashes
- data Defaults = Defaults {}
- parseDefaults :: XParse Defaults
- mkDefaults :: Layout -> Defaults
- data Degree = Degree {}
- parseDegree :: XParse Degree
- mkDegree :: DegreeValue -> DegreeAlter -> DegreeType -> Degree
- data DegreeAlter = DegreeAlter {
- degreeAlterSemitones :: Semitones
- degreeAlterPlusMinus :: Maybe YesNo
- degreeAlterDefaultX :: Maybe Tenths
- degreeAlterDefaultY :: Maybe Tenths
- degreeAlterRelativeX :: Maybe Tenths
- degreeAlterRelativeY :: Maybe Tenths
- degreeAlterFontFamily :: Maybe CommaSeparatedText
- degreeAlterFontStyle :: Maybe FontStyle
- degreeAlterFontSize :: Maybe FontSize
- degreeAlterFontWeight :: Maybe FontWeight
- degreeAlterColor :: Maybe Color
- parseDegreeAlter :: XParse DegreeAlter
- mkDegreeAlter :: Semitones -> DegreeAlter
- data DegreeType = DegreeType {
- degreeTypeDegreeTypeValue :: DegreeTypeValue
- degreeTypeText :: Maybe Token
- degreeTypeDefaultX :: Maybe Tenths
- degreeTypeDefaultY :: Maybe Tenths
- degreeTypeRelativeX :: Maybe Tenths
- degreeTypeRelativeY :: Maybe Tenths
- degreeTypeFontFamily :: Maybe CommaSeparatedText
- degreeTypeFontStyle :: Maybe FontStyle
- degreeTypeFontSize :: Maybe FontSize
- degreeTypeFontWeight :: Maybe FontWeight
- degreeTypeColor :: Maybe Color
- parseDegreeType :: XParse DegreeType
- mkDegreeType :: DegreeTypeValue -> DegreeType
- data DegreeValue = DegreeValue {
- degreeValuePositiveInteger :: PositiveInteger
- degreeValueSymbol :: Maybe DegreeSymbolValue
- degreeValueText :: Maybe Token
- degreeValueDefaultX :: Maybe Tenths
- degreeValueDefaultY :: Maybe Tenths
- degreeValueRelativeX :: Maybe Tenths
- degreeValueRelativeY :: Maybe Tenths
- degreeValueFontFamily :: Maybe CommaSeparatedText
- degreeValueFontStyle :: Maybe FontStyle
- degreeValueFontSize :: Maybe FontSize
- degreeValueFontWeight :: Maybe FontWeight
- degreeValueColor :: Maybe Color
- parseDegreeValue :: XParse DegreeValue
- mkDegreeValue :: PositiveInteger -> DegreeValue
- data Direction = Direction {}
- parseDirection :: XParse Direction
- mkDirection :: EditorialVoiceDirection -> Direction
- data DirectionType = DirectionType {}
- parseDirectionType :: XParse DirectionType
- mkDirectionType :: ChxDirectionType -> DirectionType
- data Directive = Directive {
- directiveString :: String
- directiveLang :: Maybe Lang
- directiveDefaultX :: Maybe Tenths
- directiveDefaultY :: Maybe Tenths
- directiveRelativeX :: Maybe Tenths
- directiveRelativeY :: Maybe Tenths
- directiveFontFamily :: Maybe CommaSeparatedText
- directiveFontStyle :: Maybe FontStyle
- directiveFontSize :: Maybe FontSize
- directiveFontWeight :: Maybe FontWeight
- directiveColor :: Maybe Color
- parseDirective :: XParse Directive
- mkDirective :: String -> Directive
- data Distance = Distance {}
- parseDistance :: XParse Distance
- mkDistance :: Tenths -> DistanceType -> Distance
- data Dynamics = Dynamics {
- dynamicsDefaultX :: Maybe Tenths
- dynamicsDefaultY :: Maybe Tenths
- dynamicsRelativeX :: Maybe Tenths
- dynamicsRelativeY :: Maybe Tenths
- dynamicsFontFamily :: Maybe CommaSeparatedText
- dynamicsFontStyle :: Maybe FontStyle
- dynamicsFontSize :: Maybe FontSize
- dynamicsFontWeight :: Maybe FontWeight
- dynamicsColor :: Maybe Color
- dynamicsHalign :: Maybe LeftCenterRight
- dynamicsValign :: Maybe Valign
- dynamicsPlacement :: Maybe AboveBelow
- dynamicsUnderline :: Maybe NumberOfLines
- dynamicsOverline :: Maybe NumberOfLines
- dynamicsLineThrough :: Maybe NumberOfLines
- dynamicsEnclosure :: Maybe EnclosureShape
- dynamicsId :: Maybe ID
- dynamicsDynamics :: [ChxDynamics]
- parseDynamics :: XParse Dynamics
- mkDynamics :: Dynamics
- data Elision = Elision {}
- parseElision :: XParse Elision
- mkElision :: String -> Elision
- data Empty = Empty
- parseEmpty :: XParse Empty
- mkEmpty :: Empty
- data EmptyFont = EmptyFont {}
- parseEmptyFont :: XParse EmptyFont
- mkEmptyFont :: EmptyFont
- data EmptyLine = EmptyLine {
- emptyLineLineShape :: Maybe LineShape
- emptyLineLineType :: Maybe LineType
- emptyLineLineLength :: Maybe LineLength
- emptyLineDashLength :: Maybe Tenths
- emptyLineSpaceLength :: Maybe Tenths
- emptyLineDefaultX :: Maybe Tenths
- emptyLineDefaultY :: Maybe Tenths
- emptyLineRelativeX :: Maybe Tenths
- emptyLineRelativeY :: Maybe Tenths
- emptyLineFontFamily :: Maybe CommaSeparatedText
- emptyLineFontStyle :: Maybe FontStyle
- emptyLineFontSize :: Maybe FontSize
- emptyLineFontWeight :: Maybe FontWeight
- emptyLineColor :: Maybe Color
- emptyLinePlacement :: Maybe AboveBelow
- parseEmptyLine :: XParse EmptyLine
- mkEmptyLine :: EmptyLine
- data EmptyPlacement = EmptyPlacement {
- emptyPlacementDefaultX :: Maybe Tenths
- emptyPlacementDefaultY :: Maybe Tenths
- emptyPlacementRelativeX :: Maybe Tenths
- emptyPlacementRelativeY :: Maybe Tenths
- emptyPlacementFontFamily :: Maybe CommaSeparatedText
- emptyPlacementFontStyle :: Maybe FontStyle
- emptyPlacementFontSize :: Maybe FontSize
- emptyPlacementFontWeight :: Maybe FontWeight
- emptyPlacementColor :: Maybe Color
- emptyPlacementPlacement :: Maybe AboveBelow
- parseEmptyPlacement :: XParse EmptyPlacement
- mkEmptyPlacement :: EmptyPlacement
- data EmptyPlacementSmufl = EmptyPlacementSmufl {
- emptyPlacementSmuflDefaultX :: Maybe Tenths
- emptyPlacementSmuflDefaultY :: Maybe Tenths
- emptyPlacementSmuflRelativeX :: Maybe Tenths
- emptyPlacementSmuflRelativeY :: Maybe Tenths
- emptyPlacementSmuflFontFamily :: Maybe CommaSeparatedText
- emptyPlacementSmuflFontStyle :: Maybe FontStyle
- emptyPlacementSmuflFontSize :: Maybe FontSize
- emptyPlacementSmuflFontWeight :: Maybe FontWeight
- emptyPlacementSmuflColor :: Maybe Color
- emptyPlacementSmuflPlacement :: Maybe AboveBelow
- emptyPlacementSmuflSmufl :: Maybe SmuflGlyphName
- parseEmptyPlacementSmufl :: XParse EmptyPlacementSmufl
- mkEmptyPlacementSmufl :: EmptyPlacementSmufl
- data EmptyPrintObjectStyleAlign = EmptyPrintObjectStyleAlign {
- emptyPrintObjectStyleAlignPrintObject :: Maybe YesNo
- emptyPrintObjectStyleAlignDefaultX :: Maybe Tenths
- emptyPrintObjectStyleAlignDefaultY :: Maybe Tenths
- emptyPrintObjectStyleAlignRelativeX :: Maybe Tenths
- emptyPrintObjectStyleAlignRelativeY :: Maybe Tenths
- emptyPrintObjectStyleAlignFontFamily :: Maybe CommaSeparatedText
- emptyPrintObjectStyleAlignFontStyle :: Maybe FontStyle
- emptyPrintObjectStyleAlignFontSize :: Maybe FontSize
- emptyPrintObjectStyleAlignFontWeight :: Maybe FontWeight
- emptyPrintObjectStyleAlignColor :: Maybe Color
- emptyPrintObjectStyleAlignHalign :: Maybe LeftCenterRight
- emptyPrintObjectStyleAlignValign :: Maybe Valign
- parseEmptyPrintObjectStyleAlign :: XParse EmptyPrintObjectStyleAlign
- mkEmptyPrintObjectStyleAlign :: EmptyPrintObjectStyleAlign
- data EmptyPrintStyleAlignId = EmptyPrintStyleAlignId {
- emptyPrintStyleAlignIdDefaultX :: Maybe Tenths
- emptyPrintStyleAlignIdDefaultY :: Maybe Tenths
- emptyPrintStyleAlignIdRelativeX :: Maybe Tenths
- emptyPrintStyleAlignIdRelativeY :: Maybe Tenths
- emptyPrintStyleAlignIdFontFamily :: Maybe CommaSeparatedText
- emptyPrintStyleAlignIdFontStyle :: Maybe FontStyle
- emptyPrintStyleAlignIdFontSize :: Maybe FontSize
- emptyPrintStyleAlignIdFontWeight :: Maybe FontWeight
- emptyPrintStyleAlignIdColor :: Maybe Color
- emptyPrintStyleAlignIdHalign :: Maybe LeftCenterRight
- emptyPrintStyleAlignIdValign :: Maybe Valign
- emptyPrintStyleAlignIdId :: Maybe ID
- parseEmptyPrintStyleAlignId :: XParse EmptyPrintStyleAlignId
- mkEmptyPrintStyleAlignId :: EmptyPrintStyleAlignId
- data EmptyTrillSound = EmptyTrillSound {
- emptyTrillSoundDefaultX :: Maybe Tenths
- emptyTrillSoundDefaultY :: Maybe Tenths
- emptyTrillSoundRelativeX :: Maybe Tenths
- emptyTrillSoundRelativeY :: Maybe Tenths
- emptyTrillSoundFontFamily :: Maybe CommaSeparatedText
- emptyTrillSoundFontStyle :: Maybe FontStyle
- emptyTrillSoundFontSize :: Maybe FontSize
- emptyTrillSoundFontWeight :: Maybe FontWeight
- emptyTrillSoundColor :: Maybe Color
- emptyTrillSoundPlacement :: Maybe AboveBelow
- emptyTrillSoundStartNote :: Maybe StartNote
- emptyTrillSoundTrillStep :: Maybe TrillStep
- emptyTrillSoundTwoNoteTurn :: Maybe TwoNoteTurn
- emptyTrillSoundAccelerate :: Maybe YesNo
- emptyTrillSoundBeats :: Maybe TrillBeats
- emptyTrillSoundSecondBeat :: Maybe Percent
- emptyTrillSoundLastBeat :: Maybe Percent
- parseEmptyTrillSound :: XParse EmptyTrillSound
- mkEmptyTrillSound :: EmptyTrillSound
- data Encoding = Encoding {}
- parseEncoding :: XParse Encoding
- mkEncoding :: Encoding
- data Ending = Ending {
- endingString :: String
- cmpendingNumber :: EndingNumber
- endingType :: StartStopDiscontinue
- endingEndLength :: Maybe Tenths
- endingTextX :: Maybe Tenths
- endingTextY :: Maybe Tenths
- endingPrintObject :: Maybe YesNo
- endingDefaultX :: Maybe Tenths
- endingDefaultY :: Maybe Tenths
- endingRelativeX :: Maybe Tenths
- endingRelativeY :: Maybe Tenths
- endingFontFamily :: Maybe CommaSeparatedText
- endingFontStyle :: Maybe FontStyle
- endingFontSize :: Maybe FontSize
- endingFontWeight :: Maybe FontWeight
- endingColor :: Maybe Color
- parseEnding :: XParse Ending
- mkEnding :: String -> EndingNumber -> StartStopDiscontinue -> Ending
- data Extend = Extend {}
- parseExtend :: XParse Extend
- mkExtend :: Extend
- data Feature = Feature {}
- parseFeature :: XParse Feature
- mkFeature :: String -> Feature
- data Fermata = Fermata {
- fermataFermataShape :: FermataShape
- fermataType :: Maybe UprightInverted
- fermataDefaultX :: Maybe Tenths
- fermataDefaultY :: Maybe Tenths
- fermataRelativeX :: Maybe Tenths
- fermataRelativeY :: Maybe Tenths
- fermataFontFamily :: Maybe CommaSeparatedText
- fermataFontStyle :: Maybe FontStyle
- fermataFontSize :: Maybe FontSize
- fermataFontWeight :: Maybe FontWeight
- fermataColor :: Maybe Color
- fermataId :: Maybe ID
- parseFermata :: XParse Fermata
- mkFermata :: FermataShape -> Fermata
- data Figure = Figure {}
- parseFigure :: XParse Figure
- mkFigure :: Editorial -> Figure
- data FiguredBass = FiguredBass {
- figuredBassParentheses :: Maybe YesNo
- figuredBassDefaultX :: Maybe Tenths
- figuredBassDefaultY :: Maybe Tenths
- figuredBassRelativeX :: Maybe Tenths
- figuredBassRelativeY :: Maybe Tenths
- figuredBassFontFamily :: Maybe CommaSeparatedText
- figuredBassFontStyle :: Maybe FontStyle
- figuredBassFontSize :: Maybe FontSize
- figuredBassFontWeight :: Maybe FontWeight
- figuredBassColor :: Maybe Color
- figuredBassPrintDot :: Maybe YesNo
- figuredBassPrintLyric :: Maybe YesNo
- figuredBassPrintObject :: Maybe YesNo
- figuredBassPrintSpacing :: Maybe YesNo
- figuredBassId :: Maybe ID
- figuredBassFigure :: [Figure]
- figuredBassDuration :: Maybe Duration
- figuredBassEditorial :: Editorial
- parseFiguredBass :: XParse FiguredBass
- mkFiguredBass :: Editorial -> FiguredBass
- data Fingering = Fingering {
- fingeringString :: String
- fingeringSubstitution :: Maybe YesNo
- fingeringAlternate :: Maybe YesNo
- fingeringDefaultX :: Maybe Tenths
- fingeringDefaultY :: Maybe Tenths
- fingeringRelativeX :: Maybe Tenths
- fingeringRelativeY :: Maybe Tenths
- fingeringFontFamily :: Maybe CommaSeparatedText
- fingeringFontStyle :: Maybe FontStyle
- fingeringFontSize :: Maybe FontSize
- fingeringFontWeight :: Maybe FontWeight
- fingeringColor :: Maybe Color
- fingeringPlacement :: Maybe AboveBelow
- parseFingering :: XParse Fingering
- mkFingering :: String -> Fingering
- data FirstFret = FirstFret {}
- parseFirstFret :: XParse FirstFret
- mkFirstFret :: PositiveInteger -> FirstFret
- data FormattedSymbolId = FormattedSymbolId {
- formattedSymbolIdSmuflGlyphName :: SmuflGlyphName
- formattedSymbolIdJustify :: Maybe LeftCenterRight
- formattedSymbolIdDefaultX :: Maybe Tenths
- formattedSymbolIdDefaultY :: Maybe Tenths
- formattedSymbolIdRelativeX :: Maybe Tenths
- formattedSymbolIdRelativeY :: Maybe Tenths
- formattedSymbolIdFontFamily :: Maybe CommaSeparatedText
- formattedSymbolIdFontStyle :: Maybe FontStyle
- formattedSymbolIdFontSize :: Maybe FontSize
- formattedSymbolIdFontWeight :: Maybe FontWeight
- formattedSymbolIdColor :: Maybe Color
- formattedSymbolIdHalign :: Maybe LeftCenterRight
- formattedSymbolIdValign :: Maybe Valign
- formattedSymbolIdUnderline :: Maybe NumberOfLines
- formattedSymbolIdOverline :: Maybe NumberOfLines
- formattedSymbolIdLineThrough :: Maybe NumberOfLines
- formattedSymbolIdRotation :: Maybe RotationDegrees
- formattedSymbolIdLetterSpacing :: Maybe NumberOrNormal
- formattedSymbolIdLineHeight :: Maybe NumberOrNormal
- formattedSymbolIdDir :: Maybe TextDirection
- formattedSymbolIdEnclosure :: Maybe EnclosureShape
- formattedSymbolIdId :: Maybe ID
- parseFormattedSymbolId :: XParse FormattedSymbolId
- mkFormattedSymbolId :: SmuflGlyphName -> FormattedSymbolId
- data FormattedText = FormattedText {
- formattedTextString :: String
- formattedTextLang :: Maybe Lang
- formattedTextSpace :: Maybe Space
- formattedTextJustify :: Maybe LeftCenterRight
- formattedTextDefaultX :: Maybe Tenths
- formattedTextDefaultY :: Maybe Tenths
- formattedTextRelativeX :: Maybe Tenths
- formattedTextRelativeY :: Maybe Tenths
- formattedTextFontFamily :: Maybe CommaSeparatedText
- formattedTextFontStyle :: Maybe FontStyle
- formattedTextFontSize :: Maybe FontSize
- formattedTextFontWeight :: Maybe FontWeight
- formattedTextColor :: Maybe Color
- formattedTextHalign :: Maybe LeftCenterRight
- formattedTextValign :: Maybe Valign
- formattedTextUnderline :: Maybe NumberOfLines
- formattedTextOverline :: Maybe NumberOfLines
- formattedTextLineThrough :: Maybe NumberOfLines
- formattedTextRotation :: Maybe RotationDegrees
- formattedTextLetterSpacing :: Maybe NumberOrNormal
- formattedTextLineHeight :: Maybe NumberOrNormal
- formattedTextDir :: Maybe TextDirection
- formattedTextEnclosure :: Maybe EnclosureShape
- parseFormattedText :: XParse FormattedText
- mkFormattedText :: String -> FormattedText
- data FormattedTextId = FormattedTextId {
- formattedTextIdString :: String
- formattedTextIdLang :: Maybe Lang
- formattedTextIdSpace :: Maybe Space
- formattedTextIdJustify :: Maybe LeftCenterRight
- formattedTextIdDefaultX :: Maybe Tenths
- formattedTextIdDefaultY :: Maybe Tenths
- formattedTextIdRelativeX :: Maybe Tenths
- formattedTextIdRelativeY :: Maybe Tenths
- formattedTextIdFontFamily :: Maybe CommaSeparatedText
- formattedTextIdFontStyle :: Maybe FontStyle
- formattedTextIdFontSize :: Maybe FontSize
- formattedTextIdFontWeight :: Maybe FontWeight
- formattedTextIdColor :: Maybe Color
- formattedTextIdHalign :: Maybe LeftCenterRight
- formattedTextIdValign :: Maybe Valign
- formattedTextIdUnderline :: Maybe NumberOfLines
- formattedTextIdOverline :: Maybe NumberOfLines
- formattedTextIdLineThrough :: Maybe NumberOfLines
- formattedTextIdRotation :: Maybe RotationDegrees
- formattedTextIdLetterSpacing :: Maybe NumberOrNormal
- formattedTextIdLineHeight :: Maybe NumberOrNormal
- formattedTextIdDir :: Maybe TextDirection
- formattedTextIdEnclosure :: Maybe EnclosureShape
- formattedTextIdId :: Maybe ID
- parseFormattedTextId :: XParse FormattedTextId
- mkFormattedTextId :: String -> FormattedTextId
- data Forward = Forward {}
- parseForward :: XParse Forward
- mkForward :: Duration -> EditorialVoice -> Forward
- data Frame = Frame {
- frameHeight :: Maybe Tenths
- frameWidth :: Maybe Tenths
- frameUnplayed :: Maybe Token
- frameDefaultX :: Maybe Tenths
- frameDefaultY :: Maybe Tenths
- frameRelativeX :: Maybe Tenths
- frameRelativeY :: Maybe Tenths
- frameColor :: Maybe Color
- frameHalign :: Maybe LeftCenterRight
- frameValign :: Maybe ValignImage
- frameId :: Maybe ID
- frameFrameStrings :: PositiveInteger
- frameFrameFrets :: PositiveInteger
- frameFirstFret :: Maybe FirstFret
- frameFrameNote :: [FrameNote]
- parseFrame :: XParse Frame
- mkFrame :: PositiveInteger -> PositiveInteger -> Frame
- data FrameNote = FrameNote {}
- parseFrameNote :: XParse FrameNote
- mkFrameNote :: CmpString -> Fret -> FrameNote
- data Fret = Fret {}
- parseFret :: XParse Fret
- mkFret :: NonNegativeInteger -> Fret
- data Glass = Glass {}
- parseGlass :: XParse Glass
- mkGlass :: GlassValue -> Glass
- data Glissando = Glissando {
- glissandoString :: String
- glissandoType :: StartStop
- glissandoNumber :: Maybe NumberLevel
- glissandoLineType :: Maybe LineType
- glissandoDashLength :: Maybe Tenths
- glissandoSpaceLength :: Maybe Tenths
- glissandoDefaultX :: Maybe Tenths
- glissandoDefaultY :: Maybe Tenths
- glissandoRelativeX :: Maybe Tenths
- glissandoRelativeY :: Maybe Tenths
- glissandoFontFamily :: Maybe CommaSeparatedText
- glissandoFontStyle :: Maybe FontStyle
- glissandoFontSize :: Maybe FontSize
- glissandoFontWeight :: Maybe FontWeight
- glissandoColor :: Maybe Color
- glissandoId :: Maybe ID
- parseGlissando :: XParse Glissando
- mkGlissando :: String -> StartStop -> Glissando
- data Glyph = Glyph {}
- parseGlyph :: XParse Glyph
- mkGlyph :: SmuflGlyphName -> GlyphType -> Glyph
- data Grace = Grace {}
- parseGrace :: XParse Grace
- mkGrace :: Grace
- data GroupBarline = GroupBarline {}
- parseGroupBarline :: XParse GroupBarline
- mkGroupBarline :: GroupBarlineValue -> GroupBarline
- data GroupName = GroupName {
- groupNameString :: String
- groupNameDefaultX :: Maybe Tenths
- groupNameDefaultY :: Maybe Tenths
- groupNameRelativeX :: Maybe Tenths
- groupNameRelativeY :: Maybe Tenths
- groupNameFontFamily :: Maybe CommaSeparatedText
- groupNameFontStyle :: Maybe FontStyle
- groupNameFontSize :: Maybe FontSize
- groupNameFontWeight :: Maybe FontWeight
- groupNameColor :: Maybe Color
- groupNameJustify :: Maybe LeftCenterRight
- parseGroupName :: XParse GroupName
- mkGroupName :: String -> GroupName
- data GroupSymbol = GroupSymbol {}
- parseGroupSymbol :: XParse GroupSymbol
- mkGroupSymbol :: GroupSymbolValue -> GroupSymbol
- data Grouping = Grouping {}
- parseGrouping :: XParse Grouping
- mkGrouping :: StartStopSingle -> Grouping
- data HammerOnPullOff = HammerOnPullOff {
- hammerOnPullOffString :: String
- hammerOnPullOffType :: StartStop
- hammerOnPullOffNumber :: Maybe NumberLevel
- hammerOnPullOffDefaultX :: Maybe Tenths
- hammerOnPullOffDefaultY :: Maybe Tenths
- hammerOnPullOffRelativeX :: Maybe Tenths
- hammerOnPullOffRelativeY :: Maybe Tenths
- hammerOnPullOffFontFamily :: Maybe CommaSeparatedText
- hammerOnPullOffFontStyle :: Maybe FontStyle
- hammerOnPullOffFontSize :: Maybe FontSize
- hammerOnPullOffFontWeight :: Maybe FontWeight
- hammerOnPullOffColor :: Maybe Color
- hammerOnPullOffPlacement :: Maybe AboveBelow
- parseHammerOnPullOff :: XParse HammerOnPullOff
- mkHammerOnPullOff :: String -> StartStop -> HammerOnPullOff
- data Handbell = Handbell {
- handbellHandbellValue :: HandbellValue
- handbellDefaultX :: Maybe Tenths
- handbellDefaultY :: Maybe Tenths
- handbellRelativeX :: Maybe Tenths
- handbellRelativeY :: Maybe Tenths
- handbellFontFamily :: Maybe CommaSeparatedText
- handbellFontStyle :: Maybe FontStyle
- handbellFontSize :: Maybe FontSize
- handbellFontWeight :: Maybe FontWeight
- handbellColor :: Maybe Color
- handbellPlacement :: Maybe AboveBelow
- parseHandbell :: XParse Handbell
- mkHandbell :: HandbellValue -> Handbell
- data HarmonClosed = HarmonClosed {}
- parseHarmonClosed :: XParse HarmonClosed
- mkHarmonClosed :: HarmonClosedValue -> HarmonClosed
- data HarmonMute = HarmonMute {
- harmonMuteDefaultX :: Maybe Tenths
- harmonMuteDefaultY :: Maybe Tenths
- harmonMuteRelativeX :: Maybe Tenths
- harmonMuteRelativeY :: Maybe Tenths
- harmonMuteFontFamily :: Maybe CommaSeparatedText
- harmonMuteFontStyle :: Maybe FontStyle
- harmonMuteFontSize :: Maybe FontSize
- harmonMuteFontWeight :: Maybe FontWeight
- harmonMuteColor :: Maybe Color
- harmonMutePlacement :: Maybe AboveBelow
- harmonMuteHarmonClosed :: HarmonClosed
- parseHarmonMute :: XParse HarmonMute
- mkHarmonMute :: HarmonClosed -> HarmonMute
- data Harmonic = Harmonic {
- harmonicPrintObject :: Maybe YesNo
- harmonicDefaultX :: Maybe Tenths
- harmonicDefaultY :: Maybe Tenths
- harmonicRelativeX :: Maybe Tenths
- harmonicRelativeY :: Maybe Tenths
- harmonicFontFamily :: Maybe CommaSeparatedText
- harmonicFontStyle :: Maybe FontStyle
- harmonicFontSize :: Maybe FontSize
- harmonicFontWeight :: Maybe FontWeight
- harmonicColor :: Maybe Color
- harmonicPlacement :: Maybe AboveBelow
- harmonicHarmonic :: Maybe ChxHarmonic
- harmonicHarmonic1 :: Maybe ChxHarmonic1
- parseHarmonic :: XParse Harmonic
- mkHarmonic :: Harmonic
- data Harmony = Harmony {
- harmonyType :: Maybe HarmonyType
- harmonyPrintFrame :: Maybe YesNo
- harmonyPrintObject :: Maybe YesNo
- harmonyDefaultX :: Maybe Tenths
- harmonyDefaultY :: Maybe Tenths
- harmonyRelativeX :: Maybe Tenths
- harmonyRelativeY :: Maybe Tenths
- harmonyFontFamily :: Maybe CommaSeparatedText
- harmonyFontStyle :: Maybe FontStyle
- harmonyFontSize :: Maybe FontSize
- harmonyFontWeight :: Maybe FontWeight
- harmonyColor :: Maybe Color
- harmonyPlacement :: Maybe AboveBelow
- harmonyId :: Maybe ID
- harmonyHarmonyChord :: [HarmonyChord]
- harmonyFrame :: Maybe Frame
- harmonyOffset :: Maybe Offset
- harmonyEditorial :: Editorial
- harmonyStaff :: Maybe Staff
- parseHarmony :: XParse Harmony
- mkHarmony :: Editorial -> Harmony
- data HarpPedals = HarpPedals {
- harpPedalsDefaultX :: Maybe Tenths
- harpPedalsDefaultY :: Maybe Tenths
- harpPedalsRelativeX :: Maybe Tenths
- harpPedalsRelativeY :: Maybe Tenths
- harpPedalsFontFamily :: Maybe CommaSeparatedText
- harpPedalsFontStyle :: Maybe FontStyle
- harpPedalsFontSize :: Maybe FontSize
- harpPedalsFontWeight :: Maybe FontWeight
- harpPedalsColor :: Maybe Color
- harpPedalsHalign :: Maybe LeftCenterRight
- harpPedalsValign :: Maybe Valign
- harpPedalsId :: Maybe ID
- harpPedalsPedalTuning :: [PedalTuning]
- parseHarpPedals :: XParse HarpPedals
- mkHarpPedals :: HarpPedals
- data HeelToe = HeelToe {}
- parseHeelToe :: XParse HeelToe
- mkHeelToe :: HeelToe -> HeelToe
- data Hole = Hole {
- holeDefaultX :: Maybe Tenths
- holeDefaultY :: Maybe Tenths
- holeRelativeX :: Maybe Tenths
- holeRelativeY :: Maybe Tenths
- holeFontFamily :: Maybe CommaSeparatedText
- holeFontStyle :: Maybe FontStyle
- holeFontSize :: Maybe FontSize
- holeFontWeight :: Maybe FontWeight
- holeColor :: Maybe Color
- holePlacement :: Maybe AboveBelow
- holeHoleType :: Maybe String
- holeHoleClosed :: HoleClosed
- holeHoleShape :: Maybe String
- parseHole :: XParse Hole
- mkHole :: HoleClosed -> Hole
- data HoleClosed = HoleClosed {}
- parseHoleClosed :: XParse HoleClosed
- mkHoleClosed :: HoleClosedValue -> HoleClosed
- data HorizontalTurn = HorizontalTurn {
- horizontalTurnSlash :: Maybe YesNo
- horizontalTurnDefaultX :: Maybe Tenths
- horizontalTurnDefaultY :: Maybe Tenths
- horizontalTurnRelativeX :: Maybe Tenths
- horizontalTurnRelativeY :: Maybe Tenths
- horizontalTurnFontFamily :: Maybe CommaSeparatedText
- horizontalTurnFontStyle :: Maybe FontStyle
- horizontalTurnFontSize :: Maybe FontSize
- horizontalTurnFontWeight :: Maybe FontWeight
- horizontalTurnColor :: Maybe Color
- horizontalTurnPlacement :: Maybe AboveBelow
- horizontalTurnStartNote :: Maybe StartNote
- horizontalTurnTrillStep :: Maybe TrillStep
- horizontalTurnTwoNoteTurn :: Maybe TwoNoteTurn
- horizontalTurnAccelerate :: Maybe YesNo
- horizontalTurnBeats :: Maybe TrillBeats
- horizontalTurnSecondBeat :: Maybe Percent
- horizontalTurnLastBeat :: Maybe Percent
- parseHorizontalTurn :: XParse HorizontalTurn
- mkHorizontalTurn :: HorizontalTurn
- data Identification = Identification {}
- parseIdentification :: XParse Identification
- mkIdentification :: Identification
- data Image = Image {}
- parseImage :: XParse Image
- mkImage :: String -> Token -> Image
- data Instrument = Instrument {}
- parseInstrument :: XParse Instrument
- mkInstrument :: IDREF -> Instrument
- data Interchangeable = Interchangeable {}
- parseInterchangeable :: XParse Interchangeable
- mkInterchangeable :: Interchangeable
- data Inversion = Inversion {
- inversionNonNegativeInteger :: NonNegativeInteger
- inversionDefaultX :: Maybe Tenths
- inversionDefaultY :: Maybe Tenths
- inversionRelativeX :: Maybe Tenths
- inversionRelativeY :: Maybe Tenths
- inversionFontFamily :: Maybe CommaSeparatedText
- inversionFontStyle :: Maybe FontStyle
- inversionFontSize :: Maybe FontSize
- inversionFontWeight :: Maybe FontWeight
- inversionColor :: Maybe Color
- parseInversion :: XParse Inversion
- mkInversion :: NonNegativeInteger -> Inversion
- data Key = Key {
- keyNumber :: Maybe StaffNumber
- keyDefaultX :: Maybe Tenths
- keyDefaultY :: Maybe Tenths
- keyRelativeX :: Maybe Tenths
- keyRelativeY :: Maybe Tenths
- keyFontFamily :: Maybe CommaSeparatedText
- keyFontStyle :: Maybe FontStyle
- keyFontSize :: Maybe FontSize
- keyFontWeight :: Maybe FontWeight
- keyColor :: Maybe Color
- keyPrintObject :: Maybe YesNo
- keyId :: Maybe ID
- keyKey :: ChxKey
- keyKeyOctave :: [KeyOctave]
- parseKey :: XParse Key
- mkKey :: ChxKey -> Key
- data KeyAccidental = KeyAccidental {}
- parseKeyAccidental :: XParse KeyAccidental
- mkKeyAccidental :: AccidentalValue -> KeyAccidental
- data KeyOctave = KeyOctave {}
- parseKeyOctave :: XParse KeyOctave
- mkKeyOctave :: Octave -> PositiveInteger -> KeyOctave
- data Kind = Kind {
- kindKindValue :: KindValue
- kindUseSymbols :: Maybe YesNo
- kindText :: Maybe Token
- kindStackDegrees :: Maybe YesNo
- kindParenthesesDegrees :: Maybe YesNo
- kindBracketDegrees :: Maybe YesNo
- kindDefaultX :: Maybe Tenths
- kindDefaultY :: Maybe Tenths
- kindRelativeX :: Maybe Tenths
- kindRelativeY :: Maybe Tenths
- kindFontFamily :: Maybe CommaSeparatedText
- kindFontStyle :: Maybe FontStyle
- kindFontSize :: Maybe FontSize
- kindFontWeight :: Maybe FontWeight
- kindColor :: Maybe Color
- kindHalign :: Maybe LeftCenterRight
- kindValign :: Maybe Valign
- parseKind :: XParse Kind
- mkKind :: KindValue -> Kind
- data Level = Level {}
- parseLevel :: XParse Level
- mkLevel :: String -> Level
- data LineWidth = LineWidth {}
- parseLineWidth :: XParse LineWidth
- mkLineWidth :: Tenths -> LineWidthType -> LineWidth
- data Link = Link {
- linkName :: Maybe Token
- linkHref :: String
- linkType :: Maybe Type
- linkRole :: Maybe Token
- linkTitle :: Maybe Token
- linkShow :: Maybe SmpShow
- linkActuate :: Maybe Actuate
- linkElement :: Maybe NMTOKEN
- linkPosition :: Maybe PositiveInteger
- linkDefaultX :: Maybe Tenths
- linkDefaultY :: Maybe Tenths
- linkRelativeX :: Maybe Tenths
- linkRelativeY :: Maybe Tenths
- parseLink :: XParse Link
- mkLink :: String -> Link
- data Lyric = Lyric {
- lyricNumber :: Maybe NMTOKEN
- lyricName :: Maybe Token
- lyricTimeOnly :: Maybe TimeOnly
- lyricJustify :: Maybe LeftCenterRight
- lyricDefaultX :: Maybe Tenths
- lyricDefaultY :: Maybe Tenths
- lyricRelativeX :: Maybe Tenths
- lyricRelativeY :: Maybe Tenths
- lyricPlacement :: Maybe AboveBelow
- lyricColor :: Maybe Color
- lyricPrintObject :: Maybe YesNo
- lyricId :: Maybe ID
- lyricLyric :: ChxLyric
- lyricEndLine :: Maybe Empty
- lyricEndParagraph :: Maybe Empty
- lyricEditorial :: Editorial
- parseLyric :: XParse Lyric
- mkLyric :: ChxLyric -> Editorial -> Lyric
- data LyricFont = LyricFont {}
- parseLyricFont :: XParse LyricFont
- mkLyricFont :: LyricFont
- data LyricLanguage = LyricLanguage {}
- parseLyricLanguage :: XParse LyricLanguage
- mkLyricLanguage :: Lang -> LyricLanguage
- data Measure = Measure {}
- parseMeasure :: XParse Measure
- mkMeasure :: Token -> MusicData -> Measure
- data CmpMeasure = CmpMeasure {}
- parseCmpMeasure :: XParse CmpMeasure
- mkCmpMeasure :: Token -> CmpMeasure
- data MeasureLayout = MeasureLayout {}
- parseMeasureLayout :: XParse MeasureLayout
- mkMeasureLayout :: MeasureLayout
- data MeasureNumbering = MeasureNumbering {
- measureNumberingMeasureNumberingValue :: MeasureNumberingValue
- measureNumberingDefaultX :: Maybe Tenths
- measureNumberingDefaultY :: Maybe Tenths
- measureNumberingRelativeX :: Maybe Tenths
- measureNumberingRelativeY :: Maybe Tenths
- measureNumberingFontFamily :: Maybe CommaSeparatedText
- measureNumberingFontStyle :: Maybe FontStyle
- measureNumberingFontSize :: Maybe FontSize
- measureNumberingFontWeight :: Maybe FontWeight
- measureNumberingColor :: Maybe Color
- measureNumberingHalign :: Maybe LeftCenterRight
- measureNumberingValign :: Maybe Valign
- parseMeasureNumbering :: XParse MeasureNumbering
- mkMeasureNumbering :: MeasureNumberingValue -> MeasureNumbering
- data MeasureRepeat = MeasureRepeat {}
- parseMeasureRepeat :: XParse MeasureRepeat
- mkMeasureRepeat :: PositiveIntegerOrEmpty -> StartStop -> MeasureRepeat
- data MeasureStyle = MeasureStyle {
- measureStyleNumber :: Maybe StaffNumber
- measureStyleFontFamily :: Maybe CommaSeparatedText
- measureStyleFontStyle :: Maybe FontStyle
- measureStyleFontSize :: Maybe FontSize
- measureStyleFontWeight :: Maybe FontWeight
- measureStyleColor :: Maybe Color
- measureStyleId :: Maybe ID
- measureStyleMeasureStyle :: ChxMeasureStyle
- parseMeasureStyle :: XParse MeasureStyle
- mkMeasureStyle :: ChxMeasureStyle -> MeasureStyle
- data Metronome = Metronome {
- metronomeParentheses :: Maybe YesNo
- metronomeDefaultX :: Maybe Tenths
- metronomeDefaultY :: Maybe Tenths
- metronomeRelativeX :: Maybe Tenths
- metronomeRelativeY :: Maybe Tenths
- metronomeFontFamily :: Maybe CommaSeparatedText
- metronomeFontStyle :: Maybe FontStyle
- metronomeFontSize :: Maybe FontSize
- metronomeFontWeight :: Maybe FontWeight
- metronomeColor :: Maybe Color
- metronomeHalign :: Maybe LeftCenterRight
- metronomeValign :: Maybe Valign
- metronomeJustify :: Maybe LeftCenterRight
- metronomeId :: Maybe ID
- metronomeMetronome :: ChxMetronome
- parseMetronome :: XParse Metronome
- mkMetronome :: ChxMetronome -> Metronome
- data MetronomeBeam = MetronomeBeam {}
- parseMetronomeBeam :: XParse MetronomeBeam
- mkMetronomeBeam :: BeamValue -> MetronomeBeam
- data MetronomeNote = MetronomeNote {}
- parseMetronomeNote :: XParse MetronomeNote
- mkMetronomeNote :: NoteTypeValue -> MetronomeNote
- data MetronomeTied = MetronomeTied {}
- parseMetronomeTied :: XParse MetronomeTied
- mkMetronomeTied :: StartStop -> MetronomeTied
- data MetronomeTuplet = MetronomeTuplet {}
- parseMetronomeTuplet :: XParse MetronomeTuplet
- mkMetronomeTuplet :: MetronomeTuplet -> StartStop -> MetronomeTuplet
- data MidiDevice = MidiDevice {}
- parseMidiDevice :: XParse MidiDevice
- mkMidiDevice :: String -> MidiDevice
- data MidiInstrument = MidiInstrument {
- midiInstrumentId :: IDREF
- midiInstrumentMidiChannel :: Maybe Midi16
- midiInstrumentMidiName :: Maybe String
- midiInstrumentMidiBank :: Maybe Midi16384
- midiInstrumentMidiProgram :: Maybe Midi128
- midiInstrumentMidiUnpitched :: Maybe Midi128
- midiInstrumentVolume :: Maybe Percent
- midiInstrumentPan :: Maybe RotationDegrees
- midiInstrumentElevation :: Maybe RotationDegrees
- parseMidiInstrument :: XParse MidiInstrument
- mkMidiInstrument :: IDREF -> MidiInstrument
- data Miscellaneous = Miscellaneous {}
- parseMiscellaneous :: XParse Miscellaneous
- mkMiscellaneous :: Miscellaneous
- data MiscellaneousField = MiscellaneousField {}
- parseMiscellaneousField :: XParse MiscellaneousField
- mkMiscellaneousField :: String -> Token -> MiscellaneousField
- data Mordent = Mordent {}
- parseMordent :: XParse Mordent
- mkMordent :: Mordent -> Mordent
- data MultipleRest = MultipleRest {}
- parseMultipleRest :: XParse MultipleRest
- mkMultipleRest :: PositiveIntegerOrEmpty -> MultipleRest
- data NameDisplay = NameDisplay {}
- parseNameDisplay :: XParse NameDisplay
- mkNameDisplay :: NameDisplay
- data NonArpeggiate = NonArpeggiate {
- nonArpeggiateType :: TopBottom
- nonArpeggiateNumber :: Maybe NumberLevel
- nonArpeggiateDefaultX :: Maybe Tenths
- nonArpeggiateDefaultY :: Maybe Tenths
- nonArpeggiateRelativeX :: Maybe Tenths
- nonArpeggiateRelativeY :: Maybe Tenths
- nonArpeggiatePlacement :: Maybe AboveBelow
- nonArpeggiateColor :: Maybe Color
- nonArpeggiateId :: Maybe ID
- parseNonArpeggiate :: XParse NonArpeggiate
- mkNonArpeggiate :: TopBottom -> NonArpeggiate
- data Notations = Notations {}
- parseNotations :: XParse Notations
- mkNotations :: Editorial -> Notations
- data Note = Note {
- notePrintLeger :: Maybe YesNo
- noteDynamics :: Maybe NonNegativeDecimal
- noteEndDynamics :: Maybe NonNegativeDecimal
- noteAttack :: Maybe Divisions
- noteRelease :: Maybe Divisions
- noteTimeOnly :: Maybe TimeOnly
- notePizzicato :: Maybe YesNo
- noteDefaultX :: Maybe Tenths
- noteDefaultY :: Maybe Tenths
- noteRelativeX :: Maybe Tenths
- noteRelativeY :: Maybe Tenths
- noteFontFamily :: Maybe CommaSeparatedText
- noteFontStyle :: Maybe FontStyle
- noteFontSize :: Maybe FontSize
- noteFontWeight :: Maybe FontWeight
- noteColor :: Maybe Color
- notePrintDot :: Maybe YesNo
- notePrintLyric :: Maybe YesNo
- notePrintObject :: Maybe YesNo
- notePrintSpacing :: Maybe YesNo
- noteId :: Maybe ID
- noteNote :: ChxNote
- noteInstrument :: Maybe Instrument
- noteEditorialVoice :: EditorialVoice
- noteType :: Maybe NoteType
- noteDot :: [EmptyPlacement]
- noteAccidental :: Maybe Accidental
- noteTimeModification :: Maybe TimeModification
- noteStem :: Maybe Stem
- noteNotehead :: Maybe Notehead
- noteNoteheadText :: Maybe NoteheadText
- noteStaff :: Maybe Staff
- noteBeam :: [Beam]
- noteNotations :: [Notations]
- noteLyric :: [Lyric]
- notePlay :: Maybe Play
- parseNote :: XParse Note
- mkNote :: ChxNote -> EditorialVoice -> Note
- data NoteSize = NoteSize {}
- parseNoteSize :: XParse NoteSize
- mkNoteSize :: NonNegativeDecimal -> NoteSizeType -> NoteSize
- data NoteType = NoteType {}
- parseNoteType :: XParse NoteType
- mkNoteType :: NoteTypeValue -> NoteType
- data Notehead = Notehead {
- noteheadNoteheadValue :: NoteheadValue
- noteheadFilled :: Maybe YesNo
- noteheadParentheses :: Maybe YesNo
- noteheadFontFamily :: Maybe CommaSeparatedText
- noteheadFontStyle :: Maybe FontStyle
- noteheadFontSize :: Maybe FontSize
- noteheadFontWeight :: Maybe FontWeight
- noteheadColor :: Maybe Color
- noteheadSmufl :: Maybe SmuflGlyphName
- parseNotehead :: XParse Notehead
- mkNotehead :: NoteheadValue -> Notehead
- data NoteheadText = NoteheadText {}
- parseNoteheadText :: XParse NoteheadText
- mkNoteheadText :: NoteheadText
- data OctaveShift = OctaveShift {
- octaveShiftType :: UpDownStopContinue
- octaveShiftNumber :: Maybe NumberLevel
- octaveShiftSize :: Maybe PositiveInteger
- octaveShiftDashLength :: Maybe Tenths
- octaveShiftSpaceLength :: Maybe Tenths
- octaveShiftDefaultX :: Maybe Tenths
- octaveShiftDefaultY :: Maybe Tenths
- octaveShiftRelativeX :: Maybe Tenths
- octaveShiftRelativeY :: Maybe Tenths
- octaveShiftFontFamily :: Maybe CommaSeparatedText
- octaveShiftFontStyle :: Maybe FontStyle
- octaveShiftFontSize :: Maybe FontSize
- octaveShiftFontWeight :: Maybe FontWeight
- octaveShiftColor :: Maybe Color
- octaveShiftId :: Maybe ID
- parseOctaveShift :: XParse OctaveShift
- mkOctaveShift :: UpDownStopContinue -> OctaveShift
- data Offset = Offset {}
- parseOffset :: XParse Offset
- mkOffset :: Divisions -> Offset
- data Opus = Opus {}
- parseOpus :: XParse Opus
- mkOpus :: String -> Opus
- data Ornaments = Ornaments {}
- parseOrnaments :: XParse Ornaments
- mkOrnaments :: Ornaments
- data OtherAppearance = OtherAppearance {}
- parseOtherAppearance :: XParse OtherAppearance
- mkOtherAppearance :: String -> Token -> OtherAppearance
- data OtherDirection = OtherDirection {
- otherDirectionString :: String
- otherDirectionPrintObject :: Maybe YesNo
- otherDirectionDefaultX :: Maybe Tenths
- otherDirectionDefaultY :: Maybe Tenths
- otherDirectionRelativeX :: Maybe Tenths
- otherDirectionRelativeY :: Maybe Tenths
- otherDirectionFontFamily :: Maybe CommaSeparatedText
- otherDirectionFontStyle :: Maybe FontStyle
- otherDirectionFontSize :: Maybe FontSize
- otherDirectionFontWeight :: Maybe FontWeight
- otherDirectionColor :: Maybe Color
- otherDirectionHalign :: Maybe LeftCenterRight
- otherDirectionValign :: Maybe Valign
- otherDirectionSmufl :: Maybe SmuflGlyphName
- otherDirectionId :: Maybe ID
- parseOtherDirection :: XParse OtherDirection
- mkOtherDirection :: String -> OtherDirection
- data OtherNotation = OtherNotation {
- otherNotationString :: String
- otherNotationType :: StartStopSingle
- otherNotationNumber :: Maybe NumberLevel
- otherNotationPrintObject :: Maybe YesNo
- otherNotationDefaultX :: Maybe Tenths
- otherNotationDefaultY :: Maybe Tenths
- otherNotationRelativeX :: Maybe Tenths
- otherNotationRelativeY :: Maybe Tenths
- otherNotationFontFamily :: Maybe CommaSeparatedText
- otherNotationFontStyle :: Maybe FontStyle
- otherNotationFontSize :: Maybe FontSize
- otherNotationFontWeight :: Maybe FontWeight
- otherNotationColor :: Maybe Color
- otherNotationPlacement :: Maybe AboveBelow
- otherNotationSmufl :: Maybe SmuflGlyphName
- otherNotationId :: Maybe ID
- parseOtherNotation :: XParse OtherNotation
- mkOtherNotation :: String -> StartStopSingle -> OtherNotation
- data OtherPlacementText = OtherPlacementText {
- otherPlacementTextString :: String
- otherPlacementTextDefaultX :: Maybe Tenths
- otherPlacementTextDefaultY :: Maybe Tenths
- otherPlacementTextRelativeX :: Maybe Tenths
- otherPlacementTextRelativeY :: Maybe Tenths
- otherPlacementTextFontFamily :: Maybe CommaSeparatedText
- otherPlacementTextFontStyle :: Maybe FontStyle
- otherPlacementTextFontSize :: Maybe FontSize
- otherPlacementTextFontWeight :: Maybe FontWeight
- otherPlacementTextColor :: Maybe Color
- otherPlacementTextPlacement :: Maybe AboveBelow
- otherPlacementTextSmufl :: Maybe SmuflGlyphName
- parseOtherPlacementText :: XParse OtherPlacementText
- mkOtherPlacementText :: String -> OtherPlacementText
- data OtherPlay = OtherPlay {}
- parseOtherPlay :: XParse OtherPlay
- mkOtherPlay :: String -> Token -> OtherPlay
- data OtherText = OtherText {}
- parseOtherText :: XParse OtherText
- mkOtherText :: String -> OtherText
- data PageLayout = PageLayout {}
- parsePageLayout :: XParse PageLayout
- mkPageLayout :: PageLayout
- data PageMargins = PageMargins {}
- parsePageMargins :: XParse PageMargins
- mkPageMargins :: AllMargins -> PageMargins
- data CmpPart = CmpPart {
- partId :: IDREF
- partMeasure :: [Measure]
- parseCmpPart :: XParse CmpPart
- mkCmpPart :: IDREF -> CmpPart
- data Part = Part {}
- parsePart :: XParse Part
- mkPart :: IDREF -> MusicData -> Part
- data PartGroup = PartGroup {
- partGroupType :: StartStop
- partGroupNumber :: Maybe Token
- partGroupGroupName :: Maybe GroupName
- partGroupGroupNameDisplay :: Maybe NameDisplay
- partGroupGroupAbbreviation :: Maybe GroupName
- partGroupGroupAbbreviationDisplay :: Maybe NameDisplay
- partGroupGroupSymbol :: Maybe GroupSymbol
- partGroupGroupBarline :: Maybe GroupBarline
- partGroupGroupTime :: Maybe Empty
- partGroupEditorial :: Editorial
- parsePartGroup :: XParse PartGroup
- mkPartGroup :: StartStop -> Editorial -> PartGroup
- data PartList = PartList {}
- parsePartList :: XParse PartList
- mkPartList :: ScorePart -> PartList
- data PartName = PartName {
- partNameString :: String
- partNameDefaultX :: Maybe Tenths
- partNameDefaultY :: Maybe Tenths
- partNameRelativeX :: Maybe Tenths
- partNameRelativeY :: Maybe Tenths
- partNameFontFamily :: Maybe CommaSeparatedText
- partNameFontStyle :: Maybe FontStyle
- partNameFontSize :: Maybe FontSize
- partNameFontWeight :: Maybe FontWeight
- partNameColor :: Maybe Color
- partNamePrintObject :: Maybe YesNo
- partNameJustify :: Maybe LeftCenterRight
- parsePartName :: XParse PartName
- mkPartName :: String -> PartName
- data PartSymbol = PartSymbol {}
- parsePartSymbol :: XParse PartSymbol
- mkPartSymbol :: GroupSymbolValue -> PartSymbol
- data Pedal = Pedal {
- pedalType :: PedalType
- pedalNumber :: Maybe NumberLevel
- pedalLine :: Maybe YesNo
- pedalSign :: Maybe YesNo
- pedalAbbreviated :: Maybe YesNo
- pedalDefaultX :: Maybe Tenths
- pedalDefaultY :: Maybe Tenths
- pedalRelativeX :: Maybe Tenths
- pedalRelativeY :: Maybe Tenths
- pedalFontFamily :: Maybe CommaSeparatedText
- pedalFontStyle :: Maybe FontStyle
- pedalFontSize :: Maybe FontSize
- pedalFontWeight :: Maybe FontWeight
- pedalColor :: Maybe Color
- pedalHalign :: Maybe LeftCenterRight
- pedalValign :: Maybe Valign
- pedalId :: Maybe ID
- parsePedal :: XParse Pedal
- mkPedal :: PedalType -> Pedal
- data PedalTuning = PedalTuning {}
- parsePedalTuning :: XParse PedalTuning
- mkPedalTuning :: Step -> Semitones -> PedalTuning
- data PerMinute = PerMinute {}
- parsePerMinute :: XParse PerMinute
- mkPerMinute :: String -> PerMinute
- data Percussion = Percussion {
- percussionDefaultX :: Maybe Tenths
- percussionDefaultY :: Maybe Tenths
- percussionRelativeX :: Maybe Tenths
- percussionRelativeY :: Maybe Tenths
- percussionFontFamily :: Maybe CommaSeparatedText
- percussionFontStyle :: Maybe FontStyle
- percussionFontSize :: Maybe FontSize
- percussionFontWeight :: Maybe FontWeight
- percussionColor :: Maybe Color
- percussionHalign :: Maybe LeftCenterRight
- percussionValign :: Maybe Valign
- percussionEnclosure :: Maybe EnclosureShape
- percussionId :: Maybe ID
- percussionPercussion :: ChxPercussion
- parsePercussion :: XParse Percussion
- mkPercussion :: ChxPercussion -> Percussion
- data Pitch = Pitch {}
- parsePitch :: XParse Pitch
- mkPitch :: Step -> Octave -> Pitch
- data Pitched = Pitched {}
- parsePitched :: XParse Pitched
- mkPitched :: PitchedValue -> Pitched
- data PlacementText = PlacementText {
- placementTextString :: String
- placementTextDefaultX :: Maybe Tenths
- placementTextDefaultY :: Maybe Tenths
- placementTextRelativeX :: Maybe Tenths
- placementTextRelativeY :: Maybe Tenths
- placementTextFontFamily :: Maybe CommaSeparatedText
- placementTextFontStyle :: Maybe FontStyle
- placementTextFontSize :: Maybe FontSize
- placementTextFontWeight :: Maybe FontWeight
- placementTextColor :: Maybe Color
- placementTextPlacement :: Maybe AboveBelow
- parsePlacementText :: XParse PlacementText
- mkPlacementText :: String -> PlacementText
- data Play = Play {}
- parsePlay :: XParse Play
- mkPlay :: Play
- data PrincipalVoice = PrincipalVoice {
- principalVoiceString :: String
- principalVoiceType :: StartStop
- principalVoiceSymbol :: PrincipalVoiceSymbol
- principalVoiceDefaultX :: Maybe Tenths
- principalVoiceDefaultY :: Maybe Tenths
- principalVoiceRelativeX :: Maybe Tenths
- principalVoiceRelativeY :: Maybe Tenths
- principalVoiceFontFamily :: Maybe CommaSeparatedText
- principalVoiceFontStyle :: Maybe FontStyle
- principalVoiceFontSize :: Maybe FontSize
- principalVoiceFontWeight :: Maybe FontWeight
- principalVoiceColor :: Maybe Color
- principalVoiceHalign :: Maybe LeftCenterRight
- principalVoiceValign :: Maybe Valign
- principalVoiceId :: Maybe ID
- parsePrincipalVoice :: XParse PrincipalVoice
- mkPrincipalVoice :: String -> StartStop -> PrincipalVoiceSymbol -> PrincipalVoice
- data Print = Print {
- printStaffSpacing :: Maybe Tenths
- printNewSystem :: Maybe YesNo
- printNewPage :: Maybe YesNo
- printBlankPage :: Maybe PositiveInteger
- printPageNumber :: Maybe Token
- printId :: Maybe ID
- printLayout :: Layout
- printMeasureLayout :: Maybe MeasureLayout
- printMeasureNumbering :: Maybe MeasureNumbering
- printPartNameDisplay :: Maybe NameDisplay
- printPartAbbreviationDisplay :: Maybe NameDisplay
- parsePrint :: XParse Print
- mkPrint :: Layout -> Print
- data Repeat = Repeat {}
- parseRepeat :: XParse Repeat
- mkRepeat :: BackwardForward -> Repeat
- data Rest = Rest {}
- parseRest :: XParse Rest
- mkRest :: Rest
- data Root = Root {}
- parseRoot :: XParse Root
- mkRoot :: RootStep -> Root
- data RootAlter = RootAlter {
- rootAlterSemitones :: Semitones
- rootAlterLocation :: Maybe LeftRight
- rootAlterPrintObject :: Maybe YesNo
- rootAlterDefaultX :: Maybe Tenths
- rootAlterDefaultY :: Maybe Tenths
- rootAlterRelativeX :: Maybe Tenths
- rootAlterRelativeY :: Maybe Tenths
- rootAlterFontFamily :: Maybe CommaSeparatedText
- rootAlterFontStyle :: Maybe FontStyle
- rootAlterFontSize :: Maybe FontSize
- rootAlterFontWeight :: Maybe FontWeight
- rootAlterColor :: Maybe Color
- parseRootAlter :: XParse RootAlter
- mkRootAlter :: Semitones -> RootAlter
- data RootStep = RootStep {
- rootStepStep :: Step
- rootStepText :: Maybe Token
- rootStepDefaultX :: Maybe Tenths
- rootStepDefaultY :: Maybe Tenths
- rootStepRelativeX :: Maybe Tenths
- rootStepRelativeY :: Maybe Tenths
- rootStepFontFamily :: Maybe CommaSeparatedText
- rootStepFontStyle :: Maybe FontStyle
- rootStepFontSize :: Maybe FontSize
- rootStepFontWeight :: Maybe FontWeight
- rootStepColor :: Maybe Color
- parseRootStep :: XParse RootStep
- mkRootStep :: Step -> RootStep
- data Scaling = Scaling {}
- parseScaling :: XParse Scaling
- mkScaling :: Millimeters -> Tenths -> Scaling
- data Scordatura = Scordatura {
- scordaturaId :: Maybe ID
- scordaturaAccord :: [Accord]
- parseScordatura :: XParse Scordatura
- mkScordatura :: Scordatura
- data ScoreInstrument = ScoreInstrument {}
- parseScoreInstrument :: XParse ScoreInstrument
- mkScoreInstrument :: ID -> String -> ScoreInstrument
- data CmpScorePart = CmpScorePart {
- scorePartId :: ID
- scorePartIdentification :: Maybe Identification
- scorePartPartName :: PartName
- scorePartPartNameDisplay :: Maybe NameDisplay
- scorePartPartAbbreviation :: Maybe PartName
- scorePartPartAbbreviationDisplay :: Maybe NameDisplay
- scorePartGroup :: [String]
- scorePartScoreInstrument :: [ScoreInstrument]
- scorePartScorePart :: [SeqScorePart]
- parseCmpScorePart :: XParse CmpScorePart
- mkCmpScorePart :: ID -> PartName -> CmpScorePart
- data ScorePartwise = ScorePartwise {}
- parseScorePartwise :: XParse ScorePartwise
- mkScorePartwise :: ScoreHeader -> ScorePartwise
- data ScoreTimewise = ScoreTimewise {}
- parseScoreTimewise :: XParse ScoreTimewise
- mkScoreTimewise :: ScoreHeader -> ScoreTimewise
- data Segno = Segno {
- segnoSmufl :: Maybe SmuflSegnoGlyphName
- segnoDefaultX :: Maybe Tenths
- segnoDefaultY :: Maybe Tenths
- segnoRelativeX :: Maybe Tenths
- segnoRelativeY :: Maybe Tenths
- segnoFontFamily :: Maybe CommaSeparatedText
- segnoFontStyle :: Maybe FontStyle
- segnoFontSize :: Maybe FontSize
- segnoFontWeight :: Maybe FontWeight
- segnoColor :: Maybe Color
- segnoHalign :: Maybe LeftCenterRight
- segnoValign :: Maybe Valign
- segnoId :: Maybe ID
- parseSegno :: XParse Segno
- mkSegno :: Segno
- data CmpSlash = CmpSlash {}
- parseCmpSlash :: XParse CmpSlash
- mkCmpSlash :: StartStop -> CmpSlash
- data Slide = Slide {
- slideString :: String
- slideType :: StartStop
- slideNumber :: Maybe NumberLevel
- slideLineType :: Maybe LineType
- slideDashLength :: Maybe Tenths
- slideSpaceLength :: Maybe Tenths
- slideDefaultX :: Maybe Tenths
- slideDefaultY :: Maybe Tenths
- slideRelativeX :: Maybe Tenths
- slideRelativeY :: Maybe Tenths
- slideFontFamily :: Maybe CommaSeparatedText
- slideFontStyle :: Maybe FontStyle
- slideFontSize :: Maybe FontSize
- slideFontWeight :: Maybe FontWeight
- slideColor :: Maybe Color
- slideAccelerate :: Maybe YesNo
- slideBeats :: Maybe TrillBeats
- slideFirstBeat :: Maybe Percent
- slideLastBeat :: Maybe Percent
- slideId :: Maybe ID
- parseSlide :: XParse Slide
- mkSlide :: String -> StartStop -> Slide
- data Slur = Slur {
- slurType :: StartStopContinue
- slurNumber :: Maybe NumberLevel
- slurLineType :: Maybe LineType
- slurDashLength :: Maybe Tenths
- slurSpaceLength :: Maybe Tenths
- slurDefaultX :: Maybe Tenths
- slurDefaultY :: Maybe Tenths
- slurRelativeX :: Maybe Tenths
- slurRelativeY :: Maybe Tenths
- slurPlacement :: Maybe AboveBelow
- slurOrientation :: Maybe OverUnder
- slurBezierX :: Maybe Tenths
- slurBezierY :: Maybe Tenths
- slurBezierX2 :: Maybe Tenths
- slurBezierY2 :: Maybe Tenths
- slurBezierOffset :: Maybe Divisions
- slurBezierOffset2 :: Maybe Divisions
- slurColor :: Maybe Color
- slurId :: Maybe ID
- parseSlur :: XParse Slur
- mkSlur :: StartStopContinue -> Slur
- data Sound = Sound {
- soundTempo :: Maybe NonNegativeDecimal
- soundDynamics :: Maybe NonNegativeDecimal
- soundDacapo :: Maybe YesNo
- soundSegno :: Maybe Token
- soundDalsegno :: Maybe Token
- soundCoda :: Maybe Token
- soundTocoda :: Maybe Token
- soundDivisions :: Maybe Divisions
- soundForwardRepeat :: Maybe YesNo
- soundFine :: Maybe Token
- soundTimeOnly :: Maybe TimeOnly
- soundPizzicato :: Maybe YesNo
- soundPan :: Maybe RotationDegrees
- soundElevation :: Maybe RotationDegrees
- soundDamperPedal :: Maybe YesNoNumber
- soundSoftPedal :: Maybe YesNoNumber
- soundSostenutoPedal :: Maybe YesNoNumber
- soundId :: Maybe ID
- soundSound :: [SeqSound]
- soundOffset :: Maybe Offset
- parseSound :: XParse Sound
- mkSound :: Sound
- data StaffDetails = StaffDetails {
- staffDetailsNumber :: Maybe StaffNumber
- staffDetailsShowFrets :: Maybe ShowFrets
- staffDetailsPrintObject :: Maybe YesNo
- staffDetailsPrintSpacing :: Maybe YesNo
- staffDetailsStaffType :: Maybe StaffType
- staffDetailsStaffLines :: Maybe NonNegativeInteger
- staffDetailsStaffTuning :: [StaffTuning]
- staffDetailsCapo :: Maybe NonNegativeInteger
- staffDetailsStaffSize :: Maybe NonNegativeDecimal
- parseStaffDetails :: XParse StaffDetails
- mkStaffDetails :: StaffDetails
- data StaffDivide = StaffDivide {
- staffDivideType :: StaffDivideSymbol
- staffDivideDefaultX :: Maybe Tenths
- staffDivideDefaultY :: Maybe Tenths
- staffDivideRelativeX :: Maybe Tenths
- staffDivideRelativeY :: Maybe Tenths
- staffDivideFontFamily :: Maybe CommaSeparatedText
- staffDivideFontStyle :: Maybe FontStyle
- staffDivideFontSize :: Maybe FontSize
- staffDivideFontWeight :: Maybe FontWeight
- staffDivideColor :: Maybe Color
- staffDivideHalign :: Maybe LeftCenterRight
- staffDivideValign :: Maybe Valign
- staffDivideId :: Maybe ID
- parseStaffDivide :: XParse StaffDivide
- mkStaffDivide :: StaffDivideSymbol -> StaffDivide
- data StaffLayout = StaffLayout {}
- parseStaffLayout :: XParse StaffLayout
- mkStaffLayout :: StaffLayout
- data StaffTuning = StaffTuning {}
- parseStaffTuning :: XParse StaffTuning
- mkStaffTuning :: Tuning -> StaffTuning
- data Stem = Stem {}
- parseStem :: XParse Stem
- mkStem :: StemValue -> Stem
- data Stick = Stick {}
- parseStick :: XParse Stick
- mkStick :: StickType -> StickMaterial -> Stick
- data CmpString = CmpString {
- stringStringNumber :: StringNumber
- stringDefaultX :: Maybe Tenths
- stringDefaultY :: Maybe Tenths
- stringRelativeX :: Maybe Tenths
- stringRelativeY :: Maybe Tenths
- stringFontFamily :: Maybe CommaSeparatedText
- stringFontStyle :: Maybe FontStyle
- stringFontSize :: Maybe FontSize
- stringFontWeight :: Maybe FontWeight
- stringColor :: Maybe Color
- stringPlacement :: Maybe AboveBelow
- parseCmpString :: XParse CmpString
- mkCmpString :: StringNumber -> CmpString
- data StringMute = StringMute {
- stringMuteType :: OnOff
- stringMuteDefaultX :: Maybe Tenths
- stringMuteDefaultY :: Maybe Tenths
- stringMuteRelativeX :: Maybe Tenths
- stringMuteRelativeY :: Maybe Tenths
- stringMuteFontFamily :: Maybe CommaSeparatedText
- stringMuteFontStyle :: Maybe FontStyle
- stringMuteFontSize :: Maybe FontSize
- stringMuteFontWeight :: Maybe FontWeight
- stringMuteColor :: Maybe Color
- stringMuteHalign :: Maybe LeftCenterRight
- stringMuteValign :: Maybe Valign
- stringMuteId :: Maybe ID
- parseStringMute :: XParse StringMute
- mkStringMute :: OnOff -> StringMute
- data StrongAccent = StrongAccent {}
- parseStrongAccent :: XParse StrongAccent
- mkStrongAccent :: StrongAccent -> StrongAccent
- data StyleText = StyleText {
- styleTextString :: String
- styleTextDefaultX :: Maybe Tenths
- styleTextDefaultY :: Maybe Tenths
- styleTextRelativeX :: Maybe Tenths
- styleTextRelativeY :: Maybe Tenths
- styleTextFontFamily :: Maybe CommaSeparatedText
- styleTextFontStyle :: Maybe FontStyle
- styleTextFontSize :: Maybe FontSize
- styleTextFontWeight :: Maybe FontWeight
- styleTextColor :: Maybe Color
- parseStyleText :: XParse StyleText
- mkStyleText :: String -> StyleText
- data Supports = Supports {}
- parseSupports :: XParse Supports
- mkSupports :: YesNo -> NMTOKEN -> Supports
- data SystemDividers = SystemDividers {}
- parseSystemDividers :: XParse SystemDividers
- mkSystemDividers :: EmptyPrintObjectStyleAlign -> EmptyPrintObjectStyleAlign -> SystemDividers
- data SystemLayout = SystemLayout {}
- parseSystemLayout :: XParse SystemLayout
- mkSystemLayout :: SystemLayout
- data SystemMargins = SystemMargins {}
- parseSystemMargins :: XParse SystemMargins
- mkSystemMargins :: LeftRightMargins -> SystemMargins
- data Tap = Tap {
- tapString :: String
- tapHand :: Maybe TapHand
- tapDefaultX :: Maybe Tenths
- tapDefaultY :: Maybe Tenths
- tapRelativeX :: Maybe Tenths
- tapRelativeY :: Maybe Tenths
- tapFontFamily :: Maybe CommaSeparatedText
- tapFontStyle :: Maybe FontStyle
- tapFontSize :: Maybe FontSize
- tapFontWeight :: Maybe FontWeight
- tapColor :: Maybe Color
- tapPlacement :: Maybe AboveBelow
- parseTap :: XParse Tap
- mkTap :: String -> Tap
- data Technical = Technical {}
- parseTechnical :: XParse Technical
- mkTechnical :: Technical
- data TextElementData = TextElementData {
- textElementDataString :: String
- textElementDataLang :: Maybe Lang
- textElementDataFontFamily :: Maybe CommaSeparatedText
- textElementDataFontStyle :: Maybe FontStyle
- textElementDataFontSize :: Maybe FontSize
- textElementDataFontWeight :: Maybe FontWeight
- textElementDataColor :: Maybe Color
- textElementDataUnderline :: Maybe NumberOfLines
- textElementDataOverline :: Maybe NumberOfLines
- textElementDataLineThrough :: Maybe NumberOfLines
- textElementDataRotation :: Maybe RotationDegrees
- textElementDataLetterSpacing :: Maybe NumberOrNormal
- textElementDataDir :: Maybe TextDirection
- parseTextElementData :: XParse TextElementData
- mkTextElementData :: String -> TextElementData
- data Tie = Tie {}
- parseTie :: XParse Tie
- mkTie :: StartStop -> Tie
- data Tied = Tied {
- tiedType :: TiedType
- tiedNumber :: Maybe NumberLevel
- tiedLineType :: Maybe LineType
- tiedDashLength :: Maybe Tenths
- tiedSpaceLength :: Maybe Tenths
- tiedDefaultX :: Maybe Tenths
- tiedDefaultY :: Maybe Tenths
- tiedRelativeX :: Maybe Tenths
- tiedRelativeY :: Maybe Tenths
- tiedPlacement :: Maybe AboveBelow
- tiedOrientation :: Maybe OverUnder
- tiedBezierX :: Maybe Tenths
- tiedBezierY :: Maybe Tenths
- tiedBezierX2 :: Maybe Tenths
- tiedBezierY2 :: Maybe Tenths
- tiedBezierOffset :: Maybe Divisions
- tiedBezierOffset2 :: Maybe Divisions
- tiedColor :: Maybe Color
- tiedId :: Maybe ID
- parseTied :: XParse Tied
- mkTied :: TiedType -> Tied
- data Time = Time {
- timeNumber :: Maybe StaffNumber
- timeSymbol :: Maybe TimeSymbol
- timeSeparator :: Maybe TimeSeparator
- timeDefaultX :: Maybe Tenths
- timeDefaultY :: Maybe Tenths
- timeRelativeX :: Maybe Tenths
- timeRelativeY :: Maybe Tenths
- timeFontFamily :: Maybe CommaSeparatedText
- timeFontStyle :: Maybe FontStyle
- timeFontSize :: Maybe FontSize
- timeFontWeight :: Maybe FontWeight
- timeColor :: Maybe Color
- timeHalign :: Maybe LeftCenterRight
- timeValign :: Maybe Valign
- timePrintObject :: Maybe YesNo
- timeId :: Maybe ID
- timeTime :: ChxTime
- parseTime :: XParse Time
- mkTime :: ChxTime -> Time
- data TimeModification = TimeModification {}
- parseTimeModification :: XParse TimeModification
- mkTimeModification :: NonNegativeInteger -> NonNegativeInteger -> TimeModification
- data Transpose = Transpose {}
- parseTranspose :: XParse Transpose
- mkTranspose :: Semitones -> Transpose
- data Tremolo = Tremolo {
- tremoloTremoloMarks :: TremoloMarks
- tremoloType :: Maybe TremoloType
- tremoloDefaultX :: Maybe Tenths
- tremoloDefaultY :: Maybe Tenths
- tremoloRelativeX :: Maybe Tenths
- tremoloRelativeY :: Maybe Tenths
- tremoloFontFamily :: Maybe CommaSeparatedText
- tremoloFontStyle :: Maybe FontStyle
- tremoloFontSize :: Maybe FontSize
- tremoloFontWeight :: Maybe FontWeight
- tremoloColor :: Maybe Color
- tremoloPlacement :: Maybe AboveBelow
- tremoloSmufl :: Maybe SmuflGlyphName
- parseTremolo :: XParse Tremolo
- mkTremolo :: TremoloMarks -> Tremolo
- data Tuplet = Tuplet {
- tupletType :: StartStop
- tupletNumber :: Maybe NumberLevel
- tupletBracket :: Maybe YesNo
- tupletShowNumber :: Maybe ShowTuplet
- tupletShowType :: Maybe ShowTuplet
- tupletLineShape :: Maybe LineShape
- tupletDefaultX :: Maybe Tenths
- tupletDefaultY :: Maybe Tenths
- tupletRelativeX :: Maybe Tenths
- tupletRelativeY :: Maybe Tenths
- tupletPlacement :: Maybe AboveBelow
- tupletId :: Maybe ID
- tupletTupletActual :: Maybe TupletPortion
- tupletTupletNormal :: Maybe TupletPortion
- parseTuplet :: XParse Tuplet
- mkTuplet :: StartStop -> Tuplet
- data TupletDot = TupletDot {}
- parseTupletDot :: XParse TupletDot
- mkTupletDot :: TupletDot
- data TupletNumber = TupletNumber {}
- parseTupletNumber :: XParse TupletNumber
- mkTupletNumber :: NonNegativeInteger -> TupletNumber
- data TupletPortion = TupletPortion {}
- parseTupletPortion :: XParse TupletPortion
- mkTupletPortion :: TupletPortion
- data TupletType = TupletType {}
- parseTupletType :: XParse TupletType
- mkTupletType :: NoteTypeValue -> TupletType
- data TypedText = TypedText {}
- parseTypedText :: XParse TypedText
- mkTypedText :: String -> TypedText
- data Unpitched = Unpitched {}
- parseUnpitched :: XParse Unpitched
- mkUnpitched :: Unpitched
- data VirtualInstrument = VirtualInstrument {}
- parseVirtualInstrument :: XParse VirtualInstrument
- mkVirtualInstrument :: VirtualInstrument
- data WavyLine = WavyLine {
- wavyLineType :: StartStopContinue
- wavyLineNumber :: Maybe NumberLevel
- wavyLineDefaultX :: Maybe Tenths
- wavyLineDefaultY :: Maybe Tenths
- wavyLineRelativeX :: Maybe Tenths
- wavyLineRelativeY :: Maybe Tenths
- wavyLinePlacement :: Maybe AboveBelow
- wavyLineColor :: Maybe Color
- wavyLineStartNote :: Maybe StartNote
- wavyLineTrillStep :: Maybe TrillStep
- wavyLineTwoNoteTurn :: Maybe TwoNoteTurn
- wavyLineAccelerate :: Maybe YesNo
- wavyLineBeats :: Maybe TrillBeats
- wavyLineSecondBeat :: Maybe Percent
- wavyLineLastBeat :: Maybe Percent
- parseWavyLine :: XParse WavyLine
- mkWavyLine :: StartStopContinue -> WavyLine
- data Wedge = Wedge {
- wedgeType :: WedgeType
- wedgeNumber :: Maybe NumberLevel
- wedgeSpread :: Maybe Tenths
- wedgeNiente :: Maybe YesNo
- wedgeLineType :: Maybe LineType
- wedgeDashLength :: Maybe Tenths
- wedgeSpaceLength :: Maybe Tenths
- wedgeDefaultX :: Maybe Tenths
- wedgeDefaultY :: Maybe Tenths
- wedgeRelativeX :: Maybe Tenths
- wedgeRelativeY :: Maybe Tenths
- wedgeColor :: Maybe Color
- wedgeId :: Maybe ID
- parseWedge :: XParse Wedge
- mkWedge :: WedgeType -> Wedge
- data Work = Work {}
- parseWork :: XParse Work
- mkWork :: Work
- data ChxArrow
- parseChxArrow :: XParse ChxArrow
- mkArrowArrowDirection :: ArrowDirection -> ChxArrow
- mkArrowCircularArrow :: CircularArrow -> ChxArrow
- data ChxArticulations
- = ArticulationsAccent { }
- | ArticulationsStrongAccent { }
- | ArticulationsStaccato { }
- | ArticulationsTenuto { }
- | ArticulationsDetachedLegato { }
- | ArticulationsStaccatissimo { }
- | ArticulationsSpiccato { }
- | ArticulationsScoop { }
- | ArticulationsPlop { }
- | ArticulationsDoit { }
- | ArticulationsFalloff { }
- | ArticulationsBreathMark { }
- | ArticulationsCaesura { }
- | ArticulationsStress { }
- | ArticulationsUnstress { }
- | ArticulationsSoftAccent { }
- | ArticulationsOtherArticulation { }
- parseChxArticulations :: XParse ChxArticulations
- mkArticulationsAccent :: EmptyPlacement -> ChxArticulations
- mkArticulationsStrongAccent :: StrongAccent -> ChxArticulations
- mkArticulationsStaccato :: EmptyPlacement -> ChxArticulations
- mkArticulationsTenuto :: EmptyPlacement -> ChxArticulations
- mkArticulationsDetachedLegato :: EmptyPlacement -> ChxArticulations
- mkArticulationsStaccatissimo :: EmptyPlacement -> ChxArticulations
- mkArticulationsSpiccato :: EmptyPlacement -> ChxArticulations
- mkArticulationsScoop :: EmptyLine -> ChxArticulations
- mkArticulationsPlop :: EmptyLine -> ChxArticulations
- mkArticulationsDoit :: EmptyLine -> ChxArticulations
- mkArticulationsFalloff :: EmptyLine -> ChxArticulations
- mkArticulationsBreathMark :: BreathMark -> ChxArticulations
- mkArticulationsCaesura :: Caesura -> ChxArticulations
- mkArticulationsStress :: EmptyPlacement -> ChxArticulations
- mkArticulationsUnstress :: EmptyPlacement -> ChxArticulations
- mkArticulationsSoftAccent :: EmptyPlacement -> ChxArticulations
- mkArticulationsOtherArticulation :: OtherPlacementText -> ChxArticulations
- data ChxBend
- = BendPreBend {
- bendPreBend :: Empty
- | BendRelease {
- bendRelease :: Empty
- = BendPreBend {
- parseChxBend :: XParse ChxBend
- mkBendPreBend :: Empty -> ChxBend
- mkBendRelease :: Empty -> ChxBend
- data ChxCredit0
- parseChxCredit0 :: XParse ChxCredit0
- mkCreditCreditWords :: FormattedTextId -> ChxCredit0
- mkCreditCreditSymbol :: FormattedSymbolId -> ChxCredit0
- data ChxCredit1
- parseChxCredit1 :: XParse ChxCredit1
- mkChxCreditCreditWords :: FormattedTextId -> ChxCredit1
- mkChxCreditCreditSymbol :: FormattedSymbolId -> ChxCredit1
- data ChxCredit
- = CreditCreditImage { }
- | CreditCredit { }
- parseChxCredit :: XParse ChxCredit
- mkCreditCreditImage :: Image -> ChxCredit
- mkCreditCredit :: ChxCredit0 -> ChxCredit
- data ChxDirectionType0
- parseChxDirectionType0 :: XParse ChxDirectionType0
- mkDirectionTypeWords :: FormattedTextId -> ChxDirectionType0
- mkDirectionTypeSymbol :: FormattedSymbolId -> ChxDirectionType0
- data ChxDirectionType
- = DirectionTypeRehearsal { }
- | DirectionTypeSegno {
- directionTypeSegno :: [Segno]
- | DirectionTypeCoda {
- directionTypeCoda :: [Coda]
- | DirectionTypeDirectionType { }
- | DirectionTypeWedge { }
- | DirectionTypeDynamics { }
- | DirectionTypeDashes { }
- | DirectionTypeBracket { }
- | DirectionTypePedal { }
- | DirectionTypeMetronome { }
- | DirectionTypeOctaveShift { }
- | DirectionTypeHarpPedals { }
- | DirectionTypeDamp { }
- | DirectionTypeDampAll { }
- | DirectionTypeEyeglasses { }
- | DirectionTypeStringMute { }
- | DirectionTypeScordatura { }
- | DirectionTypeImage { }
- | DirectionTypePrincipalVoice { }
- | DirectionTypePercussion { }
- | DirectionTypeAccordionRegistration { }
- | DirectionTypeStaffDivide { }
- | DirectionTypeOtherDirection { }
- parseChxDirectionType :: XParse ChxDirectionType
- mkDirectionTypeRehearsal :: ChxDirectionType
- mkDirectionTypeSegno :: ChxDirectionType
- mkDirectionTypeCoda :: ChxDirectionType
- mkDirectionTypeDirectionType :: ChxDirectionType
- mkDirectionTypeWedge :: Wedge -> ChxDirectionType
- mkDirectionTypeDynamics :: ChxDirectionType
- mkDirectionTypeDashes :: Dashes -> ChxDirectionType
- mkDirectionTypeBracket :: Bracket -> ChxDirectionType
- mkDirectionTypePedal :: Pedal -> ChxDirectionType
- mkDirectionTypeMetronome :: Metronome -> ChxDirectionType
- mkDirectionTypeOctaveShift :: OctaveShift -> ChxDirectionType
- mkDirectionTypeHarpPedals :: HarpPedals -> ChxDirectionType
- mkDirectionTypeDamp :: EmptyPrintStyleAlignId -> ChxDirectionType
- mkDirectionTypeDampAll :: EmptyPrintStyleAlignId -> ChxDirectionType
- mkDirectionTypeEyeglasses :: EmptyPrintStyleAlignId -> ChxDirectionType
- mkDirectionTypeStringMute :: StringMute -> ChxDirectionType
- mkDirectionTypeScordatura :: Scordatura -> ChxDirectionType
- mkDirectionTypeImage :: Image -> ChxDirectionType
- mkDirectionTypePrincipalVoice :: PrincipalVoice -> ChxDirectionType
- mkDirectionTypePercussion :: ChxDirectionType
- mkDirectionTypeAccordionRegistration :: AccordionRegistration -> ChxDirectionType
- mkDirectionTypeStaffDivide :: StaffDivide -> ChxDirectionType
- mkDirectionTypeOtherDirection :: OtherDirection -> ChxDirectionType
- data ChxDynamics
- = DynamicsP { }
- | DynamicsPp {
- dynamicsPp :: Empty
- | DynamicsPpp {
- dynamicsPpp :: Empty
- | DynamicsPppp { }
- | DynamicsPpppp { }
- | DynamicsPppppp { }
- | DynamicsF { }
- | DynamicsFf {
- dynamicsFf :: Empty
- | DynamicsFff {
- dynamicsFff :: Empty
- | DynamicsFfff { }
- | DynamicsFffff { }
- | DynamicsFfffff { }
- | DynamicsMp {
- dynamicsMp :: Empty
- | DynamicsMf {
- dynamicsMf :: Empty
- | DynamicsSf {
- dynamicsSf :: Empty
- | DynamicsSfp {
- dynamicsSfp :: Empty
- | DynamicsSfpp { }
- | DynamicsFp {
- dynamicsFp :: Empty
- | DynamicsRf {
- dynamicsRf :: Empty
- | DynamicsRfz {
- dynamicsRfz :: Empty
- | DynamicsSfz {
- dynamicsSfz :: Empty
- | DynamicsSffz { }
- | DynamicsFz {
- dynamicsFz :: Empty
- | DynamicsN { }
- | DynamicsPf {
- dynamicsPf :: Empty
- | DynamicsSfzp { }
- | DynamicsOtherDynamics { }
- parseChxDynamics :: XParse ChxDynamics
- mkDynamicsP :: Empty -> ChxDynamics
- mkDynamicsPp :: Empty -> ChxDynamics
- mkDynamicsPpp :: Empty -> ChxDynamics
- mkDynamicsPppp :: Empty -> ChxDynamics
- mkDynamicsPpppp :: Empty -> ChxDynamics
- mkDynamicsPppppp :: Empty -> ChxDynamics
- mkDynamicsF :: Empty -> ChxDynamics
- mkDynamicsFf :: Empty -> ChxDynamics
- mkDynamicsFff :: Empty -> ChxDynamics
- mkDynamicsFfff :: Empty -> ChxDynamics
- mkDynamicsFffff :: Empty -> ChxDynamics
- mkDynamicsFfffff :: Empty -> ChxDynamics
- mkDynamicsMp :: Empty -> ChxDynamics
- mkDynamicsMf :: Empty -> ChxDynamics
- mkDynamicsSf :: Empty -> ChxDynamics
- mkDynamicsSfp :: Empty -> ChxDynamics
- mkDynamicsSfpp :: Empty -> ChxDynamics
- mkDynamicsFp :: Empty -> ChxDynamics
- mkDynamicsRf :: Empty -> ChxDynamics
- mkDynamicsRfz :: Empty -> ChxDynamics
- mkDynamicsSfz :: Empty -> ChxDynamics
- mkDynamicsSffz :: Empty -> ChxDynamics
- mkDynamicsFz :: Empty -> ChxDynamics
- mkDynamicsN :: Empty -> ChxDynamics
- mkDynamicsPf :: Empty -> ChxDynamics
- mkDynamicsSfzp :: Empty -> ChxDynamics
- mkDynamicsOtherDynamics :: OtherText -> ChxDynamics
- data ChxEncoding
- parseChxEncoding :: XParse ChxEncoding
- mkEncodingEncodingDate :: YyyyMmDd -> ChxEncoding
- mkEncodingEncoder :: TypedText -> ChxEncoding
- mkEncodingSoftware :: String -> ChxEncoding
- mkEncodingEncodingDescription :: String -> ChxEncoding
- mkEncodingSupports :: Supports -> ChxEncoding
- data FullNote
- = FullNotePitch { }
- | FullNoteUnpitched { }
- | FullNoteRest {
- fullNoteRest :: Rest
- parseFullNote :: XParse FullNote
- mkFullNotePitch :: Pitch -> FullNote
- mkFullNoteUnpitched :: Unpitched -> FullNote
- mkFullNoteRest :: Rest -> FullNote
- data ChxHarmonic
- = HarmonicNatural { }
- | HarmonicArtificial { }
- parseChxHarmonic :: XParse ChxHarmonic
- mkHarmonicNatural :: Empty -> ChxHarmonic
- mkHarmonicArtificial :: Empty -> ChxHarmonic
- data ChxHarmonic1
- parseChxHarmonic1 :: XParse ChxHarmonic1
- mkHarmonicBasePitch :: Empty -> ChxHarmonic1
- mkHarmonicTouchingPitch :: Empty -> ChxHarmonic1
- mkHarmonicSoundingPitch :: Empty -> ChxHarmonic1
- data ChxHarmonyChord
- = HarmonyChordRoot { }
- | HarmonyChordFunction { }
- parseChxHarmonyChord :: XParse ChxHarmonyChord
- mkHarmonyChordRoot :: Root -> ChxHarmonyChord
- mkHarmonyChordFunction :: StyleText -> ChxHarmonyChord
- data ChxKey
- parseChxKey :: XParse ChxKey
- mkKeyTraditionalKey :: TraditionalKey -> ChxKey
- mkKeyNonTraditionalKey :: ChxKey
- data ChxLyric
- = LyricSyllabic { }
- | LyricExtend { }
- | LyricLaughing { }
- | LyricHumming { }
- parseChxLyric :: XParse ChxLyric
- mkLyricSyllabic :: TextElementData -> ChxLyric
- mkLyricExtend :: Extend -> ChxLyric
- mkLyricLaughing :: Empty -> ChxLyric
- mkLyricHumming :: Empty -> ChxLyric
- data ChxMeasureStyle
- parseChxMeasureStyle :: XParse ChxMeasureStyle
- mkMeasureStyleMultipleRest :: MultipleRest -> ChxMeasureStyle
- mkMeasureStyleMeasureRepeat :: MeasureRepeat -> ChxMeasureStyle
- mkMeasureStyleBeatRepeat :: BeatRepeat -> ChxMeasureStyle
- mkMeasureStyleSlash :: CmpSlash -> ChxMeasureStyle
- data ChxMetronome0
- parseChxMetronome0 :: XParse ChxMetronome0
- mkMetronomePerMinute :: PerMinute -> ChxMetronome0
- mkMetronomeBeatUnit :: BeatUnit -> ChxMetronome0
- data ChxMetronome
- parseChxMetronome :: XParse ChxMetronome
- mkChxMetronomeBeatUnit :: BeatUnit -> ChxMetronome0 -> ChxMetronome
- mkMetronomeMetronomeArrows :: ChxMetronome
- data ChxMusicData
- = MusicDataNote { }
- | MusicDataBackup { }
- | MusicDataForward { }
- | MusicDataDirection { }
- | MusicDataAttributes { }
- | MusicDataHarmony { }
- | MusicDataFiguredBass { }
- | MusicDataPrint { }
- | MusicDataSound { }
- | MusicDataBarline { }
- | MusicDataGrouping { }
- | MusicDataLink { }
- | MusicDataBookmark { }
- parseChxMusicData :: XParse ChxMusicData
- mkMusicDataNote :: Note -> ChxMusicData
- mkMusicDataBackup :: Backup -> ChxMusicData
- mkMusicDataForward :: Forward -> ChxMusicData
- mkMusicDataDirection :: Direction -> ChxMusicData
- mkMusicDataAttributes :: Attributes -> ChxMusicData
- mkMusicDataHarmony :: Harmony -> ChxMusicData
- mkMusicDataFiguredBass :: FiguredBass -> ChxMusicData
- mkMusicDataPrint :: Print -> ChxMusicData
- mkMusicDataSound :: Sound -> ChxMusicData
- mkMusicDataBarline :: Barline -> ChxMusicData
- mkMusicDataGrouping :: Grouping -> ChxMusicData
- mkMusicDataLink :: Link -> ChxMusicData
- mkMusicDataBookmark :: Bookmark -> ChxMusicData
- data ChxNameDisplay
- parseChxNameDisplay :: XParse ChxNameDisplay
- mkNameDisplayDisplayText :: FormattedText -> ChxNameDisplay
- mkNameDisplayAccidentalText :: AccidentalText -> ChxNameDisplay
- data ChxNotations
- = NotationsTied { }
- | NotationsSlur { }
- | NotationsTuplet { }
- | NotationsGlissando { }
- | NotationsSlide { }
- | NotationsOrnaments { }
- | NotationsTechnical { }
- | NotationsArticulations { }
- | NotationsDynamics { }
- | NotationsFermata { }
- | NotationsArpeggiate { }
- | NotationsNonArpeggiate { }
- | NotationsAccidentalMark { }
- | NotationsOtherNotation { }
- parseChxNotations :: XParse ChxNotations
- mkNotationsTied :: Tied -> ChxNotations
- mkNotationsSlur :: Slur -> ChxNotations
- mkNotationsTuplet :: Tuplet -> ChxNotations
- mkNotationsGlissando :: Glissando -> ChxNotations
- mkNotationsSlide :: Slide -> ChxNotations
- mkNotationsOrnaments :: Ornaments -> ChxNotations
- mkNotationsTechnical :: Technical -> ChxNotations
- mkNotationsArticulations :: Articulations -> ChxNotations
- mkNotationsDynamics :: Dynamics -> ChxNotations
- mkNotationsFermata :: Fermata -> ChxNotations
- mkNotationsArpeggiate :: Arpeggiate -> ChxNotations
- mkNotationsNonArpeggiate :: NonArpeggiate -> ChxNotations
- mkNotationsAccidentalMark :: AccidentalMark -> ChxNotations
- mkNotationsOtherNotation :: OtherNotation -> ChxNotations
- data ChxNote0
- = NoteFullNote {
- noteFullNote :: GrpFullNote
- noteTie :: [Tie]
- | NoteCue { }
- = NoteFullNote {
- parseChxNote0 :: XParse ChxNote0
- mkNoteFullNote :: GrpFullNote -> ChxNote0
- mkNoteCue :: Empty -> GrpFullNote -> ChxNote0
- data ChxNote
- = NoteGrace { }
- | ChxNoteCue { }
- | ChxNoteFullNote { }
- parseChxNote :: XParse ChxNote
- mkNoteGrace :: Grace -> ChxNote0 -> ChxNote
- mkChxNoteCue :: Empty -> GrpFullNote -> Duration -> ChxNote
- mkChxNoteFullNote :: GrpFullNote -> Duration -> ChxNote
- data ChxNoteheadText
- parseChxNoteheadText :: XParse ChxNoteheadText
- mkNoteheadTextDisplayText :: FormattedText -> ChxNoteheadText
- mkNoteheadTextAccidentalText :: AccidentalText -> ChxNoteheadText
- data ChxOrnaments
- = OrnamentsTrillMark { }
- | OrnamentsTurn { }
- | OrnamentsDelayedTurn { }
- | OrnamentsInvertedTurn { }
- | OrnamentsDelayedInvertedTurn { }
- | OrnamentsVerticalTurn { }
- | OrnamentsInvertedVerticalTurn { }
- | OrnamentsShake { }
- | OrnamentsWavyLine { }
- | OrnamentsMordent { }
- | OrnamentsInvertedMordent { }
- | OrnamentsSchleifer { }
- | OrnamentsTremolo { }
- | OrnamentsHaydn { }
- | OrnamentsOtherOrnament { }
- parseChxOrnaments :: XParse ChxOrnaments
- mkOrnamentsTrillMark :: EmptyTrillSound -> ChxOrnaments
- mkOrnamentsTurn :: HorizontalTurn -> ChxOrnaments
- mkOrnamentsDelayedTurn :: HorizontalTurn -> ChxOrnaments
- mkOrnamentsInvertedTurn :: HorizontalTurn -> ChxOrnaments
- mkOrnamentsDelayedInvertedTurn :: HorizontalTurn -> ChxOrnaments
- mkOrnamentsVerticalTurn :: EmptyTrillSound -> ChxOrnaments
- mkOrnamentsInvertedVerticalTurn :: EmptyTrillSound -> ChxOrnaments
- mkOrnamentsShake :: EmptyTrillSound -> ChxOrnaments
- mkOrnamentsWavyLine :: WavyLine -> ChxOrnaments
- mkOrnamentsMordent :: Mordent -> ChxOrnaments
- mkOrnamentsInvertedMordent :: Mordent -> ChxOrnaments
- mkOrnamentsSchleifer :: EmptyPlacement -> ChxOrnaments
- mkOrnamentsTremolo :: Tremolo -> ChxOrnaments
- mkOrnamentsHaydn :: EmptyTrillSound -> ChxOrnaments
- mkOrnamentsOtherOrnament :: OtherPlacementText -> ChxOrnaments
- data ChxPartList
- parseChxPartList :: XParse ChxPartList
- mkPartListPartGroup :: GrpPartGroup -> ChxPartList
- mkPartListScorePart :: ScorePart -> ChxPartList
- data ChxPercussion
- = PercussionGlass { }
- | PercussionMetal { }
- | PercussionWood { }
- | PercussionPitched { }
- | PercussionMembrane { }
- | PercussionEffect { }
- | PercussionTimpani { }
- | PercussionBeater { }
- | PercussionStick { }
- | PercussionStickLocation { }
- | PercussionOtherPercussion { }
- parseChxPercussion :: XParse ChxPercussion
- mkPercussionGlass :: Glass -> ChxPercussion
- mkPercussionMetal :: Metal -> ChxPercussion
- mkPercussionWood :: Wood -> ChxPercussion
- mkPercussionPitched :: Pitched -> ChxPercussion
- mkPercussionMembrane :: Membrane -> ChxPercussion
- mkPercussionEffect :: Effect -> ChxPercussion
- mkPercussionTimpani :: Empty -> ChxPercussion
- mkPercussionBeater :: Beater -> ChxPercussion
- mkPercussionStick :: Stick -> ChxPercussion
- mkPercussionStickLocation :: StickLocation -> ChxPercussion
- mkPercussionOtherPercussion :: OtherText -> ChxPercussion
- data ChxPlay
- = PlayIpa { }
- | PlayMute { }
- | PlaySemiPitched { }
- | PlayOtherPlay { }
- parseChxPlay :: XParse ChxPlay
- mkPlayIpa :: String -> ChxPlay
- mkPlayMute :: Mute -> ChxPlay
- mkPlaySemiPitched :: SemiPitched -> ChxPlay
- mkPlayOtherPlay :: OtherPlay -> ChxPlay
- data ChxScoreInstrument
- parseChxScoreInstrument :: XParse ChxScoreInstrument
- mkScoreInstrumentSolo :: Empty -> ChxScoreInstrument
- mkScoreInstrumentEnsemble :: PositiveIntegerOrEmpty -> ChxScoreInstrument
- data ChxTechnical
- = TechnicalUpBow { }
- | TechnicalDownBow { }
- | TechnicalHarmonic { }
- | TechnicalOpenString { }
- | TechnicalThumbPosition { }
- | TechnicalFingering { }
- | TechnicalPluck { }
- | TechnicalDoubleTongue { }
- | TechnicalTripleTongue { }
- | TechnicalStopped { }
- | TechnicalSnapPizzicato { }
- | TechnicalFret { }
- | TechnicalString { }
- | TechnicalHammerOn { }
- | TechnicalPullOff { }
- | TechnicalBend { }
- | TechnicalTap {
- technicalTap :: Tap
- | TechnicalHeel { }
- | TechnicalToe { }
- | TechnicalFingernails { }
- | TechnicalHole { }
- | TechnicalArrow { }
- | TechnicalHandbell { }
- | TechnicalBrassBend { }
- | TechnicalFlip { }
- | TechnicalSmear { }
- | TechnicalOpen { }
- | TechnicalHalfMuted { }
- | TechnicalHarmonMute { }
- | TechnicalGolpe { }
- | TechnicalOtherTechnical { }
- parseChxTechnical :: XParse ChxTechnical
- mkTechnicalUpBow :: EmptyPlacement -> ChxTechnical
- mkTechnicalDownBow :: EmptyPlacement -> ChxTechnical
- mkTechnicalHarmonic :: Harmonic -> ChxTechnical
- mkTechnicalOpenString :: EmptyPlacement -> ChxTechnical
- mkTechnicalThumbPosition :: EmptyPlacement -> ChxTechnical
- mkTechnicalFingering :: Fingering -> ChxTechnical
- mkTechnicalPluck :: PlacementText -> ChxTechnical
- mkTechnicalDoubleTongue :: EmptyPlacement -> ChxTechnical
- mkTechnicalTripleTongue :: EmptyPlacement -> ChxTechnical
- mkTechnicalStopped :: EmptyPlacementSmufl -> ChxTechnical
- mkTechnicalSnapPizzicato :: EmptyPlacement -> ChxTechnical
- mkTechnicalFret :: Fret -> ChxTechnical
- mkTechnicalString :: CmpString -> ChxTechnical
- mkTechnicalHammerOn :: HammerOnPullOff -> ChxTechnical
- mkTechnicalPullOff :: HammerOnPullOff -> ChxTechnical
- mkTechnicalBend :: Bend -> ChxTechnical
- mkTechnicalTap :: Tap -> ChxTechnical
- mkTechnicalHeel :: HeelToe -> ChxTechnical
- mkTechnicalToe :: HeelToe -> ChxTechnical
- mkTechnicalFingernails :: EmptyPlacement -> ChxTechnical
- mkTechnicalHole :: Hole -> ChxTechnical
- mkTechnicalArrow :: Arrow -> ChxTechnical
- mkTechnicalHandbell :: Handbell -> ChxTechnical
- mkTechnicalBrassBend :: EmptyPlacement -> ChxTechnical
- mkTechnicalFlip :: EmptyPlacement -> ChxTechnical
- mkTechnicalSmear :: EmptyPlacement -> ChxTechnical
- mkTechnicalOpen :: EmptyPlacementSmufl -> ChxTechnical
- mkTechnicalHalfMuted :: EmptyPlacementSmufl -> ChxTechnical
- mkTechnicalHarmonMute :: HarmonMute -> ChxTechnical
- mkTechnicalGolpe :: EmptyPlacement -> ChxTechnical
- mkTechnicalOtherTechnical :: OtherPlacementText -> ChxTechnical
- data ChxTime
- parseChxTime :: XParse ChxTime
- mkTimeTimeSignature :: ChxTime
- mkTimeSenzaMisura :: String -> ChxTime
- data SeqCredit = SeqCredit {}
- parseSeqCredit :: XParse SeqCredit
- mkSeqCredit :: ChxCredit1 -> SeqCredit
- data SeqLyric0 = SeqLyric0 {}
- parseSeqLyric0 :: XParse SeqLyric0
- mkSeqLyric0 :: Elision -> SeqLyric0
- data SeqLyric = SeqLyric {}
- parseSeqLyric :: XParse SeqLyric
- mkSeqLyric :: TextElementData -> SeqLyric
- data SeqMetronome = SeqMetronome {}
- parseSeqMetronome :: XParse SeqMetronome
- mkSeqMetronome :: String -> SeqMetronome
- data SeqMetronomeTuplet = SeqMetronomeTuplet {}
- parseSeqMetronomeTuplet :: XParse SeqMetronomeTuplet
- mkSeqMetronomeTuplet :: NoteTypeValue -> SeqMetronomeTuplet
- data SeqOrnaments = SeqOrnaments {}
- parseSeqOrnaments :: XParse SeqOrnaments
- mkSeqOrnaments :: ChxOrnaments -> SeqOrnaments
- data SeqPageLayout = SeqPageLayout {}
- parseSeqPageLayout :: XParse SeqPageLayout
- mkSeqPageLayout :: Tenths -> Tenths -> SeqPageLayout
- data SeqScorePart = SeqScorePart {}
- parseSeqScorePart :: XParse SeqScorePart
- mkSeqScorePart :: SeqScorePart
- data SeqSlash = SeqSlash {}
- parseSeqSlash :: XParse SeqSlash
- mkSeqSlash :: NoteTypeValue -> SeqSlash
- data SeqSound = SeqSound {}
- parseSeqSound :: XParse SeqSound
- mkSeqSound :: SeqSound
- data SeqTimeModification = SeqTimeModification {}
- parseSeqTimeModification :: XParse SeqTimeModification
- mkSeqTimeModification :: NoteTypeValue -> SeqTimeModification
- data AllMargins = AllMargins {}
- parseAllMargins :: XParse AllMargins
- mkAllMargins :: LeftRightMargins -> Tenths -> Tenths -> AllMargins
- data BeatUnit = BeatUnit {}
- parseBeatUnit :: XParse BeatUnit
- mkBeatUnit :: NoteTypeValue -> BeatUnit
- data DisplayStepOctave = DisplayStepOctave {}
- parseDisplayStepOctave :: XParse DisplayStepOctave
- mkDisplayStepOctave :: Step -> Octave -> DisplayStepOctave
- data Duration = Duration {}
- parseDuration :: XParse Duration
- mkDuration :: PositiveDivisions -> Duration
- data Editorial = Editorial {}
- parseEditorial :: XParse Editorial
- mkEditorial :: Editorial
- data EditorialVoice = EditorialVoice {}
- parseEditorialVoice :: XParse EditorialVoice
- mkEditorialVoice :: EditorialVoice
- data EditorialVoiceDirection = EditorialVoiceDirection {}
- parseEditorialVoiceDirection :: XParse EditorialVoiceDirection
- mkEditorialVoiceDirection :: EditorialVoiceDirection
- data Footnote = Footnote {}
- parseFootnote :: XParse Footnote
- mkFootnote :: FormattedText -> Footnote
- data GrpFullNote = GrpFullNote {}
- parseGrpFullNote :: XParse GrpFullNote
- mkGrpFullNote :: FullNote -> GrpFullNote
- data HarmonyChord = HarmonyChord {}
- parseHarmonyChord :: XParse HarmonyChord
- mkHarmonyChord :: ChxHarmonyChord -> Kind -> HarmonyChord
- data Layout = Layout {}
- parseLayout :: XParse Layout
- mkLayout :: Layout
- data LeftRightMargins = LeftRightMargins {}
- parseLeftRightMargins :: XParse LeftRightMargins
- mkLeftRightMargins :: Tenths -> Tenths -> LeftRightMargins
- data GrpLevel = GrpLevel {
- levelLevel :: Level
- parseGrpLevel :: XParse GrpLevel
- mkGrpLevel :: Level -> GrpLevel
- data MusicData = MusicData {}
- parseMusicData :: XParse MusicData
- mkMusicData :: MusicData
- data NonTraditionalKey = NonTraditionalKey {}
- parseNonTraditionalKey :: XParse NonTraditionalKey
- mkNonTraditionalKey :: Step -> Semitones -> NonTraditionalKey
- data GrpPartGroup = GrpPartGroup {}
- parseGrpPartGroup :: XParse GrpPartGroup
- mkGrpPartGroup :: PartGroup -> GrpPartGroup
- data ScoreHeader = ScoreHeader {}
- parseScoreHeader :: XParse ScoreHeader
- mkScoreHeader :: PartList -> ScoreHeader
- data ScorePart = ScorePart {}
- parseScorePart :: XParse ScorePart
- mkScorePart :: CmpScorePart -> ScorePart
- data Slash = Slash {}
- parseSlash :: XParse Slash
- mkSlash :: Slash
- data Staff = Staff {}
- parseStaff :: XParse Staff
- mkStaff :: PositiveInteger -> Staff
- data TimeSignature = TimeSignature {}
- parseTimeSignature :: XParse TimeSignature
- mkTimeSignature :: String -> String -> TimeSignature
- data TraditionalKey = TraditionalKey {}
- parseTraditionalKey :: XParse TraditionalKey
- mkTraditionalKey :: Fifths -> TraditionalKey
- data Tuning = Tuning {}
- parseTuning :: XParse Tuning
- mkTuning :: Step -> Octave -> Tuning
- data Voice = Voice {
- voiceVoice :: String
- parseVoice :: XParse Voice
- mkVoice :: String -> Voice
Documentation
xs:ID (simple)
xs:IDREF (simple)
xs:NCName (simple)
Instances
xs:NMTOKEN (simple)
Instances
| IsString NMTOKEN Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods fromString :: String -> NMTOKEN # | |
| Generic NMTOKEN Source # | |
| Read NMTOKEN Source # | |
| Show NMTOKEN Source # | |
| EmitXml NMTOKEN Source # | |
| Eq NMTOKEN Source # | |
| Ord NMTOKEN Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep NMTOKEN Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
xs:Name (simple)
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
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. The quarter- and three-quarters- accidentals are Tartini-style quarter-tone accidentals. The -down and -up accidentals are quarter-tone accidentals that include arrows pointing down or up. The slash- accidentals are used in Turkish classical music. The numbered sharp and flat accidentals are superscripted versions of the accidental signs, used in Turkish folk music. The sori and koron accidentals are microtonal sharp and flat accidentals used in Iranian and Persian music. The other accidental covers accidentals other than those listed here. It is usually used in combination with the smufl attribute to specify a particular SMuFL accidental. The smufl attribute may be used with any accidental value to help specify the appearance of symbols that share the same MusicXML semantics.
Constructors
Instances
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. This type is not used if no dots are present.
Constructors
| AccordionMiddle | |
Fields | |
Instances
xlink:actuate (simple)
Constructors
| ActuateOnRequest | onRequest |
| ActuateOnLoad | onLoad |
| ActuateOther | other |
| ActuateNone | none |
Instances
| Bounded Actuate Source # | |
| Enum Actuate Source # | |
| Generic Actuate Source # | |
| Show Actuate Source # | |
| EmitXml Actuate Source # | |
| Eq Actuate Source # | |
| Ord Actuate Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep Actuate Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Actuate = D1 ('MetaData "Actuate" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) ((C1 ('MetaCons "ActuateOnRequest" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ActuateOnLoad" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "ActuateOther" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ActuateNone" 'PrefixI 'False) (U1 :: Type -> Type))) | |
data ArrowDirection Source #
arrow-direction (simple)
The arrow-direction type represents the direction in which an arrow points, using Unicode arrow terminology.
Constructors
| ArrowDirectionLeft | left |
| ArrowDirectionUp | up |
| ArrowDirectionRight | right |
| ArrowDirectionDown | down |
| ArrowDirectionNorthwest | northwest |
| ArrowDirectionNortheast | northeast |
| ArrowDirectionSoutheast | southeast |
| ArrowDirectionSouthwest | southwest |
| ArrowDirectionLeftRight | left right |
| ArrowDirectionUpDown | up down |
| ArrowDirectionNorthwestSoutheast | northwest southeast |
| ArrowDirectionNortheastSouthwest | northeast southwest |
| ArrowDirectionOther | other |
Instances
data ArrowStyle Source #
arrow-style (simple)
The arrow-style type represents the style of an arrow, using Unicode arrow terminology. Filled and hollow arrows indicate polygonal single arrows. Paired arrows are duplicate single arrows in the same direction. Combined arrows apply to double direction arrows like left right, indicating that an arrow in one direction should be combined with an arrow in the other direction.
Constructors
| ArrowStyleSingle | single |
| ArrowStyleDouble | double |
| ArrowStyleFilled | filled |
| ArrowStyleHollow | hollow |
| ArrowStylePaired | paired |
| ArrowStyleCombined | combined |
| ArrowStyleOther | other |
Instances
parseArrowStyle :: String -> XParse ArrowStyle 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
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
beam-level (simple)
The MusicXML format supports six levels of beaming, up to 1024th 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 | |
Instances
beam-value (simple)
The beam-value type represents the type of beam associated with each of 8 beam levels (up to 1024th notes) available for each note.
Constructors
| BeamValueBegin | begin |
| BeamValueContinue | continue |
| BeamValueEnd | end |
| BeamValueForwardHook | forward hook |
| BeamValueBackwardHook | backward hook |
Instances
data BeaterValue Source #
beater-value (simple)
The beater-value type represents pictograms for beaters, mallets, and sticks that do not have different materials represented in the pictogram. The finger and hammer values are in addition to Stone's list.
Constructors
| BeaterValueBow | bow |
| BeaterValueChimeHammer | chime hammer |
| BeaterValueCoin | coin |
| BeaterValueDrumStick | drum stick |
| BeaterValueFinger | finger |
| BeaterValueFingernail | fingernail |
| BeaterValueFist | fist |
| BeaterValueGuiroScraper | guiro scraper |
| BeaterValueHammer | hammer |
| BeaterValueHand | hand |
| BeaterValueJazzStick | jazz stick |
| BeaterValueKnittingNeedle | knitting needle |
| BeaterValueMetalHammer | metal hammer |
| BeaterValueSlideBrushOnGong | slide brush on gong |
| BeaterValueSnareStick | snare stick |
| BeaterValueSpoonMallet | spoon mallet |
| BeaterValueSuperball | superball |
| BeaterValueTriangleBeater | triangle beater |
| BeaterValueTriangleBeaterPlain | triangle beater plain |
| BeaterValueWireBrush | wire brush |
Instances
data BreathMarkValue Source #
breath-mark-value (simple)
The breath-mark-value type represents the symbol used for a breath mark.
Constructors
| BreathMarkValue | // |
| BreathMarkValueComma | comma |
| BreathMarkValueTick | tick |
| BreathMarkValueUpbow | upbow |
| BreathMarkValueSalzedo | salzedo |
Instances
data CaesuraValue Source #
caesura-value (simple)
The caesura-value type represents the shape of the caesura sign.
Constructors
| CaesuraValueNormal | normal |
| CaesuraValueThick | thick |
| CaesuraValueShort | short |
| CaesuraValueCurved | curved |
| CaesuraValueSingle | single |
| CaesuraValue | // |
Instances
data CancelLocation Source #
cancel-location (simple)
The cancel-location type is used to indicate where a key signature cancellation appears relative to a new key signature: to the left, to the right, or before the barline and to the left. It is left by default. For mid-measure key elements, a cancel-location of before-barline should be treated like a cancel-location of left.
Constructors
| CancelLocationLeft | left |
| CancelLocationRight | right |
| CancelLocationBeforeBarline | before-barline |
Instances
data CircularArrow Source #
circular-arrow (simple)
The circular-arrow type represents the direction in which a circular arrow points, using Unicode arrow terminology.
Constructors
| CircularArrowClockwise | clockwise |
| CircularArrowAnticlockwise | anticlockwise |
Instances
clef-sign (simple)
The clef-sign element represents the different clef symbols. The jianpu sign indicates that the music that follows should be in jianpu numbered notation, just as the TAB sign indicates that the music that follows should be in tablature notation. Unlike TAB, a jianpu sign does not correspond to a visual clef notation.
Constructors
| ClefSignG | G |
| ClefSignF | F |
| ClefSignC | C |
| ClefSignPercussion | percussion |
| ClefSignTAB | TAB |
| ClefSignJianpu | jianpu |
| ClefSignNone | none |
Instances
| Bounded ClefSign Source # | |
| Enum ClefSign Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Generic ClefSign Source # | |
| Show ClefSign Source # | |
| EmitXml ClefSign Source # | |
| Eq ClefSign Source # | |
| Ord ClefSign Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep ClefSign Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep ClefSign = D1 ('MetaData "ClefSign" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) ((C1 ('MetaCons "ClefSignG" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "ClefSignF" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ClefSignC" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "ClefSignPercussion" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ClefSignTAB" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "ClefSignJianpu" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ClefSignNone" 'PrefixI 'False) (U1 :: Type -> Type)))) | |
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 "#800080" represents purple. An ARGB value of "#40800080" would be a transparent purple.
As in SVG 1.1, colors are defined in terms of the sRGB color space (IEC 61966).
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 | |
Instances
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
data DegreeSymbolValue Source #
degree-symbol-value (simple)
The degree-symbol-value type indicates indicates that a symbol should be used in specifying the degree.
Constructors
| DegreeSymbolValueMajor | major |
| DegreeSymbolValueMinor | minor |
| DegreeSymbolValueAugmented | augmented |
| DegreeSymbolValueDiminished | diminished |
| DegreeSymbolValueHalfDiminished | half-diminished |
Instances
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
newtype DistanceType Source #
distance-type (simple)
The distance-type defines what type of distance is being defined in a distance element. Values include beam and hyphen. 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
| DistanceType | |
Fields | |
Instances
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.
Instances
| Generic Divisions Source # | |
| Num Divisions Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Read Divisions Source # | |
| Fractional Divisions Source # | |
| Real Divisions Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods toRational :: Divisions -> Rational # | |
| RealFrac Divisions Source # | |
| Show Divisions Source # | |
| EmitXml Divisions Source # | |
| Eq Divisions Source # | |
| Ord Divisions Source # | |
| type Rep Divisions Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
effect (simple)
The effect type represents pictograms for sound effect percussion instruments. The cannon, lotus flute, and megaphone values are in addition to Stone's list.
Constructors
| EffectAnvil | anvil |
| EffectAutoHorn | auto horn |
| EffectBirdWhistle | bird whistle |
| EffectCannon | cannon |
| EffectDuckCall | duck call |
| EffectGunShot | gun shot |
| EffectKlaxonHorn | klaxon horn |
| EffectLionsRoar | lions roar |
| EffectLotusFlute | lotus flute |
| EffectMegaphone | megaphone |
| EffectPoliceWhistle | police whistle |
| EffectSiren | siren |
| EffectSlideWhistle | slide whistle |
| EffectThunderSheet | thunder sheet |
| EffectWindMachine | wind machine |
| EffectWindWhistle | wind whistle |
Instances
| Bounded Effect Source # | |
| Enum Effect Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Generic Effect Source # | |
| Show Effect Source # | |
| EmitXml Effect Source # | |
| Eq Effect Source # | |
| Ord Effect Source # | |
| type Rep Effect Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Effect = D1 ('MetaData "Effect" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) ((((C1 ('MetaCons "EffectAnvil" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EffectAutoHorn" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "EffectBirdWhistle" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EffectCannon" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "EffectDuckCall" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EffectGunShot" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "EffectKlaxonHorn" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EffectLionsRoar" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "EffectLotusFlute" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EffectMegaphone" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "EffectPoliceWhistle" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EffectSiren" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "EffectSlideWhistle" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EffectThunderSheet" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "EffectWindMachine" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "EffectWindWhistle" 'PrefixI 'False) (U1 :: Type -> Type))))) | |
data EnclosureShape Source #
enclosure-shape (simple)
The enclosure-shape type describes the shape and presence / absence of an enclosure around text or symbols. A bracket enclosure is similar to a rectangle with the bottom line missing, as is common in jazz notation.
Constructors
| EnclosureShapeRectangle | rectangle |
| EnclosureShapeSquare | square |
| EnclosureShapeOval | oval |
| EnclosureShapeCircle | circle |
| EnclosureShapeBracket | bracket |
| EnclosureShapeTriangle | triangle |
| EnclosureShapeDiamond | diamond |
| EnclosureShapePentagon | pentagon |
| EnclosureShapeHexagon | hexagon |
| EnclosureShapeHeptagon | heptagon |
| EnclosureShapeOctagon | octagon |
| EnclosureShapeNonagon | nonagon |
| EnclosureShapeDecagon | decagon |
| EnclosureShapeNone | none |
Instances
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 | |
Instances
fan (simple)
The fan type represents the type of beam fanning present on a note, used to represent accelerandos and ritardandos.
Instances
| Bounded Fan Source # | |
| Enum Fan Source # | |
| Generic Fan Source # | |
| Show Fan Source # | |
| EmitXml Fan Source # | |
| Eq Fan Source # | |
| Ord Fan Source # | |
| type Rep Fan Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Fan = D1 ('MetaData "Fan" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "FanAccel" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "FanRit" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "FanNone" 'PrefixI 'False) (U1 :: Type -> Type))) | |
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 |
| FermataShapeDoubleAngled | double-angled |
| FermataShapeDoubleSquare | double-square |
| FermataShapeDoubleDot | double-dot |
| FermataShapeHalfCurve | half-curve |
| FermataShapeCurlew | curlew |
| FermataShape | // |
Instances
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).
Instances
| Bounded Fifths Source # | |
| Enum Fifths Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Generic Fifths Source # | |
| Num Fifths Source # | |
| Read Fifths Source # | |
| Integral Fifths Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Real Fifths Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods toRational :: Fifths -> Rational # | |
| Show Fifths Source # | |
| EmitXml Fifths Source # | |
| Eq Fifths Source # | |
| Ord Fifths Source # | |
| type Rep Fifths Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
font-size (simple)
The font-size can be one of the CSS font sizes or a numeric point size.
Constructors
| FontSizeDecimal | |
| FontSizeCssFontSize | |
Fields | |
Instances
| Generic FontSize Source # | |
| Show FontSize Source # | |
| EmitXml FontSize Source # | |
| Eq FontSize Source # | |
| type Rep FontSize Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep FontSize = D1 ('MetaData "FontSize" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "FontSizeDecimal" 'PrefixI 'True) (S1 ('MetaSel ('Just "fontSize1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Decimal)) :+: C1 ('MetaCons "FontSizeCssFontSize" 'PrefixI 'True) (S1 ('MetaSel ('Just "fontSize2") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CssFontSize))) | |
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 # | |
| Enum FontStyle Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods succ :: FontStyle -> FontStyle # pred :: FontStyle -> FontStyle # fromEnum :: FontStyle -> Int # enumFrom :: FontStyle -> [FontStyle] # enumFromThen :: FontStyle -> FontStyle -> [FontStyle] # enumFromTo :: FontStyle -> FontStyle -> [FontStyle] # enumFromThenTo :: FontStyle -> FontStyle -> FontStyle -> [FontStyle] # | |
| Generic FontStyle Source # | |
| Show FontStyle Source # | |
| EmitXml FontStyle Source # | |
| Eq FontStyle Source # | |
| Ord FontStyle Source # | |
| type Rep FontStyle Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
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
parseFontWeight :: String -> XParse FontWeight Source #
data GlassValue Source #
glass-value (simple)
The glass-value type represents pictograms for glass percussion instruments.
Constructors
| GlassValueGlassHarmonica | glass harmonica |
| GlassValueGlassHarp | glass harp |
| GlassValueWindChimes | wind chimes |
Instances
parseGlassValue :: String -> XParse GlassValue Source #
glyph-type (simple)
The glyph-type defines what type of glyph is being defined in a glyph element. Values include quarter-rest, g-clef-ottava-bassa, c-clef, f-clef, percussion-clef, octave-shift-up-8, octave-shift-down-8, octave-shift-continue-8, octave-shift-down-15, octave-shift-up-15, octave-shift-continue-15, octave-shift-down-22, octave-shift-up-22, and octave-shift-continue-22. 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.
A quarter-rest type specifies the glyph to use when a note has a rest element and a type value of quarter. The c-clef, f-clef, and percussion-clef types specify the glyph to use when a clef sign element value is C, F, or percussion respectively. The g-clef-ottava-bassa type specifies the glyph to use when a clef sign element value is G and the clef-octave-change element value is -1. The octave-shift types specify the glyph to use when an octave-shift type attribute value is up, down, or continue and the octave-shift size attribute value is 8, 15, or 22.
Instances
| IsString GlyphType Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods fromString :: String -> GlyphType # | |
| Generic GlyphType Source # | |
| Read GlyphType Source # | |
| Show GlyphType Source # | |
| EmitXml GlyphType Source # | |
| Eq GlyphType Source # | |
| Ord GlyphType Source # | |
| type Rep GlyphType Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
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
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 |
| GroupSymbolValueSquare | square |
Instances
data HandbellValue Source #
handbell-value (simple)
The handbell-value type represents the type of handbell technique being notated.
Constructors
| HandbellValueBelltree | belltree |
| HandbellValueDamp | damp |
| HandbellValueEcho | echo |
| HandbellValueGyro | gyro |
| HandbellValueHandMartellato | hand martellato |
| HandbellValueMalletLift | mallet lift |
| HandbellValueMalletTable | mallet table |
| HandbellValueMartellato | martellato |
| HandbellValueMartellatoLift | martellato lift |
| HandbellValueMutedMartellato | muted martellato |
| HandbellValuePluckLift | pluck lift |
| HandbellValueSwing | swing |
Instances
data HarmonClosedLocation Source #
harmon-closed-location (simple)
The harmon-closed-location type indicates which portion of the symbol is filled in when the corresponding harmon-closed-value is half.
Constructors
| HarmonClosedLocationRight | right |
| HarmonClosedLocationBottom | bottom |
| HarmonClosedLocationLeft | left |
| HarmonClosedLocationTop | top |
Instances
data HarmonClosedValue Source #
harmon-closed-value (simple)
The harmon-closed-value type represents whether the harmon mute is closed, open, or half-open.
Constructors
| HarmonClosedValueYes | yes |
| HarmonClosedValueNo | no |
| HarmonClosedValueHalf | half |
Instances
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
data HoleClosedLocation Source #
hole-closed-location (simple)
The hole-closed-location type indicates which portion of the hole is filled in when the corresponding hole-closed-value is half.
Constructors
| HoleClosedLocationRight | right |
| HoleClosedLocationBottom | bottom |
| HoleClosedLocationLeft | left |
| HoleClosedLocationTop | top |
Instances
data HoleClosedValue Source #
hole-closed-value (simple)
The hole-closed-value type represents whether the hole is closed, open, or half-open.
Constructors
| HoleClosedValueYes | yes |
| HoleClosedValueNo | no |
| HoleClosedValueHalf | half |
Instances
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 # | |
| Enum KindValue Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods succ :: KindValue -> KindValue # pred :: KindValue -> KindValue # fromEnum :: KindValue -> Int # enumFrom :: KindValue -> [KindValue] # enumFromThen :: KindValue -> KindValue -> [KindValue] # enumFromTo :: KindValue -> KindValue -> [KindValue] # enumFromThenTo :: KindValue -> KindValue -> KindValue -> [KindValue] # | |
| Generic KindValue Source # | |
| Show KindValue Source # | |
| EmitXml KindValue Source # | |
| Eq KindValue Source # | |
| Ord KindValue Source # | |
| type Rep KindValue Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep KindValue = D1 ('MetaData "KindValue" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (((((C1 ('MetaCons "KindValueMajor" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindValueMinor" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "KindValueAugmented" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindValueDiminished" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "KindValueDominant" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindValueMajorSeventh" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "KindValueMinorSeventh" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindValueDiminishedSeventh" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "KindValueAugmentedSeventh" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindValueHalfDiminished" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "KindValueMajorMinor" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindValueMajorSixth" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "KindValueMinorSixth" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindValueDominantNinth" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "KindValueMajorNinth" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindValueMinorNinth" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: ((((C1 ('MetaCons "KindValueDominant11th" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindValueMajor11th" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "KindValueMinor11th" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindValueDominant13th" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "KindValueMajor13th" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindValueMinor13th" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "KindValueSuspendedSecond" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindValueSuspendedFourth" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "KindValueNeapolitan" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindValueItalian" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "KindValueFrench" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindValueGerman" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "KindValuePedal" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindValuePower" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "KindValueTristan" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "KindValueOther" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "KindValueNone" 'PrefixI 'False) (U1 :: Type -> Type))))))) | |
xml:lang (simple)
Instances
| Generic Lang Source # | |
| Show Lang Source # | |
| EmitXml Lang Source # | |
| Eq Lang Source # | |
| type Rep Lang Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Lang = D1 ('MetaData "Lang" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "LangLanguage" 'PrefixI 'True) (S1 ('MetaSel ('Just "lang1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Language)) :+: C1 ('MetaCons "LangLang" 'PrefixI 'True) (S1 ('MetaSel ('Just "lang2") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SumLang))) | |
xs:language (simple)
Instances
| IsString Language Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods fromString :: String -> Language # | |
| Generic Language Source # | |
| Read Language Source # | |
| Show Language Source # | |
| EmitXml Language Source # | |
| Eq Language Source # | |
| Ord Language Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep Language Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
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
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 # | |
| Enum LeftRight Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods succ :: LeftRight -> LeftRight # pred :: LeftRight -> LeftRight # fromEnum :: LeftRight -> Int # enumFrom :: LeftRight -> [LeftRight] # enumFromThen :: LeftRight -> LeftRight -> [LeftRight] # enumFromTo :: LeftRight -> LeftRight -> [LeftRight] # enumFromThenTo :: LeftRight -> LeftRight -> LeftRight -> [LeftRight] # | |
| Generic LeftRight Source # | |
| Show LeftRight Source # | |
| EmitXml LeftRight Source # | |
| Eq LeftRight Source # | |
| Ord LeftRight Source # | |
| type Rep LeftRight Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
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 # | |
| Enum LineEnd Source # | |
| Generic LineEnd Source # | |
| Show LineEnd Source # | |
| EmitXml LineEnd Source # | |
| Eq LineEnd Source # | |
| Ord LineEnd Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep LineEnd Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep LineEnd = D1 ('MetaData "LineEnd" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) ((C1 ('MetaCons "LineEndUp" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LineEndDown" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "LineEndBoth" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "LineEndArrow" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LineEndNone" 'PrefixI 'False) (U1 :: Type -> Type)))) | |
data LineLength Source #
line-length (simple)
The line-length type distinguishes between different line lengths for doit, falloff, plop, and scoop articulations.
Constructors
| LineLengthShort | short |
| LineLengthMedium | medium |
| LineLengthLong | long |
Instances
parseLineLength :: String -> XParse LineLength Source #
line-shape (simple)
The line-shape type distinguishes between straight and curved lines.
Constructors
| LineShapeStraight | straight |
| LineShapeCurved | curved |
Instances
| Bounded LineShape Source # | |
| Enum LineShape Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods succ :: LineShape -> LineShape # pred :: LineShape -> LineShape # fromEnum :: LineShape -> Int # enumFrom :: LineShape -> [LineShape] # enumFromThen :: LineShape -> LineShape -> [LineShape] # enumFromTo :: LineShape -> LineShape -> [LineShape] # enumFromThenTo :: LineShape -> LineShape -> LineShape -> [LineShape] # | |
| Generic LineShape Source # | |
| Show LineShape Source # | |
| EmitXml LineShape Source # | |
| Eq LineShape Source # | |
| Ord LineShape Source # | |
| type Rep LineShape Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
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 # | |
| Enum LineType Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Generic LineType Source # | |
| Show LineType Source # | |
| EmitXml LineType Source # | |
| Eq LineType Source # | |
| Ord LineType Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep LineType Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep LineType = D1 ('MetaData "LineType" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) ((C1 ('MetaCons "LineTypeSolid" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LineTypeDashed" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "LineTypeDotted" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "LineTypeWavy" 'PrefixI 'False) (U1 :: Type -> Type))) | |
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 | |
Instances
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
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
newtype MeasureText Source #
measure-text (simple)
The measure-text type is used for the text attribute of measure elements. It has at least one character. The implicit attribute of the measure element should be set to "yes" rather than setting the text attribute to an empty string.
Constructors
| MeasureText | |
Fields
| |
Instances
membrane (simple)
The membrane type represents pictograms for membrane percussion instruments.
Constructors
| MembraneBassDrum | bass drum |
| MembraneBassDrumOnSide | bass drum on side |
| MembraneBongos | bongos |
| MembraneChineseTomtom | Chinese tomtom |
| MembraneCongaDrum | conga drum |
| MembraneCuica | cuica |
| MembraneGobletDrum | goblet drum |
| MembraneIndoAmericanTomtom | Indo-American tomtom |
| MembraneJapaneseTomtom | Japanese tomtom |
| MembraneMilitaryDrum | military drum |
| MembraneSnareDrum | snare drum |
| MembraneSnareDrumSnaresOff | snare drum snares off |
| MembraneTabla | tabla |
| MembraneTambourine | tambourine |
| MembraneTenorDrum | tenor drum |
| MembraneTimbales | timbales |
| MembraneTomtom | tomtom |
Instances
| Bounded Membrane Source # | |
| Enum Membrane Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Generic Membrane Source # | |
| Show Membrane Source # | |
| EmitXml Membrane Source # | |
| Eq Membrane Source # | |
| Ord Membrane Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep Membrane Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Membrane = D1 ('MetaData "Membrane" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) ((((C1 ('MetaCons "MembraneBassDrum" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MembraneBassDrumOnSide" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "MembraneBongos" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MembraneChineseTomtom" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "MembraneCongaDrum" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MembraneCuica" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "MembraneGobletDrum" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MembraneIndoAmericanTomtom" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "MembraneJapaneseTomtom" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MembraneMilitaryDrum" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "MembraneSnareDrum" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MembraneSnareDrumSnaresOff" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "MembraneTabla" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MembraneTambourine" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "MembraneTenorDrum" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "MembraneTimbales" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MembraneTomtom" 'PrefixI 'False) (U1 :: Type -> Type)))))) | |
metal (simple)
The metal type represents pictograms for metal percussion instruments. The hi-hat value refers to a pictogram like Stone's high-hat cymbals but without the long vertical line at the bottom.
Constructors
| MetalAgogo | agogo |
| MetalAlmglocken | almglocken |
| MetalBell | bell |
| MetalBellPlate | bell plate |
| MetalBellTree | bell tree |
| MetalBrakeDrum | brake drum |
| MetalCencerro | cencerro |
| MetalChainRattle | chain rattle |
| MetalChineseCymbal | Chinese cymbal |
| MetalCowbell | cowbell |
| MetalCrashCymbals | crash cymbals |
| MetalCrotale | crotale |
| MetalCymbalTongs | cymbal tongs |
| MetalDomedGong | domed gong |
| MetalFingerCymbals | finger cymbals |
| MetalFlexatone | flexatone |
| MetalGong | gong |
| MetalHiHat | hi-hat |
| MetalHighHatCymbals | high-hat cymbals |
| MetalHandbell | handbell |
| MetalJawHarp | jaw harp |
| MetalJingleBells | jingle bells |
| MetalMusicalSaw | musical saw |
| MetalShellBells | shell bells |
| MetalSistrum | sistrum |
| MetalSizzleCymbal | sizzle cymbal |
| MetalSleighBells | sleigh bells |
| MetalSuspendedCymbal | suspended cymbal |
| MetalTamTam | tam tam |
| MetalTamTamWithBeater | tam tam with beater |
| MetalTriangle | triangle |
| MetalVietnameseHat | Vietnamese hat |
Instances
| Bounded Metal Source # | |
| Enum Metal Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Generic Metal Source # | |
| Show Metal Source # | |
| EmitXml Metal Source # | |
| Eq Metal Source # | |
| Ord Metal Source # | |
| type Rep Metal Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Metal = D1 ('MetaData "Metal" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (((((C1 ('MetaCons "MetalAgogo" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MetalAlmglocken" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "MetalBell" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MetalBellPlate" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "MetalBellTree" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MetalBrakeDrum" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "MetalCencerro" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MetalChainRattle" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "MetalChineseCymbal" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MetalCowbell" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "MetalCrashCymbals" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MetalCrotale" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "MetalCymbalTongs" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MetalDomedGong" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "MetalFingerCymbals" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MetalFlexatone" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: ((((C1 ('MetaCons "MetalGong" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MetalHiHat" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "MetalHighHatCymbals" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MetalHandbell" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "MetalJawHarp" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MetalJingleBells" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "MetalMusicalSaw" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MetalShellBells" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: (((C1 ('MetaCons "MetalSistrum" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MetalSizzleCymbal" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "MetalSleighBells" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MetalSuspendedCymbal" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "MetalTamTam" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MetalTamTamWithBeater" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "MetalTriangle" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "MetalVietnameseHat" 'PrefixI 'False) (U1 :: Type -> Type)))))) | |
midi-128 (simple)
The midi-16 type is used to express MIDI 1.0 values that range from 1 to 128.
Constructors
| Midi128 | |
Fields | |
Instances
| Bounded Midi128 Source # | |
| Enum Midi128 Source # | |
| Generic Midi128 Source # | |
| Num Midi128 Source # | |
| Read Midi128 Source # | |
| Integral Midi128 Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Real Midi128 Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods toRational :: Midi128 -> Rational # | |
| Show Midi128 Source # | |
| EmitXml Midi128 Source # | |
| Eq Midi128 Source # | |
| Ord Midi128 Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep Midi128 Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Midi128 = D1 ('MetaData "Midi128" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'True) (C1 ('MetaCons "Midi128" 'PrefixI 'True) (S1 ('MetaSel ('Just "midi128") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PositiveInteger))) | |
midi-16 (simple)
The midi-16 type is used to express MIDI 1.0 values that range from 1 to 16.
Constructors
| Midi16 | |
Fields | |
Instances
| Bounded Midi16 Source # | |
| Enum Midi16 Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Generic Midi16 Source # | |
| Num Midi16 Source # | |
| Read Midi16 Source # | |
| Integral Midi16 Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Real Midi16 Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods toRational :: Midi16 -> Rational # | |
| Show Midi16 Source # | |
| EmitXml Midi16 Source # | |
| Eq Midi16 Source # | |
| Ord Midi16 Source # | |
| type Rep Midi16 Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Midi16 = D1 ('MetaData "Midi16" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'True) (C1 ('MetaCons "Midi16" 'PrefixI 'True) (S1 ('MetaSel ('Just "midi16") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PositiveInteger))) | |
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 | |
Instances
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 | |
Instances
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, locrian, and none.
mute (simple)
The mute type represents muting for different instruments, including brass, winds, and strings. The on and off values are used for undifferentiated mutes. The remaining values represent specific mutes.
Constructors
| MuteOn | on |
| MuteOff | off |
| MuteStraight | straight |
| MuteCup | cup |
| MuteHarmonNoStem | harmon-no-stem |
| MuteHarmonStem | harmon-stem |
| MuteBucket | bucket |
| MutePlunger | plunger |
| MuteHat | hat |
| MuteSolotone | solotone |
| MutePractice | practice |
| MuteStopMute | stop-mute |
| MuteStopHand | stop-hand |
| MuteEcho | echo |
| MutePalm | palm |
Instances
newtype NonNegativeDecimal Source #
non-negative-decimal (simple)
The non-negative-decimal type specifies a non-negative decimal value.
Constructors
| NonNegativeDecimal | |
Fields | |
Instances
newtype NonNegativeInteger Source #
xs:nonNegativeInteger (simple)
Constructors
| NonNegativeInteger | |
Fields | |
Instances
newtype NormalizedString Source #
xs:normalizedString (simple)
Constructors
| NormalizedString | |
Fields | |
Instances
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-cue type is used for notes of grace-cue size. The grace type is used for notes of cue size 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 |
| NoteSizeTypeGraceCue | grace-cue |
| NoteSizeTypeLarge | large |
Instances
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 1024th (shortest) to maxima (longest).
Constructors
| NoteTypeValue1024th | 1024th |
| NoteTypeValue512th | 512th |
| NoteTypeValue256th | 256th |
| NoteTypeValue128th | 128th |
| NoteTypeValue64th | 64th |
| NoteTypeValue32nd | 32nd |
| NoteTypeValue16th | 16th |
| NoteTypeValueEighth | eighth |
| NoteTypeValueQuarter | quarter |
| NoteTypeValueHalf | half |
| NoteTypeValueWhole | whole |
| NoteTypeValueBreve | breve |
| NoteTypeValueLong | long |
| NoteTypeValueMaxima | maxima |
Instances
data NoteheadValue Source #
notehead-value (simple)
The notehead-value type indicates shapes other than the open and closed ovals associated with note durations.
The values do, re, mi, fa, fa up, so, la, and ti correspond to Aikin's 7-shape system. The fa up shape is typically used with upstems; the fa shape is typically used with downstems or no stems.
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. The left triangle shape is a right triangle with the hypotenuse facing up and to the left.
The other notehead covers noteheads other than those listed here. It is usually used in combination with the smufl attribute to specify a particular SMuFL notehead. The smufl attribute may be used with any notehead value to help specify the appearance of symbols that share the same MusicXML semantics. Noteheads in the SMuFL "Note name noteheads" range (U+E150–U+E1AF) should not use the smufl attribute or the "other" value, but instead use the notehead-text element.
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 |
| NoteheadValueCircled | circled |
| NoteheadValueSlashed | slashed |
| NoteheadValueBackSlashed | back slashed |
| NoteheadValueNormal | normal |
| NoteheadValueCluster | cluster |
| NoteheadValueCircleDot | circle dot |
| NoteheadValueLeftTriangle | left triangle |
| NoteheadValueRectangle | rectangle |
| NoteheadValueNone | none |
| NoteheadValueDo | do |
| NoteheadValueRe | re |
| NoteheadValueMi | mi |
| NoteheadValueFa | fa |
| NoteheadValueFaUp | fa up |
| NoteheadValueSo | so |
| NoteheadValueLa | la |
| NoteheadValueTi | ti |
| NoteheadValueOther | other |
Instances
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 document order. When a number-level value is optional, the value is 1 by default.
Constructors
| NumberLevel | |
Fields | |
Instances
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 | |
Instances
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 | |
| NumberOrNormalNumberOrNormal | |
Fields | |
Instances
octave (simple)
Octaves are represented by the numbers 0 to 9, where 4 indicates the octave started by middle C.
Instances
| Bounded Octave Source # | |
| Enum Octave Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Generic Octave Source # | |
| Num Octave Source # | |
| Read Octave Source # | |
| Integral Octave Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Real Octave Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods toRational :: Octave -> Rational # | |
| Show Octave Source # | |
| EmitXml Octave Source # | |
| Eq Octave Source # | |
| Ord Octave Source # | |
| type Rep Octave Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
on-off (simple)
The on-off type is used for notation elements such as string mutes.
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 # | |
| Enum OverUnder Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods succ :: OverUnder -> OverUnder # pred :: OverUnder -> OverUnder # fromEnum :: OverUnder -> Int # enumFrom :: OverUnder -> [OverUnder] # enumFromThen :: OverUnder -> OverUnder -> [OverUnder] # enumFromTo :: OverUnder -> OverUnder -> [OverUnder] # enumFromThenTo :: OverUnder -> OverUnder -> OverUnder -> [OverUnder] # | |
| Generic OverUnder Source # | |
| Show OverUnder Source # | |
| EmitXml OverUnder Source # | |
| Eq OverUnder Source # | |
| Ord OverUnder Source # | |
| type Rep OverUnder Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
pedal-type (simple)
The pedal-type simple type is used to distinguish types of pedal directions. The start value indicates the start of a damper pedal, while the sostenuto value indicates the start of a sostenuto pedal. The change, continue, and stop values can be used with either the damper or sostenuto pedal. The soft pedal is not included here because there is no special symbol or graphic used for it beyond what can be specified with words and bracket elements.
Constructors
| PedalTypeStart | start |
| PedalTypeStop | stop |
| PedalTypeSostenuto | sostenuto |
| PedalTypeChange | change |
| PedalTypeContinue | continue |
Instances
percent (simple)
The percent type specifies a percentage from 0 to 100.
Instances
| Generic Percent Source # | |
| Num Percent Source # | |
| Read Percent Source # | |
| Fractional Percent Source # | |
| Real Percent Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods toRational :: Percent -> Rational # | |
| RealFrac Percent Source # | |
| Show Percent Source # | |
| EmitXml Percent Source # | |
| Eq Percent Source # | |
| Ord Percent Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep Percent Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
data PitchedValue Source #
pitched-value (simple)
The pitched-value type represents pictograms for pitched percussion instruments. The chimes and tubular chimes values distinguish the single-line and double-line versions of the pictogram.
Constructors
| PitchedValueCelesta | celesta |
| PitchedValueChimes | chimes |
| PitchedValueGlockenspiel | glockenspiel |
| PitchedValueLithophone | lithophone |
| PitchedValueMallet | mallet |
| PitchedValueMarimba | marimba |
| PitchedValueSteelDrums | steel drums |
| PitchedValueTubaphone | tubaphone |
| PitchedValueTubularChimes | tubular chimes |
| PitchedValueVibraphone | vibraphone |
| PitchedValueXylophone | xylophone |
Instances
newtype PositiveDivisions Source #
positive-divisions (simple)
The positive-divisions type restricts divisions values to positive numbers.
Constructors
| PositiveDivisions | |
Fields | |
Instances
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 | |
| PositiveIntegerOrEmptyPositiveIntegerOrEmpty | |
Instances
newtype PositiveInteger Source #
xs:positiveInteger (simple)
Constructors
| PositiveInteger | |
Fields | |
Instances
data PrincipalVoiceSymbol Source #
principal-voice-symbol (simple)
The principal-voice-symbol type represents the type of symbol used to indicate the start of a principal or secondary voice. The "plain" value represents a plain square bracket. The value of "none" is used for analysis markup when the principal-voice element does not have a corresponding appearance in the score.
Constructors
| PrincipalVoiceSymbolHauptstimme | Hauptstimme |
| PrincipalVoiceSymbolNebenstimme | Nebenstimme |
| PrincipalVoiceSymbolPlain | plain |
| PrincipalVoiceSymbolNone | none |
Instances
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
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 | |
Instances
data SemiPitched Source #
semi-pitched (simple)
The semi-pitched type represents categories of indefinite pitch for percussion instruments.
Constructors
| SemiPitchedHigh | high |
| SemiPitchedMediumHigh | medium-high |
| SemiPitchedMedium | medium |
| SemiPitchedMediumLow | medium-low |
| SemiPitchedLow | low |
| SemiPitchedVeryLow | very-low |
Instances
semitones (simple)
The semitones 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) are used for microtones.
Instances
| Generic Semitones Source # | |
| Num Semitones Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Read Semitones Source # | |
| Fractional Semitones Source # | |
| Real Semitones Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods toRational :: Semitones -> Rational # | |
| RealFrac Semitones Source # | |
| Show Semitones Source # | |
| EmitXml Semitones Source # | |
| Eq Semitones Source # | |
| Ord Semitones Source # | |
| type Rep Semitones Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
xlink:show (simple)
Constructors
| ShowNew | new |
| ShowReplace | replace |
| ShowEmbed | embed |
| ShowOther | other |
| ShowNone | none |
Instances
| Bounded SmpShow Source # | |
| Enum SmpShow Source # | |
| Generic SmpShow Source # | |
| Show SmpShow Source # | |
| EmitXml SmpShow Source # | |
| Eq SmpShow Source # | |
| Ord SmpShow Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep SmpShow Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep SmpShow = D1 ('MetaData "SmpShow" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) ((C1 ('MetaCons "ShowNew" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ShowReplace" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "ShowEmbed" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "ShowOther" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ShowNone" 'PrefixI 'False) (U1 :: Type -> Type)))) | |
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 # | |
| Enum ShowFrets Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods succ :: ShowFrets -> ShowFrets # pred :: ShowFrets -> ShowFrets # fromEnum :: ShowFrets -> Int # enumFrom :: ShowFrets -> [ShowFrets] # enumFromThen :: ShowFrets -> ShowFrets -> [ShowFrets] # enumFromTo :: ShowFrets -> ShowFrets -> [ShowFrets] # enumFromThenTo :: ShowFrets -> ShowFrets -> ShowFrets -> [ShowFrets] # | |
| Generic ShowFrets Source # | |
| Show ShowFrets Source # | |
| EmitXml ShowFrets Source # | |
| Eq ShowFrets Source # | |
| Ord ShowFrets Source # | |
| type Rep ShowFrets Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
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
parseShowTuplet :: String -> XParse ShowTuplet Source #
newtype SmuflAccidentalGlyphName Source #
smufl-accidental-glyph-name (simple)
The smufl-accidental-glyph-name type is used to reference a specific Standard Music Font Layout (SMuFL) accidental character. The value is a SMuFL canonical glyph name that starts with acc.
Constructors
| SmuflAccidentalGlyphName | |
Fields | |
Instances
newtype SmuflCodaGlyphName Source #
smufl-coda-glyph-name (simple)
The smufl-coda-glyph-name type is used to reference a specific Standard Music Font Layout (SMuFL) coda character. The value is a SMuFL canonical glyph name that starts with coda.
Constructors
| SmuflCodaGlyphName | |
Fields | |
Instances
newtype SmuflGlyphName Source #
smufl-glyph-name (simple)
The smufl-glyph-name type is used for attributes that reference a specific Standard Music Font Layout (SMuFL) character. The value is a SMuFL canonical glyph name, not a code point. For instance, the value for a standard piano pedal mark would be keyboardPedalPed, not U+E650.
Constructors
| SmuflGlyphName | |
Fields | |
Instances
newtype SmuflLyricsGlyphName Source #
smufl-lyrics-glyph-name (simple)
The smufl-lyrics-glyph-name type is used to reference a specific Standard Music Font Layout (SMuFL) lyrics elision character. The value is a SMuFL canonical glyph name that starts with lyrics.
Constructors
| SmuflLyricsGlyphName | |
Fields | |
Instances
newtype SmuflPictogramGlyphName Source #
smufl-pictogram-glyph-name (simple)
The smufl-pictogram-glyph-name type is used to reference a specific Standard Music Font Layout (SMuFL) percussion pictogram character. The value is a SMuFL canonical glyph name that starts with pict.
Constructors
| SmuflPictogramGlyphName | |
Fields | |
Instances
newtype SmuflSegnoGlyphName Source #
smufl-segno-glyph-name (simple)
The smufl-segno-glyph-name type is used to reference a specific Standard Music Font Layout (SMuFL) segno character. The value is a SMuFL canonical glyph name that starts with segno.
Constructors
| SmuflSegnoGlyphName | |
Fields | |
Instances
xml:space (simple)
Constructors
| SpaceDefault | default |
| SpacePreserve | preserve |
data StaffDivideSymbol Source #
staff-divide-symbol (simple)
The staff-divide-symbol type is used for staff division symbols. The down, up, and up-down values correspond to SMuFL code points U+E00B, U+E00C, and U+E00D respectively.
Constructors
| StaffDivideSymbolDown | down |
| StaffDivideSymbolUp | up |
| StaffDivideSymbolUpDown | up-down |
Instances
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.
Instances
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 | |
Instances
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
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 # | |
| Enum StartNote Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods succ :: StartNote -> StartNote # pred :: StartNote -> StartNote # fromEnum :: StartNote -> Int # enumFrom :: StartNote -> [StartNote] # enumFromThen :: StartNote -> StartNote -> [StartNote] # enumFromTo :: StartNote -> StartNote -> [StartNote] # enumFromThenTo :: StartNote -> StartNote -> StartNote -> [StartNote] # | |
| Generic StartNote Source # | |
| Show StartNote Source # | |
| EmitXml StartNote Source # | |
| Eq StartNote Source # | |
| Ord StartNote Source # | |
| type Rep StartNote Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep StartNote = D1 ('MetaData "StartNote" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "StartNoteUpper" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "StartNoteMain" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StartNoteBelow" 'PrefixI 'False) (U1 :: Type -> Type))) | |
start-stop (simple)
The start-stop type is used for an attribute of musical elements that can either start or stop, such as tuplets.
The values of start and stop refer to how an element appears in musical score order, not in MusicXML document order. An element with a stop attribute may precede the corresponding element with a start attribute within a MusicXML document. This is particularly common in multi-staff music. For example, the stopping point for a tuplet may appear in staff 1 before the starting point for the tuplet appears in staff 2 later in the document.
Constructors
| StartStopStart | start |
| StartStopStop | stop |
Instances
| Bounded StartStop Source # | |
| Enum StartStop Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods succ :: StartStop -> StartStop # pred :: StartStop -> StartStop # fromEnum :: StartStop -> Int # enumFrom :: StartStop -> [StartStop] # enumFromThen :: StartStop -> StartStop -> [StartStop] # enumFromTo :: StartStop -> StartStop -> [StartStop] # enumFromThenTo :: StartStop -> StartStop -> StartStop -> [StartStop] # | |
| Generic StartStop Source # | |
| Show StartStop Source # | |
| EmitXml StartStop Source # | |
| Eq StartStop Source # | |
| Ord StartStop Source # | |
| type Rep StartStop Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
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 or for formatting of symbols across system breaks.
The values of start, stop, and continue refer to how an element appears in musical score order, not in MusicXML document order. An element with a stop attribute may precede the corresponding element with a start attribute within a MusicXML document. This is particularly common in multi-staff music. For example, the stopping point for a slur may appear in staff 1 before the starting point for the slur appears in staff 2 later in the document.
Constructors
| StartStopContinueStart | start |
| StartStopContinueStop | stop |
| StartStopContinueContinue | continue |
Instances
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
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 groupings.
Constructors
| StartStopSingleStart | start |
| StartStopSingleStop | stop |
| StartStopSingleSingle | single |
Instances
stem-value (simple)
The stem type represents the notated stem direction.
Constructors
| StemValueDown | down |
| StemValueUp | up |
| StemValueDouble | double |
| StemValueNone | none |
Instances
step (simple)
The step type represents a step of the diatonic scale, represented using the English letters A through G.
Instances
| Bounded Step Source # | |
| Enum Step Source # | |
| Generic Step Source # | |
| Show Step Source # | |
| EmitXml Step Source # | |
| Eq Step Source # | |
| Ord Step Source # | |
| type Rep Step Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Step = D1 ('MetaData "Step" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) ((C1 ('MetaCons "StepA" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "StepB" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StepC" 'PrefixI 'False) (U1 :: Type -> Type))) :+: ((C1 ('MetaCons "StepD" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StepE" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "StepF" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "StepG" 'PrefixI 'False) (U1 :: Type -> Type)))) | |
data StickLocation Source #
stick-location (simple)
The stick-location type represents pictograms for the location of sticks, beaters, or mallets on cymbals, gongs, drums, and other instruments.
Constructors
| StickLocationCenter | center |
| StickLocationRim | rim |
| StickLocationCymbalBell | cymbal bell |
| StickLocationCymbalEdge | cymbal edge |
Instances
data StickMaterial Source #
stick-material (simple)
The stick-material type represents the material being displayed in a stick pictogram.
Constructors
| StickMaterialSoft | soft |
| StickMaterialMedium | medium |
| StickMaterialHard | hard |
| StickMaterialShaded | shaded |
| StickMaterialX | x |
Instances
stick-type (simple)
The stick-type type represents the shape of pictograms where the material in the stick, mallet, or beater is represented in the pictogram.
Constructors
| StickTypeBassDrum | bass drum |
| StickTypeDoubleBassDrum | double bass drum |
| StickTypeGlockenspiel | glockenspiel |
| StickTypeGum | gum |
| StickTypeHammer | hammer |
| StickTypeSuperball | superball |
| StickTypeTimpani | timpani |
| StickTypeWound | wound |
| StickTypeXylophone | xylophone |
| StickTypeYarn | yarn |
Instances
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 full-length string.
Constructors
| StringNumber | |
Fields | |
Instances
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 # | |
| Enum Syllabic Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Generic Syllabic Source # | |
| Show Syllabic Source # | |
| EmitXml Syllabic Source # | |
| Eq Syllabic Source # | |
| Ord Syllabic Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep Syllabic Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Syllabic = D1 ('MetaData "Syllabic" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) ((C1 ('MetaCons "SyllabicSingle" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SyllabicBegin" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "SyllabicEnd" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "SyllabicMiddle" 'PrefixI 'False) (U1 :: Type -> Type))) | |
data SymbolSize Source #
symbol-size (simple)
The symbol-size type is used to distinguish between full, cue sized, grace cue sized, and oversized symbols.
Constructors
| SymbolSizeFull | full |
| SymbolSizeCue | cue |
| SymbolSizeGraceCue | grace-cue |
| SymbolSizeLarge | large |
Instances
parseSymbolSize :: String -> XParse SymbolSize Source #
tap-hand (simple)
The tap-hand type represents the symbol to use for a tap element. The left and right values refer to the SMuFL guitarLeftHandTapping and guitarRightHandTapping glyphs respectively.
Constructors
| TapHandLeft | left |
| TapHandRight | right |
Instances
| Bounded TapHand Source # | |
| Enum TapHand Source # | |
| Generic TapHand Source # | |
| Show TapHand Source # | |
| EmitXml TapHand Source # | |
| Eq TapHand Source # | |
| Ord TapHand Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep TapHand 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.
Instances
| Generic Tenths Source # | |
| Num Tenths Source # | |
| Read Tenths Source # | |
| Fractional Tenths Source # | |
| Real Tenths Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods toRational :: Tenths -> Rational # | |
| RealFrac Tenths Source # | |
| Show Tenths Source # | |
| EmitXml Tenths Source # | |
| Eq Tenths Source # | |
| Ord Tenths Source # | |
| type Rep Tenths Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
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
tied-type (simple)
The tied-type type is used as an attribute of the tied element to specify where the visual representation of a tie begins and ends. A tied element which joins two notes of the same pitch can be specified with tied-type start on the first note and tied-type stop on the second note. To indicate a note should be undamped, use a single tied element with tied-type let-ring. For other ties that are visually attached to a single note, such as a tie leading into or out of a repeated section or coda, use two tied elements on the same note, one start and one stop.
In start-stop cases, ties can add more elements using a continue type. This is typically used to specify the formatting of cross-system ties.
Constructors
| TiedTypeStart | start |
| TiedTypeStop | stop |
| TiedTypeContinue | continue |
| TiedTypeLetRing | let-ring |
Instances
| Bounded TiedType Source # | |
| Enum TiedType Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Generic TiedType Source # | |
| Show TiedType Source # | |
| EmitXml TiedType Source # | |
| Eq TiedType Source # | |
| Ord TiedType Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep TiedType Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep TiedType = D1 ('MetaData "TiedType" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) ((C1 ('MetaCons "TiedTypeStart" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TiedTypeStop" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "TiedTypeContinue" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TiedTypeLetRing" 'PrefixI 'False) (U1 :: Type -> Type))) | |
time-only (simple)
The time-only type is used to indicate that a particular playback-related element only applies particular times through a repeated section. The value is a comma-separated list of positive integers arranged in ascending order, indicating which times through the repeated section that the element applies.
Instances
| IsString TimeOnly Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods fromString :: String -> TimeOnly # | |
| Generic TimeOnly Source # | |
| Read TimeOnly Source # | |
| Show TimeOnly Source # | |
| EmitXml TimeOnly Source # | |
| Eq TimeOnly Source # | |
| Ord TimeOnly Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep TimeOnly Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
data TimeRelation Source #
time-relation (simple)
The time-relation type indicates the symbol used to represent the interchangeable aspect of dual time signatures.
Constructors
| TimeRelationParentheses | parentheses |
| TimeRelationBracket | bracket |
| TimeRelationEquals | equals |
| TimeRelationSlash | slash |
| TimeRelationSpace | space |
| TimeRelationHyphen | hyphen |
Instances
data TimeSeparator Source #
time-separator (simple)
The time-separator type indicates how to display the arrangement between the beats and beat-type values in a time signature. The default value is none. The horizontal, diagonal, and vertical values represent horizontal, diagonal lower-left to upper-right, and vertical lines respectively. For these values, the beats and beat-type values are arranged on either side of the separator line. The none value represents no separator with the beats and beat-type arranged vertically. The adjacent value represents no separator with the beats and beat-type arranged horizontally.
Constructors
| TimeSeparatorNone | none |
| TimeSeparatorHorizontal | horizontal |
| TimeSeparatorDiagonal | diagonal |
| TimeSeparatorVertical | vertical |
| TimeSeparatorAdjacent | adjacent |
Instances
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. The note symbol indicates that the beat-type should be represented with the corresponding downstem note rather than a number. The dotted-note symbol indicates that the beat-type should be represented with a dotted downstem note that corresponds to three times the beat-type value, and a numerator that is one third the beats value.
Constructors
| TimeSymbolCommon | common |
| TimeSymbolCut | cut |
| TimeSymbolSingleNumber | single-number |
| TimeSymbolNote | note |
| TimeSymbolDottedNote | dotted-note |
| TimeSymbolNormal | normal |
Instances
parseTimeSymbol :: String -> XParse TimeSymbol Source #
data TipDirection Source #
tip-direction (simple)
The tip-direction type represents the direction in which the tip of a stick or beater points, using Unicode arrow terminology.
Constructors
| TipDirectionUp | up |
| TipDirectionDown | down |
| TipDirectionLeft | left |
| TipDirectionRight | right |
| TipDirectionNorthwest | northwest |
| TipDirectionNortheast | northeast |
| TipDirectionSoutheast | southeast |
| TipDirectionSouthwest | southwest |
Instances
xs:token (simple)
Constructors
| Token | |
Fields | |
Instances
| IsString Token Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods fromString :: String -> Token # | |
| Generic Token Source # | |
| Read Token Source # | |
| Show Token Source # | |
| EmitXml Token Source # | |
| Eq Token Source # | |
| Ord Token Source # | |
| type Rep Token Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Token = D1 ('MetaData "Token" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'True) (C1 ('MetaCons "Token" 'PrefixI 'True) (S1 ('MetaSel ('Just "token") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NormalizedString))) | |
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 # | |
| Enum TopBottom Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods succ :: TopBottom -> TopBottom # pred :: TopBottom -> TopBottom # fromEnum :: TopBottom -> Int # enumFrom :: TopBottom -> [TopBottom] # enumFromThen :: TopBottom -> TopBottom -> [TopBottom] # enumFromTo :: TopBottom -> TopBottom -> [TopBottom] # enumFromThenTo :: TopBottom -> TopBottom -> TopBottom -> [TopBottom] # | |
| Generic TopBottom Source # | |
| Show TopBottom Source # | |
| EmitXml TopBottom Source # | |
| Eq TopBottom Source # | |
| Ord TopBottom Source # | |
| type Rep TopBottom Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
newtype TremoloMarks Source #
tremolo-marks (simple)
The number of tremolo marks is represented by a number from 0 to 8: the same as beam-level with 0 added.
Constructors
| TremoloMarks | |
Fields
| |
Instances
data TremoloType Source #
tremolo-type (simple)
The tremolo-type is used to distinguish multi-note, single-note, and unmeasured tremolos.
Constructors
| TremoloTypeStart | start |
| TremoloTypeStop | stop |
| TremoloTypeSingle | single |
| TremoloTypeUnmeasured | unmeasured |
Instances
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 | |
Instances
parseTrillBeats :: String -> XParse TrillBeats 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 # | |
| Enum TrillStep Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods succ :: TrillStep -> TrillStep # pred :: TrillStep -> TrillStep # fromEnum :: TrillStep -> Int # enumFrom :: TrillStep -> [TrillStep] # enumFromThen :: TrillStep -> TrillStep -> [TrillStep] # enumFromTo :: TrillStep -> TrillStep -> [TrillStep] # enumFromThenTo :: TrillStep -> TrillStep -> TrillStep -> [TrillStep] # | |
| Generic TrillStep Source # | |
| Show TrillStep Source # | |
| EmitXml TrillStep Source # | |
| Eq TrillStep Source # | |
| Ord TrillStep Source # | |
| type Rep TrillStep Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep TrillStep = D1 ('MetaData "TrillStep" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "TrillStepWhole" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "TrillStepHalf" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "TrillStepUnison" 'PrefixI 'False) (U1 :: Type -> Type))) | |
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
xlink:type (simple)
Constructors
| TypeSimple | simple |
up-down (simple)
The up-down type is used for the direction of arrows and other pointed symbols like vertical accents, indicating which way the tip is pointing.
Constructors
| UpDownUp | up |
| UpDownDown | down |
data UpDownStopContinue Source #
up-down-stop-continue (simple)
The up-down-stop-continue type is used for octave-shift elements, indicating the direction of the shift from their true pitched values because of printing difficulty.
Constructors
| UpDownStopContinueUp | up |
| UpDownStopContinueDown | down |
| UpDownStopContinueStop | stop |
| UpDownStopContinueContinue | continue |
Instances
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
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 # | |
| Enum Valign Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Generic Valign Source # | |
| Show Valign Source # | |
| EmitXml Valign Source # | |
| Eq Valign Source # | |
| Ord Valign Source # | |
| type Rep Valign Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Valign = D1 ('MetaData "Valign" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) ((C1 ('MetaCons "ValignTop" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ValignMiddle" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "ValignBottom" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "ValignBaseline" 'PrefixI 'False) (U1 :: Type -> Type))) | |
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
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. The continue type is used for formatting wedges over a system break, or for other situations where a single wedge is divided into multiple segments.
Constructors
| WedgeTypeCrescendo | crescendo |
| WedgeTypeDiminuendo | diminuendo |
| WedgeTypeStop | stop |
| WedgeTypeContinue | continue |
Instances
winged (simple)
The winged attribute indicates whether the repeat has winged extensions that appear above and below the barline. The straight and curved values represent single wings, while the double-straight and double-curved values represent double wings. The none value indicates no wings and is the default.
Constructors
| WingedNone | none |
| WingedStraight | straight |
| WingedCurved | curved |
| WingedDoubleStraight | double-straight |
| WingedDoubleCurved | double-curved |
Instances
| Bounded Winged Source # | |
| Enum Winged Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| Generic Winged Source # | |
| Show Winged Source # | |
| EmitXml Winged Source # | |
| Eq Winged Source # | |
| Ord Winged Source # | |
| type Rep Winged Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Winged = D1 ('MetaData "Winged" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) ((C1 ('MetaCons "WingedNone" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "WingedStraight" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "WingedCurved" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "WingedDoubleStraight" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "WingedDoubleCurved" 'PrefixI 'False) (U1 :: Type -> Type)))) | |
wood (simple)
The wood type represents pictograms for wood percussion instruments. The maraca and maracas values distinguish the one- and two-maraca versions of the pictogram.
Constructors
| WoodBambooScraper | bamboo scraper |
| WoodBoardClapper | board clapper |
| WoodCabasa | cabasa |
| WoodCastanets | castanets |
| WoodCastanetsWithHandle | castanets with handle |
| WoodClaves | claves |
| WoodFootballRattle | football rattle |
| WoodGuiro | guiro |
| WoodLogDrum | log drum |
| WoodMaraca | maraca |
| WoodMaracas | maracas |
| WoodQuijada | quijada |
| WoodRainstick | rainstick |
| WoodRatchet | ratchet |
| WoodRecoReco | reco-reco |
| WoodSandpaperBlocks | sandpaper blocks |
| WoodSlitDrum | slit drum |
| WoodTempleBlock | temple block |
| WoodVibraslap | vibraslap |
| WoodWhip | whip |
| WoodWoodBlock | wood block |
Instances
| Bounded Wood Source # | |
| Enum Wood Source # | |
| Generic Wood Source # | |
| Show Wood Source # | |
| EmitXml Wood Source # | |
| Eq Wood Source # | |
| Ord Wood Source # | |
| type Rep Wood Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Wood = D1 ('MetaData "Wood" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) ((((C1 ('MetaCons "WoodBambooScraper" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "WoodBoardClapper" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "WoodCabasa" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "WoodCastanets" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "WoodCastanetsWithHandle" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "WoodClaves" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "WoodFootballRattle" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "WoodGuiro" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "WoodLogDrum" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "WoodMaraca" 'PrefixI 'False) (U1 :: Type -> Type))))) :+: (((C1 ('MetaCons "WoodMaracas" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "WoodQuijada" 'PrefixI 'False) (U1 :: Type -> Type)) :+: (C1 ('MetaCons "WoodRainstick" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "WoodRatchet" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "WoodRecoReco" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "WoodSandpaperBlocks" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "WoodSlitDrum" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "WoodTempleBlock" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "WoodVibraslap" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "WoodWhip" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "WoodWoodBlock" 'PrefixI 'False) (U1 :: Type -> Type)))))) | |
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.
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 | |
| YesNoNumberDecimal | |
Fields | |
Instances
| Generic YesNoNumber Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep YesNoNumber :: Type -> Type # | |
| Show YesNoNumber Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> YesNoNumber -> ShowS # show :: YesNoNumber -> String # showList :: [YesNoNumber] -> ShowS # | |
| EmitXml YesNoNumber Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: YesNoNumber -> XmlRep Source # | |
| Eq YesNoNumber Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep YesNoNumber Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep YesNoNumber = D1 ('MetaData "YesNoNumber" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "YesNoNumberYesNo" 'PrefixI 'True) (S1 ('MetaSel ('Just "yesNoNumber1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 YesNo)) :+: C1 ('MetaCons "YesNoNumberDecimal" 'PrefixI 'True) (S1 ('MetaSel ('Just "yesNoNumber2") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Decimal))) | |
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.
Instances
| IsString YyyyMmDd Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods fromString :: String -> YyyyMmDd # | |
| Generic YyyyMmDd Source # | |
| Read YyyyMmDd Source # | |
| Show YyyyMmDd Source # | |
| EmitXml YyyyMmDd Source # | |
| Eq YyyyMmDd Source # | |
| Ord YyyyMmDd Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep YyyyMmDd Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
xml:lang (union)
Constructors
| SumLang | // |
Instances
| Bounded SumLang Source # | |
| Enum SumLang Source # | |
| Generic SumLang Source # | |
| Show SumLang Source # | |
| EmitXml SumLang Source # | |
| Eq SumLang Source # | |
| Ord SumLang Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep SumLang Source # | |
data SumNumberOrNormal Source #
number-or-normal (union)
Constructors
| NumberOrNormalNormal | normal |
Instances
data SumPositiveIntegerOrEmpty Source #
positive-integer-or-empty (union)
Constructors
| SumPositiveIntegerOrEmpty | // |
Instances
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
| |
Instances
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
| |
Instances
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
Instances
mkAccidentalText :: AccidentalValue -> AccidentalText Source #
Smart constructor for AccidentalText
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
| |
Instances
| Generic Accord Source # | |
| Show Accord Source # | |
| EmitXml Accord Source # | |
| Eq Accord Source # | |
| type Rep Accord Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Accord = D1 ('MetaData "Accord" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Accord" 'PrefixI 'True) (S1 ('MetaSel ('Just "accordString") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe StringNumber)) :*: S1 ('MetaSel ('Just "accordTuning") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Tuning))) | |
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
Instances
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. This includes support for line widths, definitions for note sizes, and standard distances between notation elements, plus an extension element for other aspects of appearance.
Constructors
| Appearance | |
Fields
| |
Instances
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
| |
Instances
mkArpeggiate :: Arpeggiate Source #
Smart constructor for Arpeggiate
arrow (complex)
The arrow element represents an arrow used for a musical technical indication. It can represent both Unicode and SMuFL arrows. The presence of an arrowhead element indicates that only the arrowhead is displayed, not the arrow stem. The smufl attribute distinguishes different SMuFL glyphs that have an arrow appearance such as arrowBlackUp, guitarStrumUp, or handbellsSwingUp. The specified glyph should match the descriptive representation.
Constructors
| Arrow | |
Fields
| |
Instances
parseArrow :: XParse Arrow Source #
data Articulations Source #
articulations (complex)
Articulations and accents are grouped together here.
Constructors
| Articulations | |
Fields
| |
Instances
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. When attributes are changed mid-measure, it affects the music in score order, not in MusicXML document order.
Constructors
| Attributes | |
Fields
| |
Instances
mkAttributes :: Editorial -> Attributes Source #
Smart constructor for Attributes
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 or mid-measure changes in the divisions value.
Constructors
| Backup | |
Fields | |
Instances
| Generic Backup Source # | |
| Show Backup Source # | |
| EmitXml Backup Source # | |
| Eq Backup Source # | |
| type Rep Backup Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Backup = D1 ('MetaData "Backup" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Backup" 'PrefixI 'True) (S1 ('MetaSel ('Just "backupDuration") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Duration) :*: S1 ('MetaSel ('Just "backupEditorial") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Editorial))) | |
data BarStyleColor Source #
bar-style-color (complex)
The bar-style-color type contains barline style and color information.
Constructors
| BarStyleColor | |
Fields
| |
Instances
mkBarStyleColor :: BarStyle -> BarStyleColor Source #
Smart constructor for BarStyleColor
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
| |
Instances
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
| |
Instances
| Generic Barre Source # | |
| Show Barre Source # | |
| EmitXml Barre Source # | |
| Eq Barre Source # | |
| type Rep Barre Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Barre = D1 ('MetaData "Barre" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Barre" 'PrefixI 'True) (S1 ('MetaSel ('Just "barreType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 StartStop) :*: S1 ('MetaSel ('Just "barreColor") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Color)))) | |
parseBarre :: XParse Barre 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
| |
Instances
| Generic Bass Source # | |
| Show Bass Source # | |
| EmitXml Bass Source # | |
| Eq Bass Source # | |
| type Rep Bass Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Bass = D1 ('MetaData "Bass" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Bass" 'PrefixI 'True) (S1 ('MetaSel ('Just "bassBassStep") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 BassStep) :*: S1 ('MetaSel ('Just "bassBassAlter") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe BassAlter)))) | |
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
| |
Instances
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 in a score if not using the element contents.
Constructors
| BassStep | |
Fields
| |
Instances
beam (complex)
Beam values include begin, continue, end, forward hook, and backward hook. Up to eight concurrent beams are available to cover up to 1024th notes. Each beam in a note is represented with a separate beam element, starting with the eighth note beam using a number attribute of 1.
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.
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.
The repeater attribute has been deprecated in MusicXML 3.0. Formerly used for tremolos, it needs to be specified with a "yes" value for each beam using it.
Constructors
| Beam | |
Instances
| Generic Beam Source # | |
| Show Beam Source # | |
| EmitXml Beam Source # | |
| Eq Beam Source # | |
| type Rep Beam Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Beam = D1 ('MetaData "Beam" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Beam" 'PrefixI 'True) ((S1 ('MetaSel ('Just "beamBeamValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 BeamValue) :*: (S1 ('MetaSel ('Just "beamNumber") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe BeamLevel)) :*: S1 ('MetaSel ('Just "beamRepeater") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo)))) :*: (S1 ('MetaSel ('Just "beamFan") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Fan)) :*: (S1 ('MetaSel ('Just "beamColor") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Color)) :*: S1 ('MetaSel ('Just "beamId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ID)))))) | |
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
| |
Instances
mkBeatRepeat :: StartStop -> BeatRepeat Source #
Smart constructor for BeatRepeat
data BeatUnitTied Source #
beat-unit-tied (complex)
The beat-unit-tied type indicates a beat-unit within a metronome mark that is tied to the preceding beat-unit. This allows or two or more tied notes to be associated with a per-minute value in a metronome mark, whereas the metronome-tied element is restricted to metric relationship marks.
Constructors
| BeatUnitTied | |
Fields | |
Instances
| Generic BeatUnitTied Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep BeatUnitTied :: Type -> Type # | |
| Show BeatUnitTied Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> BeatUnitTied -> ShowS # show :: BeatUnitTied -> String # showList :: [BeatUnitTied] -> ShowS # | |
| EmitXml BeatUnitTied Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: BeatUnitTied -> XmlRep Source # | |
| Eq BeatUnitTied Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep BeatUnitTied Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep BeatUnitTied = D1 ('MetaData "BeatUnitTied" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "BeatUnitTied" 'PrefixI 'True) (S1 ('MetaSel ('Just "beatUnitTiedBeatUnit") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 BeatUnit))) | |
mkBeatUnitTied :: BeatUnit -> BeatUnitTied Source #
Smart constructor for BeatUnitTied
beater (complex)
The beater type represents pictograms for beaters, mallets, and sticks that do not have different materials represented in the pictogram.
Constructors
| Beater | |
Fields
| |
Instances
| Generic Beater Source # | |
| Show Beater Source # | |
| EmitXml Beater Source # | |
| Eq Beater Source # | |
| type Rep Beater Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Beater = D1 ('MetaData "Beater" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Beater" 'PrefixI 'True) (S1 ('MetaSel ('Just "beaterBeaterValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 BeaterValue) :*: S1 ('MetaSel ('Just "beaterTip") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe TipDirection)))) | |
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
| |
Instances
bookmark (complex)
The bookmark type serves as a well-defined target for an incoming simple XLink.
Constructors
| Bookmark | |
Fields
| |
Instances
| Generic Bookmark Source # | |
| Show Bookmark Source # | |
| EmitXml Bookmark Source # | |
| Eq Bookmark Source # | |
| type Rep Bookmark Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Bookmark = D1 ('MetaData "Bookmark" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Bookmark" 'PrefixI 'True) ((S1 ('MetaSel ('Just "bookmarkId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ID) :*: S1 ('MetaSel ('Just "bookmarkName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Token))) :*: (S1 ('MetaSel ('Just "bookmarkElement") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe NMTOKEN)) :*: S1 ('MetaSel ('Just "bookmarkPosition") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe PositiveInteger))))) | |
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
| |
Instances
data BreathMark Source #
breath-mark (complex)
The breath-mark element indicates a place to take a breath.
Constructors
| BreathMark | |
Fields
| |
Instances
mkBreathMark :: BreathMarkValue -> BreathMark Source #
Smart constructor for BreathMark
caesura (complex)
The caesura element indicates a slight pause. It is notated using a "railroad tracks" symbol or other variations specified in the element content.
Constructors
| Caesura | |
Fields
| |
Instances
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 where the cancellation appears relative to the new key signature.
Constructors
| Cancel | |
Fields
| |
Instances
| Generic Cancel Source # | |
| Show Cancel Source # | |
| EmitXml Cancel Source # | |
| Eq Cancel Source # | |
| type Rep Cancel Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Cancel = D1 ('MetaData "Cancel" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Cancel" 'PrefixI 'True) (S1 ('MetaSel ('Just "cancelFifths") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Fifths) :*: S1 ('MetaSel ('Just "cancelLocation") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe CancelLocation)))) | |
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.
Sometimes clefs at the start of a measure need to appear after the barline rather than before, as for cues or for use after a repeated section. The after-barline attribute is set to "yes" in this situation. The attribute is ignored for mid-measure clefs.
Clefs appear at the start of each system unless the print-object attribute has been set to "no" or the additional attribute has been set to "yes".
Constructors
| Clef | |
Fields
| |
Instances
coda (complex)
The coda type is the visual indicator of a coda sign. The exact glyph can be specified with the smufl attribute. A sound element is also needed to guide playback applications reliably.
Constructors
| Coda | |
Fields
| |
Instances
credit (complex)
The credit type represents the appearance of the title, composer, arranger, lyricist, copyright, dedication, and other text, symbols, and graphics that commonly appear on the first page of a score. The credit-words, credit-symbol, and credit-image elements are similar to the words, symbol, 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 page. The enclosure for credit-words and credit-symbol is none by default.
By default, a series of credit-words and credit-symbol 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 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.
The credit-type element indicates the purpose behind a credit. Multiple types of data may be combined in a single credit, so multiple elements may be used. Standard values include page number, title, subtitle, composer, arranger, lyricist, and rights.
Constructors
| Credit | |
Fields
| |
Instances
dashes (complex)
The dashes type represents dashes, used for instance with cresc. and dim. marks.
Constructors
| Dashes | |
Fields
| |
Instances
defaults (complex)
The defaults type specifies score-wide defaults for scaling, layout, and appearance.
Constructors
| Defaults | |
Fields
| |
Instances
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
| |
Instances
| Generic Degree Source # | |
| Show Degree Source # | |
| EmitXml Degree Source # | |
| Eq Degree Source # | |
| type Rep Degree Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Degree = D1 ('MetaData "Degree" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Degree" 'PrefixI 'True) ((S1 ('MetaSel ('Just "degreePrintObject") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo)) :*: S1 ('MetaSel ('Just "degreeDegreeValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DegreeValue)) :*: (S1 ('MetaSel ('Just "degreeDegreeAlter") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DegreeAlter) :*: S1 ('MetaSel ('Just "degreeDegreeType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DegreeType)))) | |
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
| |
Instances
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 in a score.
Constructors
| DegreeType | |
Fields
| |
Instances
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 in a score. The degree-value symbol attribute indicates that a symbol should be used in specifying the degree. If the symbol attribute is present, the value of the text attribute follows the symbol.
Constructors
| DegreeValue | |
Fields
| |
Instances
mkDegreeValue :: PositiveInteger -> DegreeValue Source #
Smart constructor for DegreeValue
direction (complex)
A direction is a musical indication that is not necessarily attached to a specific note. Two or more may be combined to indicate starts and stops of wedges, dashes, etc. For applications where a specific direction is indeed attached to a specific note, the direction element can be associated with the note element that follows it in score order that is not in a different voice.
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
| |
Instances
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
| |
Instances
mkDirectionType :: ChxDirectionType -> DirectionType Source #
Smart constructor for DirectionType
directive (complex)
Constructors
| Directive | |
Fields
| |
Instances
distance (complex)
The distance element represents standard distances between notation elements in tenths. The type attribute defines what type of distance is being defined. Valid values include hyphen (for hyphens in lyrics) and beam.
Constructors
| Distance | |
Fields
| |
Instances
| Generic Distance Source # | |
| Show Distance Source # | |
| EmitXml Distance Source # | |
| Eq Distance Source # | |
| type Rep Distance Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Distance = D1 ('MetaData "Distance" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Distance" 'PrefixI 'True) (S1 ('MetaSel ('Just "distanceTenths") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Tenths) :*: S1 ('MetaSel ('Just "cmpdistanceType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 DistanceType))) | |
mkDistance :: Tenths -> DistanceType -> Distance Source #
Smart constructor for Distance
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
| |
Instances
mkDynamics :: Dynamics Source #
Smart constructor for Dynamics
elision (complex)
The elision type represents an elision between lyric syllables. The text content specifies 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). If the text content is empty, the smufl attribute is used to specify the symbol to use. Its value is a SMuFL canonical glyph name that starts with lyrics. The SMuFL attribute is ignored if the elision glyph is already specified by the text content. If neither text content nor a smufl attribute are present, the elision glyph is application-specific.
Constructors
| Elision | |
Fields
| |
Instances
empty (complex)
The empty type represents an empty element with no attributes.
Constructors
| Empty |
parseEmpty :: XParse Empty Source #
empty-font (complex)
The empty-font type represents an empty element with font attributes.
Constructors
| EmptyFont | |
Fields
| |
Instances
| Generic EmptyFont Source # | |
| Show EmptyFont Source # | |
| EmitXml EmptyFont Source # | |
| Eq EmptyFont Source # | |
| type Rep EmptyFont Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep EmptyFont = D1 ('MetaData "EmptyFont" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "EmptyFont" 'PrefixI 'True) ((S1 ('MetaSel ('Just "emptyFontFontFamily") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe CommaSeparatedText)) :*: S1 ('MetaSel ('Just "emptyFontFontStyle") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe FontStyle))) :*: (S1 ('MetaSel ('Just "emptyFontFontSize") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe FontSize)) :*: S1 ('MetaSel ('Just "emptyFontFontWeight") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe FontWeight))))) | |
mkEmptyFont :: EmptyFont Source #
Smart constructor for EmptyFont
empty-line (complex)
The empty-line type represents an empty element with line-shape, line-type, line-length, dashed-formatting, print-style and placement attributes.
Constructors
| EmptyLine | |
Fields
| |
Instances
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
| |
Instances
mkEmptyPlacement :: EmptyPlacement Source #
Smart constructor for EmptyPlacement
data EmptyPlacementSmufl Source #
empty-placement-smufl (complex)
The empty-placement-smufl type represents an empty element with print-style, placement, and smufl attributes.
Constructors
| EmptyPlacementSmufl | |
Fields
| |
Instances
mkEmptyPlacementSmufl :: EmptyPlacementSmufl Source #
Smart constructor for EmptyPlacementSmufl
data EmptyPrintObjectStyleAlign Source #
empty-print-object-style-align (complex)
The empty-print-style-align-object type represents an empty element with print-object and print-style-align attribute groups.
Constructors
| EmptyPrintObjectStyleAlign | |
Fields
| |
Instances
mkEmptyPrintObjectStyleAlign :: EmptyPrintObjectStyleAlign Source #
Smart constructor for EmptyPrintObjectStyleAlign
data EmptyPrintStyleAlignId Source #
empty-print-style-align-id (complex)
The empty-print-style-align-id type represents an empty element with print-style-align and optional-unique-id attribute groups.
Constructors
| EmptyPrintStyleAlignId | |
Fields
| |
Instances
mkEmptyPrintStyleAlignId :: EmptyPrintStyleAlignId Source #
Smart constructor for EmptyPrintStyleAlignId
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
Instances
mkEmptyTrillSound :: EmptyTrillSound Source #
Smart constructor for EmptyTrillSound
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 | |
Instances
| Generic Encoding Source # | |
| Show Encoding Source # | |
| EmitXml Encoding Source # | |
| Eq Encoding Source # | |
| type Rep Encoding Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Encoding = D1 ('MetaData "Encoding" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Encoding" 'PrefixI 'True) (S1 ('MetaSel ('Just "encodingEncoding") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ChxEncoding]))) | |
mkEncoding :: Encoding Source #
Smart constructor for Encoding
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
| |
Instances
mkEnding :: String -> EndingNumber -> StartStopDiscontinue -> Ending Source #
Smart constructor for Ending
extend (complex)
The extend type represents lyric word extension / melisma lines as well as figured bass extensions. The optional type and position attributes are added in Version 3.0 to provide better formatting control.
Constructors
| Extend | |
Fields
| |
Instances
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
| |
Instances
| Generic Feature Source # | |
| Show Feature Source # | |
| EmitXml Feature Source # | |
| Eq Feature Source # | |
| type Rep Feature Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Feature = D1 ('MetaData "Feature" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Feature" 'PrefixI 'True) (S1 ('MetaSel ('Just "featureString") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Just "featureType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Token)))) | |
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
| |
Instances
figure (complex)
The figure type represents a single figure within a figured-bass element.
Constructors
| Figure | |
Fields
| |
Instances
| Generic Figure Source # | |
| Show Figure Source # | |
| EmitXml Figure Source # | |
| Eq Figure Source # | |
| type Rep Figure Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Figure = D1 ('MetaData "Figure" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Figure" 'PrefixI 'True) ((S1 ('MetaSel ('Just "figurePrefix") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe StyleText)) :*: S1 ('MetaSel ('Just "figureFigureNumber") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe StyleText))) :*: (S1 ('MetaSel ('Just "figureSuffix") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe StyleText)) :*: (S1 ('MetaSel ('Just "figureExtend") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Extend)) :*: S1 ('MetaSel ('Just "figureEditorial") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Editorial))))) | |
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 (not a grace note or chord note) that follows in score order. The optional duration element is used to indicate changes of figures under a note.
Figures are ordered from top to bottom. The value of parentheses is "no" if not present.
Constructors
| FiguredBass | |
Fields
| |
Instances
mkFiguredBass :: Editorial -> FiguredBass Source #
Smart constructor for FiguredBass
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
| |
Instances
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
| |
Instances
| Generic FirstFret Source # | |
| Show FirstFret Source # | |
| EmitXml FirstFret Source # | |
| Eq FirstFret Source # | |
| type Rep FirstFret Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep FirstFret = D1 ('MetaData "FirstFret" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "FirstFret" 'PrefixI 'True) (S1 ('MetaSel ('Just "firstFretPositiveInteger") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PositiveInteger) :*: (S1 ('MetaSel ('Just "firstFretText") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Token)) :*: S1 ('MetaSel ('Just "firstFretLocation") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe LeftRight))))) | |
mkFirstFret :: PositiveInteger -> FirstFret Source #
Smart constructor for FirstFret
data FormattedSymbolId Source #
formatted-symbol-id (complex)
The formatted-symbol-id type represents a SMuFL musical symbol element with formatting and id attributes.
Constructors
Instances
mkFormattedSymbolId :: SmuflGlyphName -> FormattedSymbolId Source #
Smart constructor for FormattedSymbolId
data FormattedText Source #
formatted-text (complex)
The formatted-text type represents a text element with text-formatting attributes.
Constructors
Instances
mkFormattedText :: String -> FormattedText Source #
Smart constructor for FormattedText
data FormattedTextId Source #
formatted-text-id (complex)
The formatted-text-id type represents a text element with text-formatting and id attributes.
Constructors
Instances
mkFormattedTextId :: String -> FormattedTextId Source #
Smart constructor for FormattedTextId
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 or mid-measure changes in the divisions value.
Constructors
| Forward | |
Fields | |
Instances
| Generic Forward Source # | |
| Show Forward Source # | |
| EmitXml Forward Source # | |
| Eq Forward Source # | |
| type Rep Forward Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Forward = D1 ('MetaData "Forward" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Forward" 'PrefixI 'True) (S1 ('MetaSel ('Just "forwardDuration") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Duration) :*: (S1 ('MetaSel ('Just "forwardEditorialVoice") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 EditorialVoice) :*: S1 ('MetaSel ('Just "forwardStaff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Staff))))) | |
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. The frame type's unplayed attribute indicates what to display above a string that has no associated frame-note element. Typical values are x and the empty string. If the attribute is not present, the display of the unplayed string is application-defined.
Constructors
| Frame | |
Fields
| |
Instances
parseFrame :: XParse Frame Source #
mkFrame :: PositiveInteger -> PositiveInteger -> Frame Source #
Smart constructor for Frame
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
| |
Instances
| Generic FrameNote Source # | |
| Show FrameNote Source # | |
| EmitXml FrameNote Source # | |
| Eq FrameNote Source # | |
| type Rep FrameNote Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep FrameNote = D1 ('MetaData "FrameNote" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "FrameNote" 'PrefixI 'True) ((S1 ('MetaSel ('Just "frameNoteString") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CmpString) :*: S1 ('MetaSel ('Just "frameNoteFret") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Fret)) :*: (S1 ('MetaSel ('Just "frameNoteFingering") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Fingering)) :*: S1 ('MetaSel ('Just "frameNoteBarre") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Barre))))) | |
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
| |
Instances
glass (complex)
The glass type represents pictograms for glass percussion instruments. The smufl attribute is used to distinguish different SMuFL glyphs for wind chimes in the chimes pictograms range, including those made of materials other than glass.
Constructors
| Glass | |
Fields
| |
Instances
| Generic Glass Source # | |
| Show Glass Source # | |
| EmitXml Glass Source # | |
| Eq Glass Source # | |
| type Rep Glass Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Glass = D1 ('MetaData "Glass" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Glass" 'PrefixI 'True) (S1 ('MetaSel ('Just "glassGlassValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 GlassValue) :*: S1 ('MetaSel ('Just "glassSmufl") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe SmuflPictogramGlyphName)))) | |
parseGlass :: XParse Glass 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
| |
Instances
glyph (complex)
The glyph element represents what SMuFL glyph should be used for different variations of symbols that are semantically identical. The type attribute specifies what type of glyph is being defined. The element value specifies what SMuFL glyph to use, including recommended stylistic alternates. The SMuFL glyph name should match the type. For instance, a type of quarter-rest would use values restQuarter, restQuarterOld, or restQuarterZ. A type of g-clef-ottava-bassa would use values gClef8vb, gClef8vbOld, or gClef8vbCClef. A type of octave-shift-up-8 would use values ottava, ottavaBassa, ottavaBassaBa, ottavaBassaVb, or octaveBassa.
Constructors
| Glyph | |
Fields
| |
Instances
| Generic Glyph Source # | |
| Show Glyph Source # | |
| EmitXml Glyph Source # | |
| Eq Glyph Source # | |
| type Rep Glyph Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Glyph = D1 ('MetaData "Glyph" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Glyph" 'PrefixI 'True) (S1 ('MetaSel ('Just "glyphSmuflGlyphName") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SmuflGlyphName) :*: S1 ('MetaSel ('Just "cmpglyphType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 GlyphType))) | |
parseGlyph :: XParse Glyph 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. The steal-time-previous attribute indicates the percentage of time to steal from the previous note for the grace note. The steal-time-following attribute indicates the percentage of time to steal from the following note for the grace note, as for appoggiaturas. The make-time attribute indicates to make time, not steal time; the units are in real-time divisions for the grace note.
Constructors
| Grace | |
Fields
| |
Instances
| Generic Grace Source # | |
| Show Grace Source # | |
| EmitXml Grace Source # | |
| Eq Grace Source # | |
| type Rep Grace Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Grace = D1 ('MetaData "Grace" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Grace" 'PrefixI 'True) ((S1 ('MetaSel ('Just "graceStealTimePrevious") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Percent)) :*: S1 ('MetaSel ('Just "graceStealTimeFollowing") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Percent))) :*: (S1 ('MetaSel ('Just "graceMakeTime") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Divisions)) :*: S1 ('MetaSel ('Just "graceSlash") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo))))) | |
parseGrace :: XParse Grace Source #
data GroupBarline Source #
group-barline (complex)
The group-barline type indicates if the group should have common barlines.
Constructors
| GroupBarline | |
Fields
| |
Instances
| Generic GroupBarline Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep GroupBarline :: Type -> Type # | |
| Show GroupBarline Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> GroupBarline -> ShowS # show :: GroupBarline -> String # showList :: [GroupBarline] -> ShowS # | |
| EmitXml GroupBarline Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: GroupBarline -> XmlRep Source # | |
| Eq GroupBarline Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep GroupBarline Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep GroupBarline = D1 ('MetaData "GroupBarline" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "GroupBarline" 'PrefixI 'True) (S1 ('MetaSel ('Just "groupBarlineGroupBarlineValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 GroupBarlineValue) :*: S1 ('MetaSel ('Just "groupBarlineColor") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Color)))) | |
mkGroupBarline :: GroupBarlineValue -> GroupBarline Source #
Smart constructor for GroupBarline
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
| |
Instances
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
| |
Instances
mkGroupSymbol :: GroupSymbolValue -> GroupSymbol Source #
Smart constructor for GroupSymbol
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
| |
Instances
| Generic Grouping Source # | |
| Show Grouping Source # | |
| EmitXml Grouping Source # | |
| Eq Grouping Source # | |
| type Rep Grouping Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Grouping = D1 ('MetaData "Grouping" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Grouping" 'PrefixI 'True) ((S1 ('MetaSel ('Just "groupingType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 StartStopSingle) :*: S1 ('MetaSel ('Just "groupingNumber") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Token))) :*: (S1 ('MetaSel ('Just "groupingMemberOf") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Token)) :*: (S1 ('MetaSel ('Just "groupingId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ID)) :*: S1 ('MetaSel ('Just "groupingFeature") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Feature]))))) | |
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
| |
Instances
mkHammerOnPullOff :: String -> StartStop -> HammerOnPullOff Source #
Smart constructor for HammerOnPullOff
handbell (complex)
The handbell element represents notation for various techniques used in handbell and handchime music.
Constructors
| Handbell | |
Fields
| |
Instances
mkHandbell :: HandbellValue -> Handbell Source #
Smart constructor for Handbell
data HarmonClosed Source #
harmon-closed (complex)
The harmon-closed type represents whether the harmon mute is closed, open, or half-open. The optional location attribute indicates which portion of the symbol is filled in when the element value is half.
Constructors
| HarmonClosed | |
Fields
| |
Instances
mkHarmonClosed :: HarmonClosedValue -> HarmonClosed Source #
Smart constructor for HarmonClosed
data HarmonMute Source #
harmon-mute (complex)
The harmon-mute type represents the symbols used for harmon mutes in brass notation.
Constructors
| HarmonMute | |
Fields
| |
Instances
mkHarmonMute :: HarmonClosed -> HarmonMute Source #
Smart constructor for HarmonMute
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
| |
Instances
mkHarmonic :: Harmonic Source #
Smart constructor for Harmonic
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
| |
Instances
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
| |
Instances
mkHarpPedals :: HarpPedals Source #
Smart constructor for HarpPedals
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
| |
Instances
| Generic HeelToe Source # | |
| Show HeelToe Source # | |
| EmitXml HeelToe Source # | |
| Eq HeelToe Source # | |
| type Rep HeelToe Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep HeelToe = D1 ('MetaData "HeelToe" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "HeelToe" 'PrefixI 'True) (S1 ('MetaSel ('Just "heelToeEmptyPlacement") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 HeelToe) :*: S1 ('MetaSel ('Just "heelToeSubstitution") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo)))) | |
hole (complex)
The hole type represents the symbols used for woodwind and brass fingerings as well as other notations.
Constructors
| Hole | |
Fields
| |
Instances
data HoleClosed Source #
hole-closed (complex)
The hole-closed type represents whether the hole is closed, open, or half-open. The optional location attribute indicates which portion of the hole is filled in when the element value is half.
Constructors
| HoleClosed | |
Fields
| |
Instances
| Generic HoleClosed Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep HoleClosed :: Type -> Type # | |
| Show HoleClosed Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> HoleClosed -> ShowS # show :: HoleClosed -> String # showList :: [HoleClosed] -> ShowS # | |
| EmitXml HoleClosed Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: HoleClosed -> XmlRep Source # | |
| Eq HoleClosed Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep HoleClosed Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep HoleClosed = D1 ('MetaData "HoleClosed" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "HoleClosed" 'PrefixI 'True) (S1 ('MetaSel ('Just "holeClosedHoleClosedValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 HoleClosedValue) :*: S1 ('MetaSel ('Just "holeClosedLocation") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe HoleClosedLocation)))) | |
mkHoleClosed :: HoleClosedValue -> HoleClosed Source #
Smart constructor for HoleClosed
data HorizontalTurn Source #
horizontal-turn (complex)
The horizontal-turn type represents turn elements that are horizontal rather than vertical. These are empty elements with print-style, placement, trill-sound, and slash attributes. If the slash attribute is yes, then a vertical line is used to slash the turn; it is no by default.
Constructors
Instances
mkHorizontalTurn :: HorizontalTurn Source #
Smart constructor for HorizontalTurn
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
| |
Instances
mkIdentification :: Identification Source #
Smart constructor for Identification
image (complex)
The image type is used to include graphical images in a score.
Constructors
| Image | |
Fields
| |
Instances
parseImage :: XParse Image Source #
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
| |
Instances
| Generic Instrument Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep Instrument :: Type -> Type # | |
| Show Instrument Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> Instrument -> ShowS # show :: Instrument -> String # showList :: [Instrument] -> ShowS # | |
| EmitXml Instrument Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: Instrument -> XmlRep Source # | |
| Eq Instrument Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep Instrument Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Instrument = D1 ('MetaData "Instrument" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Instrument" 'PrefixI 'True) (S1 ('MetaSel ('Just "instrumentId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 IDREF))) | |
mkInstrument :: IDREF -> Instrument Source #
Smart constructor for Instrument
data Interchangeable Source #
interchangeable (complex)
The interchangeable type is used to represent the second in a pair of interchangeable dual time signatures, such as the 68 in 34 (6/8). A separate symbol attribute value is available compared to the time element's symbol attribute, which applies to the first of the dual time signatures.
Constructors
| Interchangeable | |
Fields
| |
Instances
mkInterchangeable :: Interchangeable Source #
Smart constructor for Interchangeable
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
| |
Instances
mkInversion :: NonNegativeInteger -> Inversion Source #
Smart constructor for Inversion
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. Key signatures appear at the start of each system unless the print-object attribute has been set to "no".
Constructors
| Key | |
Fields
| |
Instances
data KeyAccidental Source #
key-accidental (complex)
The key-accidental type indicates the accidental to be displayed in a non-traditional key signature, represented in the same manner as the accidental type without the formatting attributes.
Constructors
| KeyAccidental | |
Fields
| |
Instances
mkKeyAccidental :: AccidentalValue -> KeyAccidental Source #
Smart constructor for KeyAccidental
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 the canceling key signature specified by the cancel element in the parent key element. The cancel attribute cannot be set to yes if there is no corresponding cancel element within the parent key element. It is no by default.
Constructors
| KeyOctave | |
Fields
| |
Instances
| Generic KeyOctave Source # | |
| Show KeyOctave Source # | |
| EmitXml KeyOctave Source # | |
| Eq KeyOctave Source # | |
| type Rep KeyOctave Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep KeyOctave = D1 ('MetaData "KeyOctave" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "KeyOctave" 'PrefixI 'True) (S1 ('MetaSel ('Just "keyOctaveOctave") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Octave) :*: (S1 ('MetaSel ('Just "keyOctaveNumber") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PositiveInteger) :*: S1 ('MetaSel ('Just "keyOctaveCancel") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo))))) | |
mkKeyOctave :: Octave -> PositiveInteger -> KeyOctave Source #
Smart constructor for KeyOctave
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 For the major-minor kind, only the minor symbol is used when use-symbols is yes. The major symbol is set using the symbol attribute in the degree-value element. The corresponding degree-alter value will usually be 0 in this case. The text attribute describes how the kind should be spelled in a score. If use-symbols is yes, the value of the text attribute follows the symbol. 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
| |
Instances
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
| |
Instances
| Generic Level Source # | |
| Show Level Source # | |
| EmitXml Level Source # | |
| Eq Level Source # | |
| type Rep Level Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Level = D1 ('MetaData "Level" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Level" 'PrefixI 'True) ((S1 ('MetaSel ('Just "levelString") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Just "levelReference") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo))) :*: (S1 ('MetaSel ('Just "levelParentheses") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo)) :*: (S1 ('MetaSel ('Just "levelBracket") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo)) :*: S1 ('MetaSel ('Just "levelSize") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe SymbolSize)))))) | |
parseLevel :: XParse Level 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
| |
Instances
| Generic LineWidth Source # | |
| Show LineWidth Source # | |
| EmitXml LineWidth Source # | |
| Eq LineWidth Source # | |
| type Rep LineWidth Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep LineWidth = D1 ('MetaData "LineWidth" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "LineWidth" 'PrefixI 'True) (S1 ('MetaSel ('Just "lineWidthTenths") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Tenths) :*: S1 ('MetaSel ('Just "cmplineWidthType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 LineWidthType))) | |
mkLineWidth :: Tenths -> LineWidthType -> LineWidth Source #
Smart constructor for LineWidth
link (complex)
The link type serves as an outgoing simple XLink. It is also used to connect a MusicXML score with a MusicXML opus. If a relative link is used within a document that is part of a compressed MusicXML file, the link is relative to the root folder of the zip file.
Constructors
| Link | |
Fields
| |
Instances
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 XSD is more strict than the 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. The print-object attribute can override a note's print-lyric attribute in cases where only some lyrics on a note are printed, as when lyrics for later verses are printed in a block of text rather than with each note. The time-only attribute precisely specifies which lyrics are to be sung which time through a repeated section.
Constructors
| Lyric | |
Fields
| |
Instances
parseLyric :: XParse Lyric Source #
lyric-font (complex)
The lyric-font type specifies the default font for a particular name and number of lyric.
Constructors
| LyricFont | |
Fields
| |
Instances
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
| |
Instances
mkLyricLanguage :: Lang -> LyricLanguage Source #
Smart constructor for LyricLanguage
measure (complex)
Constructors
| Measure | |
Fields
| |
Instances
data CmpMeasure Source #
measure (complex)
Constructors
| CmpMeasure | |
Fields
| |
Instances
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
| |
Instances
| Generic MeasureLayout Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep MeasureLayout :: Type -> Type # | |
| Show MeasureLayout Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> MeasureLayout -> ShowS # show :: MeasureLayout -> String # showList :: [MeasureLayout] -> ShowS # | |
| EmitXml MeasureLayout Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: MeasureLayout -> XmlRep Source # | |
| Eq MeasureLayout Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods (==) :: MeasureLayout -> MeasureLayout -> Bool # (/=) :: MeasureLayout -> MeasureLayout -> Bool # | |
| type Rep MeasureLayout Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep MeasureLayout = D1 ('MetaData "MeasureLayout" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "MeasureLayout" 'PrefixI 'True) (S1 ('MetaSel ('Just "measureLayoutMeasureDistance") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Tenths)))) | |
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
| |
Instances
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
| |
Instances
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
| |
Instances
mkMeasureStyle :: ChxMeasureStyle -> MeasureStyle Source #
Smart constructor for MeasureStyle
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 metric modulations and other metric relationships, such as swing tempo marks where two eighths are equated to a quarter note / eighth note triplet. Tied notes can be represented in both types of metronome marks by using the beat-unit-tied and metronome-tied elements. The parentheses attribute indicates whether or not to put the metronome mark in parentheses; its value is no if not specified.
Constructors
| Metronome | |
Fields
| |
Instances
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
| |
Instances
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
| |
Instances
mkMetronomeNote :: NoteTypeValue -> MetronomeNote Source #
Smart constructor for MetronomeNote
data MetronomeTied Source #
metronome-tied (complex)
The metronome-tied indicates the presence of a tie within a metric relationship mark. As with the tied element, both the start and stop of the tie should be specified, in this case within separate metronome-note elements.
Constructors
| MetronomeTied | |
Fields
| |
Instances
| Generic MetronomeTied Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep MetronomeTied :: Type -> Type # | |
| Show MetronomeTied Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> MetronomeTied -> ShowS # show :: MetronomeTied -> String # showList :: [MetronomeTied] -> ShowS # | |
| EmitXml MetronomeTied Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: MetronomeTied -> XmlRep Source # | |
| Eq MetronomeTied Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods (==) :: MetronomeTied -> MetronomeTied -> Bool # (/=) :: MetronomeTied -> MetronomeTied -> Bool # | |
| type Rep MetronomeTied Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep MetronomeTied = D1 ('MetaData "MetronomeTied" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "MetronomeTied" 'PrefixI 'True) (S1 ('MetaSel ('Just "metronomeTiedType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 StartStop))) | |
mkMetronomeTied :: StartStop -> MetronomeTied Source #
Smart constructor for MetronomeTied
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
| |
Instances
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. Unlike the DeviceName meta event, there can be multiple midi-device elements per MusicXML part starting in MusicXML 3.0. The optional id attribute refers to the score-instrument assigned to this device. If missing, the device assignment affects all score-instrument elements in the score-part.
Constructors
| MidiDevice | |
Fields
| |
Instances
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
| |
Instances
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
| |
Instances
| Generic Miscellaneous Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep Miscellaneous :: Type -> Type # | |
| Show Miscellaneous Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> Miscellaneous -> ShowS # show :: Miscellaneous -> String # showList :: [Miscellaneous] -> ShowS # | |
| EmitXml Miscellaneous Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: Miscellaneous -> XmlRep Source # | |
| Eq Miscellaneous Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods (==) :: Miscellaneous -> Miscellaneous -> Bool # (/=) :: Miscellaneous -> Miscellaneous -> Bool # | |
| type Rep Miscellaneous Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Miscellaneous = D1 ('MetaData "Miscellaneous" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Miscellaneous" 'PrefixI 'True) (S1 ('MetaSel ('Just "miscellaneousMiscellaneousField") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [MiscellaneousField]))) | |
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
| |
Instances
mkMiscellaneousField :: String -> Token -> MiscellaneousField Source #
Smart constructor for MiscellaneousField
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. The approach and departure attributes are used for compound ornaments, indicating how the beginning and ending of the ornament look relative to the main part of the mordent.
Constructors
| Mordent | |
Fields
| |
Instances
| Generic Mordent Source # | |
| Show Mordent Source # | |
| EmitXml Mordent Source # | |
| Eq Mordent Source # | |
| type Rep Mordent Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Mordent = D1 ('MetaData "Mordent" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Mordent" 'PrefixI 'True) ((S1 ('MetaSel ('Just "mordentEmptyTrillSound") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Mordent) :*: S1 ('MetaSel ('Just "mordentLong") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo))) :*: (S1 ('MetaSel ('Just "mordentApproach") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe AboveBelow)) :*: S1 ('MetaSel ('Just "mordentDeparture") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe AboveBelow))))) | |
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.
Constructors
| MultipleRest | |
Fields
| |
Instances
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
| |
Instances
| Generic NameDisplay Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep NameDisplay :: Type -> Type # | |
| Show NameDisplay Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> NameDisplay -> ShowS # show :: NameDisplay -> String # showList :: [NameDisplay] -> ShowS # | |
| EmitXml NameDisplay Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: NameDisplay -> XmlRep Source # | |
| Eq NameDisplay Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep NameDisplay Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep NameDisplay = D1 ('MetaData "NameDisplay" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "NameDisplay" 'PrefixI 'True) (S1 ('MetaSel ('Just "nameDisplayPrintObject") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo)) :*: S1 ('MetaSel ('Just "nameDisplayNameDisplay") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ChxNameDisplay]))) | |
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
| |
Instances
mkNonArpeggiate :: TopBottom -> NonArpeggiate Source #
Smart constructor for NonArpeggiate
notations (complex)
Notations refer to musical notations, not XML notations. Multiple notations are allowed in order to represent multiple editorial levels. The print-object attribute, added in Version 3.0, allows notations to represent details of performance technique, such as fingerings, without having them appear in the score.
Constructors
| Notations | |
Fields
| |
Instances
| Generic Notations Source # | |
| Show Notations Source # | |
| EmitXml Notations Source # | |
| Eq Notations Source # | |
| type Rep Notations Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Notations = D1 ('MetaData "Notations" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Notations" 'PrefixI 'True) ((S1 ('MetaSel ('Just "notationsPrintObject") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo)) :*: S1 ('MetaSel ('Just "notationsId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ID))) :*: (S1 ('MetaSel ('Just "notationsEditorial") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Editorial) :*: S1 ('MetaSel ('Just "notationsNotations") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ChxNotations])))) | |
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 print-leger attribute is used to indicate whether leger lines are printed. Notes without leger lines are used to indicate indeterminate high and low notes. By default, it is set to yes. If print-object is set to no, print-leger is interpreted to also be set to no if not present. This attribute is ignored for rests. 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 starting 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. The attack and release attributes are independent of each other. The attack attribute only changes the starting time of a note, and the release attribute only changes the stopping time of a note. If a note is played only particular times through a repeat, the time-only attribute shows which times 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
Instances
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
| |
Instances
| Generic NoteSize Source # | |
| Show NoteSize Source # | |
| EmitXml NoteSize Source # | |
| Eq NoteSize Source # | |
| type Rep NoteSize Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep NoteSize = D1 ('MetaData "NoteSize" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "NoteSize" 'PrefixI 'True) (S1 ('MetaSel ('Just "noteSizeNonNegativeDecimal") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NonNegativeDecimal) :*: S1 ('MetaSel ('Just "noteSizeType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NoteSizeType))) | |
mkNoteSize :: NonNegativeDecimal -> NoteSizeType -> NoteSize Source #
Smart constructor for NoteSize
note-type (complex)
The note-type type indicates the graphic note type. Values range from 1024th to maxima. The size attribute indicates full, cue, grace-cue, or large size. The default is full for regular notes, grace-cue for notes that contain both grace and cue elements, and cue for notes that contain either a cue or a grace element, but not both.
Constructors
| NoteType | |
Fields
| |
Instances
| Generic NoteType Source # | |
| Show NoteType Source # | |
| EmitXml NoteType Source # | |
| Eq NoteType Source # | |
| type Rep NoteType Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep NoteType = D1 ('MetaData "NoteType" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "NoteType" 'PrefixI 'True) (S1 ('MetaSel ('Just "noteTypeNoteTypeValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NoteTypeValue) :*: S1 ('MetaSel ('Just "noteTypeSize") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe SymbolSize)))) | |
mkNoteType :: NoteTypeValue -> NoteType Source #
Smart constructor for NoteType
notehead (complex)
The notehead type indicates shapes other than the open and closed ovals associated with note durations.
The smufl attribute can be used to specify a particular notehead, allowing application interoperability without requiring every SMuFL glyph to have a MusicXML element equivalent. This attribute can be used either with the "other" value, or to refine a specific notehead value such as "cluster". Noteheads in the SMuFL "Note name noteheads" range (U+E150–U+E1AF) should not use the smufl attribute or the "other" value, but instead use the notehead-text element.
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
| |
Instances
mkNotehead :: NoteheadValue -> Notehead Source #
Smart constructor for Notehead
data NoteheadText Source #
notehead-text (complex)
The notehead-text type represents text that is displayed inside a notehead, as is done in some educational music. It is not needed for the numbers used in tablature or jianpu notation. The presence of a TAB or jianpu clefs is sufficient to indicate that numbers are used. The display-text and accidental-text elements allow display of fully formatted text and accidentals.
Constructors
| NoteheadText | |
Fields | |
Instances
| Generic NoteheadText Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep NoteheadText :: Type -> Type # | |
| Show NoteheadText Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> NoteheadText -> ShowS # show :: NoteheadText -> String # showList :: [NoteheadText] -> ShowS # | |
| EmitXml NoteheadText Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: NoteheadText -> XmlRep Source # | |
| Eq NoteheadText Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep NoteheadText Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep NoteheadText = D1 ('MetaData "NoteheadText" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "NoteheadText" 'PrefixI 'True) (S1 ('MetaSel ('Just "noteheadTextNoteheadText") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ChxNoteheadText]))) | |
mkNoteheadText :: NoteheadText Source #
Smart constructor for NoteheadText
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
| |
Instances
mkOctaveShift :: UpDownStopContinue -> OctaveShift Source #
Smart constructor for OctaveShift
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
| |
Instances
| Generic Offset Source # | |
| Show Offset Source # | |
| EmitXml Offset Source # | |
| Eq Offset Source # | |
| type Rep Offset Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Offset = D1 ('MetaData "Offset" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Offset" 'PrefixI 'True) (S1 ('MetaSel ('Just "offsetDivisions") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Divisions) :*: S1 ('MetaSel ('Just "offsetSound") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo)))) | |
opus (complex)
The opus type represents a link to a MusicXML opus document that composes multiple MusicXML scores into a collection.
Constructors
| Opus | |
Instances
| Generic Opus Source # | |
| Show Opus Source # | |
| EmitXml Opus Source # | |
| Eq Opus Source # | |
| type Rep Opus Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Opus = D1 ('MetaData "Opus" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Opus" 'PrefixI 'True) ((S1 ('MetaSel ('Just "opusHref") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: (S1 ('MetaSel ('Just "opusType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Type)) :*: S1 ('MetaSel ('Just "opusRole") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Token)))) :*: (S1 ('MetaSel ('Just "opusTitle") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Token)) :*: (S1 ('MetaSel ('Just "opusShow") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe SmpShow)) :*: S1 ('MetaSel ('Just "opusActuate") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Actuate)))))) | |
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
| |
Instances
| Generic Ornaments Source # | |
| Show Ornaments Source # | |
| EmitXml Ornaments Source # | |
| Eq Ornaments Source # | |
| type Rep Ornaments Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Ornaments = D1 ('MetaData "Ornaments" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Ornaments" 'PrefixI 'True) (S1 ('MetaSel ('Just "ornamentsId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ID)) :*: S1 ('MetaSel ('Just "ornamentsOrnaments") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [SeqOrnaments]))) | |
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
| |
Instances
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 MusicXML format. The smufl attribute can be used to specify a particular direction symbol, allowing application interoperability without requiring every SMuFL glyph to have a MusicXML element equivalent. Using the other-direction type without the smufl attribute allows for extended representation, though without application interoperability.
Constructors
| OtherDirection | |
Fields
| |
Instances
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. It handles notations where more specific extension elements such as other-dynamics and other-technical are not appropriate. The smufl attribute can be used to specify a particular notation, allowing application interoperability without requiring every SMuFL glyph to have a MusicXML element equivalent. Using the other-notation type without the smufl attribute allows for extended representation, though without application interoperability.
Constructors
| OtherNotation | |
Fields
| |
Instances
mkOtherNotation :: String -> StartStopSingle -> OtherNotation Source #
Smart constructor for OtherNotation
data OtherPlacementText Source #
other-placement-text (complex)
The other-placement-text type represents a text element with print-style, placement, and smufl attribute groups. This type is used by MusicXML notation extension elements to allow specification of specific SMuFL glyphs without needed to add every glyph as a MusicXML element.
Constructors
| OtherPlacementText | |
Fields
| |
Instances
mkOtherPlacementText :: String -> OtherPlacementText Source #
Smart constructor for OtherPlacementText
other-play (complex)
The other-play element represents other types of playback. The required type attribute indicates the type of playback to which the element content applies.
Constructors
| OtherPlay | |
Fields
| |
Instances
| Generic OtherPlay Source # | |
| Show OtherPlay Source # | |
| EmitXml OtherPlay Source # | |
| Eq OtherPlay Source # | |
| type Rep OtherPlay Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep OtherPlay = D1 ('MetaData "OtherPlay" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "OtherPlay" 'PrefixI 'True) (S1 ('MetaSel ('Just "otherPlayString") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Just "otherPlayType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Token))) | |
other-text (complex)
The other-text type represents a text element with a smufl attribute group. This type is used by MusicXML direction extension elements to allow specification of specific SMuFL glyphs without needed to add every glyph as a MusicXML element.
Constructors
| OtherText | |
Fields
| |
Instances
| Generic OtherText Source # | |
| Show OtherText Source # | |
| EmitXml OtherText Source # | |
| Eq OtherText Source # | |
| type Rep OtherText Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep OtherText = D1 ('MetaData "OtherText" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "OtherText" 'PrefixI 'True) (S1 ('MetaSel ('Just "otherTextString") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Just "otherTextSmufl") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe SmuflGlyphName)))) | |
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
| |
Instances
| Generic PageLayout Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep PageLayout :: Type -> Type # | |
| Show PageLayout Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> PageLayout -> ShowS # show :: PageLayout -> String # showList :: [PageLayout] -> ShowS # | |
| EmitXml PageLayout Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: PageLayout -> XmlRep Source # | |
| Eq PageLayout Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep PageLayout Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep PageLayout = D1 ('MetaData "PageLayout" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "PageLayout" 'PrefixI 'True) (S1 ('MetaSel ('Just "pageLayoutPageLayout") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe SeqPageLayout)) :*: S1 ('MetaSel ('Just "pageLayoutPageMargins") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [PageMargins]))) | |
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
| |
Instances
| Generic PageMargins Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep PageMargins :: Type -> Type # | |
| Show PageMargins Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> PageMargins -> ShowS # show :: PageMargins -> String # showList :: [PageMargins] -> ShowS # | |
| EmitXml PageMargins Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: PageMargins -> XmlRep Source # | |
| Eq PageMargins Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep PageMargins Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep PageMargins = D1 ('MetaData "PageMargins" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "PageMargins" 'PrefixI 'True) (S1 ('MetaSel ('Just "pageMarginsType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe MarginType)) :*: S1 ('MetaSel ('Just "pageMarginsAllMargins") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 AllMargins))) | |
mkPageMargins :: AllMargins -> PageMargins Source #
Smart constructor for PageMargins
part (complex)
Constructors
| CmpPart | |
Fields
| |
Instances
| Generic CmpPart Source # | |
| Show CmpPart Source # | |
| EmitXml CmpPart Source # | |
| Eq CmpPart Source # | |
| type Rep CmpPart Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep CmpPart = D1 ('MetaData "CmpPart" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "CmpPart" 'PrefixI 'True) (S1 ('MetaSel ('Just "partId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 IDREF) :*: S1 ('MetaSel ('Just "partMeasure") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Measure]))) | |
part (complex)
Constructors
| Part | |
Fields
| |
Instances
| Generic Part Source # | |
| Show Part Source # | |
| EmitXml Part Source # | |
| Eq Part Source # | |
| type Rep Part Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Part = D1 ('MetaData "Part" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Part" 'PrefixI 'True) (S1 ('MetaSel ('Just "cmppartId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 IDREF) :*: S1 ('MetaSel ('Just "partMusicData") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 MusicData))) | |
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
| |
Instances
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 | |
Instances
| Generic PartList Source # | |
| Show PartList Source # | |
| EmitXml PartList Source # | |
| Eq PartList Source # | |
| type Rep PartList Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep PartList = D1 ('MetaData "PartList" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "PartList" 'PrefixI 'True) (S1 ('MetaSel ('Just "partListPartGroup") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [GrpPartGroup]) :*: (S1 ('MetaSel ('Just "partListScorePart") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ScorePart) :*: S1 ('MetaSel ('Just "partListPartList") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ChxPartList])))) | |
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
| |
Instances
data PartSymbol Source #
part-symbol (complex)
The part-symbol type indicates how a symbol for a multi-staff part is indicated in the score; brace is the default value. 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
| |
Instances
mkPartSymbol :: GroupSymbolValue -> PartSymbol Source #
Smart constructor for PartSymbol
pedal (complex)
The pedal type represents piano pedal marks. In MusicXML 3.1 this includes sostenuto as well as damper pedal marks. The line attribute is yes if pedal lines are used. The sign attribute is yes if Ped, Sost, and * signs are used. For MusicXML 2.0 compatibility, the sign attribute is yes by default if the line attribute is no, and is no by default if the line attribute is yes. If the sign attribute is set to yes and the type is start or sostenuto, the abbreviated attribute is yes if the short P and S signs are used, and no if the full Ped and Sost signs are used. It is no by default. Otherwise the abbreviated attribute is ignored.
The change and continue types are used when the line attribute is yes. The change type indicates a pedal lift and retake indicated with an inverted V marking. The continue type allows more precise formatting across system breaks and for more complex pedaling lines. The alignment attributes are ignored if the line attribute is yes.
Constructors
| Pedal | |
Fields
| |
Instances
parsePedal :: XParse Pedal Source #
data PedalTuning Source #
pedal-tuning (complex)
The pedal-tuning type specifies the tuning of a single harp pedal.
Constructors
| PedalTuning | |
Fields
| |
Instances
| Generic PedalTuning Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep PedalTuning :: Type -> Type # | |
| Show PedalTuning Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> PedalTuning -> ShowS # show :: PedalTuning -> String # showList :: [PedalTuning] -> ShowS # | |
| EmitXml PedalTuning Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: PedalTuning -> XmlRep Source # | |
| Eq PedalTuning Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep PedalTuning Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep PedalTuning = D1 ('MetaData "PedalTuning" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "PedalTuning" 'PrefixI 'True) (S1 ('MetaSel ('Just "pedalTuningPedalStep") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Step) :*: S1 ('MetaSel ('Just "pedalTuningPedalAlter") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Semitones))) | |
mkPedalTuning :: Step -> Semitones -> PedalTuning Source #
Smart constructor for PedalTuning
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
| |
Instances
| Generic PerMinute Source # | |
| Show PerMinute Source # | |
| EmitXml PerMinute Source # | |
| Eq PerMinute Source # | |
| type Rep PerMinute Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep PerMinute = D1 ('MetaData "PerMinute" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "PerMinute" 'PrefixI 'True) ((S1 ('MetaSel ('Just "perMinuteString") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Just "perMinuteFontFamily") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe CommaSeparatedText))) :*: (S1 ('MetaSel ('Just "perMinuteFontStyle") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe FontStyle)) :*: (S1 ('MetaSel ('Just "perMinuteFontSize") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe FontSize)) :*: S1 ('MetaSel ('Just "perMinuteFontWeight") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe FontWeight)))))) | |
data Percussion Source #
percussion (complex)
The percussion element is used to define percussion pictogram symbols. Definitions for these symbols can be found in Kurt Stone's "Music Notation in the Twentieth Century" on pages 206-212 and 223. Some values are added to these based on how usage has evolved in the 30 years since Stone's book was published.
Constructors
| Percussion | |
Fields
| |
Instances
mkPercussion :: ChxPercussion -> Percussion Source #
Smart constructor for Percussion
pitch (complex)
Pitch is represented as a combination of the step of the diatonic scale, the chromatic alteration, and the octave.
Constructors
| Pitch | |
Fields
| |
Instances
| Generic Pitch Source # | |
| Show Pitch Source # | |
| EmitXml Pitch Source # | |
| Eq Pitch Source # | |
| type Rep Pitch Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Pitch = D1 ('MetaData "Pitch" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Pitch" 'PrefixI 'True) (S1 ('MetaSel ('Just "pitchStep") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Step) :*: (S1 ('MetaSel ('Just "pitchAlter") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Semitones)) :*: S1 ('MetaSel ('Just "pitchOctave") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Octave)))) | |
parsePitch :: XParse Pitch Source #
pitched (complex)
The pitched-value type represents pictograms for pitched percussion instruments. The smufl attribute is used to distinguish different SMuFL glyphs for a particular pictogram within the tuned mallet percussion pictograms range.
Constructors
| Pitched | |
Fields
| |
Instances
| Generic Pitched Source # | |
| Show Pitched Source # | |
| EmitXml Pitched Source # | |
| Eq Pitched Source # | |
| type Rep Pitched Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Pitched = D1 ('MetaData "Pitched" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Pitched" 'PrefixI 'True) (S1 ('MetaSel ('Just "pitchedPitchedValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PitchedValue) :*: S1 ('MetaSel ('Just "pitchedSmufl") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe SmuflPictogramGlyphName)))) | |
data PlacementText Source #
placement-text (complex)
The placement-text type represents a text element with print-style and placement attribute groups.
Constructors
| PlacementText | |
Fields
| |
Instances
mkPlacementText :: String -> PlacementText Source #
Smart constructor for PlacementText
play (complex)
The play type, new in Version 3.0, specifies playback techniques to be used in conjunction with the instrument-sound element. When used as part of a sound element, it applies to all notes going forward in score order. In multi-instrument parts, the affected instrument should be specified using the id attribute. When used as part of a note element, it applies to the current note only.
Instances
| Generic Play Source # | |
| Show Play Source # | |
| EmitXml Play Source # | |
| Eq Play Source # | |
| type Rep Play Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Play = D1 ('MetaData "Play" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Play" 'PrefixI 'True) (S1 ('MetaSel ('Just "playId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe IDREF)) :*: S1 ('MetaSel ('Just "playPlay") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ChxPlay]))) | |
data PrincipalVoice Source #
principal-voice (complex)
The principal-voice element represents principal and secondary voices in a score, either for analysis or for square bracket symbols that appear in a score. The symbol attribute indicates the type of symbol used at the start of the principal-voice. The content of the principal-voice element is used for analysis and may be any text value. When used for analysis separate from any printed score markings, the symbol attribute should be set to "none".
Constructors
| PrincipalVoice | |
Fields
| |
Instances
mkPrincipalVoice :: String -> StartStop -> PrincipalVoiceSymbol -> PrincipalVoice Source #
Smart constructor for PrincipalVoice
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
Fields
| |
Instances
parsePrint :: XParse Print 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
| |
Instances
| Generic Repeat Source # | |
| Show Repeat Source # | |
| EmitXml Repeat Source # | |
| Eq Repeat Source # | |
| type Rep Repeat Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Repeat = D1 ('MetaData "Repeat" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Repeat" 'PrefixI 'True) (S1 ('MetaSel ('Just "repeatDirection") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 BackwardForward) :*: (S1 ('MetaSel ('Just "repeatTimes") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe NonNegativeInteger)) :*: S1 ('MetaSel ('Just "repeatWinged") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Winged))))) | |
rest (complex)
The rest element indicates notated rests or silences. Rest elements are usually empty, but placement on the staff can be specified using display-step and display-octave elements. If the measure attribute is set to yes, this indicates this is a complete measure rest.
Constructors
| Rest | |
Fields
| |
Instances
| Generic Rest Source # | |
| Show Rest Source # | |
| EmitXml Rest Source # | |
| Eq Rest Source # | |
| type Rep Rest Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Rest = D1 ('MetaData "Rest" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Rest" 'PrefixI 'True) (S1 ('MetaSel ('Just "restMeasure") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo)) :*: S1 ('MetaSel ('Just "restDisplayStepOctave") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe DisplayStepOctave)))) | |
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
| |
Instances
| Generic Root Source # | |
| Show Root Source # | |
| EmitXml Root Source # | |
| Eq Root Source # | |
| type Rep Root Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Root = D1 ('MetaData "Root" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Root" 'PrefixI 'True) (S1 ('MetaSel ('Just "rootRootStep") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 RootStep) :*: S1 ('MetaSel ('Just "rootRootAlter") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe RootAlter)))) | |
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
| |
Instances
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 in a score if not using the element contents.
Constructors
| RootStep | |
Fields
| |
Instances
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
| |
Instances
| Generic Scaling Source # | |
| Show Scaling Source # | |
| EmitXml Scaling Source # | |
| Eq Scaling Source # | |
| type Rep Scaling Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Scaling = D1 ('MetaData "Scaling" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Scaling" 'PrefixI 'True) (S1 ('MetaSel ('Just "scalingMillimeters") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Millimeters) :*: S1 ('MetaSel ('Just "scalingTenths") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Tenths))) | |
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
| |
Instances
| Generic Scordatura Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep Scordatura :: Type -> Type # | |
| Show Scordatura Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> Scordatura -> ShowS # show :: Scordatura -> String # showList :: [Scordatura] -> ShowS # | |
| EmitXml Scordatura Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: Scordatura -> XmlRep Source # | |
| Eq Scordatura Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep Scordatura Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Scordatura = D1 ('MetaData "Scordatura" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Scordatura" 'PrefixI 'True) (S1 ('MetaSel ('Just "scordaturaId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ID)) :*: S1 ('MetaSel ('Just "scordaturaAccord") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Accord]))) | |
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
| |
Instances
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 or specific MIDI instruments. Initial midi-instrument assignments may be made here as well.
Constructors
| CmpScorePart | |
Fields
| |
Instances
mkCmpScorePart :: ID -> PartName -> CmpScorePart Source #
Smart constructor for CmpScorePart
data ScorePartwise Source #
score-partwise (complex)
Constructors
| ScorePartwise | |
Fields
| |
Instances
mkScorePartwise :: ScoreHeader -> ScorePartwise Source #
Smart constructor for ScorePartwise
data ScoreTimewise Source #
score-timewise (complex)
Constructors
| ScoreTimewise | |
Fields
| |
Instances
mkScoreTimewise :: ScoreHeader -> ScoreTimewise Source #
Smart constructor for ScoreTimewise
segno (complex)
The segno type is the visual indicator of a segno sign. The exact glyph can be specified with the smufl attribute. A sound element is also needed to guide playback applications reliably.
Constructors
| Segno | |
Fields
| |
Instances
parseSegno :: XParse Segno 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
| |
Instances
| Generic CmpSlash Source # | |
| Show CmpSlash Source # | |
| EmitXml CmpSlash Source # | |
| Eq CmpSlash Source # | |
| type Rep CmpSlash Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep CmpSlash = D1 ('MetaData "CmpSlash" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "CmpSlash" 'PrefixI 'True) ((S1 ('MetaSel ('Just "slashType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 StartStop) :*: S1 ('MetaSel ('Just "slashUseDots") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo))) :*: (S1 ('MetaSel ('Just "slashUseStems") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo)) :*: S1 ('MetaSel ('Just "slashSlash") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Slash))))) | |
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
| |
Instances
parseSlide :: XParse Slide 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
| |
Instances
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 particular times through a repeat, the time-only attribute indicates which times 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 devices, MIDI instruments, and playback techniques are changed using the midi-device, midi-instrument, and play elements. When there are multiple instances of these elements, they should be grouped together by instrument using the id attribute values. 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
| |
Instances
parseSound :: XParse Sound Source #
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
| |
Instances
mkStaffDetails :: StaffDetails Source #
Smart constructor for StaffDetails
data StaffDivide Source #
staff-divide (complex)
The staff-divide element represents the staff division arrow symbols found at SMuFL code points U+E00B, U+E00C, and U+E00D.
Constructors
| StaffDivide | |
Fields
| |
Instances
mkStaffDivide :: StaffDivideSymbol -> StaffDivide Source #
Smart constructor for StaffDivide
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
| |
Instances
| Generic StaffLayout Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep StaffLayout :: Type -> Type # | |
| Show StaffLayout Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> StaffLayout -> ShowS # show :: StaffLayout -> String # showList :: [StaffLayout] -> ShowS # | |
| EmitXml StaffLayout Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: StaffLayout -> XmlRep Source # | |
| Eq StaffLayout Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep StaffLayout Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep StaffLayout = D1 ('MetaData "StaffLayout" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "StaffLayout" 'PrefixI 'True) (S1 ('MetaSel ('Just "staffLayoutNumber") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe StaffNumber)) :*: S1 ('MetaSel ('Just "staffLayoutStaffDistance") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Tenths)))) | |
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
| |
Instances
| Generic StaffTuning Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep StaffTuning :: Type -> Type # | |
| Show StaffTuning Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> StaffTuning -> ShowS # show :: StaffTuning -> String # showList :: [StaffTuning] -> ShowS # | |
| EmitXml StaffTuning Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: StaffTuning -> XmlRep Source # | |
| Eq StaffTuning Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep StaffTuning Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep StaffTuning = D1 ('MetaData "StaffTuning" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "StaffTuning" 'PrefixI 'True) (S1 ('MetaSel ('Just "staffTuningLine") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe StaffLine)) :*: S1 ('MetaSel ('Just "staffTuningTuning") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Tuning))) | |
mkStaffTuning :: Tuning -> StaffTuning Source #
Smart constructor for StaffTuning
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. A stem element associated with a rest refers to a stemlet.
Constructors
| Stem | |
Fields
| |
Instances
stick (complex)
The stick type represents pictograms where the material of the stick, mallet, or beater is included.The parentheses and dashed-circle attributes indicate the presence of these marks around the round beater part of a pictogram. Values for these attributes are "no" if not present.
Constructors
| Stick | |
Fields
| |
Instances
| Generic Stick Source # | |
| Show Stick Source # | |
| EmitXml Stick Source # | |
| Eq Stick Source # | |
| type Rep Stick Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Stick = D1 ('MetaData "Stick" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Stick" 'PrefixI 'True) ((S1 ('MetaSel ('Just "stickTip") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe TipDirection)) :*: S1 ('MetaSel ('Just "stickParentheses") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo))) :*: (S1 ('MetaSel ('Just "stickDashedCircle") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe YesNo)) :*: (S1 ('MetaSel ('Just "stickStickType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 StickType) :*: S1 ('MetaSel ('Just "stickStickMaterial") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 StickMaterial))))) | |
parseStick :: XParse Stick 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 pitched full-length string.
Constructors
| CmpString | |
Fields
| |
Instances
mkCmpString :: StringNumber -> CmpString Source #
Smart constructor for CmpString
data StringMute Source #
string-mute (complex)
The string-mute type represents string mute on and mute off symbols.
Constructors
| StringMute | |
Fields
| |
Instances
mkStringMute :: OnOff -> StringMute Source #
Smart constructor for StringMute
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
| |
Instances
| Generic StrongAccent Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep StrongAccent :: Type -> Type # | |
| Show StrongAccent Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> StrongAccent -> ShowS # show :: StrongAccent -> String # showList :: [StrongAccent] -> ShowS # | |
| EmitXml StrongAccent Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: StrongAccent -> XmlRep Source # | |
| Eq StrongAccent Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep StrongAccent Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep StrongAccent = D1 ('MetaData "StrongAccent" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "StrongAccent" 'PrefixI 'True) (S1 ('MetaSel ('Just "strongAccentEmptyPlacement") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 StrongAccent) :*: S1 ('MetaSel ('Just "strongAccentType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe UpDown)))) | |
mkStrongAccent :: StrongAccent -> StrongAccent Source #
Smart constructor for StrongAccent
style-text (complex)
The style-text type represents a text element with a print-style attribute group.
Constructors
| StyleText | |
Fields
| |
Instances
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
| |
Instances
| Generic Supports Source # | |
| Show Supports Source # | |
| EmitXml Supports Source # | |
| Eq Supports Source # | |
| type Rep Supports Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Supports = D1 ('MetaData "Supports" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Supports" 'PrefixI 'True) ((S1 ('MetaSel ('Just "supportsType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 YesNo) :*: S1 ('MetaSel ('Just "supportsElement") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NMTOKEN)) :*: (S1 ('MetaSel ('Just "supportsAttribute") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe NMTOKEN)) :*: S1 ('MetaSel ('Just "supportsValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Token))))) | |
data SystemDividers Source #
system-dividers (complex)
The system-dividers element indicates the presence or absence of system dividers (also known as system separation marks) between systems displayed on the same page. Dividers on the left and right side of the page are controlled by the left-divider and right-divider elements respectively. The default vertical position is half the system-distance value from the top of the system that is below the divider. The default horizontal position is the left and right system margin, respectively.
When used in the print element, the system-dividers element affects the dividers that would appear between the current system and the previous system.
Constructors
| SystemDividers | |
Fields
| |
Instances
mkSystemDividers :: EmptyPrintObjectStyleAlign -> EmptyPrintObjectStyleAlign -> SystemDividers Source #
Smart constructor for SystemDividers
data SystemLayout Source #
system-layout (complex)
A system is a group of staves that are read and played simultaneously. 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
| |
Instances
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 | |
Instances
| Generic SystemMargins Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep SystemMargins :: Type -> Type # | |
| Show SystemMargins Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> SystemMargins -> ShowS # show :: SystemMargins -> String # showList :: [SystemMargins] -> ShowS # | |
| EmitXml SystemMargins Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: SystemMargins -> XmlRep Source # | |
| Eq SystemMargins Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods (==) :: SystemMargins -> SystemMargins -> Bool # (/=) :: SystemMargins -> SystemMargins -> Bool # | |
| type Rep SystemMargins Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep SystemMargins = D1 ('MetaData "SystemMargins" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "SystemMargins" 'PrefixI 'True) (S1 ('MetaSel ('Just "systemMarginsLeftRightMargins") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 LeftRightMargins))) | |
mkSystemMargins :: LeftRightMargins -> SystemMargins Source #
Smart constructor for SystemMargins
tap (complex)
The tap type indicates a tap on the fretboard. The text content allows specification of the notation; + and T are common choices. If the element is empty, the hand attribute is used to specify the symbol to use. The hand attribute is ignored if the tap glyph is already specified by the text content. If neither text content nor the hand attribute are present, the display is application-specific.
Constructors
| Tap | |
Fields
| |
Instances
technical (complex)
Technical indications give performance information for individual instruments.
Constructors
| Technical | |
Fields
| |
Instances
| Generic Technical Source # | |
| Show Technical Source # | |
| EmitXml Technical Source # | |
| Eq Technical Source # | |
| type Rep Technical Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Technical = D1 ('MetaData "Technical" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Technical" 'PrefixI 'True) (S1 ('MetaSel ('Just "technicalId") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ID)) :*: S1 ('MetaSel ('Just "technicalTechnical") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ChxTechnical]))) | |
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
| |
Instances
mkTextElementData :: String -> TextElementData Source #
Smart constructor for TextElementData
tie (complex)
The tie element indicates that a tie begins or ends with this note. If the tie element applies only particular times through a repeat, the time-only attribute indicates which times to apply it. The tie element indicates sound; the tied element indicates notation.
Constructors
| Tie | |
Fields
| |
Instances
| Generic Tie Source # | |
| Show Tie Source # | |
| EmitXml Tie Source # | |
| Eq Tie Source # | |
| type Rep Tie Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Tie = D1 ('MetaData "Tie" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Tie" 'PrefixI 'True) (S1 ('MetaSel ('Just "tieType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 StartStop) :*: S1 ('MetaSel ('Just "tieTimeOnly") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe TimeOnly)))) | |
tied (complex)
The tied element represents the notated tie. The tie element represents the tie sound.
The number attribute is rarely needed to disambiguate ties, since note pitches will usually suffice. The attribute is implied rather than defaulting to 1 as with most elements. It is available for use in more complex tied notation situations.
Ties that join two notes of the same pitch together should be represented with a tied element on the first note with type="start" and a tied element on the second note with type="stop". This can also be done if the two notes being tied are enharmonically equivalent, but have different step values. It is not recommended to use tied elements to join two notes with enharmonically inequivalent pitches.
Ties that indicate that an instrument should be undamped are specified with a single tied element with type="let-ring".
Ties that are visually attached to only one note, other than undamped ties, should be specified with two tied elements on the same note, first type="start" then type="stop". This can be used to represent ties into or out of repeated sections or codas.
Constructors
| Tied | |
Fields
| |
Instances
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
| |
Instances
data TimeModification Source #
time-modification (complex)
Time modification indicates tuplets, double-note tremolos, and other durational changes. A time-modification element shows how the cumulative, sounding effect of tuplets and double-note tremolos compare to the written note type represented by the type and dot elements. Nested tuplets and other notations that use more detailed information need both the time-modification and tuplet elements to be represented accurately.
Constructors
| TimeModification | |
Fields
| |
Instances
mkTimeModification :: NonNegativeInteger -> NonNegativeInteger -> TimeModification Source #
Smart constructor for TimeModification
transpose (complex)
The transpose type represents what must be added to a written pitch to get a correct sounding pitch. The optional number attribute refers to staff numbers, from top to bottom on the system. If absent, the transposition applies to all staves in the part. Per-staff transposition is most often used in parts that represent multiple instruments.
Constructors
| Transpose | |
Fields
| |
Instances
tremolo (complex)
The tremolo ornament can be used to indicate single-note, double-note, or unmeasured tremolos. Single-note tremolos use the single type, double-note tremolos use the start and stop types, and unmeasured tremolos use the unmeasured type. 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 8. Note that the number of attached beams is not included in this value, but is represented separately using the beam element. The value should be 0 for unmeasured tremolos.
When using double-note tremolos, the duration of each note in the tremolo should correspond to half of the notated type value. A time-modification element should also be added with an actual-notes value of 2 and a normal-notes value of 1. If used within a tuplet, this 2/1 ratio should be multiplied by the existing tuplet ratio.
The smufl attribute specifies the glyph to use from the SMuFL tremolos range for an unmeasured tremolo. It is ignored for other tremolo types. The SMuFL buzzRoll glyph is used by default if the attribute is missing.
Using repeater beams for indicating tremolos is deprecated as of MusicXML 3.0.
Constructors
| Tremolo | |
Fields
| |
Instances
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 and double-note tremolos compare to the written note type, the tuplet element describes how this is displayed. The tuplet element also provides more detailed representation information than the time-modification element, and is needed to represent nested tuplets and other complex tuplets accurately.
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
| |
Instances
tuplet-dot (complex)
The tuplet-dot type is used to specify dotted normal tuplet types.
Constructors
| TupletDot | |
Fields
| |
Instances
| Generic TupletDot Source # | |
| Show TupletDot Source # | |
| EmitXml TupletDot Source # | |
| Eq TupletDot Source # | |
| type Rep TupletDot Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep TupletDot = D1 ('MetaData "TupletDot" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "TupletDot" 'PrefixI 'True) ((S1 ('MetaSel ('Just "tupletDotFontFamily") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe CommaSeparatedText)) :*: S1 ('MetaSel ('Just "tupletDotFontStyle") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe FontStyle))) :*: (S1 ('MetaSel ('Just "tupletDotFontSize") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe FontSize)) :*: (S1 ('MetaSel ('Just "tupletDotFontWeight") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe FontWeight)) :*: S1 ('MetaSel ('Just "tupletDotColor") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Color)))))) | |
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
| |
Instances
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
| |
Instances
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
| |
Instances
mkTupletType :: NoteTypeValue -> TupletType Source #
Smart constructor for TupletType
typed-text (complex)
The typed-text type represents a text element with a type attributes.
Constructors
| TypedText | |
Fields
| |
Instances
| Generic TypedText Source # | |
| Show TypedText Source # | |
| EmitXml TypedText Source # | |
| Eq TypedText Source # | |
| type Rep TypedText Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep TypedText = D1 ('MetaData "TypedText" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "TypedText" 'PrefixI 'True) (S1 ('MetaSel ('Just "typedTextString") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Just "typedTextType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Token)))) | |
unpitched (complex)
The unpitched type represents musical elements that are notated on the staff but lack definite pitch, such as unpitched percussion and speaking voice.
Constructors
| Unpitched | |
Instances
| Generic Unpitched Source # | |
| Show Unpitched Source # | |
| EmitXml Unpitched Source # | |
| Eq Unpitched Source # | |
| type Rep Unpitched Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Unpitched = D1 ('MetaData "Unpitched" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Unpitched" 'PrefixI 'True) (S1 ('MetaSel ('Just "unpitchedDisplayStepOctave") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe DisplayStepOctave)))) | |
mkUnpitched :: Unpitched Source #
Smart constructor for Unpitched
data VirtualInstrument Source #
virtual-instrument (complex)
The virtual-instrument element defines a specific virtual instrument used for an instrument sound.
Constructors
| VirtualInstrument | |
Fields
| |
Instances
mkVirtualInstrument :: VirtualInstrument Source #
Smart constructor for VirtualInstrument
wavy-line (complex)
Wavy lines are one way to indicate trills. When used with a barline element, they should always have type="continue" set.
Constructors
| WavyLine | |
Fields
| |
Instances
mkWavyLine :: StartStopContinue -> WavyLine Source #
Smart constructor for WavyLine
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. The niente attribute is yes if a circle appears at the point of the wedge, indicating a crescendo from nothing or diminuendo to nothing. It is no by default, and used only when the type is crescendo, or the type is stop for a wedge that began with a diminuendo type. The line-type is solid by default.
Constructors
| Wedge | |
Fields
| |
Instances
parseWedge :: XParse Wedge 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
| |
Instances
| Generic Work Source # | |
| Show Work Source # | |
| EmitXml Work Source # | |
| Eq Work Source # | |
| type Rep Work Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Work = D1 ('MetaData "Work" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Work" 'PrefixI 'True) (S1 ('MetaSel ('Just "workWorkNumber") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe String)) :*: (S1 ('MetaSel ('Just "workWorkTitle") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe String)) :*: S1 ('MetaSel ('Just "workOpus") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Opus))))) | |
arrow (choice)
Constructors
| ArrowArrowDirection | |
Fields
| |
| ArrowCircularArrow | |
Fields
| |
Instances
| Generic ChxArrow Source # | |
| Show ChxArrow Source # | |
| EmitXml ChxArrow Source # | |
| Eq ChxArrow Source # | |
| type Rep ChxArrow Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep ChxArrow = D1 ('MetaData "ChxArrow" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "ArrowArrowDirection" 'PrefixI 'True) (S1 ('MetaSel ('Just "arrowArrowDirection") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ArrowDirection) :*: (S1 ('MetaSel ('Just "arrowArrowStyle") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe ArrowStyle)) :*: S1 ('MetaSel ('Just "arrowArrowhead") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Empty)))) :+: C1 ('MetaCons "ArrowCircularArrow" 'PrefixI 'True) (S1 ('MetaSel ('Just "arrowCircularArrow") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CircularArrow))) | |
mkArrowArrowDirection :: ArrowDirection -> ChxArrow Source #
Smart constructor for ArrowArrowDirection
mkArrowCircularArrow :: CircularArrow -> ChxArrow Source #
Smart constructor for ArrowCircularArrow
data ChxArticulations Source #
articulations (choice)
Constructors
Instances
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 :: BreathMark -> ChxArticulations Source #
Smart constructor for ArticulationsBreathMark
mkArticulationsCaesura :: Caesura -> ChxArticulations Source #
Smart constructor for ArticulationsCaesura
mkArticulationsStress :: EmptyPlacement -> ChxArticulations Source #
Smart constructor for ArticulationsStress
mkArticulationsUnstress :: EmptyPlacement -> ChxArticulations Source #
Smart constructor for ArticulationsUnstress
mkArticulationsSoftAccent :: EmptyPlacement -> ChxArticulations Source #
Smart constructor for ArticulationsSoftAccent
mkArticulationsOtherArticulation :: OtherPlacementText -> ChxArticulations Source #
Smart constructor for ArticulationsOtherArticulation
bend (choice)
Constructors
| BendPreBend | |
Fields
| |
| BendRelease | |
Fields
| |
Instances
| Generic ChxBend Source # | |
| Show ChxBend Source # | |
| EmitXml ChxBend Source # | |
| Eq ChxBend Source # | |
| type Rep ChxBend Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep ChxBend = D1 ('MetaData "ChxBend" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "BendPreBend" 'PrefixI 'True) (S1 ('MetaSel ('Just "bendPreBend") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Empty)) :+: C1 ('MetaCons "BendRelease" 'PrefixI 'True) (S1 ('MetaSel ('Just "bendRelease") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Empty))) | |
mkBendPreBend :: Empty -> ChxBend Source #
Smart constructor for BendPreBend
mkBendRelease :: Empty -> ChxBend Source #
Smart constructor for BendRelease
data ChxCredit0 Source #
credit (choice)
Constructors
| CreditCreditWords | |
Fields
| |
| CreditCreditSymbol | |
Fields
| |
Instances
mkCreditCreditWords :: FormattedTextId -> ChxCredit0 Source #
Smart constructor for CreditCreditWords
mkCreditCreditSymbol :: FormattedSymbolId -> ChxCredit0 Source #
Smart constructor for CreditCreditSymbol
data ChxCredit1 Source #
credit (choice)
Constructors
| ChxCreditCreditWords | |
Fields
| |
| ChxCreditCreditSymbol | |
Fields
| |
Instances
mkChxCreditCreditWords :: FormattedTextId -> ChxCredit1 Source #
Smart constructor for ChxCreditCreditWords
mkChxCreditCreditSymbol :: FormattedSymbolId -> ChxCredit1 Source #
Smart constructor for ChxCreditCreditSymbol
credit (choice)
Constructors
| CreditCreditImage | |
Fields
| |
| CreditCredit | |
Fields | |
Instances
| Generic ChxCredit Source # | |
| Show ChxCredit Source # | |
| EmitXml ChxCredit Source # | |
| Eq ChxCredit Source # | |
| type Rep ChxCredit Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep ChxCredit = D1 ('MetaData "ChxCredit" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "CreditCreditImage" 'PrefixI 'True) (S1 ('MetaSel ('Just "creditCreditImage") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Image)) :+: C1 ('MetaCons "CreditCredit" 'PrefixI 'True) (S1 ('MetaSel ('Just "chxcreditCredit") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ChxCredit0) :*: S1 ('MetaSel ('Just "creditCredit1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [SeqCredit]))) | |
mkCreditCreditImage :: Image -> ChxCredit Source #
Smart constructor for CreditCreditImage
mkCreditCredit :: ChxCredit0 -> ChxCredit Source #
Smart constructor for CreditCredit
data ChxDirectionType0 Source #
direction-type (choice)
Constructors
| DirectionTypeWords | |
Fields
| |
| DirectionTypeSymbol | |
Fields
| |
Instances
mkDirectionTypeWords :: FormattedTextId -> ChxDirectionType0 Source #
Smart constructor for DirectionTypeWords
mkDirectionTypeSymbol :: FormattedSymbolId -> ChxDirectionType0 Source #
Smart constructor for DirectionTypeSymbol
data ChxDirectionType Source #
direction-type (choice)
Constructors
Instances
mkDirectionTypeRehearsal :: ChxDirectionType Source #
Smart constructor for DirectionTypeRehearsal
mkDirectionTypeSegno :: ChxDirectionType Source #
Smart constructor for DirectionTypeSegno
mkDirectionTypeCoda :: ChxDirectionType Source #
Smart constructor for DirectionTypeCoda
mkDirectionTypeDirectionType :: ChxDirectionType Source #
Smart constructor for DirectionTypeDirectionType
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 :: EmptyPrintStyleAlignId -> ChxDirectionType Source #
Smart constructor for DirectionTypeDamp
mkDirectionTypeDampAll :: EmptyPrintStyleAlignId -> ChxDirectionType Source #
Smart constructor for DirectionTypeDampAll
mkDirectionTypeEyeglasses :: EmptyPrintStyleAlignId -> ChxDirectionType Source #
Smart constructor for DirectionTypeEyeglasses
mkDirectionTypeStringMute :: StringMute -> ChxDirectionType Source #
Smart constructor for DirectionTypeStringMute
mkDirectionTypeScordatura :: Scordatura -> ChxDirectionType Source #
Smart constructor for DirectionTypeScordatura
mkDirectionTypeImage :: Image -> ChxDirectionType Source #
Smart constructor for DirectionTypeImage
mkDirectionTypePrincipalVoice :: PrincipalVoice -> ChxDirectionType Source #
Smart constructor for DirectionTypePrincipalVoice
mkDirectionTypePercussion :: ChxDirectionType Source #
Smart constructor for DirectionTypePercussion
mkDirectionTypeAccordionRegistration :: AccordionRegistration -> ChxDirectionType Source #
Smart constructor for DirectionTypeAccordionRegistration
mkDirectionTypeStaffDivide :: StaffDivide -> ChxDirectionType Source #
Smart constructor for DirectionTypeStaffDivide
mkDirectionTypeOtherDirection :: OtherDirection -> ChxDirectionType Source #
Smart constructor for DirectionTypeOtherDirection
data ChxDynamics Source #
dynamics (choice)
Constructors
Instances
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
mkDynamicsN :: Empty -> ChxDynamics Source #
Smart constructor for DynamicsN
mkDynamicsPf :: Empty -> ChxDynamics Source #
Smart constructor for DynamicsPf
mkDynamicsSfzp :: Empty -> ChxDynamics Source #
Smart constructor for DynamicsSfzp
mkDynamicsOtherDynamics :: OtherText -> ChxDynamics Source #
Smart constructor for DynamicsOtherDynamics
data ChxEncoding Source #
encoding (choice)
Constructors
| EncodingEncodingDate | |
Fields
| |
| EncodingEncoder | |
Fields
| |
| EncodingSoftware | |
Fields
| |
| EncodingEncodingDescription | |
Fields
| |
| EncodingSupports | |
Fields
| |
Instances
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
full-note (choice)
Constructors
| FullNotePitch | |
Fields
| |
| FullNoteUnpitched | |
Fields
| |
| FullNoteRest | |
Fields
| |
Instances
| Generic FullNote Source # | |
| Show FullNote Source # | |
| EmitXml FullNote Source # | |
| Eq FullNote Source # | |
| type Rep FullNote Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep FullNote = D1 ('MetaData "FullNote" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "FullNotePitch" 'PrefixI 'True) (S1 ('MetaSel ('Just "fullNotePitch") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Pitch)) :+: (C1 ('MetaCons "FullNoteUnpitched" 'PrefixI 'True) (S1 ('MetaSel ('Just "fullNoteUnpitched") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Unpitched)) :+: C1 ('MetaCons "FullNoteRest" 'PrefixI 'True) (S1 ('MetaSel ('Just "fullNoteRest") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Rest)))) | |
mkFullNotePitch :: Pitch -> FullNote Source #
Smart constructor for FullNotePitch
mkFullNoteUnpitched :: Unpitched -> FullNote Source #
Smart constructor for FullNoteUnpitched
mkFullNoteRest :: Rest -> FullNote Source #
Smart constructor for FullNoteRest
data ChxHarmonic Source #
harmonic (choice)
Constructors
| HarmonicNatural | |
Fields
| |
| HarmonicArtificial | |
Fields
| |
Instances
| Generic ChxHarmonic Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep ChxHarmonic :: Type -> Type # | |
| Show ChxHarmonic Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> ChxHarmonic -> ShowS # show :: ChxHarmonic -> String # showList :: [ChxHarmonic] -> ShowS # | |
| EmitXml ChxHarmonic Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: ChxHarmonic -> XmlRep Source # | |
| Eq ChxHarmonic Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep ChxHarmonic Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep ChxHarmonic = D1 ('MetaData "ChxHarmonic" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "HarmonicNatural" 'PrefixI 'True) (S1 ('MetaSel ('Just "harmonicNatural") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Empty)) :+: C1 ('MetaCons "HarmonicArtificial" 'PrefixI 'True) (S1 ('MetaSel ('Just "harmonicArtificial") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Empty))) | |
mkHarmonicNatural :: Empty -> ChxHarmonic Source #
Smart constructor for HarmonicNatural
mkHarmonicArtificial :: Empty -> ChxHarmonic Source #
Smart constructor for HarmonicArtificial
data ChxHarmonic1 Source #
harmonic (choice)
Constructors
| HarmonicBasePitch | |
Fields
| |
| HarmonicTouchingPitch | |
Fields
| |
| HarmonicSoundingPitch | |
Fields
| |
Instances
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
| |
| HarmonyChordFunction | |
Fields
| |
Instances
mkHarmonyChordRoot :: Root -> ChxHarmonyChord Source #
Smart constructor for HarmonyChordRoot
mkHarmonyChordFunction :: StyleText -> ChxHarmonyChord Source #
Smart constructor for HarmonyChordFunction
key (choice)
Constructors
| KeyTraditionalKey | |
Fields | |
| KeyNonTraditionalKey | |
Fields | |
Instances
| Generic ChxKey Source # | |
| Show ChxKey Source # | |
| EmitXml ChxKey Source # | |
| Eq ChxKey Source # | |
| type Rep ChxKey Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep ChxKey = D1 ('MetaData "ChxKey" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "KeyTraditionalKey" 'PrefixI 'True) (S1 ('MetaSel ('Just "keyTraditionalKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TraditionalKey)) :+: C1 ('MetaCons "KeyNonTraditionalKey" 'PrefixI 'True) (S1 ('MetaSel ('Just "keyNonTraditionalKey") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [NonTraditionalKey]))) | |
mkKeyTraditionalKey :: TraditionalKey -> ChxKey Source #
Smart constructor for KeyTraditionalKey
mkKeyNonTraditionalKey :: ChxKey Source #
Smart constructor for KeyNonTraditionalKey
lyric (choice)
Constructors
| LyricSyllabic | |
Fields
| |
| LyricExtend | |
Fields
| |
| LyricLaughing | |
Fields
| |
| LyricHumming | |
Fields
| |
Instances
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
| |
| MeasureStyleMeasureRepeat | |
Fields
| |
| MeasureStyleBeatRepeat | |
Fields
| |
| MeasureStyleSlash | |
Fields
| |
Instances
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
| |
| MetronomeBeatUnit | |
Fields
| |
Instances
mkMetronomePerMinute :: PerMinute -> ChxMetronome0 Source #
Smart constructor for MetronomePerMinute
mkMetronomeBeatUnit :: BeatUnit -> ChxMetronome0 Source #
Smart constructor for MetronomeBeatUnit
data ChxMetronome Source #
metronome (choice)
Constructors
| ChxMetronomeBeatUnit | |
Fields
| |
| MetronomeMetronomeArrows | |
Fields
| |
Instances
mkChxMetronomeBeatUnit :: BeatUnit -> ChxMetronome0 -> ChxMetronome Source #
Smart constructor for ChxMetronomeBeatUnit
mkMetronomeMetronomeArrows :: ChxMetronome Source #
Smart constructor for MetronomeMetronomeArrows
data ChxMusicData Source #
music-data (choice)
Constructors
| MusicDataNote | |
Fields
| |
| MusicDataBackup | |
Fields
| |
| MusicDataForward | |
Fields
| |
| MusicDataDirection | |
Fields
| |
| MusicDataAttributes | |
Fields
| |
| MusicDataHarmony | |
Fields
| |
| MusicDataFiguredBass | |
Fields
| |
| MusicDataPrint | |
Fields
| |
| MusicDataSound | |
Fields
| |
| MusicDataBarline | |
Fields
| |
| MusicDataGrouping | |
Fields
| |
| MusicDataLink | |
Fields
| |
| MusicDataBookmark | |
Fields
| |
Instances
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
| |
| NameDisplayAccidentalText | |
Fields
| |
Instances
mkNameDisplayDisplayText :: FormattedText -> ChxNameDisplay Source #
Smart constructor for NameDisplayDisplayText
mkNameDisplayAccidentalText :: AccidentalText -> ChxNameDisplay Source #
Smart constructor for NameDisplayAccidentalText
data ChxNotations Source #
notations (choice)
Constructors
Instances
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
note (choice)
Constructors
| NoteFullNote | |
Fields
| |
| NoteCue | |
Fields
| |
Instances
| Generic ChxNote0 Source # | |
| Show ChxNote0 Source # | |
| EmitXml ChxNote0 Source # | |
| Eq ChxNote0 Source # | |
| type Rep ChxNote0 Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep ChxNote0 = D1 ('MetaData "ChxNote0" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "NoteFullNote" 'PrefixI 'True) (S1 ('MetaSel ('Just "noteFullNote") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 GrpFullNote) :*: S1 ('MetaSel ('Just "noteTie") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Tie])) :+: C1 ('MetaCons "NoteCue" 'PrefixI 'True) (S1 ('MetaSel ('Just "noteCue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Empty) :*: S1 ('MetaSel ('Just "noteFullNote1") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 GrpFullNote))) | |
mkNoteFullNote :: GrpFullNote -> ChxNote0 Source #
Smart constructor for NoteFullNote
note (choice)
Constructors
| NoteGrace | |
Fields
| |
| ChxNoteCue | |
Fields
| |
| ChxNoteFullNote | |
Fields
| |
Instances
mkChxNoteCue :: Empty -> GrpFullNote -> Duration -> ChxNote Source #
Smart constructor for ChxNoteCue
mkChxNoteFullNote :: GrpFullNote -> Duration -> ChxNote Source #
Smart constructor for ChxNoteFullNote
data ChxNoteheadText Source #
notehead-text (choice)
Constructors
| NoteheadTextDisplayText | |
Fields
| |
| NoteheadTextAccidentalText | |
Fields
| |
Instances
mkNoteheadTextDisplayText :: FormattedText -> ChxNoteheadText Source #
Smart constructor for NoteheadTextDisplayText
mkNoteheadTextAccidentalText :: AccidentalText -> ChxNoteheadText Source #
Smart constructor for NoteheadTextAccidentalText
data ChxOrnaments Source #
ornaments (choice)
Constructors
Instances
mkOrnamentsTrillMark :: EmptyTrillSound -> ChxOrnaments Source #
Smart constructor for OrnamentsTrillMark
mkOrnamentsTurn :: HorizontalTurn -> ChxOrnaments Source #
Smart constructor for OrnamentsTurn
mkOrnamentsDelayedTurn :: HorizontalTurn -> ChxOrnaments Source #
Smart constructor for OrnamentsDelayedTurn
mkOrnamentsInvertedTurn :: HorizontalTurn -> ChxOrnaments Source #
Smart constructor for OrnamentsInvertedTurn
mkOrnamentsDelayedInvertedTurn :: HorizontalTurn -> ChxOrnaments Source #
Smart constructor for OrnamentsDelayedInvertedTurn
mkOrnamentsVerticalTurn :: EmptyTrillSound -> ChxOrnaments Source #
Smart constructor for OrnamentsVerticalTurn
mkOrnamentsInvertedVerticalTurn :: EmptyTrillSound -> ChxOrnaments Source #
Smart constructor for OrnamentsInvertedVerticalTurn
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
mkOrnamentsHaydn :: EmptyTrillSound -> ChxOrnaments Source #
Smart constructor for OrnamentsHaydn
mkOrnamentsOtherOrnament :: OtherPlacementText -> ChxOrnaments Source #
Smart constructor for OrnamentsOtherOrnament
data ChxPartList Source #
part-list (choice)
Constructors
| PartListPartGroup | |
Fields | |
| PartListScorePart | |
Fields | |
Instances
mkPartListPartGroup :: GrpPartGroup -> ChxPartList Source #
Smart constructor for PartListPartGroup
mkPartListScorePart :: ScorePart -> ChxPartList Source #
Smart constructor for PartListScorePart
data ChxPercussion Source #
percussion (choice)
Constructors
| PercussionGlass | |
Fields
| |
| PercussionMetal | |
Fields
| |
| PercussionWood | |
Fields
| |
| PercussionPitched | |
Fields
| |
| PercussionMembrane | |
Fields
| |
| PercussionEffect | |
Fields
| |
| PercussionTimpani | |
Fields
| |
| PercussionBeater | |
Fields
| |
| PercussionStick | |
Fields
| |
| PercussionStickLocation | |
Fields
| |
| PercussionOtherPercussion | |
Fields
| |
Instances
mkPercussionGlass :: Glass -> ChxPercussion Source #
Smart constructor for PercussionGlass
mkPercussionMetal :: Metal -> ChxPercussion Source #
Smart constructor for PercussionMetal
mkPercussionWood :: Wood -> ChxPercussion Source #
Smart constructor for PercussionWood
mkPercussionPitched :: Pitched -> ChxPercussion Source #
Smart constructor for PercussionPitched
mkPercussionMembrane :: Membrane -> ChxPercussion Source #
Smart constructor for PercussionMembrane
mkPercussionEffect :: Effect -> ChxPercussion Source #
Smart constructor for PercussionEffect
mkPercussionTimpani :: Empty -> ChxPercussion Source #
Smart constructor for PercussionTimpani
mkPercussionBeater :: Beater -> ChxPercussion Source #
Smart constructor for PercussionBeater
mkPercussionStick :: Stick -> ChxPercussion Source #
Smart constructor for PercussionStick
mkPercussionStickLocation :: StickLocation -> ChxPercussion Source #
Smart constructor for PercussionStickLocation
mkPercussionOtherPercussion :: OtherText -> ChxPercussion Source #
Smart constructor for PercussionOtherPercussion
play (choice)
Constructors
| PlayIpa | |
| PlayMute | |
| PlaySemiPitched | |
Fields
| |
| PlayOtherPlay | |
Fields
| |
Instances
| Generic ChxPlay Source # | |
| Show ChxPlay Source # | |
| EmitXml ChxPlay Source # | |
| Eq ChxPlay Source # | |
| type Rep ChxPlay Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep ChxPlay = D1 ('MetaData "ChxPlay" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) ((C1 ('MetaCons "PlayIpa" 'PrefixI 'True) (S1 ('MetaSel ('Just "playIpa") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "PlayMute" 'PrefixI 'True) (S1 ('MetaSel ('Just "playMute") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Mute))) :+: (C1 ('MetaCons "PlaySemiPitched" 'PrefixI 'True) (S1 ('MetaSel ('Just "playSemiPitched") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 SemiPitched)) :+: C1 ('MetaCons "PlayOtherPlay" 'PrefixI 'True) (S1 ('MetaSel ('Just "playOtherPlay") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 OtherPlay)))) | |
mkPlaySemiPitched :: SemiPitched -> ChxPlay Source #
Smart constructor for PlaySemiPitched
mkPlayOtherPlay :: OtherPlay -> ChxPlay Source #
Smart constructor for PlayOtherPlay
data ChxScoreInstrument Source #
score-instrument (choice)
Constructors
| ScoreInstrumentSolo | |
Fields
| |
| ScoreInstrumentEnsemble | |
Fields
| |
Instances
mkScoreInstrumentSolo :: Empty -> ChxScoreInstrument Source #
Smart constructor for ScoreInstrumentSolo
mkScoreInstrumentEnsemble :: PositiveIntegerOrEmpty -> ChxScoreInstrument Source #
Smart constructor for ScoreInstrumentEnsemble
data ChxTechnical Source #
technical (choice)
Constructors
Instances
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 :: EmptyPlacementSmufl -> 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 :: Tap -> 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
mkTechnicalHole :: Hole -> ChxTechnical Source #
Smart constructor for TechnicalHole
mkTechnicalArrow :: Arrow -> ChxTechnical Source #
Smart constructor for TechnicalArrow
mkTechnicalHandbell :: Handbell -> ChxTechnical Source #
Smart constructor for TechnicalHandbell
mkTechnicalBrassBend :: EmptyPlacement -> ChxTechnical Source #
Smart constructor for TechnicalBrassBend
mkTechnicalFlip :: EmptyPlacement -> ChxTechnical Source #
Smart constructor for TechnicalFlip
mkTechnicalSmear :: EmptyPlacement -> ChxTechnical Source #
Smart constructor for TechnicalSmear
mkTechnicalOpen :: EmptyPlacementSmufl -> ChxTechnical Source #
Smart constructor for TechnicalOpen
mkTechnicalHalfMuted :: EmptyPlacementSmufl -> ChxTechnical Source #
Smart constructor for TechnicalHalfMuted
mkTechnicalHarmonMute :: HarmonMute -> ChxTechnical Source #
Smart constructor for TechnicalHarmonMute
mkTechnicalGolpe :: EmptyPlacement -> ChxTechnical Source #
Smart constructor for TechnicalGolpe
mkTechnicalOtherTechnical :: OtherPlacementText -> ChxTechnical Source #
Smart constructor for TechnicalOtherTechnical
time (choice)
Constructors
| TimeTimeSignature | |
Fields
| |
| TimeSenzaMisura | |
Fields
| |
Instances
| Generic ChxTime Source # | |
| Show ChxTime Source # | |
| EmitXml ChxTime Source # | |
| Eq ChxTime Source # | |
| type Rep ChxTime Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep ChxTime = D1 ('MetaData "ChxTime" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "TimeTimeSignature" 'PrefixI 'True) (S1 ('MetaSel ('Just "timeTimeSignature") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [TimeSignature]) :*: S1 ('MetaSel ('Just "timeInterchangeable") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Interchangeable))) :+: C1 ('MetaCons "TimeSenzaMisura" 'PrefixI 'True) (S1 ('MetaSel ('Just "timeSenzaMisura") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String))) | |
mkTimeTimeSignature :: ChxTime Source #
Smart constructor for TimeTimeSignature
mkTimeSenzaMisura :: String -> ChxTime Source #
Smart constructor for TimeSenzaMisura
credit (sequence)
Constructors
| SeqCredit | |
Fields
| |
Instances
| Generic SeqCredit Source # | |
| Show SeqCredit Source # | |
| EmitXml SeqCredit Source # | |
| Eq SeqCredit Source # | |
| type Rep SeqCredit Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep SeqCredit = D1 ('MetaData "SeqCredit" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "SeqCredit" 'PrefixI 'True) (S1 ('MetaSel ('Just "seqcreditLink") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Link]) :*: (S1 ('MetaSel ('Just "seqcreditBookmark") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Bookmark]) :*: S1 ('MetaSel ('Just "seqcreditCredit") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ChxCredit1)))) | |
mkSeqCredit :: ChxCredit1 -> SeqCredit Source #
Smart constructor for SeqCredit
lyric (sequence)
Constructors
| SeqLyric0 | |
Fields
| |
Instances
| Generic SeqLyric0 Source # | |
| Show SeqLyric0 Source # | |
| EmitXml SeqLyric0 Source # | |
| Eq SeqLyric0 Source # | |
| type Rep SeqLyric0 Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep SeqLyric0 = D1 ('MetaData "SeqLyric0" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "SeqLyric0" 'PrefixI 'True) (S1 ('MetaSel ('Just "lyricElision") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Elision) :*: S1 ('MetaSel ('Just "seqlyricSyllabic") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Syllabic)))) | |
lyric (sequence)
Constructors
| SeqLyric | |
Fields
| |
Instances
| Generic SeqLyric Source # | |
| Show SeqLyric Source # | |
| EmitXml SeqLyric Source # | |
| Eq SeqLyric Source # | |
| type Rep SeqLyric Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep SeqLyric = D1 ('MetaData "SeqLyric" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "SeqLyric" 'PrefixI 'True) (S1 ('MetaSel ('Just "seqlyricLyric") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe SeqLyric0)) :*: S1 ('MetaSel ('Just "seqlyricText") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 TextElementData))) | |
mkSeqLyric :: TextElementData -> SeqLyric Source #
Smart constructor for SeqLyric
data SeqMetronome Source #
metronome (sequence)
Constructors
| SeqMetronome | |
Fields
| |
Instances
| Generic SeqMetronome Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep SeqMetronome :: Type -> Type # | |
| Show SeqMetronome Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> SeqMetronome -> ShowS # show :: SeqMetronome -> String # showList :: [SeqMetronome] -> ShowS # | |
| EmitXml SeqMetronome Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: SeqMetronome -> XmlRep Source # | |
| Eq SeqMetronome Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep SeqMetronome Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep SeqMetronome = D1 ('MetaData "SeqMetronome" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "SeqMetronome" 'PrefixI 'True) (S1 ('MetaSel ('Just "metronomeMetronomeRelation") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String) :*: S1 ('MetaSel ('Just "seqmetronomeMetronomeNote") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [MetronomeNote]))) | |
mkSeqMetronome :: String -> SeqMetronome Source #
Smart constructor for SeqMetronome
data SeqMetronomeTuplet Source #
metronome-tuplet (sequence)
Constructors
| SeqMetronomeTuplet | |
Fields
| |
Instances
mkSeqMetronomeTuplet :: NoteTypeValue -> SeqMetronomeTuplet Source #
Smart constructor for SeqMetronomeTuplet
data SeqOrnaments Source #
ornaments (sequence)
Constructors
| SeqOrnaments | |
Fields
| |
Instances
| Generic SeqOrnaments Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep SeqOrnaments :: Type -> Type # | |
| Show SeqOrnaments Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> SeqOrnaments -> ShowS # show :: SeqOrnaments -> String # showList :: [SeqOrnaments] -> ShowS # | |
| EmitXml SeqOrnaments Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: SeqOrnaments -> XmlRep Source # | |
| Eq SeqOrnaments Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep SeqOrnaments Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep SeqOrnaments = D1 ('MetaData "SeqOrnaments" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "SeqOrnaments" 'PrefixI 'True) (S1 ('MetaSel ('Just "seqornamentsOrnaments") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 ChxOrnaments) :*: S1 ('MetaSel ('Just "ornamentsAccidentalMark") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [AccidentalMark]))) | |
mkSeqOrnaments :: ChxOrnaments -> SeqOrnaments Source #
Smart constructor for SeqOrnaments
data SeqPageLayout Source #
page-layout (sequence)
Constructors
| SeqPageLayout | |
Fields
| |
Instances
mkSeqPageLayout :: Tenths -> Tenths -> SeqPageLayout Source #
Smart constructor for SeqPageLayout
data SeqScorePart Source #
score-part (sequence)
Constructors
| SeqScorePart | |
Fields
| |
Instances
| Generic SeqScorePart Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep SeqScorePart :: Type -> Type # | |
| Show SeqScorePart Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> SeqScorePart -> ShowS # show :: SeqScorePart -> String # showList :: [SeqScorePart] -> ShowS # | |
| EmitXml SeqScorePart Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: SeqScorePart -> XmlRep Source # | |
| Eq SeqScorePart Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep SeqScorePart Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep SeqScorePart = D1 ('MetaData "SeqScorePart" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "SeqScorePart" 'PrefixI 'True) (S1 ('MetaSel ('Just "scorePartMidiDevice") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe MidiDevice)) :*: S1 ('MetaSel ('Just "scorePartMidiInstrument") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe MidiInstrument)))) | |
mkSeqScorePart :: SeqScorePart Source #
Smart constructor for SeqScorePart
slash (sequence)
Constructors
| SeqSlash | |
Fields
| |
Instances
| Generic SeqSlash Source # | |
| Show SeqSlash Source # | |
| EmitXml SeqSlash Source # | |
| Eq SeqSlash Source # | |
| type Rep SeqSlash Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep SeqSlash = D1 ('MetaData "SeqSlash" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "SeqSlash" 'PrefixI 'True) (S1 ('MetaSel ('Just "slashSlashType") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NoteTypeValue) :*: S1 ('MetaSel ('Just "slashSlashDot") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Empty]))) | |
mkSeqSlash :: NoteTypeValue -> SeqSlash Source #
Smart constructor for SeqSlash
sound (sequence)
Constructors
| SeqSound | |
Fields
| |
Instances
| Generic SeqSound Source # | |
| Show SeqSound Source # | |
| EmitXml SeqSound Source # | |
| Eq SeqSound Source # | |
| type Rep SeqSound Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep SeqSound = D1 ('MetaData "SeqSound" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "SeqSound" 'PrefixI 'True) (S1 ('MetaSel ('Just "soundMidiDevice") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe MidiDevice)) :*: (S1 ('MetaSel ('Just "soundMidiInstrument") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe MidiInstrument)) :*: S1 ('MetaSel ('Just "soundPlay") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Play))))) | |
mkSeqSound :: SeqSound Source #
Smart constructor for SeqSound
data SeqTimeModification Source #
time-modification (sequence)
Constructors
| SeqTimeModification | |
Fields
| |
Instances
mkSeqTimeModification :: NoteTypeValue -> SeqTimeModification Source #
Smart constructor for SeqTimeModification
data AllMargins Source #
all-margins (group)
Constructors
| AllMargins | |
Fields
| |
Instances
mkAllMargins :: LeftRightMargins -> Tenths -> Tenths -> AllMargins Source #
Smart constructor for AllMargins
beat-unit (group)
Constructors
| BeatUnit | |
Fields
| |
Instances
| Generic BeatUnit Source # | |
| Show BeatUnit Source # | |
| EmitXml BeatUnit Source # | |
| Eq BeatUnit Source # | |
| type Rep BeatUnit Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep BeatUnit = D1 ('MetaData "BeatUnit" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "BeatUnit" 'PrefixI 'True) (S1 ('MetaSel ('Just "beatUnitBeatUnit") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 NoteTypeValue) :*: S1 ('MetaSel ('Just "beatUnitBeatUnitDot") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Empty]))) | |
mkBeatUnit :: NoteTypeValue -> BeatUnit Source #
Smart constructor for BeatUnit
data DisplayStepOctave Source #
display-step-octave (group)
Constructors
| DisplayStepOctave | |
Fields
| |
Instances
mkDisplayStepOctave :: Step -> Octave -> DisplayStepOctave Source #
Smart constructor for DisplayStepOctave
duration (group)
Constructors
| Duration | |
Fields
| |
Instances
| Generic Duration Source # | |
| Show Duration Source # | |
| EmitXml Duration Source # | |
| Eq Duration Source # | |
| type Rep Duration Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Duration = D1 ('MetaData "Duration" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Duration" 'PrefixI 'True) (S1 ('MetaSel ('Just "durationDuration") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PositiveDivisions))) | |
mkDuration :: PositiveDivisions -> Duration Source #
Smart constructor for Duration
editorial (group)
Constructors
| Editorial | |
Fields | |
Instances
| Generic Editorial Source # | |
| Show Editorial Source # | |
| EmitXml Editorial Source # | |
| Eq Editorial Source # | |
| type Rep Editorial Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Editorial = D1 ('MetaData "Editorial" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Editorial" 'PrefixI 'True) (S1 ('MetaSel ('Just "editorialFootnote") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Footnote)) :*: S1 ('MetaSel ('Just "editorialLevel") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe GrpLevel)))) | |
mkEditorial :: Editorial Source #
Smart constructor for Editorial
data EditorialVoice Source #
editorial-voice (group)
Constructors
| EditorialVoice | |
Instances
mkEditorialVoice :: EditorialVoice Source #
Smart constructor for EditorialVoice
data EditorialVoiceDirection Source #
editorial-voice-direction (group)
Constructors
| EditorialVoiceDirection | |
Instances
mkEditorialVoiceDirection :: EditorialVoiceDirection Source #
Smart constructor for EditorialVoiceDirection
footnote (group)
Constructors
| Footnote | |
Fields
| |
Instances
| Generic Footnote Source # | |
| Show Footnote Source # | |
| EmitXml Footnote Source # | |
| Eq Footnote Source # | |
| type Rep Footnote Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Footnote = D1 ('MetaData "Footnote" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Footnote" 'PrefixI 'True) (S1 ('MetaSel ('Just "footnoteFootnote") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 FormattedText))) | |
mkFootnote :: FormattedText -> Footnote Source #
Smart constructor for Footnote
data GrpFullNote Source #
full-note (group)
Constructors
| GrpFullNote | |
Fields
| |
Instances
| Generic GrpFullNote Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep GrpFullNote :: Type -> Type # | |
| Show GrpFullNote Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> GrpFullNote -> ShowS # show :: GrpFullNote -> String # showList :: [GrpFullNote] -> ShowS # | |
| EmitXml GrpFullNote Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: GrpFullNote -> XmlRep Source # | |
| Eq GrpFullNote Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep GrpFullNote Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep GrpFullNote = D1 ('MetaData "GrpFullNote" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "GrpFullNote" 'PrefixI 'True) (S1 ('MetaSel ('Just "fullNoteChord") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Empty)) :*: S1 ('MetaSel ('Just "fullNoteFullNote") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 FullNote))) | |
mkGrpFullNote :: FullNote -> GrpFullNote Source #
Smart constructor for GrpFullNote
data HarmonyChord Source #
harmony-chord (group)
Constructors
| HarmonyChord | |
Fields
| |
Instances
mkHarmonyChord :: ChxHarmonyChord -> Kind -> HarmonyChord Source #
Smart constructor for HarmonyChord
layout (group)
Constructors
| Layout | |
Fields
| |
Instances
| Generic Layout Source # | |
| Show Layout Source # | |
| EmitXml Layout Source # | |
| Eq Layout Source # | |
| type Rep Layout Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Layout = D1 ('MetaData "Layout" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Layout" 'PrefixI 'True) (S1 ('MetaSel ('Just "layoutPageLayout") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe PageLayout)) :*: (S1 ('MetaSel ('Just "layoutSystemLayout") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe SystemLayout)) :*: S1 ('MetaSel ('Just "layoutStaffLayout") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [StaffLayout])))) | |
data LeftRightMargins Source #
left-right-margins (group)
Constructors
| LeftRightMargins | |
Fields
| |
Instances
mkLeftRightMargins :: Tenths -> Tenths -> LeftRightMargins Source #
Smart constructor for LeftRightMargins
level (group)
Constructors
| GrpLevel | |
Fields
| |
music-data (group)
Constructors
| MusicData | |
Fields | |
Instances
| Generic MusicData Source # | |
| Show MusicData Source # | |
| EmitXml MusicData Source # | |
| Eq MusicData Source # | |
| type Rep MusicData Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep MusicData = D1 ('MetaData "MusicData" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "MusicData" 'PrefixI 'True) (S1 ('MetaSel ('Just "musicDataMusicData") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [ChxMusicData]))) | |
mkMusicData :: MusicData Source #
Smart constructor for MusicData
data NonTraditionalKey Source #
non-traditional-key (group)
Constructors
| NonTraditionalKey | |
Fields
| |
Instances
mkNonTraditionalKey :: Step -> Semitones -> NonTraditionalKey Source #
Smart constructor for NonTraditionalKey
data GrpPartGroup Source #
part-group (group)
Constructors
| GrpPartGroup | |
Fields
| |
Instances
| Generic GrpPartGroup Source # | |
Defined in Fadno.MusicXml.MusicXml31 Associated Types type Rep GrpPartGroup :: Type -> Type # | |
| Show GrpPartGroup Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods showsPrec :: Int -> GrpPartGroup -> ShowS # show :: GrpPartGroup -> String # showList :: [GrpPartGroup] -> ShowS # | |
| EmitXml GrpPartGroup Source # | |
Defined in Fadno.MusicXml.MusicXml31 Methods emitXml :: GrpPartGroup -> XmlRep Source # | |
| Eq GrpPartGroup Source # | |
Defined in Fadno.MusicXml.MusicXml31 | |
| type Rep GrpPartGroup Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep GrpPartGroup = D1 ('MetaData "GrpPartGroup" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "GrpPartGroup" 'PrefixI 'True) (S1 ('MetaSel ('Just "partGroupPartGroup") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PartGroup))) | |
mkGrpPartGroup :: PartGroup -> GrpPartGroup Source #
Smart constructor for GrpPartGroup
data ScoreHeader Source #
score-header (group)
Constructors
| ScoreHeader | |
Fields
| |
Instances
mkScoreHeader :: PartList -> ScoreHeader Source #
Smart constructor for ScoreHeader
score-part (group)
Constructors
| ScorePart | |
Fields
| |
Instances
| Generic ScorePart Source # | |
| Show ScorePart Source # | |
| EmitXml ScorePart Source # | |
| Eq ScorePart Source # | |
| type Rep ScorePart Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep ScorePart = D1 ('MetaData "ScorePart" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "ScorePart" 'PrefixI 'True) (S1 ('MetaSel ('Just "grpscorePartScorePart") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 CmpScorePart))) | |
mkScorePart :: CmpScorePart -> ScorePart Source #
Smart constructor for ScorePart
slash (group)
Constructors
| Slash | |
Fields
| |
Instances
| Generic Slash Source # | |
| Show Slash Source # | |
| EmitXml Slash Source # | |
| Eq Slash Source # | |
| type Rep Slash Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Slash = D1 ('MetaData "Slash" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Slash" 'PrefixI 'True) (S1 ('MetaSel ('Just "grpslashSlash") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe SeqSlash)) :*: S1 ('MetaSel ('Just "slashExceptVoice") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [String]))) | |
parseSlash :: XParse Slash Source #
staff (group)
Constructors
| Staff | |
Fields
| |
Instances
| Generic Staff Source # | |
| Show Staff Source # | |
| EmitXml Staff Source # | |
| Eq Staff Source # | |
| type Rep Staff Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Staff = D1 ('MetaData "Staff" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Staff" 'PrefixI 'True) (S1 ('MetaSel ('Just "staffStaff") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 PositiveInteger))) | |
parseStaff :: XParse Staff Source #
data TimeSignature Source #
time-signature (group)
Constructors
| TimeSignature | |
Fields
| |
Instances
mkTimeSignature :: String -> String -> TimeSignature Source #
Smart constructor for TimeSignature
data TraditionalKey Source #
traditional-key (group)
Constructors
| TraditionalKey | |
Fields
| |
Instances
mkTraditionalKey :: Fifths -> TraditionalKey Source #
Smart constructor for TraditionalKey
tuning (group)
Constructors
| Tuning | |
Fields
| |
Instances
| Generic Tuning Source # | |
| Show Tuning Source # | |
| EmitXml Tuning Source # | |
| Eq Tuning Source # | |
| type Rep Tuning Source # | |
Defined in Fadno.MusicXml.MusicXml31 type Rep Tuning = D1 ('MetaData "Tuning" "Fadno.MusicXml.MusicXml31" "fadno-xml-1.2.1-FxsdrLn5vyXHX48wsPBBu6" 'False) (C1 ('MetaCons "Tuning" 'PrefixI 'True) (S1 ('MetaSel ('Just "tuningTuningStep") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Step) :*: (S1 ('MetaSel ('Just "tuningTuningAlter") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Semitones)) :*: S1 ('MetaSel ('Just "tuningTuningOctave") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Octave)))) | |
voice (group)
Constructors
| Voice | |
Fields
| |
parseVoice :: XParse Voice Source #