*/
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_)
{
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 ();
{
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
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));
}
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);
}
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.
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);
/* 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
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);
}
}
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
*/
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
****************************************************/
-IMPLEMENT_UNSMOB (Grob, grob);
+
IMPLEMENT_SMOBS (Grob);
IMPLEMENT_DEFAULT_EQUAL_P (Grob);
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);
{
interfaces_sym = scm_permanent_object (ly_symbol2scm ("interfaces"));
- scm_make_gsubr ("ly-get-grob-property", 2, 0, 0, (Scheme_function_unknown)ly_get_grob_property);
- scm_make_gsubr ("ly-set-grob-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