Refactor get/set_property to take the item as first argument

lily/beam.cc

 /*
   This file is part of LilyPond, the GNU music typesetter.
 
   Copyright (C) 1997--2020 Han-Wen Nienhuys <hanwen@xs4all.nl>
   Jan Nieuwenhuizen <janneke@gnu.org>
 
   LilyPond is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
@@ skipping 99 matching lines @@
 void
 Beam::add_stem (Grob *me, Grob *s)
 {
   if (Stem::get_beam (s))
     {
       programming_error ("Stem already has beam");
       return;
     }
 
   Pointer_group_interface::add_grob (me, ly_symbol2scm ("stems"), s);
-  s->set_object ("beam", me->self_scm ());
+  set_object (s, "beam", me->self_scm ());
   add_bound_item (dynamic_cast<Spanner *> (me), dynamic_cast<Item *> (s));
 }
 
 Real
 Beam::get_beam_thickness (Grob *me)
 {
-  return robust_scm2double (me->get_property ("beam-thickness"), 0)
+  return robust_scm2double (get_property (me, "beam-thickness"), 0)
          * Staff_symbol_referencer::staff_space (me);
 }
 
 /* Return the translation between 2 adjoining beams. */
 Real
 Beam::get_beam_translation (Grob *me)
 {
   int beam_count = get_beam_count (me);
   Real staff_space = Staff_symbol_referencer::staff_space (me);
   Real line = Staff_symbol_referencer::line_thickness (me);
   Real beam_thickness = get_beam_thickness (me);
-  Real fract = robust_scm2double (me->get_property ("length-fraction"), 1.0);
+  Real fract = robust_scm2double (get_property (me, "length-fraction"), 1.0);
 
   /*
     if fract != 1.0, as is the case for grace notes, we want the gap
     to decrease too. To achieve this, we divide the thickness by
     fract */
   return (beam_count < 4
           ? (2 * staff_space * fract + line * fract - beam_thickness) / 2.0
           : (3 * staff_space * fract + line * fract - beam_thickness) / 3.0);
 }
 
@@ skipping 57 matching lines @@
       else
         {
           Grob *stem = first_normal_stem (me);
 
           /*
             This happens for chord tremolos.
           */
           if (!stem)
             stem = stems[0];
 
-          if (is_direction (stem->get_property_data ("direction")))
-            dir = to_dir (stem->get_property_data ("direction"));
+          if (is_direction (get_property_data (stem, "direction")))
+            dir = to_dir (get_property_data (stem, "direction"));
           else
-            dir = to_dir (stem->get_property ("default-direction"));
+            dir = to_dir (get_property (stem, "default-direction"));
 
           extract_grob_set (stem, "note-heads", heads);
           /* default position of Kievan heads with beams is down
              placing this here avoids warnings downstream */
           if (heads.size ())
             {
-              if (scm_is_eq (heads[0]->get_property ("style"),
+              if (scm_is_eq (get_property (heads[0], "style"),
                              ly_symbol2scm ("kievan")))
                 {
                   if (dir == CENTER)
                     dir = DOWN;
                 }
             }
         }
     }
 
   if (count >= 1)
@@ skipping 63 matching lines @@
   extract_grob_set (me, "stems", stems);
 
   Slice last_int;
   last_int.set_empty ();
 
   SCM last_beaming = scm_cons (SCM_EOL, scm_list_1 (scm_from_int (0)));
   Direction last_dir = CENTER;
   for (vsize i = 0; i < stems.size (); i++)
     {
       Grob *this_stem = stems[i];
-      SCM this_beaming = this_stem->get_property ("beaming");
+      SCM this_beaming = get_property (this_stem, "beaming");
 
       Direction this_dir = get_grob_direction (this_stem);
       if (scm_is_pair (last_beaming) && scm_is_pair (this_beaming))
         {
           int start_point = position_with_maximal_common_beams
                             (last_beaming, this_beaming,
                              last_dir ? last_dir : this_dir,
                              this_dir);
 
           Slice new_slice;
@@ skipping 47 matching lines @@
 
 typedef map<int, vector<Beam_stem_segment> > Position_stem_segments_map;
 
 MAKE_SCHEME_CALLBACK (Beam, calc_beam_segments, 1);
 SCM
 Beam::calc_beam_segments (SCM smob)
 {
   /* ugh, this has a side-effect that we need to ensure that
      Stem.beaming is correct */
   Grob *me_grob = unsmob<Grob> (smob);
-  (void) me_grob->get_property ("beaming");
+  (void) get_property (me_grob, "beaming");
 
   Spanner *me = dynamic_cast<Spanner *> (me_grob);
 
   extract_grob_set (me, "stems", stems);
 
   Grob *commonx = common_refpoint_of_array (stems, me, X_AXIS);
   for (LEFT_and_RIGHT (d))
     commonx = me->get_bound (d)->common_refpoint (commonx, X_AXIS);
 
-  int gap_count = robust_scm2int (me->get_property ("gap-count"), 0);
-  Real gap_length = robust_scm2double (me->get_property ("gap"), 0.0);
+  int gap_count = robust_scm2int (get_property (me, "gap-count"), 0);
+  Real gap_length = robust_scm2double (get_property (me, "gap"), 0.0);
 
   Position_stem_segments_map stem_segments;
   Real lt = Staff_symbol_referencer::line_thickness (me);
 
   /* There are two concepts of "rank" that are used in the following code.
      The beam_rank is the vertical position of the beam (larger numbers are
      closer to the noteheads). Beam_stem_segment.rank_, on the other hand,
      is the horizontal position of the segment (this is incremented by two
      for each stem; the beam segment on the right side of the stem has
      a higher rank (by one) than its neighbour to the left). */
   Slice ranks;
   for (vsize i = 0; i < stems.size (); i++)
     {
       Grob *stem = stems[i];
-      Real stem_width = robust_scm2double (stem->get_property ("thickness"), 1.0) * lt;
+      Real stem_width = robust_scm2double (get_property (stem, "thickness"), 1.0) * lt;
       Real stem_x = stem->relative_coordinate (commonx, X_AXIS);
-      SCM beaming = stem->get_property ("beaming");
+      SCM beaming = get_property (stem, "beaming");
 
       for (LEFT_and_RIGHT (d))
         {
           // Find the maximum and minimum beam ranks.
           // Given that RANKS is never reset to empty, the interval will always be
           // smallest for the left beamlet of the first stem, and then it might grow.
           // Do we really want this? (It only affects the tremolo gaps) --jneem
           for (SCM s = index_get_cell (beaming, d);
                scm_is_pair (s); s = scm_cdr (s))
             {
@@ skipping 11 matching lines @@
                 continue;
 
               int beam_rank = scm_to_int (scm_car (s));
               Beam_stem_segment seg;
               seg.stem_ = stem;
               seg.stem_x_ = stem_x;
               seg.rank_ = 2 * i + (d + 1) / 2;
               seg.width_ = stem_width;
               seg.stem_index_ = i;
               seg.dir_ = d;
-              seg.max_connect_ = robust_scm2int (stem->get_property ("max-beam-connect"), 1000);
+              seg.max_connect_ = robust_scm2int (get_property (stem, "max-beam-connect"), 1000);
 
               Direction stem_dir = get_grob_direction (stem);
 
               seg.gapped_
                 = (stem_dir * beam_rank < (stem_dir * ranks[-stem_dir] + gap_count));
               stem_segments[beam_rank].push_back (seg);
             }
         }
     }
 
   Drul_array<Real> break_overshoot
-    = robust_scm2drul (me->get_property ("break-overshoot"),
+    = robust_scm2drul (get_property (me, "break-overshoot"),
                        Drul_array<Real> (-0.5, 0.0));
 
   vector<Beam_segment> segments;
   for (Position_stem_segments_map::const_iterator i (stem_segments.begin ());
        i != stem_segments.end (); i++)
     {
       vector<Beam_stem_segment> segs = (*i).second;
       vector_sort (segs, std::less<Beam_stem_segment> ());
 
       Beam_segment current;
@@ skipping 51 matching lines @@
                     {
                       current.horizontal_[event_dir]
                         = (Axis_group_interface::generic_bound_extent (me->get_bound (event_dir),
                                                                        commonx, X_AXIS)[RIGHT]
                            + event_dir * break_overshoot[event_dir]);
                     }
                   else
                     {
                       Grob *stem = stems[seg.stem_index_];
                       Drul_array<Real> beamlet_length
-                        = robust_scm2interval (stem->get_property ("beamlet-default-length"), Interval (1.1, 1.1));
+                        = robust_scm2interval (get_property (stem, "beamlet-default-length"), Interval (1.1, 1.1));
                       Drul_array<Real> max_proportion
-                        = robust_scm2interval (stem->get_property ("beamlet-max-length-proportion"), Interval (0.75, 0.75));
+                        = robust_scm2interval (get_property (stem, "beamlet-max-length-proportion"), Interval (0.75, 0.75));
                       Real length = beamlet_length[seg.dir_];
 
                       if (inside_stem)
                         {
                           Grob *neighbor_stem = stems[seg.stem_index_ + event_dir];
                           Real neighbor_stem_x = neighbor_stem->relative_coordinate (commonx, X_AXIS);
 
                           length = std::min (length,
                                              fabs (neighbor_stem_x - seg.stem_x_) * max_proportion[seg.dir_]);
                         }
@@ skipping 50 matching lines @@
     }
 
   return segments_scm;
 }
 
 MAKE_SCHEME_CALLBACK (Beam, calc_x_positions, 1);
 SCM
 Beam::calc_x_positions (SCM smob)
 {
   Spanner *me = unsmob<Spanner> (smob);
-  SCM segments = me->get_property ("beam-segments");
+  SCM segments = get_property (me, "beam-segments");
   Interval x_positions;
   x_positions.set_empty ();
   for (SCM s = segments; scm_is_pair (s); s = scm_cdr (s))
     x_positions.unite (robust_scm2interval (ly_assoc_get (ly_symbol2scm ("horizontal"),
                                                           scm_car (s),
                                                           SCM_EOL),
                                             Interval (0.0, 0.0)));
 
   // Case for beams without segments (i.e. uniting two skips with a beam)
   // TODO: should issue a warning?  warning likely issued downstream, but couldn't hurt...
   if (x_positions.is_empty ())
     {
       extract_grob_set (me, "stems", stems);
       Grob *common_x = common_refpoint_of_array (stems, me, X_AXIS);
       for (LEFT_and_RIGHT (d))
         x_positions[d] = me->relative_coordinate (common_x, X_AXIS);
     }
   return ly_interval2scm (x_positions);
 }
 
 vector<Beam_segment>
 Beam::get_beam_segments (Grob *me)
 {
-  SCM segments_scm = me->get_property ("beam-segments");
+  SCM segments_scm = get_property (me, "beam-segments");
   vector<Beam_segment> segments;
   for (SCM s = segments_scm; scm_is_pair (s); s = scm_cdr (s))
     {
       segments.push_back (Beam_segment ());
       segments.back ().vertical_count_ = robust_scm2int (ly_assoc_get (ly_symbol2scm ("vertical-count"), scm_car (s), SCM_EOL), 0);
       segments.back ().horizontal_ = robust_scm2interval (ly_assoc_get (ly_symbol2scm ("horizontal"), scm_car (s), SCM_EOL), Interval (0.0, 0.0));
     }
 
   return segments;
 }
@@ skipping 16 matching lines @@
   for (LEFT_and_RIGHT (d))
     commonx = me->get_bound (d)->common_refpoint (commonx, X_AXIS);
 
   vector<Beam_segment> segments = get_beam_segments (me);
 
   if (!segments.size ())
     return SCM_EOL;
 
   Real blot = me->layout ()->get_dimension (ly_symbol2scm ("blot-diameter"));
 
-  SCM posns = me->get_property ("quantized-positions");
-  Interval span = robust_scm2interval (me->get_property ("X-positions"), Interval (0, 0));
+  SCM posns = get_property (me, "quantized-positions");
+  Interval span = robust_scm2interval (get_property (me, "X-positions"), Interval (0, 0));
   Interval pos;
   if (!is_number_pair (posns))
     {
       programming_error ("no beam positions?");
       pos = Interval (0, 0);
     }
   else
     pos = ly_scm2realdrul (posns);
 
   scale_drul (&pos, Staff_symbol_referencer::staff_space (me));
 
   Real dy = pos[RIGHT] - pos[LEFT];
   Real slope = (dy && span.length ()) ? dy / span.length () : 0;
 
   Real beam_thickness = get_beam_thickness (me);
   Real beam_dy = get_beam_translation (me);
 
-  Direction feather_dir = to_dir (me->get_property ("grow-direction"));
-
-  Interval placements = robust_scm2interval (me->get_property ("normalized-endpoints"), Interval (0.0, 0.0));
+  Direction feather_dir = to_dir (get_property (me, "grow-direction"));
+
+  Interval placements = robust_scm2interval (get_property (me, "normalized-endpoints"), Interval (0.0, 0.0));
 
   Stencil the_beam;
   vsize extreme = (segments[0].vertical_count_ == 0
                    ? segments[0].vertical_count_
                    : segments.back ().vertical_count_);
 
   for (vsize i = 0; i < segments.size (); i++)
     {
       Real local_slope = slope;
       /*
@@ skipping 50 matching lines @@
           weighted_average += beam_dy * n * factor;
         }
 
       b.translate_axis (weighted_average, Y_AXIS);
 
       the_beam.add_stencil (b);
 
     }
 
 #if (DEBUG_BEAM_SCORING)
-  SCM annotation = me->get_property ("annotation");
+  SCM annotation = get_property (me, "annotation");
   if (scm_is_string (annotation))
     {
       extract_grob_set (me, "stems", stems);
 
       /*
         This code prints the demerits for each beam. Perhaps this
         should be switchable for those who want to twiddle with the
         parameters.
       */
       string str;
       SCM properties = Font_interface::text_font_alist_chain (me);
 
       properties = scm_cons (scm_acons (ly_symbol2scm ("font-size"), scm_from_int (-5), SCM_EOL),
                              properties);
 
-      Direction stem_dir = stems.size () ? to_dir (stems[0]->get_property ("direction")) : UP;
+      Direction stem_dir = stems.size () ? to_dir (get_property (stems[0], "direction")) : UP;
 
       Stencil score = *unsmob<Stencil> (Text_interface::interpret_markup
                                         (me->layout ()->self_scm (), properties, annotation));
 
       if (!score.is_empty ())
         {
           score.translate_axis (me->relative_coordinate (commonx, X_AXIS), X_AXIS);
           the_beam.add_at_edge (Y_AXIS, stem_dir, score, 1.0);
         }
     }
@@ skipping 20 matching lines @@
     }
 
   Drul_array<int> total (0, 0);
   Drul_array<int> count (0, 0);
 
   bool force_dir = false;
   for (vsize i = 0; i < stems.size (); i++)
     {
       Grob *s = stems[i];
       Direction stem_dir = CENTER;
-      SCM stem_dir_scm = s->get_property_data ("direction");
+      SCM stem_dir_scm = get_property_data (s, "direction");
       if (is_direction (stem_dir_scm))
         {
           stem_dir = to_dir (stem_dir_scm);
           force_dir = true;
         }
       else
-        stem_dir = to_dir (s->get_property ("default-direction"));
+        stem_dir = to_dir (get_property (s, "default-direction"));
 
       if (!stem_dir)
-        stem_dir = to_dir (s->get_property ("neutral-direction"));
+        stem_dir = to_dir (get_property (s, "neutral-direction"));
 
       if (stem_dir)
         {
           count[stem_dir]++;
           total[stem_dir] += std::max (int (- stem_dir * Stem::head_positions (s) [-stem_dir]), 0);
         }
     }
 
   if (!force_dir)
     {
       if (abs (extremes[UP]) > -extremes[DOWN])
         return DOWN;
       else if (extremes[UP] < -extremes[DOWN])
         return UP;
     }
 
   Direction dir = CENTER;
   Direction d = CENTER;
   if ((d = (Direction) sign (count[UP] - count[DOWN])))
     dir = d;
   else if (count[UP]
            && count[DOWN]
            && (d = (Direction) sign (total[UP] / count[UP] - total[DOWN] / count[DOWN])))
     dir = d;
   else if ((d = (Direction) sign (total[UP] - total[DOWN])))
     dir = d;
   else
-    dir = to_dir (me->get_property ("neutral-direction"));
+    dir = to_dir (get_property (me, "neutral-direction"));
 
   return dir;
 }
 
 /* Set all stems with non-forced direction to beam direction.
    Urg: non-forced should become `without/with unforced' direction,
    once stem gets cleaned-up. */
 void
 Beam::set_stem_directions (Grob *me, Direction d)
 {
   extract_grob_set (me, "stems", stems);
 
   for (vsize i = 0; i < stems.size (); i++)
     {
       Grob *s = stems[i];
 
-      SCM forcedir = s->get_property_data ("direction");
+      SCM forcedir = get_property_data (s, "direction");
       if (!to_dir (forcedir))
         set_grob_direction (s, d);
     }
 }
 
 /*
   Only try horizontal beams for knees.  No reliable detection of
   anything else is possible here, since we don't know funky-beaming
   settings, or X-distances (slopes!)  People that want sloped
   knee-beams, should set the directions manually.
 
 
   TODO:
 
   this routine should take into account the stemlength scoring
   of a possible knee/nonknee beam.
 */
 void
 Beam::consider_auto_knees (Grob *me)
 {
-  SCM scm = me->get_property ("auto-knee-gap");
+  SCM scm = get_property (me, "auto-knee-gap");
   if (!scm_is_number (scm))
     return;
 
   vector<Interval> forbidden_intervals;
 
   extract_grob_set (me, "normal-stems", stems);
 
   Grob *common = common_refpoint_of_array (stems, me, Y_AXIS);
   Real staff_space = Staff_symbol_referencer::staff_space (me);
 
   vector<Interval> head_extents_array;
   for (vsize i = 0; i < stems.size (); i++)
     {
       Grob *stem = stems[i];
 
       Interval head_extents;
       if (Stem::head_count (stem))
         {
           head_extents = Stem::head_positions (stem);
           head_extents.widen (1);
           head_extents *= staff_space * 0.5;
 
           /*
             We could subtract beam Y position, but this routine only
             sets stem directions, a constant shift does not have an
             influence.
           */
           head_extents += stem->pure_relative_y_coordinate (common, 0, INT_MAX);
 
-          if (to_dir (stem->get_property_data ("direction")))
+          if (to_dir (get_property_data (stem, "direction")))
             {
-              Direction stemdir = to_dir (stem->get_property ("direction"));
+              Direction stemdir = to_dir (get_property (stem, "direction"));
               head_extents[-stemdir] = -stemdir * infinity_f;
             }
         }
       head_extents_array.push_back (head_extents);
 
       forbidden_intervals.push_back (head_extents);
     }
 
   Interval max_gap;
   Real max_gap_len = 0.0;
@@ skipping 28 matching lines @@
     {
       int j = 0;
       for (vsize i = 0; i < stems.size (); i++)
         {
           Grob *stem = stems[i];
           Interval head_extents = head_extents_array[j++];
 
           Direction d = (head_extents.center () < max_gap.center ())
                         ? UP : DOWN;
 
-          stem->set_property ("direction", scm_from_int (d));
+          set_property (stem, "direction", scm_from_int (d));
 
           head_extents.intersect (max_gap);
           assert (head_extents.is_empty () || head_extents.length () < 1e-6);
         }
     }
 }
 
 MAKE_SCHEME_CALLBACK (Beam, calc_stem_shorten, 1)
 SCM
 Beam::calc_stem_shorten (SCM smob)
 {
   Grob *me = unsmob<Grob> (smob);
 
   /*
     shortening looks silly for x staff beams
   */
   if (is_knee (me))
     return scm_from_int (0);
 
   Real forced_fraction = static_cast<Real> (forced_stem_count (me))
                          / static_cast<Real> (normal_stem_count (me));
 
   int beam_count = get_beam_count (me);
 
-  SCM shorten_list = me->get_property ("beamed-stem-shorten");
+  SCM shorten_list = get_property (me, "beamed-stem-shorten");
   if (scm_is_null (shorten_list))
     return scm_from_int (0);
 
   Real staff_space = Staff_symbol_referencer::staff_space (me);
 
   SCM shorten_elt
     = robust_list_ref (beam_count - 1, shorten_list);
   Real shorten = scm_to_double (shorten_elt) * staff_space;
 
   shorten *= forced_fraction;
@@ skipping 74 matching lines @@
   Hmm.  At this time, beam position and slope are determined.  Maybe,
   stem directions and length should set to relative to the chord's
   position of the beam.  */
 MAKE_SCHEME_CALLBACK (Beam, set_stem_lengths, 1);
 SCM
 Beam::set_stem_lengths (SCM smob)
 {
   Grob *me = unsmob<Grob> (smob);
 
   /* trigger callbacks. */
-  (void) me->get_property ("direction");
-  (void) me->get_property ("beaming");
-
-  SCM posns = me->get_property ("positions");
+  (void) get_property (me, "direction");
+  (void) get_property (me, "beaming");
+
+  SCM posns = get_property (me, "positions");
 
   extract_grob_set (me, "stems", stems);
   if (!stems.size ())
     return posns;
 
   Grob *common[2];
   for (int a = 2; a--;)
     common[a] = common_refpoint_of_array (stems, me, Axis (a));
 
   Drul_array<Real> pos = ly_scm2realdrul (posns);
   Real staff_space = Staff_symbol_referencer::staff_space (me);
   scale_drul (&pos, staff_space);
 
   bool gap = false;
   Real thick = 0.0;
-  if (robust_scm2int (me->get_property ("gap-count"), 0))
+  if (robust_scm2int (get_property (me, "gap-count"), 0))
     {
       gap = true;
       thick = get_beam_thickness (me);
     }
 
-  Interval x_span = robust_scm2interval (me->get_property ("X-positions"), Interval (0, 0));
-  Direction feather_dir = to_dir (me->get_property ("grow-direction"));
+  Interval x_span = robust_scm2interval (get_property (me, "X-positions"), Interval (0, 0));
+  Direction feather_dir = to_dir (get_property (me, "grow-direction"));
 
   for (vsize i = 0; i < stems.size (); i++)
     {
       Grob *s = stems[i];
-      bool french = to_boolean (s->get_property ("french-beaming"));
+      bool french = to_boolean (get_property (s, "french-beaming"));
       int french_count = 0;
       if (french)
         {
           /*
             french_count is the number of beams a particular stem length
             must be shortened in French Beaming.  Determined by intersecting
             left/right beaming information Slices.
           */
-          SCM beaming = s->get_property ("beaming");
+          SCM beaming = get_property (s, "beaming");
           Slice le = int_list_to_slice (scm_car (beaming));
           Slice ri = int_list_to_slice (scm_cdr (beaming));
           le.intersect (ri);
           french_count = le.length ();
         }
       Beam_stem_end stem_end = calc_stem_y (me, s, common,
                                             x_span[LEFT], x_span[RIGHT],
                                             feather_dir, pos, french_count);
       Real stem_y = stem_end.stem_y_;
       Real fb_stem_adjustment = stem_end.french_beaming_stem_adjustment_;
@@ skipping 22 matching lines @@
   extract_grob_set (me, "stems", stems);
 
   for (vsize i = 0; i < stems.size (); i++)
     {
       /*
         Don't overwrite user settings.
       */
       for (LEFT_and_RIGHT (d))
         {
           Grob *stem = stems[i];
-          SCM beaming_prop = stem->get_property ("beaming");
+          SCM beaming_prop = get_property (stem, "beaming");
           if (scm_is_null (beaming_prop)
               || scm_is_null (index_get_cell (beaming_prop, d)))
             {
               int count = beaming->beamlet_count (i, d);
               if (i > 0
                   && i + 1 < stems.size ()
                   && Stem::is_invisible (stem))
                 count = std::min (count, beaming->beamlet_count (i, -d));
 
               if ( ((i == 0 && d == LEFT)
                     || (i == stems.size () - 1 && d == RIGHT))
                    && stems.size () > 1
-                   && to_boolean (me->get_property ("clip-edges")))
+                   && to_boolean (get_property (me, "clip-edges")))
                 count = 0;
 
               Stem::set_beaming (stem, count, d);
             }
         }
     }
 }
 
 vsize
 Beam::forced_stem_count (Grob *me)
 {
   extract_grob_set (me, "normal-stems", stems);
 
   vsize f = 0;
   for (vsize i = 0; i < stems.size (); i++)
     {
       Grob *s = stems[i];
 
       /* I can imagine counting those boundaries as a half forced stem,
          but let's count them full for now. */
-      Direction defdir = to_dir (s->get_property ("default-direction"));
+      Direction defdir = to_dir (get_property (s, "default-direction"));
 
       if (abs (Stem::chord_start_y (s)) > 0.1
           && defdir
           && get_grob_direction (s) != defdir)
         f++;
     }
   return f;
 }
 
 vsize
@@ skipping 28 matching lines @@
   rest -> stem -> beam -> interpolate_y_position ()
 */
 MAKE_SCHEME_CALLBACK_WITH_OPTARGS (Beam, rest_collision_callback, 2, 1, "");
 SCM
 Beam::rest_collision_callback (SCM smob, SCM prev_offset)
 {
   if (!scm_is_number (prev_offset))
     prev_offset = SCM_INUM0;
 
   Grob *rest = unsmob<Grob> (smob);
-  if (scm_is_number (rest->get_property ("staff-position")))
+  if (scm_is_number (get_property (rest, "staff-position")))
     return prev_offset;
 
-  Grob *stem = unsmob<Grob> (rest->get_object ("stem"));
+  Grob *stem = unsmob<Grob> (get_object (rest, "stem"));
 
   if (!stem)
     return prev_offset;
 
-  Grob *beam = unsmob<Grob> (stem->get_object ("beam"));
+  Grob *beam = unsmob<Grob> (get_object (stem, "beam"));
   if (!beam
       || !has_interface<Beam> (beam)
       || !Beam::normal_stem_count (beam))
     return prev_offset;
 
   Grob *common_y = rest->common_refpoint (beam, Y_AXIS);
 
-  Drul_array<Real> pos (robust_scm2drul (beam->get_property ("positions"),
+  Drul_array<Real> pos (robust_scm2drul (get_property (beam, "positions"),
                                          Drul_array<Real> (0, 0)));
 
   for (LEFT_and_RIGHT (dir))
     pos[dir] += beam->relative_coordinate (common_y, Y_AXIS);
 
   Real staff_space = Staff_symbol_referencer::staff_space (rest);
 
   scale_drul (&pos, staff_space);
 
   Real dy = pos[RIGHT] - pos[LEFT];
 
   extract_grob_set (beam, "stems", stems);
   Grob *common = common_refpoint_of_array (stems, beam, X_AXIS);
 
-  Interval x_span = robust_scm2interval (beam->get_property ("X-positions"),
+  Interval x_span = robust_scm2interval (get_property (beam, "X-positions"),
                                          Interval (0.0, 0.0));
   Real x0 = x_span[LEFT];
   Real dx = x_span.length ();
   Real slope = dy && dx ? dy / dx : 0;
 
   Direction d = get_grob_direction (stem);
   Real stem_y = pos[LEFT]
                 + (stem->relative_coordinate (common, X_AXIS) - x0) * slope;
 
   Real beam_translation = get_beam_translation (beam);
   Real beam_thickness = Beam::get_beam_thickness (beam);
 
   /*
     TODO: this is not strictly correct for 16th knee beams.
   */
   int beam_count
     = Stem::beam_multiplicity (stem).length () + 1;
 
   Real height_of_my_beams = beam_thickness / 2
                             + (beam_count - 1) * beam_translation;
   Real beam_y = stem_y - d * height_of_my_beams;
 
   Real offset = robust_scm2double (prev_offset, 0.0);
   Interval rest_extent = rest->extent (rest, Y_AXIS);
   rest_extent.translate (offset + rest->parent_relative (common_y, Y_AXIS));
 
   Real rest_dim = rest_extent[d];
   Real minimum_distance
-    = staff_space * (robust_scm2double (stem->get_property ("stemlet-length"), 0.0)
-                     + robust_scm2double (rest->get_property ("minimum-distance"), 0.0));
+    = staff_space * (robust_scm2double (get_property (stem, "stemlet-length"), 0.0)
+                     + robust_scm2double (get_property (rest, "minimum-distance"), 0.0));
 
   Real shift = d * std::min (d * (beam_y - d * minimum_distance - rest_dim), 0.0);
 
   shift /= staff_space;
 
   /* Always move discretely by half spaces */
   shift = ceil (fabs (shift * 2.0)) / 2.0 * sign (shift);
 
   Interval staff_span = Staff_symbol_referencer::staff_span (rest);
   staff_span *= staff_space / 2;
@@ skipping 14 matching lines @@
 SCM
 Beam::pure_rest_collision_callback (SCM smob,
                                     SCM, /* start */
                                     SCM, /* end */
                                     SCM prev_offset)
 {
   if (!scm_is_number (prev_offset))
     prev_offset = SCM_INUM0;
 
   Grob *me = unsmob<Grob> (smob);
-  Grob *stem = unsmob<Grob> (me->get_object ("stem"));
+  Grob *stem = unsmob<Grob> (get_object (me, "stem"));
   if (!stem)
     return prev_offset;
-  Grob *beam = unsmob<Grob> (stem->get_object ("beam"));
+  Grob *beam = unsmob<Grob> (get_object (stem, "beam"));
   if (!beam
       || !Beam::normal_stem_count (beam)
-      || !is_direction (beam->get_property_data ("direction")))
+      || !is_direction (get_property_data (beam, "direction")))
     return prev_offset;
 
   Real ss = Staff_symbol_referencer::staff_space (me);
 
   extract_grob_set (beam, "stems", stems);
   vector<Grob *> my_stems;
 
   for (vsize i = 0; i < stems.size (); i++)
     if (Stem::head_count (stems[i]) || stems[i] == stem)
       my_stems.push_back (stems[i]);
@@ skipping 23 matching lines @@
 
   /* Estimate the closest beam to be four positions away from the heads, */
   Direction beamdir = get_grob_direction (beam);
   Real beam_pos = (Stem::head_positions (left)[beamdir]
                    + Stem::head_positions (right)[beamdir]) / 2.0
                   + 4.0 * beamdir; // four staff-positions
   /* and that the closest beam never crosses staff center by more than two positions */
   beam_pos = std::max (-2.0, beam_pos * beamdir) * beamdir;
 
   Real minimum_distance
-    = ss * (robust_scm2double (stem->get_property ("stemlet-length"), 0.0)
-            + robust_scm2double (me->get_property ("minimum-distance"), 0.0));
+    = ss * (robust_scm2double (get_property (stem, "stemlet-length"), 0.0)
+            + robust_scm2double (get_property (me, "minimum-distance"), 0.0));
   Real offset = beam_pos * ss / 2.0
                 - minimum_distance * beamdir
                 - me->extent (me, Y_AXIS)[beamdir];
   Real previous = robust_scm2double (prev_offset, 0.0);
 
   /* Always move by a whole number of staff spaces, always away from the beam */
   offset = floor (std::min (0.0, (offset - previous) / ss * beamdir))
            * ss * beamdir + previous;
 
   return scm_from_double (offset);
 }
 
 bool
 Beam::is_knee (Grob *me)
 {
-  SCM k = me->get_property ("knee");
+  SCM k = get_property (me, "knee");
   if (scm_is_bool (k))
     return ly_scm2bool (k);
 
   bool knee = false;
   int d = 0;
   extract_grob_set (me, "stems", stems);
   for (vsize i = stems.size (); i--;)
     {
       Direction dir = get_grob_direction (stems[i]);
       if (d && d != dir)
         {
           knee = true;
           break;
         }
       d = dir;
     }
 
-  me->set_property ("knee", ly_bool2scm (knee));
+  set_property (me, "knee", ly_bool2scm (knee));
 
   return knee;
 }
 
 bool
 Beam::is_cross_staff (Grob *me)
 {
   extract_grob_set (me, "stems", stems);
   Grob *staff_symbol = Staff_symbol_referencer::get_staff_symbol (me);
   for (vsize i = 0; i < stems.size (); i++)
@@ skipping 93 matching lines @@
                "least-squares-dy "
                "neutral-direction "
                "normal-stems "
                "positions "
                "quantized-positions "
                "shorten "
                "skip-quanting "
                "stems "
                "X-positions "
               );