+pl 16.jcn1
+ - dashed-slur through scheme
+
+pl 15.jcn4
+ - more scheme hacks
+
+pl 15.jcn3
+ - try at scheme in Atom
+
+pl 15.jcn2 # rest of
+ - graphical-lisp-element + silly half hook-up with autuplet
+
pl 16
- read property ydirection and tieYDirection for tie direction.
- bf: slur over rest.
MAJOR_VERSION=1
MINOR_VERSION=0
PATCH_LEVEL=16
-MY_PATCH_LEVEL=
+MY_PATCH_LEVEL=jcn1
# use the above to send patches: MY_PATCH_LEVEL is always empty for a
# released version.
AC_STEPMAKE_TEXMF
# AC_STEPMAKE_TEXMF_DIRS
AC_STEPMAKE_YODL
-
+AC_CHECK_LIB(guile, scm_shell)
dnl should check out -print
dnl huh?
\include "property.ly"
+\include "scm.ly"
+
% music = "\melodic\relative c"
--- /dev/null
+\scm "
+
+(define (add-column p) (display \"adding column (in guile): \") (display p) (newline))
+
+(define
+ (control->string c)
+ (string-append
+ (string-append (number->string (car c)) \" \")
+ (string-append (number->string (cadr c)) \" \")))
+
+(define
+ (dashed-slur-ps thick dash l)
+ (string-append
+ (apply string-append (map control->string l))
+ (number->string thick)
+ \" [ 0 \" (number->string dash) \" ] 0 draw_dashed_slur\"))
+
+(define
+ (dashed-slur-tex thick dash l)
+ (string-append
+ \"\\embedded_ps{\"
+ (dashed-slur-ps thick dash l)
+ \"}\"))
+
+(define
+ (dashed-slur o thick dash l)
+ ((eval-string (string-append \"dashed-slur-\" o)) thick dash l))
+
+";
+
But Atom is used as a simple type *everywhere*,
and we don't have virtual contructors.
*/
+ lambda_ = 0;
str_ = global_lookup_l->unknown_str ();
}
Atom::Atom (String s, Box b)
: dim_ (b)
{
+ lambda_ = 0;
str_ = s;
}
#include "auto-plet-engraver.hh"
#include "command-request.hh"
-#include "slur.hh"
+#include "graphical-lisp-element.hh"
#include "note-column.hh"
bool
return true;
}
-
void
Tuplet_engraver::do_process_requests ()
{
int stopcount =0;
- Link_array<Slur> start_arr;
+ Link_array<Graphical_lisp_element> start_arr;
for (int i=0; i < bracket_req_arr_.size (); i++)
{
stopcount++;
if (bracket_req_arr_[i]->spantype == Span_req::START)
{
- Slur *sp =new Slur;
- start_arr.push (sp);
- announce_element (Score_element_info (sp, bracket_req_arr_[i]));
+ Graphical_lisp_element* glep = new Graphical_lisp_element ("tuplet");
+ start_arr.push (glep);
+// lots of stuff does info->elem_l_->is_type ()
+// announce_element (Score_element_info (glep, bracket_req_arr_[i]));
}
}
for (; stopcount--; )
{
- Slur *sp = started_span_p_arr_.pop ();
- stop_now_span_p_arr_.push (sp);
+ Graphical_lisp_element* glep = started_span_p_arr_.pop ();
+ stop_now_span_p_arr_.push (glep);
}
for (int i=0; i < start_arr.size (); i++)
{
Note_column *nc = (Note_column*)i.elem_l_->access_Item ();
for (int j =0; j <started_span_p_arr_.size (); j++)
- started_span_p_arr_[j]->add_column (nc);
+// started_span_p_arr_[j]->add_column (nc);
+ started_span_p_arr_[j]->call ("add-column", (void*)nc);
}
}
daddy_grav_l()->announce_element (i);
}
-
void
Engraver::typeset_element (Score_element*p)
{
daddy_grav_l()->typeset_element (p);
}
+void
+Engraver::typeset_element (Graphical_lisp_element*p)
+{
+ daddy_grav_l ()->typeset_element (p);
+}
+
Paper_def*
Engraver::paper() const
{
--- /dev/null
+/*
+ graphical-lisp-element.cc -- implement Graphical_lisp_element
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1998 Jan Nieuwenhuizen <janneke@gnu.org>
+*/
+
+#include "graphical-lisp-element.hh"
+#include "string.hh"
+#include "debug.hh"
+
+#undef IMPLEMENT_STATIC_NAME
+#define IMPLEMENT_STATIC_NAME(c)\
+char const* c::static_name ()\
+{ return type_str_.ch_C (); }\
+size_t c::static_class_size () { return sizeof (c); }
+
+IMPLEMENT_IS_TYPE_B (Graphical_lisp_element);
+
+Graphical_lisp_element::Graphical_lisp_element (String str)
+{
+ type_str_ = str;
+}
+
+void*
+Graphical_lisp_element::access (String str)
+{
+ SCM scm;
+// scm = gh_cons (gh_str02scm (str.ch_C ()));
+// scm = gh_cons (gh_symbol2scm (str.ch_C ()));
+ return 0;
+}
+
+void
+Graphical_lisp_element::call (String str, void* p)
+{
+// gh_apply (str.ch_C (), SCM_EOL);
+// gh_apply (str.ch_C (), SCM_EOL);
+
+// mm, common lisp only?
+// String ptr = to_str (" \\%x", p);
+ String ptr = to_str (" '%x", p);
+ str = "(" + str + ptr + ")";
+ gh_eval_str (str.ch_l ());
+// gh_eval_str ("(add-column 0)");
+}
#ifndef ATOM_HH
#define ATOM_HH
+#include "lily-guile.hh"
#include "string.hh"
#include "box.hh"
#include "lily-proto.hh"
-
/// a symbol which can be translated, and freely copied
class Atom {
Offset off_;
public:
String str_;
String font_;
+ SCM lambda_;
Box dim_;
Offset offset () const;
protected:
Link_array<Bracket_req> bracket_req_arr_;
- Link_array<Slur> started_span_p_arr_;
- Link_array<Slur> stop_now_span_p_arr_;
+ Link_array<Graphical_lisp_element> started_span_p_arr_;
+ Link_array<Graphical_lisp_element> stop_now_span_p_arr_;
virtual void do_removal_processing ();
virtual void acknowledge_element (Score_element_info);
Invoke walker method to typeset element. Default: pass on to daddy.
*/
virtual void typeset_element (Score_element*elem_p);
+ virtual void typeset_element (Graphical_lisp_element*);
/**
take note of item/spanner
--- /dev/null
+/*
+ graphical-lisp-element.hh -- declare Graphical_lisp_element
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1998 Jan Nieuwenhuizen <janneke@gnu.org>
+*/
+
+
+#ifndef GRAPHICAL_LISP_ELEMENT_HH
+#define GRAPHICAL_LISP_ELEMENT_HH
+
+#include "lily-guile.hh"
+#include "lily-proto.hh"
+#include "string.hh"
+
+#define virtual
+#define static
+#include "virtual-methods.hh"
+
+class Graphical_lisp_element
+{
+public:
+ DECLARE_MY_RUNTIME_TYPEINFO;
+
+ Graphical_lisp_element (String);
+
+ void* access (String);
+ void call (String, void*);
+
+private:
+ String type_str_;
+};
+
+#undef virtual
+#undef static
+
+#endif // GRAPHICAL_LISP_ELEMENT_HH
+
#include "config.hh"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
#ifdef HAVE_LIBGUILE
extern "C" {
#include <guile/gh.h>
#else
typedef long SCM;
#endif
+
+SCM gh_append (SCM a, SCM b);
+SCM gh_eval (SCM a);
+SCM gh_func_o (char const* name);
+SCM gh_lambda_o ();
+SCM gh_list1 (SCM a);
+SCM gh_list2(SCM a, SCM b);
+SCM gh_quote ();
+
+#ifdef __cplusplus
+}
+#endif
+
#endif // LILY_GUILE_HH
struct Engraver_group_engraver;
struct General_script_def;
struct Graphical_element;
+struct Graphical_lisp_element;
struct Graphical_axis_group;
struct Mark_req;
struct Music_output;
Atom beam (Real,Real, Real) const;
virtual String character_str (int i) const;
Atom clef (String) const;
- virtual Atom dashed_slur (Array<Offset> controls, Real thick, Real dash) const = 0;
+ virtual Atom dashed_slur (Array<Offset> controls, Real thick, Real dash) const;
Atom dots () const;
Atom dynamic (String) const;
Atom fill (Box b) const;
virtual ~Paper_outputter ();
virtual void output_molecule (Molecule const *, Offset, char const *)=0;
- void output_molecule (Molecule const *, Offset, char const *, String);
+ void output_molecule (Molecule const *, Offset, char const *, String, String);
virtual void start_line ()=0;
virtual void stop_line ()=0;
virtual void switch_to_font (String fontname)=0;
virtual Atom afm_find (String s) const;
virtual Atom* atom_p (String, int, Box) const;
virtual String character_str (int i) const;
- virtual Atom dashed_slur (Array<Offset> controls, Real thick, Real dash) const;
virtual Atom hairpin (Real width, bool decresc, bool continued) const;
virtual Lookup* lookup_p (Lookup const&) const;
virtual Lookup* lookup_p (Symtables const&) const;
*/
struct Score_element_info {
Score_element * elem_l_;
+ Graphical_lisp_element * lisp_l_;
Request*req_l_;
Array<Engraver*> origin_grav_l_arr_;
Score_element_info (Score_element*, Request*);
+ Score_element_info (Graphical_lisp_element*, Request*);
Score_element_info();
};
virtual void announce_element (Score_element_info);
virtual void do_announces();
virtual void typeset_element (Score_element*elem_p);
+ virtual void typeset_element (Graphical_lisp_element*elem_p);
virtual void do_pre_move_processing();
virtual void do_add_processing ();
};
virtual Atom afm_find (String s) const;
virtual String character_str (int i) const;
- virtual Atom dashed_slur (Array<Offset> controls, Real thick, Real dash) const;
virtual Atom* atom_p (String, int, Box) const;
Atom embed (Atom a) const;
virtual Atom hairpin (Real width, bool decresc, bool continued) const;
--- /dev/null
+/*
+ lily-guile.cc -- implement assorted guile functions
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1998 Jan Nieuwenhuizen <janneke@gnu.org>
+*/
+
+#include "lily-guile.hh"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SCM
+gh_append (SCM a, SCM b)
+{
+ return gh_call2 (gh_eval_str ("append"), a, b);
+}
+
+SCM
+gh_list1 (SCM a)
+{
+ return gh_call1 (gh_eval_str ("list"), a);
+}
+
+SCM
+gh_list2(SCM a, SCM b)
+{
+ return gh_call2 (gh_eval_str ("list"), a, b);
+}
+
+SCM
+gh_quote ()
+{
+ return gh_eval_str ("'quote");
+}
+
+SCM
+gh_eval (SCM a)
+{
+ return gh_call1 (gh_eval_str ("eval"), a);
+}
+
+SCM
+gh_lambda_o ()
+{
+ return gh_eval_str ("'(lambda (o))");
+}
+
+SCM
+gh_func_o (char const* name)
+{
+ char buf[200];
+ snprintf (buf, 200, "'(%s o)", name);
+ return gh_eval_str (buf);
+}
+
+#ifdef __cplusplus
+}
+#endif
#include "paper-def.hh"
#include "string-convert.hh"
#include "main.hh"
+#include "lily-guile.hh"
Lookup::Lookup ()
{
return afm_find (String ("clefs") + String ("-") + st);
}
+Atom
+Lookup::dashed_slur (Array<Offset> controls, Real thick, Real dash) const
+{
+ assert (controls.size () == 8);
+
+ Real dx = controls[3].x () - controls[0].x ();
+ Real dy = controls[3].y () - controls[0].y ();
+
+ Atom a;
+ a.font_ = font_;
+ a.dim_[X_AXIS] = Interval (0, dx);
+ a.dim_[Y_AXIS] = Interval (0 <? dy, 0 >? dy);
+
+#ifndef HAVE_LIBGUILE
+
+ String ps;
+ for (int i = 1; i < 4; i++)
+ ps += String_convert::double_str (controls[i].x ()) + " "
+ + String_convert::double_str (controls[i].y ()) + " ";
+
+ ps += String_convert::double_str (controls[0].x ()) + " "
+ + String_convert::double_str (controls[0].y ()) + " ";
+
+ ps += String_convert::double_str (thick) + " ";
+ Real on = dash > 1? thick * dash - thick : 0;
+ Real off = 2 * thick;
+ ps += "[" + String_convert::double_str (on) + " ";
+ ps += String_convert::double_str (off) + "] ";
+ ps += String_convert::int_str (0) + " ";
+ ps += "draw_dashed_slur ";
+
+ a.str_ = ps;
+
+#else // HAVE_LIBGUILE
+
+ // (lambda (o) (dashed-slur o '((0.1 0.2) (1.1 1.2) (2.1 2.2) (3.1 3.2))))
+ a.lambda_ =
+ gh_append (gh_lambda_o (),
+ gh_list1 (gh_append (gh_func_o ("dashed-slur"),
+ gh_cons (gh_double2scm (thick), gh_cons (gh_double2scm (dash),
+ gh_list1 (gh_list2 (gh_quote (),
+ gh_cons (gh_list2 (gh_double2scm (controls[0].x ()), gh_double2scm (controls[0].y ())),
+ gh_cons (gh_list2 (gh_double2scm (controls[1].x ()), gh_double2scm (controls[1].y ())),
+ gh_cons (gh_list2 (gh_double2scm (controls[2].x ()), gh_double2scm (controls[2].y ())),
+ gh_cons (gh_list2 (gh_double2scm (controls[3].x ()), gh_double2scm (controls[3].y ())),
+ SCM_EOL)))))))))));
+
+#endif // HAVE_LIBGUILE
+
+ return a;
+}
+
Atom
Lookup::dots () const
{
#include <iostream.h>
#include <assert.h>
#include <locale.h>
+#include "lily-guile.hh"
+
#include "proto.hh"
#include "dimensions.hh"
#include "plist.hh"
*mlog << get_version_str () << endl;
}
-void
-guile_init ()
-{
-#ifdef HAVE_LIBGUILE
- gh_eval_str ("(define (add-column p) (display \"adding column (in guile): \") (display p) (newline))");
-#endif
-}
-
-int
+void
main_prog (int argc, char **argv)
{
- guile_init ();
-
// facilitate binary distributions
char const *env_lily = getenv ("LILYPONDPREFIX");
String prefix_directory;
case 't':
experimental_features_global_b = true;
global_lookup_l = &ps_lookup;
+ *mlog << "*** enabling experimental features, you're on your own now ***\n";
break;
case 'o':
outname_str = oparser.optional_argument_ch_C_;
default_outname_base_global = outname_str;
do_one_file (i, default_outname_base_global);
}
+}
+int
+main (int argc, char **argv)
+{
+#ifdef HAVE_LIBGUILE
+ gh_enter (argc, argv, (void(*)())main_prog);
+ return exit_status_i_;
+#else
+ main_prog (argc, argv);
return exit_status_i_;
+#endif
}
/*
return str;
}
-
-#ifdef HAVE_LIBGUILE
-int
-main (int argc, char **argv)
-{
- gh_enter (argc, argv, (void(*)())main_prog);
- return exit_status_i_;
-}
-
-#else
-int main (int argc, char **argv)
-{
- return main_prog (argc, argv);
-}
-
-#endif
{"pt", PT_T},
{"relative", RELATIVE},
{"remove", REMOVE},
+ {"scm", SCHEME},
{"score", SCORE},
{"script", SCRIPT},
{"shape", SHAPE},
}
void
-Paper_outputter::output_molecule (Molecule const*m, Offset o, char const *nm, String s)
+Paper_outputter::output_molecule (Molecule const*m, Offset o, char const *nm, String s, String output_str)
{
if (check_debug)
*outstream_l_ << String ("\n%start: ") << nm << "\n";
a.push (global_lookup_l->print_dimen (a_off.y()));
a.push (global_lookup_l->print_dimen (a_off.x()));
- a.push (i->str_);
+ if (i->lambda_)
+ {
+ SCM str_scm = gh_call1 (gh_eval (i->lambda_), gh_eval_str ("'ps"));
+ char* c = gh_scm2newstr (str_scm, NULL);
+ a.push (String (c));
+ free (c);
+ }
+ else
+ a.push (i->str_);
r += global_lookup_l->substitute_args (s, a);
*outstream_l_ << r;
}
*/
#include <iostream.h>
+#include "lily-guile.hh"
#include "notename-table.hh"
#include "scalar.hh"
#include "translation-property.hh"
%token PT_T
%token RELATIVE
%token REMOVE
+%token SCHEME /* token vs typedef; can't be named SCM */
%token SCORE
%token SCRIPT
%token SHAPE
Midi_def_identifier ($1, MIDI_IDENTIFIER);
THIS->lexer_p_->set_identifier ("$defaultmidi", id)
}
+ | embedded_scm {
+ }
;
+embedded_scm:
+ SCHEME STRING ';' {
+ #ifdef HAVE_LIBGUILE
+ gh_eval_str ($2->ch_C ());
+ #endif
+ delete $2;
+ };
+
check_version:
VERSION STRING ';' {
Mudela_version ver (*$2);
return to_str (i, "(\\%03o)");
}
-Atom
-Ps_lookup::dashed_slur (Array<Offset> controls, Real thick, Real dash) const
-{
- assert (controls.size () == 8);
-
- String ps;
-
- Real dx = controls[3].x () - controls[0].x ();
- Real dy = controls[3].y () - controls[0].y ();
-
- for (int i = 1; i < 4; i++)
- ps += String_convert::double_str (controls[i].x ()) + " "
- + String_convert::double_str (controls[i].y ()) + " ";
-
- ps += String_convert::double_str (controls[0].x ()) + " "
- + String_convert::double_str (controls[0].y ()) + " ";
-
- ps += String_convert::double_str (thick) + " ";
- Real on = dash > 1? thick * dash - thick : 0;
- Real off = 2 * thick;
- ps += "[" + String_convert::double_str (on) + " ";
- ps += String_convert::double_str (off) + "] ";
- ps += String_convert::int_str (0) + " ";
- ps += "draw_dashed_slur ";
-
- Atom a;
- a.str_ = ps;
-
- a.dim_[X_AXIS] = Interval (0, dx);
- a.dim_[Y_AXIS] = Interval (0 <? dy, 0 >? dy);
- a.font_ = font_;
- return a;
-}
-
Atom
Ps_lookup::hairpin (Real width, bool decresc, bool continued) const
{
#include "array.hh"
#include "string-convert.hh"
#include "debug.hh"
+#include "lookup.hh"
+#include "main.hh"
Ps_outputter::Ps_outputter (Paper_stream *s)
:Paper_outputter (s)
if (check_debug)
*outstream_l_ << String ("\n%start: ") << nm << "\n";
- Paper_outputter::output_molecule (m, o, nm, "% % {%}placebox \n");
+ Paper_outputter::output_molecule (m, o, nm, "% % {%}placebox \n", "'ps");
}
void
Score_element_info::Score_element_info (Score_element*s_l, Request*r_l)
{
elem_l_ = s_l;
+ lisp_l_ = 0;
+ req_l_ = r_l;
+}
+
+Score_element_info::Score_element_info (Graphical_lisp_element*g_l, Request*r_l)
+{
+ elem_l_ = 0;
+ lisp_l_ = g_l;
req_l_ = r_l;
}
Score_element_info::Score_element_info()
{
elem_l_ = 0;
+ lisp_l_ = 0;
req_l_ = 0;
}
#include "score-column.hh"
#include "command-request.hh"
#include "paper-def.hh"
+#include "graphical-lisp-element.hh"
Score_engraver::Score_engraver()
void
Score_engraver::typeset_element (Score_element *elem_p)
{
- elem_p_arr_.push(elem_p);
+ elem_p_arr_.push (elem_p);
+}
+
+void
+Score_engraver::typeset_element (Graphical_lisp_element* elem_p)
+{
+ *mlog << "not typesetting: " << elem_p->static_name () << "\n";
+ delete elem_p;
}
void
Spanner *s = elem_p->access_Spanner ();
pscore_p_->typeset_unbroken_spanner (s);
-
-
- /*
+ /*
do something sensible if spanner not
spanned on 2 items.
*/
}
-
Music_output*
Score_engraver::get_output_p ()
{
return Lookup::character_str (i);
}
-Atom
-Tex_lookup::dashed_slur (Array<Offset> controls, Real thick, Real dash) const
-{
- return embed (Ps_lookup::dashed_slur (controls, thick, dash));
-}
-
Atom
Tex_lookup::embed (Atom a) const
{
if (check_debug)
*outstream_l_ << String ("\n%start: ") << nm << "\n";
- Paper_outputter::output_molecule (m, o, nm, "\\placebox{%}{%}{%}");
+ Paper_outputter::output_molecule (m, o, nm, "\\placebox{%}{%}{%}", "'tex");
}
void
1.0.15
1.0.15.uu1
1.0.16
+1.0.16.jcn1
projects / lilypond.git / commitdiff