Refactor get/set_property to take the item as first argument

lily/paper-column.cc

 /*
   This file is part of LilyPond, the GNU music typesetter.
 
   Copyright (C) 1997--2020 Han-Wen Nienhuys <hanwen@xs4all.nl>
 
   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 80 matching lines @@
 Paper_column::Paper_column (Paper_column const &src)
   : Item (src)
 {
   system_ = 0;
   rank_ = src.rank_;
 }
 
 Moment
 Paper_column::when_mom (Grob *me)
 {
-  SCM m = me->get_property ("when");
+  SCM m = get_property (me, "when");
   if (Moment *when = unsmob<Moment> (m))
     return *when;
   return Moment (0);
 }
 
 bool
 Paper_column::is_musical (Grob *me)
 {
-  SCM m = me->get_property ("shortest-starter-duration");
+  SCM m = get_property (me, "shortest-starter-duration");
   if (Moment *s = unsmob<Moment> (m))
     return *s != Moment (0);
   return false;
 }
 
 bool
 Paper_column::is_used (Grob *me)
 {
   extract_grob_set (me, "elements", elts);
   if (elts.size ())
     return true;
 
   extract_grob_set (me, "bounded-by-me", bbm);
   if (bbm.size ())
     return true;
 
   if (Paper_column::is_breakable (me))
     return true;
 
-  if (to_boolean (me->get_property ("used")))
+  if (to_boolean (get_property (me, "used")))
     return true;
 
-  if (scm_is_pair (me->get_property ("labels")))
+  if (scm_is_pair (get_property (me, "labels")))
     return true;
 
   return false;
 }
 
 bool
 Paper_column::is_breakable (Grob *me)
 {
-  return scm_is_symbol (me->get_property ("line-break-permission"));
+  return scm_is_symbol (get_property (me, "line-break-permission"));
 }
 
 Real
 Paper_column::minimum_distance (Grob *left, Grob *right)
 {
   Drul_array<Grob *> cols (left, right);
   Drul_array<Skyline> skys = Drul_array<Skyline> (Skyline (RIGHT), Skyline (LEFT));
 
   for (LEFT_and_RIGHT (d))
     {
-      Skyline_pair *sp = unsmob<Skyline_pair> (cols[d]->get_property ("horizontal-skylines"));
+      Skyline_pair *sp = unsmob<Skyline_pair> (get_property (cols[d], "horizontal-skylines"));
       if (sp)
         skys[d] = (*sp)[-d];
     }
 
   skys[RIGHT].merge (Separation_item::conditional_skyline (right, left));
 
   return std::max (0.0, skys[LEFT].distance (skys[RIGHT]));
 }
 
 Interval
@@ skipping 19 matching lines @@
         align = Pointer_group_interface::find_grob
                 (me, ly_symbol2scm ("elements"),
                  (scm_is_eq (align_sym, ly_symbol2scm ("staff-bar"))
                   ? Bar_line::non_empty_barline
                   : has_interface<Break_alignment_interface>));
       else
         {
           extract_grob_set (me, "elements", elts);
           for (vsize i = 0; i < elts.size (); i++)
             {
-              if (scm_is_eq (align_sym, elts[i]->get_property ("break-align-symbol"))
+              if (scm_is_eq (align_sym, get_property (elts[i], "break-align-symbol"))
                   // TODO SCM: there must be a simpler way to put this.
                   && !elts[i]->extent (elts[i], X_AXIS).is_empty ())
                 {
                   align = elts[i];
                   break;
                 }
             }
         }
     }
 
@@ skipping 56 matching lines @@
                                  " its moment in time, a blue arrow showing the"
                                  " ideal distance, and a red arrow showing the"
                                  " minimum distance between columns.");
 SCM
 Paper_column::print (SCM p)
 {
   Paper_column *me = unsmob<Paper_column> (p);
 
   string r = std::to_string (me->get_rank ());
 
-  Moment *mom = unsmob<Moment> (me->get_property ("when"));
+  Moment *mom = unsmob<Moment> (get_property (me, "when"));
   string when = mom ? mom->to_string () : "?/?";
 
   Font_metric *musfont = Font_interface::get_default_font (me);
   SCM properties = Font_interface::text_font_alist_chain (me);
   SCM scm_mol = Text_interface::interpret_markup (me->layout ()->self_scm (),
                                                   properties,
                                                   ly_string2scm (r));
   SCM when_mol = Text_interface::interpret_markup (me->layout ()->self_scm (),
                                                    properties,
                                                    ly_string2scm (when));
   Stencil t = *unsmob<Stencil> (scm_mol);
   t.scale (1.2, 1.4);
   t.add_at_edge (Y_AXIS, DOWN, *unsmob<Stencil> (when_mol), 0.1);
   t.align_to (X_AXIS, LEFT);
   // compensate for font serifs and half letter-distance
   t.translate (Offset (-0.1, 0));
   t.align_to (Y_AXIS, DOWN);
 
   Stencil l = Lookup::filled_box (Box (Interval (0, 0.02),
                                        Interval (-8, -1)));
 
   Real small_pad = 0.15;
   Real big_pad = 0.35;
 
   // number of printed arrows from *both* loops
   int j = 0;
 
-  for (SCM s = me->get_object ("ideal-distances");
+  for (SCM s = get_object (me, "ideal-distances");
        scm_is_pair (s); s = scm_cdr (s))
     {
       Spring *sp = unsmob<Spring> (scm_caar (s));
       if (!unsmob<Grob> (scm_cdar (s))
           || !unsmob<Grob> (scm_cdar (s))->get_system ())
         continue;
 
       j++;
 
       Stencil arrowhead (musfont->find_by_name ("arrowheads.open.01"));
@@ skipping 24 matching lines @@
       pts.push_back (p2);
 
       Stencil id_stencil = Lookup::points_to_line_stencil (0.1, pts);
       id_stencil.add_stencil (arrowhead.translated (p2));
       id_stencil.add_stencil (number_stc->translated (num_off));
       // use a lighter shade of blue so it will remain legible on black background.
       id_stencil = id_stencil.in_color (0.2, 0.4, 1.0);
       l.add_stencil (id_stencil);
     }
 
-  for (SCM s = me->get_object ("minimum-distances");
+  for (SCM s = get_object (me, "minimum-distances");
        scm_is_pair (s); s = scm_cdr (s))
     {
       Real dist = scm_to_double (scm_cdar (s));
       Grob *other = unsmob<Grob> (scm_caar (s));
       if (!other || other->get_system () != me->get_system ())
         continue;
 
       j++;
 
       Stencil arrowhead (musfont->find_by_name ("arrowheads.open.01"));
@@ skipping 46 matching lines @@
   bounded-by-me
 
   THIS IS BROKEN KLUDGE. WE SHOULD INVENT SOMETHING BETTER.
 */
 MAKE_SCHEME_CALLBACK (Paper_column, before_line_breaking, 1);
 SCM
 Paper_column::before_line_breaking (SCM grob)
 {
   Grob *me = unsmob<Grob> (grob);
 
-  if (Grob_array *ga = unsmob<Grob_array> (me->get_object ("bounded-by-me")))
+  if (Grob_array *ga = unsmob<Grob_array> (get_object (me, "bounded-by-me")))
     ga->filter (grob_is_live);
 
   return SCM_UNSPECIFIED;
 }
 
 /* FIXME: This is a hack that we use to identify columns that used to
    contain note-heads but whose note-heads were moved by one of the ligature
    engravers. Once the ligature engravers are fixed to behave nicely, this
    function can be removed.
 */
@@ skipping 46 matching lines @@
                "page-break-penalty "
                "page-break-permission "
                "page-turn-penalty "
                "page-turn-permission "
                "rhythmic-location "
                "shortest-playing-duration "
                "shortest-starter-duration "
                "spacing "
                "used "
                "when ");