]> git.donarmstrong.com Git - lilypond.git/blobdiff - lily/paper-column.cc
* scm/define-markup-commands.scm (fill-line): use
[lilypond.git] / lily / paper-column.cc
index eab3671d1a64a31bf36bb50cf7baead695c4f2fb..bb3d8ad42ef85e24ab4b5e6946ec4b8eb8ecc880 100644 (file)
@@ -3,42 +3,44 @@
 
   source file of the GNU LilyPond music typesetter
 
-  (c)  1997--2003 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+  (c) 1997--2004 Han-Wen Nienhuys <hanwen@cs.uu.nl>
 */
 
-#include "moment.hh"
 #include "paper-column.hh"
+
+#include "moment.hh"
 #include "paper-score.hh"
 #include "warn.hh"
 #include "axis-group-interface.hh"
 #include "spaceable-grob.hh"
-#include "molecule.hh"
 #include "text-item.hh"
 #include "lookup.hh"
 #include "font-interface.hh"
+#include "output-def.hh"
 
-
-
+Grob * 
+Paper_column::clone (int count) const
+{
+  return new Paper_column (*this, count);
+}
 
 
 ADD_INTERFACE (Paper_column, "paper-column-interface",
-  "  Paper_columns form the top-most item parent. (The Paper_columns X\n"
-"  parent is System, which is a spanner.)\n"
-"\n"
-"  Paper_columns form the units for the spacing engine. They are\n"
-"  numbered, the first (leftmost) is column 0. Numbering happens before\n"
-"  line-breaking, and columns are not renumbered after line breaking.\n"
-"\n"
-"  Since many columns go unused, you should only use the rank field to\n"
-"  get ordering information.  Two adjacent columns may have\n"
-"  non-adjacent numbers.\n"
-"\n"
-"  Don't be confused by right-items: each spacing wish can also contain\n"
-"  a number of items, with which a spacing constraint may be kept. It's\n"
-"  a little baroque, but it might come in handy later on?\n"
-"\n",
-  "between-cols between-system-string when bounded-by-me shortest-playing-duration shortest-starter-duration");
-
+              "@code{Paper_column} objects form the top-most X-parents for items. "
+              "  The are two types of columns: musical columns, where are attached to, and "
+              "  non-musical columns, where bar-lines, clefs etc. are attached to. "
+              "  The spacing engine determines the X-positions of these objects."
+              "\n\n"
+              "They are\n"
+              "  numbered, the first (leftmost) is column 0. Numbering happens before\n"
+              "  line-breaking, and columns are not renumbered after line breaking.\n"
+              "  Since many columns go unused, you should only use the rank field to\n"
+              "  get ordering information.  Two adjacent columns may have\n"
+              "  non-adjacent numbers.\n"
+              "\n"
+              ,
+              "between-cols when bounded-by-me "
+              "page-penalty shortest-playing-duration shortest-starter-duration");
 
 void
 Paper_column::do_break_processing ()
@@ -66,44 +68,49 @@ Paper_column::get_column () const
   return (Paper_column*) (this);
 }
 
-Paper_column::Paper_column (SCM l)
-  : Item (l)           // guh.?
+Paper_column::Paper_column (SCM l, Object_key const*key)
+  : Item (l, key)              // guh.?
 {
-  system_=0;
+  system_ = 0;
   rank_ = -1;
 }
 
+
+Paper_column::Paper_column (Paper_column const& src, int count)
+  : Item (src, count)
+{
+  system_ = 0;
+  rank_ = count;
+}
+
+
 Moment
-Paper_column::when_mom (Grob*me)
+Paper_column::when_mom (Grob *me)
 {
-  SCM m = me->get_grob_property ("when");
-  Moment s (0);
-  if (unsmob_moment (m))
-    {
-      return *unsmob_moment (m);
-    }
-  return s;
+  SCM m = me->get_property ("when");
+  if (Moment *when = unsmob_moment (m))
+    return *when;
+  return Moment (0);
 }
 
 bool
-Paper_column::musical_b (Grob *me)
+Paper_column::is_musical (Grob *me)
 {
-  SCM m = me->get_grob_property ("shortest-starter-duration");
+  SCM m = me->get_property ("shortest-starter-duration");
   Moment s (0);
   if (unsmob_moment (m))
     {
       s = *unsmob_moment (m);
     }
   return s != Moment (0);
-  
 }
   
 
 bool
-Paper_column::used_b (Grob*me)
+Paper_column::is_used (Grob*me)
 {
-  return gh_pair_p (me->get_grob_property ("elements")) ||  Item::breakable_b (me)
-    || gh_pair_p (me->get_grob_property ("bounded-by-me"))
+  return scm_is_pair (me->get_property ("elements")) ||  Item::is_breakable (me)
+    || scm_is_pair (me->get_property ("bounded-by-me"))
     ;
 }
 
@@ -111,24 +118,26 @@ Paper_column::used_b (Grob*me)
   Print a vertical line and  the rank number, to aid debugging.  
  */
 
-MAKE_SCHEME_CALLBACK(Paper_column,brew_molecule,1);
+MAKE_SCHEME_CALLBACK (Paper_column,print,1);
 SCM
-Paper_column::brew_molecule (SCM p)
+Paper_column::print (SCM p)
 {
   Grob *me = unsmob_grob (p);
 
   String r = to_string (Paper_column::get_rank (me));
-  SCM properties = Font_interface::font_alist_chain (me);
-  
-  Molecule t = Text_item::text2molecule (me, scm_makfrom0str (r.to_str0 ()),
-                                        properties);
+  SCM properties = Font_interface::text_font_alist_chain (me);
+
+  SCM scm_mol = Text_interface::interpret_markup (me->get_layout ()->self_scm (),
+                                            properties,
+                                            scm_makfrom0str (r.to_str0 ()));
+  Stencil t = *unsmob_stencil (scm_mol);
   t.align_to (X_AXIS, CENTER);
   t.align_to (Y_AXIS, DOWN);
   
-  Molecule l = Lookup::filledbox (Box (Interval (-0.01, 0.01),
+  Stencil l = Lookup::filled_box (Box (Interval (-0.01, 0.01),
                                       Interval (-2, -1)));
 
-  t.add_molecule (l);
+  t.add_stencil (l);
   return t.smobbed_copy ();                                            
 }
 
@@ -139,22 +148,22 @@ Paper_column::brew_molecule (SCM p)
 
   THIS IS BROKEN KLUDGE. WE SHOULD INVENT SOMETHING BETTER. 
  */
-MAKE_SCHEME_CALLBACK(Paper_column,before_line_breaking,1);
+MAKE_SCHEME_CALLBACK (Paper_column,before_line_breaking,1);
 SCM
 Paper_column::before_line_breaking (SCM grob)
 {
   Grob *me = unsmob_grob (grob);
 
-  SCM c = me->get_grob_property ("bounded-by-me");
+  SCM c = me->get_property ("bounded-by-me");
   SCM *ptrptr = &c;
 
-  while (gh_pair_p (*ptrptr))
+  while (scm_is_pair (*ptrptr))
     {
-      Grob * g = unsmob_grob (gh_car (*ptrptr));
+      Grob * g = unsmob_grob (scm_car (*ptrptr));
 
-      if (!g || !g->live ())
+      if (!g || !g->is_live ())
        {
-         *ptrptr = gh_cdr (*ptrptr);
+         *ptrptr = scm_cdr (*ptrptr);
        }
       else
        {
@@ -162,6 +171,6 @@ Paper_column::before_line_breaking (SCM grob)
        }
     }
 
-  me->set_grob_property ("bounded-by-me", c);
+  me->set_property ("bounded-by-me", c);
   return SCM_UNSPECIFIED;
 }