}
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_)
{
SCM
-Grob::get_grob_property (const char *nm) const
-{
- SCM sym = ly_symbol2scm (nm);
- return get_grob_property (sym);
-}
-
-SCM
-Grob::get_grob_property (SCM sym) const
+Grob::internal_get_grob_property (SCM sym) const
{
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
return val;
}
-void
-Grob::set_grob_property (const char* k, SCM v)
-{
- SCM s = ly_symbol2scm (k);
- set_grob_property (s, v);
-}
+#if 0
/*
Puts the k, v in the immutable_property_alist_, which is convenient for
storing variables that are needed during the breaking process. (eg.
immutable_property_alist_ = gh_cons (gh_cons (s,v), mutable_property_alist_);
mutable_property_alist_ = scm_assq_remove_x (mutable_property_alist_, s);
}
+#endif
+
+
void
-Grob::set_grob_property (SCM s, SCM v)
+Grob::internal_set_grob_property (SCM s, SCM v)
{
mutable_property_alist_ = scm_assq_set_x (mutable_property_alist_, s, v);
}
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));
}
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);
}
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);
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; it is
+ one of the top functions in the profile.
+
*/
SCM
Grob::handle_broken_grobs (SCM src, SCM criterion)
Grob *sc = unsmob_grob (src);
if (sc)
{
- if (gh_number_p (criterion))
+ if (SCM_INUMP (criterion))
{
Item * i = dynamic_cast<Item*> (sc);
Direction d = to_dir (criterion);
return SCM_UNDEFINED;
/* now: sc && sc->line_l () == line */
- if (!line
- || (sc->common_refpoint (line, X_AXIS)
- && sc->common_refpoint (line, Y_AXIS)))
+ if (!line)
+ return sc->self_scm();
+ /*
+ 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.
+ */
+ if (sc->common_refpoint (line, X_AXIS)
+ && sc->common_refpoint (line, Y_AXIS))
{
return sc->self_scm ();
}
return SCM_UNDEFINED;
}
}
- else if (gh_pair_p (src))
+ else if (SCM_CONSP (src))
{
- SCM oldcar =gh_car (src);
+ SCM oldcar =ly_car (src);
/*
UGH! breaks on circular lists.
*/
SCM newcar = handle_broken_grobs (oldcar, criterion);
- SCM oldcdr = gh_cdr (src);
+ SCM oldcdr = ly_cdr (src);
if (newcar == SCM_UNDEFINED
&& (gh_pair_p (oldcdr) || oldcdr == SCM_EOL))
}
SCM newcdr = handle_broken_grobs (oldcdr, criterion);
- return gh_cons (newcar, newcdr);
+ return scm_cons (newcar, newcdr);
}
else
return src;
*/
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);
return ext;
}
-
-Grob*
-Grob::parent_l (Axis a) const
-{
- return dim_cache_[a].parent_l_;
-}
-
Grob *
Grob::common_refpoint (Grob const* s, Axis a) const
{
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);
{
scm_gc_mark (s->dim_cache_[a].offset_callbacks_);
scm_gc_mark (s->dim_cache_[a].dimension_);
+ Grob *p = s->parent_l (Y_AXIS);
+ if (p)
+ scm_gc_mark (p->self_scm ());
}
- if (s->parent_l (Y_AXIS))
- scm_gc_mark (s->parent_l (Y_AXIS)->self_scm ());
- if (s->parent_l (X_AXIS))
- scm_gc_mark (s->parent_l (X_AXIS)->self_scm ());
-
if (s->original_l_)
scm_gc_mark (s->original_l_->self_scm ());
+
return s->do_derived_mark ();
}
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);
if (sc)
{
- sc->set_grob_property (sym, val);
+ sc->internal_set_grob_property (sym, val);
}
else
{
if (sc)
{
- return sc->get_grob_property (sym);
+ return sc->internal_get_grob_property (sym);
}
else
{
-static SCM interfaces_sym;
+
static void
init_functions ()
{
- interfaces_sym = scm_permanent_object (ly_symbol2scm ("interfaces"));
-
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,
bool
Grob::has_interface (SCM k)
{
- SCM ifs = get_grob_property (interfaces_sym);
+ SCM ifs = get_grob_property ("interfaces");
return scm_memq (k, ifs) != SCM_BOOL_F;
}
return ;
else
{
- set_grob_property (interfaces_sym,
- gh_cons (k, get_grob_property (interfaces_sym)));
+ set_grob_property ("interfaces",
+ gh_cons (k, get_grob_property ("interfaces")));
}
}
projects / lilypond.git / blobdiff