/****************/
Request();
+ virtual ~Request(){}
virtual void print()const ;
virtual Note_req *note() {return 0;}
+ virtual Script_req *script() {return 0;}
virtual Stem_req *stem() {return 0;}
+ virtual Text_req*text() { return 0; }
virtual Rest_req *rest() {return 0;}
virtual Span_req *span() {return 0;}
virtual Beam_req *beam() { return 0 ; }
virtual Slur_req *slur() { return 0 ; }
- virtual Rhythmic_req*rhythmic() { return 0;}
+ virtual Rhythmic_req*rhythmic() { return 0; }
+ virtual Melodic_req *melodic() { return 0; }
virtual Moment duration() const { return 0.0; }
virtual Request* clone() const =0;
};
/**
- Any Voice_element can do a number of requests. A request is done
- to the #Staff# which contains the #Voice_element#. The staff decides
- whether to to honor the request, ignore it, or merge it with other
- requests. Merging of requests is preferably done with other
- requests done by members of the same voicegroups (beams, brackets, stems)
-
- Please refer to the documentation of the Child classes of
- #Request# for explanation of each request type.
-
- The result of a request will be an #Item# or a #Spanner#, which
- will be put on a #PStaff#. Note that the #PStaff# and the original
- #Staff# need not have anything in common. For example, the
- ``double'' piano Staff could interpret commands which juggle
- melodies across the left and right hand, and may put the result in
- two five-line PStaffs (maybe with extra PStaffs to carry the dynamic
- signs and any lyric.
-
- The class #Staff# should be thought as a container for the
- #Voice#s, and an interpreter for #Request#s and #Command#s.
- Different staffs can produce different outputs; a melodious voice
- which is put into a percussion-Staff, will be typeset as the rythm of
- that voice.
-
- After #Staff# made up her mind (Would #Staff# be a smart
- name? How about #struct Susan {}# :-), the resultant items and
- spanners are put on the PScore, and pointers to these items are
- stored in the #Voice_element#. This construction enables the
- beams/stems to look up the balls it has to connect to. */
+see lilygut page
+ */
/// a request with a duration
-struct Rhythmic_req : Request {
+struct Rhythmic_req : virtual Request {
int balltype;
int dots;
-
+ Moment plet_factor;
/****************/
Moment duration() const;
Request*clone() const;
};
-/// Put a note of specified type, height, and with accidental on the staff.
-struct Note_req : Rhythmic_req {
- char name;
+
+struct Melodic_req :virtual Request
+{
+ /// 0 is c
+ int name;
int octave;
int accidental;
bool forceacc;
-
- /****************/
// return height from central c (in halflines)
int height()const;
- Note_req();
+ Melodic_req();
+ Melodic_req*melodic() { return this;}
+ virtual void print() const;
+ Request*clone() const;
+};
+
+/// Put a note of specified type, height, and with accidental on the staff.
+struct Note_req : Rhythmic_req, virtual Melodic_req {
+ Rhythmic_req* rhythmic() { return Rhythmic_req::rhythmic(); }
+
Note_req*note() { return this;}
virtual void print() const;
Request*clone() const;
};
/**
-Staff has to decide if the ball should be hanging left or right. This
-influences the horizontal dimensions of a column, and this is why
-request processing should be done before horizontal spacing.
-
-Other voices' frivolities may cause the need for accidentals, so this
-is also for the Staff to decide. The Staff can decide on positioning
-based on ottava commands and the appropriate clef.
*/
virtual Beam_req * beam() { return this; }
virtual Request*clone()const;
};
-/** Staff will have to combine this with the stem_request, since the
- number of flags that a stem wants to carry will determine the
- number of beams. if #nplet# is set, the staff will try to put an
- appropriate number over the beam
-
+/** if #nplet# is set, the staff will try to put an
+appropriate number over the beam
*/
/// a slur
};
-#if 0
+///Put a script above or below this ``note''
+struct Script_req : Request {
+ int dir;
+ Script_def *scriptdef;
-///Put a lyric above or below (?) this staff.
-struct Lyric_req : Request {
- String text;
+ /****************/
+ Script_req*script() { return this; }
+ virtual void print() const;
+ Request *clone()const;
+ Script_req(int d, Script_def*);
+ ~Script_req();
};
+/** eg upbow, downbow. Why a request? These symbols may conflict with
+slurs and brackets, so this also a request */
-///Put a script above or below this ``note''
-struct Script_req : Request {
- int orientation;
- Symbol sym;
+///Put a text above or below (?) this staff.
+struct Text_req : Request {
+ int dir;
+ Text_def *spec;
+ /****************/
+ Text_req*text() { return this; }
+ virtual void print() const;
+ Request *clone()const;
+ Text_req(int d, Text_def*);
+ ~Text_req();
};
-/**
-eg upbow, downbow. Why a request? These symbols may conflict with slurs and brackets, so this
-also a request
-*/
+#if 0
+
+///Put a lyric above or below (?) this staff.
+struct Lyric_req : Request {
+ String text;
+};
+
///Draw a (Guitar) chord above or below this ``note''
///Start / stop a slur or a bracket.
struct Bracket_req : Span_req {
- int nplet;
+ int nplet; // print a number over the beam.
};
+
/**
Start/stop a bracket at this note. if #nplet# is set, the staff will
try to put an appropriate number over the bracket
*/
-/// helper in the hierarchy
-struct Dynamic {
+struct Subtle_request {
Moment subtime;
};
+
+/// helper in the hierarchy
+struct Dynamic:Subtle_request {
+
+};
/** Each dynamic is bound to one note ( a crescendo spanning multiple
notes is thought to be made of two "dynamics": a start and a stop).
Dynamic changes can occur in a smaller time than the length of its
/// do a dynamic like "fff" or "mp"
struct Absdynamic_req : Request, Dynamic {
- Loudness loudness;
+ Loudness loudness;
+};
+
+struct Grace_req : Subtle_request {
+
+};
+
+struct Grace_turn_req : Grace_turn {
+
+};
+
+struct Grace_note : Melodic_req {
+
+};
+
+struct Grace_notes {
+
};
#endif
#endif
projects / lilypond.git / commitdiff