1 files changed, 237 insertions, 0 deletions
diff --git a/hdr/request.hh b/hdr/request.hh
new file mode 100644
index 0000000000..1911f20219
--- /dev/null
+++ b/hdr/request.hh
@@ -0,0 +1,237 @@
+// LilyPond's second egg of columbus!
+#ifndef REQUEST_HH
+#define REQUEST_HH
+
+#include "glob.hh"
+#include "string.hh"
+
+/// a voice element wants something printed
+struct Request {
+    Voice_element*elt;		// indirection.
+    
+    /****************/
+
+    Request();
+
+    virtual void print()const ;
+    virtual Note_req *note() {return 0;}
+    virtual Stem_req *stem() {return 0;}
+    virtual Rest_req *rest() {return 0;}
+    virtual Span_req *span() {return 0;}
+    virtual Beam_req *beam() { return 0 ; }
+    virtual  Rhythmic_req*rhythmic() { return 0;}
+    virtual Real 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.  */
+	
+
+/// a request with a duration
+struct Rhythmic_req : Request {
+    int balltype;
+    int dots;
+    
+    /****************/
+
+    Real duration() const;
+    Rhythmic_req();
+    Rhythmic_req*rhythmic() { return this;}
+    void print ()const;
+    Request*clone() const;
+};
+
+/// Put a note of specified type, height, and with accidental on the staff.
+struct Note_req : Rhythmic_req {
+    char name;
+    int octave;
+    int accidental;
+    bool forceacc;
+    
+    /****************/
+
+    // return height from central c (in halflines)
+    int height()const; 
+    Note_req();
+    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.
+*/
+
+
+///Put a rest on the staff.
+struct Rest_req : Rhythmic_req {
+
+    void print()const;
+
+    Rest_req * rest() { return this;}
+    Request*clone() const ;
+};
+/**
+Why a request? It might be a good idea to not typeset the rest, if the paper is too crowded.
+*/
+
+/// attach a stem to the noteball
+struct Stem_req : Request {
+    /// 4,8,16, ..
+    int stem_number;
+
+    virtual Stem_req *stem() {return this;}
+    Stem_req(int s) { stem_number = s; }
+    Request*clone() const;
+};
+
+/// requests to start or stop something.
+struct Span_req : Request {
+    /// should the spanner start or stop, or is it unwanted?
+    enum {
+	NOSPAN, START, STOP
+    } spantype ;
+
+    Span_req*span() { return this; }
+    Span_req();
+    virtual Request*clone()const;
+};
+/**
+ This type of request typically results in the creation of a #Spanner#
+*/
+
+
+///Start / stop a beam at this note.
+struct Beam_req : Span_req {
+    int nplet;
+
+    /****************/
+    
+    Beam_req();
+    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
+
+    */
+
+/// a slur
+struct Slur_req : Span_req {
+    virtual Request*clone()const;
+};
+
+
+#if 0
+
+///Put a lyric above or below (?) this staff.
+struct Lyric_req : Request {
+    String text;
+};
+
+
+///Put a script above or below this ``note''    
+struct Script_req : Request {
+    int orientation;
+    Symbol sym;
+};
+/**
+eg upbow, downbow. Why a request? These symbols may conflict with slurs and brackets, so this
+also a request
+*/
+
+
+
+
+///Draw a (Guitar) chord above or below this ``note''
+struct Chord : Request {
+	// don't know how this looks.
+};
+/**
+Why a request?
+Because everything else is done in requests.
+*/
+
+
+/// for absolute dynamics
+enum Loudness {
+    FFF, FF, F, MF, MP, P, PP, PPP
+} ;
+
+
+///Start / stop a slur or a bracket.
+struct Bracket_req : Span_req {
+    int nplet;
+};
+/**
+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 {
+    Real subtime;
+};
+/** 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
+    note, therefore fore each Dynamic request carries a time, measured
+    from the start of its note.
+
+    This subfield would come in handy, if mpp96 was adapted for midi
+    support.
+    
+    Dynamic should have been derived from request, but I don't want to
+    fuss with virtual baseclasses.  */
+
+/// do a crescendo
+struct Cresc_req : Span_req, Dynamic {
+    
+};
+
+/// do a decrescendo
+struct Decresc_req : Span_req, Dynamic {
+    
+};
+
+/// do a dynamic like "fff" or "mp"
+struct Absdynamic_req : Request, Dynamic {
+        Loudness loudness;
+};
+#endif
+#endif