1 // LilyPond's second egg of columbus!
8 /// a voice element wants something printed
10 Voice_element*elt; // indirection.
14 virtual void print()const ;
15 virtual Note_req *note() {return 0;}
16 virtual Stem_req *stem() {return 0;}
17 virtual Rest_req *rest() {return 0;}
18 virtual Rhythmic_req*rhythmic() { return 0;}
19 Request(Voice_element*);
21 virtual Real duration() const { return 0.0; }
22 virtual Request* clone() const =0;
26 Any Voice_element can do a number of requests. A request is done
27 to the #Staff# which contains the #Voice_element#. The staff decides
28 whether to to honor the request, ignore it, or merge it with other
29 requests. Merging of requests is preferably done with other
30 requests done by members of the same voicegroups (beams, brackets, stems)
32 Please refer to the documentation of the Child classes of
33 #Request# for explanation of each request type.
35 The result of a request will be an #Item# or a #Spanner#, which
36 will be put on a #PStaff#. Note that the #PStaff# and the original
37 #Staff# need not have anything in common. For example, the
38 ``double'' piano Staff could interpret commands which juggle
39 melodies across the left and right hand, and may put the result in
40 two five-line PStaffs (maybe with extra PStaffs to carry the dynamic
43 The class #Staff# should be thought as a container for the
44 #Voice#s, and an interpreter for #Request#s and #Command#s.
45 Different staffs can produce different outputs; a melodious voice
46 which is put into a percussion-Staff, will be typeset as the rythm of
49 After #Staff# made up her mind (Would #Staff# be a smart
50 name? How about #struct Susan {}# :-), the resultant items and
51 spanners are put on the PScore, and pointers to these items are
52 stored in the #Voice_element#. This construction enables the
53 beams/stems to look up the balls it has to connect to. */
56 /// a request with a duration
57 struct Rhythmic_req : Request {
63 Real duration() const;
64 Rhythmic_req(Voice_element*);
65 Rhythmic_req*rhythmic() { return this;}
67 Request*clone() const;
70 /// Put a note of specified type, height, and with accidental on the staff.
71 struct Note_req : Rhythmic_req {
79 // return height from central c (in halflines)
81 Note_req(Voice_element*v);
82 Note_req*note() { return this;}
83 virtual void print() const;
84 Request*clone() const;
87 Staff has to decide if the ball should be hanging left or right. This
88 influences the horizontal dimensions of a column, and this is why
89 request processing should be done before horizontal spacing.
91 Other voices' frivolities may cause the need for accidentals, so this
92 is also for the Staff to decide. The Staff can decide on positioning
93 based on ottava commands and the appropriate clef.
97 ///Put a rest on the staff.
98 struct Rest_req : Rhythmic_req {
100 Rest_req(Voice_element*v) : Rhythmic_req(v) { }
101 Rest_req * rest() { return this;}
102 Request*clone() const ;
105 Why a request? It might be a good idea to not typeset the rest, if the paper is too crowded.
108 /// attach a stem to the noteball
109 struct Stem_req : Request {
112 virtual Stem_req *stem() {return this;}
113 Stem_req(Voice_element*v, int s) : Request(v) { stem_number = s; }
114 Request*clone() const;
120 ///Put a lyric above or below (?) this staff.
121 struct Lyric_req : Request {
126 ///Put a script above or below this ``note''
127 struct Script_req : Request {
132 eg upbow, downbow. Why a request? These symbols may conflict with slurs and brackets, so this
139 ///Draw a (Guitar) chord above or below this ``note''
140 struct Chord : Request {
141 // don't know how this looks.
145 Because everything else is done in requests.
149 /// for absolute dynamics
151 FFF, FF, F, MF, MP, P, PP, PPP
154 /// requests to start or stop something.
155 struct Span_req : Request {
156 /// should the spanner start or stop, or is it unwanted?
162 This type of request typically results in the creation of a #Spanner#
166 ///Start / stop a beam at this note.
167 struct Beam_req : Span_req {
170 /** Staff will have to combine this with the stem_request, since the
171 number of flags that a stem wants to carry will determine the
172 number of beams. if #nplet# is set, the staff will try to put an
173 appropriate number over the beam
175 [what to do if the nplet fields of start and stop conflict?]
178 ///Start / stop a slur or a bracket.
179 struct Bracket_req : Span_req {
183 Start/stop a bracket at this note. if #nplet# is set, the staff will
184 try to put an appropriate number over the bracket
188 struct Slur_req : Span_req {
192 /// helper in the hierarchy
196 /** Each dynamic is bound to one note ( a crescendo spanning multiple
197 notes is thought to be made of two "dynamics": a start and a stop).
198 Dynamic changes can occur in a smaller time than the length of its
199 note, therefore fore each Dynamic request carries a time, measured
200 from the start of its note.
202 This subfield would come in handy, if mpp96 was adapted for midi
205 Dynamic should have been derived from request, but I don't want to
206 fuss with virtual baseclasses. */
209 struct Cresc_req : Span_req, Dynamic {
214 struct Decresc_req : Span_req, Dynamic {
218 /// do a dynamic like "fff" or "mp"
219 struct Absdynamic_req : Request, Dynamic {