Text.XML.MusicXML.Direction

Direction

type Direction = ((Placement, Directive), ([Direction_Type], Maybe Offset, Editorial_Voice, Maybe Staff, Maybe Sound))

read_Direction :: Eq i => StateT Result [Content i] Direction

show_Direction :: Direction -> [Content ()]

Direction_Type

type Direction_Type = Direction_Type_

read_Direction_Type :: Eq i => StateT Result [Content i] Direction_Type

show_Direction_Type :: Direction_Type -> [Content ()]

data Direction_Type_

Constructors

Direction_Type_1 [Rehearsal]

Direction_Type_2 [Segno]

Direction_Type_3 [Words]

Direction_Type_4 [Coda]

Direction_Type_5 Wedge

Direction_Type_6 [Dynamics]

Direction_Type_7 Dashes

Direction_Type_8 Bracket

Direction_Type_9 Pedal

Direction_Type_10 Metronome

Direction_Type_11 Octave_Shift

Direction_Type_12 Harp_Pedals

Direction_Type_13 Damp

Direction_Type_14 Damp_All

Direction_Type_15 Eyeglasses

Direction_Type_16 Scordatura

Direction_Type_17 Image

Direction_Type_18 Accordion_Registration

Direction_Type_19 Other_Direction

Instances

Eq Direction_Type_

Show Direction_Type_

read_Direction_Type_ :: Eq i => StateT Result [Content i] Direction_Type_

show_Direction_Type_ :: Direction_Type_ -> [Content ()]

type Rehearsal = ((Print_Style, Text_Decoration, Maybe CDATA, Text_Direction, Text_Rotation, Maybe Rehearsal_), PCDATA)

read_Rehearsal :: StateT Result [Content i] Rehearsal

show_Rehearsal :: Rehearsal -> [Content ()]

data Rehearsal_

Constructors

Rehearsal_1

Rehearsal_2

Rehearsal_3

Instances

Eq Rehearsal_

Show Rehearsal_

read_Rehearsal_ :: String -> Result Rehearsal_

show_Rehearsal_ :: Rehearsal_ -> String

type Words = (Text_Formatting, PCDATA)

read_Words :: StateT Result [Content i] Words

show_Words :: Words -> [Content ()]

type Wedge = ((Wedge_, Maybe Number_Level, Maybe CDATA, Position, Color), ())

read_Wedge :: StateT Result [Content i] Wedge

show_Wedge :: Wedge -> [Content ()]

data Wedge_

Constructors

Wedge_1

Wedge_2

Wedge_3

Instances

Eq Wedge_

Show Wedge_

read_Wedge_ :: String -> Result Wedge_

show_Wedge_ :: Wedge_ -> String

type Dashes = ((Start_Stop, Maybe Number_Level, Position, Color), ())

read_Dashes :: StateT Result [Content i] Dashes

show_Dashes :: Dashes -> [Content ()]

type Bracket = ((Start_Stop, Maybe Number_Level, Bracket_, Maybe Tenths, Line_Type, Position, Color), ())

read_Bracket :: StateT Result [Content i] Bracket

show_Bracket :: Bracket -> [Content ()]

data Bracket_

Constructors

Bracket_1

Bracket_2

Bracket_3

Bracket_4

Bracket_5

Instances

Eq Bracket_

Show Bracket_

read_Bracket_ :: String -> Result Bracket_

show_Bracket_ :: Bracket_ -> String

type Pedal = ((Pedal_, Maybe Yes_No, Print_Style), ())

read_Pedal :: StateT Result [Content i] Pedal

show_Pedal :: Pedal -> [Content ()]

data Pedal_

Constructors

Pedal_1

Pedal_2

Pedal_3

Instances

Eq Pedal_

Show Pedal_

read_Pedal_ :: String -> Result Pedal_

show_Pedal_ :: Pedal_ -> String

type Metronome = ((Print_Style, Maybe Yes_No), Metronome_A)

read_Metronome :: Eq i => StateT Result [Content i] Metronome

show_Metronome :: Metronome -> [Content ()]

data Metronome_A

Constructors

Metronome_1 (Beat_Unit, [Beat_Unit_Dot], Metronome_B)

Metronome_2 ([Metronome_Note], Maybe (Metronome_Relation, [Metronome_Note]))

Instances

Eq Metronome_A

Show Metronome_A

read_Metronome_A :: Eq i => StateT Result [Content i] Metronome_A

show_Metronome_A :: Metronome_A -> [Content ()]

read_Metronome_A_aux1 :: Eq i => StateT Result [Content i] (Beat_Unit, [Beat_Unit_Dot], Metronome_B)

read_Metronome_A_aux2 :: Eq i => StateT Result [Content i] ([Metronome_Note], Maybe (Metronome_Relation, [Metronome_Note]))

read_Metronome_A_aux3 :: Eq i => StateT Result [Content i] (Metronome_Relation, [Metronome_Note])

show_Metronome_A_aux1 :: (Metronome_Relation, [Metronome_Note]) -> [Content ()]

data Metronome_B

Constructors

Metronome_3 Per_Minute

Metronome_4 (Beat_Unit, [Beat_Unit_Dot])

Instances

Eq Metronome_B

Show Metronome_B

read_Metronome_B :: Eq i => StateT Result [Content i] Metronome_B

show_Metronome_B :: Metronome_B -> [Content ()]

read_Metronome_B_aux1 :: Eq i => StateT Result [Content i] (Beat_Unit, [Beat_Unit_Dot])

type Beat_Unit = PCDATA

read_Beat_Unit :: StateT Result [Content i] Beat_Unit

show_Beat_Unit :: Beat_Unit -> [Content ()]

type Beat_Unit_Dot = ()

read_Beat_Unit_Dot :: StateT Result [Content i] Beat_Unit_Dot

show_Beat_Unit_Dot :: Beat_Unit_Dot -> [Content ()]

type Per_Minute = (Font, PCDATA)

read_Per_Minute :: StateT Result [Content i] Per_Minute

show_Per_Minute :: Per_Minute -> [Content ()]

type Metronome_Note = (Metronome_Type, [Metronome_Dot], [Metronome_Beam], Maybe Metronome_Tuplet)

read_Metronome_Note :: Eq i => StateT Result [Content i] Metronome_Note

show_Metronome_Note :: Metronome_Note -> [Content ()]

type Metronome_Relation = PCDATA

read_Metronome_Relation :: StateT Result [Content i] Metronome_Relation

show_Metronome_Relation :: Metronome_Relation -> [Content ()]

type Metronome_Type = PCDATA

read_Metronome_Type :: StateT Result [Content i] Metronome_Type

show_Metronome_Type :: Metronome_Type -> [Content ()]

type Metronome_Dot = ()

read_Metronome_Dot :: StateT Result [Content i] Metronome_Dot

show_Metronome_Dot :: Metronome_Dot -> [Content ()]

type Metronome_Beam = (Beam_Level, PCDATA)

read_Metronome_Beam :: StateT Result [Content i] Metronome_Beam

show_Metronome_Beam :: Metronome_Beam -> [Content ()]

type Metronome_Tuplet = ((Start_Stop, Maybe Yes_No, Maybe Metronome_Tuplet_), (Actual_Notes, Normal_Notes, Maybe (Normal_Type, [Normal_Dot])))

read_Metronome_Tuplet :: Eq i => StateT Result [Content i] Metronome_Tuplet

show_Metronome_Tuplet :: Metronome_Tuplet -> [Content ()]

read_Metronome_Tuplet_aux1 :: Eq i => StateT Result [Content i] (Normal_Type, [Normal_Dot])

show_Metronome_Tuplet_aux1 :: (Normal_Type, [Normal_Dot]) -> [Content ()]

data Metronome_Tuplet_

Constructors

Metronome_Tuplet_1

Metronome_Tuplet_2

Metronome_Tuplet_3

Instances

Eq Metronome_Tuplet_

Show Metronome_Tuplet_

read_Metronome_Tuplet_ :: String -> Result Metronome_Tuplet_

show_Metronome_Tuplet_ :: Metronome_Tuplet_ -> String

type Octave_Shift = ((Octave_Shift_, Maybe Number_Level, CDATA, Print_Style), ())

read_Octave_Shift :: StateT Result [Content i] Octave_Shift

show_Octave_Shift :: Octave_Shift -> [Content ()]

data Octave_Shift_

Constructors

Octave_Shift_1

Octave_Shift_2

Octave_Shift_3

Instances

Eq Octave_Shift_

Show Octave_Shift_

read_Octave_Shift_ :: String -> Result Octave_Shift_

show_Octave_Shift_ :: Octave_Shift_ -> String

type Harp_Pedals = (Print_Style, [Pedal_Tuning])

read_Harp_Pedals :: Eq i => StateT Result [Content i] Harp_Pedals

show_Harp_Pedals :: Harp_Pedals -> [Content ()]

type Pedal_Tuning = (Pedal_Step, Pedal_Alter)

read_Pedal_Tuning :: StateT Result [Content i] Pedal_Tuning

show_Pedal_Tuning :: Pedal_Tuning -> [Content ()]

type Pedal_Step = PCDATA

read_Pedal_Step :: StateT Result [Content i] Pedal_Step

show_Pedal_Step :: Pedal_Step -> [Content ()]

type Pedal_Alter = PCDATA

read_Pedal_Alter :: StateT Result [Content i] Pedal_Alter

show_Pedal_Alter :: Pedal_Alter -> [Content ()]

type Damp = (Print_Style, ())

read_Damp :: StateT Result [Content i] Damp

show_Damp :: Damp -> [Content ()]

type Damp_All = (Print_Style, ())

read_Damp_All :: StateT Result [Content i] Damp_All

show_Damp_All :: Damp_All -> [Content ()]

type Eyeglasses = (Print_Style, ())

read_Eyeglasses :: StateT Result [Content i] Eyeglasses

show_Eyeglasses :: Eyeglasses -> [Content ()]

type Scordatura = [Accord]

read_Scordatura :: Eq i => StateT Result [Content i] Scordatura

show_Scordatura :: Scordatura -> [Content ()]

type Accord = (CDATA, (Tuning_Step, Maybe Tuning_Alter, Tuning_Octave))

read_Accord :: StateT Result [Content i] Accord

show_Accord :: Accord -> [Content ()]

type Image = ((CDATA, CDATA, Position, Halign, Valign_Image), ())

read_Image :: StateT Result [Content i] Image

show_Image :: Image -> [Content ()]

type Accordion_Registration = (Print_Style, (Maybe Accordion_High, Maybe Accordion_Middle, Maybe Accordion_Low))

read_Accordion_Registration :: StateT Result [Content i] Accordion_Registration

show_Accordion_Registration :: Accordion_Registration -> [Content ()]

type Accordion_High = ()

read_Accordion_High :: StateT Result [Content i] Accordion_High

show_Accordion_High :: Accordion_High -> [Content ()]

type Accordion_Middle = PCDATA

read_Accordion_Middle :: StateT Result [Content i] Accordion_Middle

show_Accordion_Middle :: Accordion_Middle -> [Content ()]

type Accordion_Low = ()

read_Accordion_Low :: StateT Result [Content i] Accordion_Low

show_Accordion_Low :: Accordion_Low -> [Content ()]

type Other_Direction = ((Print_Object, Print_Style), PCDATA)

read_Other_Direction :: StateT Result [Content i] Other_Direction

show_Other_Direction :: Other_Direction -> [Content ()]

type Offset = (Maybe Yes_No, PCDATA)

read_Offset :: StateT Result [Content i] Offset

show_Offset :: Offset -> [Content ()]

type Harmony_Chord = (Harmony_Chord_, Kind, Maybe Inversion, Maybe Bass, [Degree])

read_Harmony_Chord :: Eq i => StateT Result [Content i] Harmony_Chord

show_Harmony_Chord :: Harmony_Chord -> [Content ()]

data Harmony_Chord_

Constructors

Harmony_Chord_1 Root

Harmony_Chord_2 Function

Instances

Eq Harmony_Chord_

Show Harmony_Chord_

read_Harmony_Chord_ :: StateT Result [Content i] Harmony_Chord_

show_Harmony_Chord_ :: Harmony_Chord_ -> [Content ()]

type Harmony = ((Maybe Harmony_, Print_Object, Maybe Yes_No, Print_Style, Placement), ([Harmony_Chord], Maybe Frame, Maybe Offset, Editorial, Maybe Staff))

read_Harmony :: Eq i => StateT Result [Content i] Harmony

show_Harmony :: Harmony -> [Content ()]

data Harmony_

Constructors

Harmony_1

Harmony_2

Harmony_3

Instances

Eq Harmony_

Show Harmony_

read_Harmony_ :: String -> Result Harmony_

show_Harmony_ :: Harmony_ -> String

type Root = (Root_Step, Maybe Root_Alter)

read_Root :: StateT Result [Content i] Root

show_Root :: Root -> [Content ()]

type Root_Step = ((Maybe CDATA, Print_Style), PCDATA)

read_Root_Step :: StateT Result [Content i] Root_Step

show_Root_Step :: Root_Step -> [Content ()]

type Root_Alter = ((Print_Object, Print_Style, Maybe Left_Right), PCDATA)

read_Root_Alter :: StateT Result [Content i] Root_Alter

show_Root_Alter :: Root_Alter -> [Content ()]

type Function = (Print_Style, PCDATA)

read_Function :: StateT Result [Content i] Function

show_Function :: Function -> [Content ()]

type Kind = ((Maybe Yes_No, Maybe CDATA, Maybe Yes_No, Maybe Yes_No, Maybe Yes_No, Print_Style, Halign, Valign), PCDATA)

read_Kind :: StateT Result [Content i] Kind

show_Kind :: Kind -> [Content ()]

type Inversion = (Print_Style, PCDATA)

read_Inversion :: StateT Result [Content i] Inversion

show_Inversion :: Inversion -> [Content ()]

type Bass = (Bass_Step, Maybe Bass_Alter)

read_Bass :: StateT Result [Content i] Bass

show_Bass :: Bass -> [Content ()]

type Bass_Step = ((Maybe CDATA, Print_Style), PCDATA)

read_Bass_Step :: StateT Result [Content i] Bass_Step

show_Bass_Step :: Bass_Step -> [Content ()]

type Bass_Alter = ((Print_Object, Print_Style, Maybe Bass_Alter_), PCDATA)

read_Bass_Alter :: StateT Result [Content i] Bass_Alter

show_Bass_Alter :: Bass_Alter -> [Content ()]

data Bass_Alter_

This is equivalent to left-right entity

Constructors

Bass_Alter_1

Bass_Alter_2

Instances

Eq Bass_Alter_

Show Bass_Alter_

read_Bass_Alter_ :: String -> Result Bass_Alter_

show_Bass_Alter_ :: Bass_Alter_ -> String

type Degree = (Print_Object, (Degree_Value, Degree_Alter, Degree_Type))

read_Degree :: StateT Result [Content i] Degree

show_Degree :: Degree -> [Content ()]

type Degree_Value = ((Maybe CDATA, Print_Style), PCDATA)

read_Degree_Value :: StateT Result [Content i] Degree_Value

show_Degree_Value :: Degree_Value -> [Content ()]

type Degree_Alter = ((Print_Style, Maybe Yes_No), PCDATA)

read_Degree_Alter :: StateT Result [Content i] Degree_Alter

show_Degree_Alter :: Degree_Alter -> [Content ()]

type Degree_Type = ((Maybe CDATA, Print_Style), PCDATA)

read_Degree_Type :: StateT Result [Content i] Degree_Type

show_Degree_Type :: Degree_Type -> [Content ()]

type Frame = ((Position, Color, Halign, Valign, Maybe Tenths, Maybe Tenths), (Frame_Strings, Frame_Frets, Maybe First_Fret, [Frame_Note]))

read_Frame :: Eq i => StateT Result [Content i] Frame

show_Frame :: Frame -> [Content ()]

type Frame_Strings = PCDATA

read_Frame_Strings :: StateT Result [Content i] Frame_Strings

show_Frame_Strings :: Frame_Strings -> [Content ()]

type Frame_Frets = PCDATA

read_Frame_Frets :: StateT Result [Content i] Frame_Frets

show_Frame_Frets :: Frame_Frets -> [Content ()]

type First_Fret = ((Maybe CDATA, Maybe Left_Right), PCDATA)

read_First_Fret :: StateT Result [Content i] First_Fret

show_First_Fret :: First_Fret -> [Content ()]

type Frame_Note = (String, Fret, Maybe Fingering, Maybe Barre)

read_Frame_Note :: StateT Result [Content i] Frame_Note

show_Frame_Note :: Frame_Note -> [Content ()]

type Barre = ((Start_Stop, Color), ())

read_Barre :: StateT Result [Content i] Barre

show_Barre :: Barre -> [Content ()]

type Grouping = ((Start_Stop_Single, CDATA, Maybe CDATA), [Feature])

read_Grouping :: Eq i => StateT Result [Content i] Grouping

show_Grouping :: Grouping -> [Content ()]

type Feature = (Maybe CDATA, PCDATA)

read_Feature :: StateT Result [Content i] Feature

show_Feature :: Feature -> [Content ()]

type Print = ((Maybe Tenths, Maybe Yes_No, Maybe Yes_No, Maybe CDATA, Maybe CDATA), (Maybe Page_Layout, Maybe System_Layout, [Staff_Layout], Maybe Measure_Layout, Maybe Measure_Numbering, Maybe Part_Name_Display, Maybe Part_Abbreviation_Display))

read_Print :: Eq i => StateT Result [Content i] Print

show_Print :: Print -> [Content ()]

type Measure_Numbering = (Print_Style, PCDATA)

read_Measure_Numbering :: Eq i => StateT Result [Content i] Measure_Numbering

show_Measure_Numbering :: Measure_Numbering -> [Content ()]

Sound

type Sound = ((Maybe CDATA, Maybe CDATA, Maybe Yes_No, Maybe CDATA, Maybe CDATA, Maybe CDATA, Maybe CDATA, Maybe CDATA, Maybe Yes_No, Maybe CDATA, Maybe CDATA, Maybe Yes_No, Maybe CDATA, Maybe CDATA, Maybe Yes_No_Number, Maybe Yes_No_Number, Maybe Yes_No_Number), ([Midi_Instrument], Maybe Offset))

read_Sound :: Eq i => StateT Result [Content i] Sound

show_Sound :: Sound -> [Content ()]