#define INFINITY_MSG "Infinity or NaN encountered"
-Grob::Grob(SCM basicprops)
+Grob::Grob (SCM basicprops)
{
/*
fixme: default should be no callback.
*/
pscore_l_=0;
- status_i_ = 0;
+ status_c_ = 0;
original_l_ = 0;
immutable_property_alist_ = basicprops;
mutable_property_alist_ = SCM_EOL;
smobify_self ();
+ /*
+ TODO:
+
+ destill this into a function, so we can re-init the immutable
+ properties with a new BASICPROPS value after creation. Convenient
+ eg. when using \override with StaffSymbol. */
+
char const*onames[] = {"X-offset-callbacks", "Y-offset-callbacks"};
char const*enames[] = {"X-extent-callback", "Y-extent-callback"};
- for (int a = X_AXIS; a <= Y_AXIS; a++){
- SCM l = get_grob_property (onames[a]);
-
- if (scm_ilength (l) >=0)
- {
- dim_cache_[a].offset_callbacks_ = l;
- dim_cache_[a].offsets_left_ = scm_ilength (l);
- }
- else
- {
- programming_error ("[XY]-offset-callbacks must be a list");
- }
-
- SCM cb = get_grob_property (enames[a]);
-
- /*
- Should change default to be empty?
- */
- if (cb != SCM_BOOL_F && !gh_procedure_p (cb) && !gh_pair_p (cb))
- cb = molecule_extent_proc;
+ for (int a = X_AXIS; a <= Y_AXIS; a++)
+ {
+ SCM l = get_grob_property (onames[a]);
+
+ if (scm_ilength (l) >=0)
+ {
+ dim_cache_[a].offset_callbacks_ = l;
+ dim_cache_[a].offsets_left_ = scm_ilength (l);
+ }
+ else
+ {
+ programming_error ("[XY]-offset-callbacks must be a list");
+ }
+
+ SCM cb = get_grob_property (enames[a]);
+
+ /*
+ Should change default to be empty?
+ */
+ if (cb != SCM_BOOL_F && !gh_procedure_p (cb) && !gh_pair_p (cb))
+ cb = molecule_extent_proc;
- dim_cache_[a].dimension_ = cb;
- }
+ dim_cache_[a].dimension_ = cb;
+ }
SCM meta = get_grob_property ("meta");
- SCM ifs = scm_assoc (ly_symbol2scm ("interfaces"), meta);
+ if (gh_pair_p (meta))
+ {
+ SCM ifs = scm_assoc (ly_symbol2scm ("interfaces"), meta);
- set_grob_property ("interfaces",gh_cdr (ifs));
+ set_grob_property ("interfaces",ly_cdr (ifs));
+ }
}
-
Grob::Grob (Grob const&s)
: dim_cache_ (s.dim_cache_)
{
- original_l_ =(Grob*) &s;
+ original_l_ = (Grob*) &s;
immutable_property_alist_ = s.immutable_property_alist_;
mutable_property_alist_ = SCM_EOL;
- status_i_ = s.status_i_;
+ status_c_ = s.status_c_;
pscore_l_ = s.pscore_l_;
smobify_self ();
}
-Grob::~Grob()
+Grob::~Grob ()
{
/*
do nothing scm-ish and no unprotecting here.
SCM
Grob::get_grob_property (SCM sym) const
{
- SCM s = scm_sloppy_assq(sym, mutable_property_alist_);
+ SCM s = scm_sloppy_assq (sym, mutable_property_alist_);
if (s != SCM_BOOL_F)
- return gh_cdr (s);
+ return ly_cdr (s);
s = scm_sloppy_assq (sym, immutable_property_alist_);
- return (s == SCM_BOOL_F) ? SCM_EOL : gh_cdr (s);
+ return (s == SCM_BOOL_F) ? SCM_EOL : ly_cdr (s);
}
/*
Remove the value associated with KEY, and return it. The result is
- that a next call will yield SCM_UNDEFINED (and not the underlying
+ that a next call will yield SCM_EOL (and not the underlying
`basic' property.
*/
SCM
/*
Puts the k, v in the immutable_property_alist_, which is convenient for
storing variables that are needed during the breaking process. (eg.
- Line_of_score::rank : int )
+ Line_of_score::rank : int)
*/
void
Grob::set_immutable_grob_property (const char*k, SCM v)
}
-MAKE_SCHEME_CALLBACK(Grob,molecule_extent,2);
+MAKE_SCHEME_CALLBACK (Grob,molecule_extent,2);
SCM
Grob::molecule_extent (SCM element_smob, SCM scm_axis)
{
Molecule *m = s->get_molecule ();
Interval e ;
if (m)
- e = m->extent(a);
- return ly_interval2scm ( e);
+ e = m->extent (a);
+ return ly_interval2scm (e);
}
-MAKE_SCHEME_CALLBACK(Grob,preset_extent,2);
+MAKE_SCHEME_CALLBACK (Grob,preset_extent,2);
SCM
Grob::preset_extent (SCM element_smob, SCM scm_axis)
if (gh_pair_p (ext))
{
- Real l = gh_scm2double (gh_car (ext));
- Real r = gh_scm2double (gh_cdr (ext));
+ Real l = gh_scm2double (ly_car (ext));
+ Real r = gh_scm2double (ly_cdr (ext));
return ly_interval2scm (Interval (l, r));
}
- return ly_interval2scm ( Interval ());
+ return ly_interval2scm (Interval ());
}
void
Grob::calculate_dependencies (int final, int busy, SCM funcname)
{
- assert (status_i_ >=0);
-
- if (status_i_ >= final)
+ if (status_c_ >= final)
return;
- if (status_i_== busy)
+ if (status_c_== busy)
{
programming_error ("Element is busy, come back later");
return;
}
- status_i_= busy;
+ status_c_= busy;
- for (SCM d= get_grob_property ("dependencies"); gh_pair_p (d); d = gh_cdr (d))
+ for (SCM d= get_grob_property ("dependencies"); gh_pair_p (d); d = ly_cdr (d))
{
- unsmob_grob (gh_car (d))
+ unsmob_grob (ly_car (d))
->calculate_dependencies (final, busy, funcname);
}
// ughugh.
String s = ly_symbol2string (funcname);
- SCM proc = get_grob_property (s.ch_C());
+ SCM proc = get_grob_property (s.ch_C ());
if (gh_procedure_p (proc))
gh_call1 (proc, this->self_scm ());
- status_i_= final;
+ status_c_= final;
}
SCM mol = SCM_EOL;
if (gh_procedure_p (proc))
- mol = gh_apply (proc, gh_list (this->self_scm (), SCM_UNDEFINED));
+ mol = gh_apply (proc, scm_list_n (this->self_scm (), SCM_UNDEFINED));
Molecule *m = unsmob_molecule (mol);
// ugr.
mol = Molecule (m->extent_box (),
- gh_list (origin, m->get_expr (), SCM_UNDEFINED)
+ scm_list_n (origin, m->get_expr (), SCM_UNDEFINED)
). smobbed_copy ();
m = unsmob_molecule (mol);
}
-
-
/*
transparent retains dimensions of element.
*/
void
-Grob::do_break_processing()
+Grob::do_break_processing ()
{
}
Line_of_score *
-Grob::line_l() const
+Grob::line_l () const
{
return 0;
}
Do break substitution in S, using CRITERION. Return new value.
CRITERION is either a SMOB pointer to the desired line, or a number
representing the break direction. Do not modify SRC.
+
+ It is rather tightly coded, since it takes a lot of time.
*/
SCM
-Grob::handle_broken_smobs (SCM src, SCM criterion)
+Grob::handle_broken_grobs (SCM src, SCM criterion)
{
again:
Grob *sc = unsmob_grob (src);
if (i && i->break_status_dir () != d)
{
Item *br = i->find_prebroken_piece (d);
- return (br) ? br->self_scm () : SCM_UNDEFINED;
+ return (br) ? br->self_scm () : SCM_UNDEFINED;
}
}
else
/* now: sc && sc->line_l () == line */
if (!line
+ /*
+ This was introduced in 1.3.49 as a measure to prevent
+ programming errors. It looks expensive (?). TODO:
+ benchmark , document when (what kind of programming
+ errors) this happens.
+ */
|| (sc->common_refpoint (line, X_AXIS)
&& sc->common_refpoint (line, Y_AXIS)))
{
}
else if (gh_pair_p (src))
{
- SCM oldcar =gh_car (src);
+ SCM oldcar =ly_car (src);
/*
UGH! breaks on circular lists.
*/
- SCM newcar = handle_broken_smobs (oldcar, criterion);
- SCM oldcdr = gh_cdr (src);
+ SCM newcar = handle_broken_grobs (oldcar, criterion);
+ SCM oldcdr = ly_cdr (src);
if (newcar == SCM_UNDEFINED
&& (gh_pair_p (oldcdr) || oldcdr == SCM_EOL))
/*
This is tail-recursion, ie.
- return handle_broken_smobs (cdr, criterion);
+ return handle_broken_grobs (cdr, criterion);
We don't want to rely on the compiler to do this. Without
tail-recursion, this easily crashes with a stack overflow. */
goto again;
}
- SCM newcdr = handle_broken_smobs (oldcdr, criterion);
+ SCM newcdr = handle_broken_grobs (oldcdr, criterion);
return gh_cons (newcar, newcdr);
}
else
}
void
-Grob::handle_broken_dependencies()
+Grob::handle_broken_dependencies ()
{
Spanner * s= dynamic_cast<Spanner*> (this);
if (original_l_ && s)
Grob * sc = s->broken_into_l_arr_[i];
Line_of_score * l = sc->line_l ();
sc->mutable_property_alist_ =
- handle_broken_smobs (mutable_property_alist_,
+ handle_broken_grobs (mutable_property_alist_,
l ? l->self_scm () : SCM_UNDEFINED);
}
}
- Line_of_score *line = line_l();
+ Line_of_score *line = line_l ();
if (line && common_refpoint (line, X_AXIS) && common_refpoint (line, Y_AXIS))
{
mutable_property_alist_
- = handle_broken_smobs (mutable_property_alist_,
+ = handle_broken_grobs (mutable_property_alist_,
line ? line->self_scm () : SCM_UNDEFINED);
}
else if (dynamic_cast <Line_of_score*> (this))
{
- mutable_property_alist_ = handle_broken_smobs (mutable_property_alist_,
+ mutable_property_alist_ = handle_broken_grobs (mutable_property_alist_,
SCM_UNDEFINED);
}
else
do not do this for Line_of_score, since that would remove
references to the originals of score-elts, which get then GC'd
- (a bad thing.)
+ (a bad thing.)
*/
- suicide();
+ suicide ();
}
}
}
void
-Grob::handle_prebroken_dependencies()
+Grob::handle_prebroken_dependencies ()
{
}
Grob::translate_axis (Real y, Axis a)
{
if (isinf (y) || isnan (y))
- programming_error (_(INFINITY_MSG));
+ programming_error (_ (INFINITY_MSG));
else
{
dim_cache_[a].offset_ += y;
}
-MAKE_SCHEME_CALLBACK(Grob,point_dimension_callback,2);
+MAKE_SCHEME_CALLBACK (Grob,point_dimension_callback,2);
SCM
-Grob::point_dimension_callback (SCM , SCM )
+Grob::point_dimension_callback (SCM , SCM)
{
- return ly_interval2scm ( Interval (0,0));
+ return ly_interval2scm (Interval (0,0));
}
bool
Grob::empty_b (Axis a)const
{
- return ! (gh_pair_p (dim_cache_[a].dimension_ ) ||
- gh_procedure_p (dim_cache_[a].dimension_ ));
+ return ! (gh_pair_p (dim_cache_[a].dimension_) ||
+ gh_procedure_p (dim_cache_[a].dimension_));
}
/*
/*
FIXME: add doco on types, and should typecheck maybe?
*/
- d->dimension_= gh_call2 (d->dimension_, self_scm(), gh_int2scm (a));
+ d->dimension_= gh_call2 (d->dimension_, self_scm (), gh_int2scm (a));
}
else
return ext;
*/
if (gh_pair_p (extra))
{
- ext[BIGGER] += gh_scm2double (gh_cdr (extra));
- ext[SMALLER] += gh_scm2double (gh_car (extra));
+ ext[BIGGER] += gh_scm2double (ly_cdr (extra));
+ ext[SMALLER] += gh_scm2double (ly_car (extra));
}
extra = get_grob_property (a == X_AXIS
: "minimum-extent-Y");
if (gh_pair_p (extra))
{
- ext.unite (Interval (gh_scm2double (gh_car (extra)),
- gh_scm2double (gh_cdr (extra))));
+ ext.unite (Interval (gh_scm2double (ly_car (extra)),
+ gh_scm2double (ly_cdr (extra))));
}
ext.translate (x);
Grob::common_refpoint (SCM elist, Axis a) const
{
Grob * common = (Grob*) this;
- for (; gh_pair_p (elist); elist = gh_cdr (elist))
+ for (; gh_pair_p (elist); elist = ly_cdr (elist))
{
- Grob * s = unsmob_grob (gh_car (elist));
+ Grob * s = unsmob_grob (ly_car (elist));
if (s)
common = common->common_refpoint (s, a);
}
{
SCM meta = get_grob_property ("meta");
SCM nm = scm_assoc (ly_symbol2scm ("name"), meta);
- nm = (gh_pair_p (nm)) ? gh_cdr (nm) : SCM_EOL;
- return gh_string_p (nm) ?ly_scm2string (nm) : classname (this);
+ nm = (gh_pair_p (nm)) ? ly_cdr (nm) : SCM_EOL;
+ return gh_symbol_p (nm) ? ly_symbol2string (nm) : classname (this);
}
void
{
if (!has_offset_callback_b (cb, a))
{
- dim_cache_[a].offset_callbacks_ = gh_cons (cb, dim_cache_[a].offset_callbacks_ );
+ dim_cache_[a].offset_callbacks_ = gh_cons (cb, dim_cache_[a].offset_callbacks_);
dim_cache_[a].offsets_left_ ++;
}
}
dim_cache_[a].parent_l_ = g;
}
-MAKE_SCHEME_CALLBACK(Grob,fixup_refpoint,1);
+MAKE_SCHEME_CALLBACK (Grob,fixup_refpoint,1);
SCM
Grob::fixup_refpoint (SCM smob)
{
if (parenti && i)
{
Direction my_dir = i->break_status_dir () ;
- if (my_dir!= parenti->break_status_dir())
+ if (my_dir!= parenti->break_status_dir ())
{
Item *newparent = parenti->find_prebroken_piece (my_dir);
me->set_parent (newparent, ax);
****************************************************/
-IMPLEMENT_UNSMOB(Grob, grob);
-IMPLEMENT_SMOBS(Grob);
-IMPLEMENT_DEFAULT_EQUAL_P(Grob);
+
+IMPLEMENT_SMOBS (Grob);
+IMPLEMENT_DEFAULT_EQUAL_P (Grob);
SCM
Grob::mark_smob (SCM ses)
{
- Grob * s = (Grob*) SCM_CELL_WORD_1(ses);
+ Grob * s = (Grob*) SCM_CELL_WORD_1 (ses);
scm_gc_mark (s->immutable_property_alist_);
scm_gc_mark (s->mutable_property_alist_);
int
Grob::print_smob (SCM s, SCM port, scm_print_state *)
{
- Grob *sc = (Grob *) gh_cdr (s);
+ Grob *sc = (Grob *) ly_cdr (s);
scm_puts ("#<Grob ", port);
- scm_puts ((char *)sc->name ().ch_C(), port);
+ scm_puts ((char *)sc->name ().ch_C (), port);
/*
don't try to print properties, that is too much hassle.
void
-Grob::discretionary_processing()
+Grob::discretionary_processing ()
{
}
{
interfaces_sym = scm_permanent_object (ly_symbol2scm ("interfaces"));
- scm_make_gsubr ("ly-get-elt-property", 2, 0, 0, (Scheme_function_unknown)ly_get_grob_property);
- scm_make_gsubr ("ly-set-elt-property", 3, 0, 0, (Scheme_function_unknown)ly_set_grob_property);
- scm_make_gsubr ("ly-get-spanner-bound", 2 , 0, 0, (Scheme_function_unknown) spanner_get_bound);
+ scm_c_define_gsubr ("ly-get-grob-property", 2, 0, 0,
+ (Scheme_function_unknown)ly_get_grob_property);
+ scm_c_define_gsubr ("ly-set-grob-property", 3, 0, 0,
+ (Scheme_function_unknown)ly_set_grob_property);
+ scm_c_define_gsubr ("ly-get-spanner-bound", 2 , 0, 0,
+ (Scheme_function_unknown) spanner_get_bound);
}
bool
else
{
set_grob_property (interfaces_sym,
- gh_cons (k, get_grob_property (interfaces_sym)));
+ gh_cons (k, get_grob_property (interfaces_sym)));
}
}
-ADD_SCM_INIT_FUNC(scoreelt, init_functions);
-IMPLEMENT_TYPE_P(Grob, "ly-grob?");
+ADD_SCM_INIT_FUNC (scoreelt, init_functions);
+IMPLEMENT_TYPE_P (Grob, "ly-grob?");
projects / lilypond.git / blobdiff