void
Dstream::clear_silence()
{
- for (Dictionary_iter<bool> i (*silent_dict_p_); i.ok(); i++)
+ for (map<String,bool>::iterator ki(silent_dict_p_->begin ());
+ silent_dict_p_->end () != ki; ki++)
{
- i.val_ref() = false;
+ (*ki).second = false;
}
}
#include "string.hh"
#include "array.hh"
+#include <map>
+
#include "hash-table.hh"
/*
- DEPRECATED. Use either SCM (preferred) or STL
+ interface to STL function.
*/
template<class V>
-class Dictionary : public Hash_table<String, V>
+class Dictionary : public map<String, V>
{
public:
Dictionary ()
{
- hash_func_ = string_hash;
}
Dictionary (Dict_initialiser<V> *p)
{
hash_func_ = string_hash;
for (Dict_initialiser<V> *q = p; q->key_; q++)
- elem (q->key_) = q->value_;
+ (*this) [q->key_] = q->value_;
}
-
- friend class Dictionary_iter<V>;
+ bool elem_b (String s)
+ {
+ map<String,V>::const_iterator ki (find (s));
+ return ki != end ();
+ }
+
};
--- /dev/null
+
+\score { \context PianoStaff \notes <
+\context Staff = up <{ c4 }
+ \times 2/3 { [c8 c\translator Staff = down c] }>
+ \context Staff = down c4
+
+ >
+
+ }
+
--- /dev/null
+
+\score { \context PianoStaff \notes <
+
+{ \times 2/3 { [c8 c\translator Staff = down c] }}
+ \context Staff = down c4
+
+ >
+
+ }
+
\header {
title = "Trip";
- enteredby = "JCN";
copyright = "public domain";
}
-% todo: clef ch .
+%{
+
+This file tests as much features of lily as possible. If there are any
+basic faults in , this file will not run correctly.
+
+TODO:
+
+* add tuplets
+
+* repeats.
+
+* tremolo
+
+%}
praeludiumRight = \notes {
\key e;
\context Staff <
\context Voice = two { r4 }
\context Voice = one { \stemup s4 dis' cis cis ~ |
- [cis8
- (
+ % BUG -> (insane springs.)
+ \times 4/5
+ { [cis8 ( cis
+
a \translator Staff = treble \stemdown \shifton d
)
- cis]
+ cis] }
\translator Staff = bass
\shiftoff
[bis gis] cis4 |
AFM_CharMetricInfo const *
Adobe_font_metric::find_char_metric (String nm, bool warn) const
{
- if (!name_to_metric_dict_.elem_b (nm))
+ map<String,int>::const_iterator ai = name_to_metric_dict_.find (nm);
+
+ if (ai == name_to_metric_dict_.end ())
{
if (warn)
{
return 0;
}
else
- return font_inf_->cmi + name_to_metric_dict_ [nm];
+ return font_inf_->cmi + (*ai).second;
}
{
Simple_spacer * sp = new Simple_spacer;
Paper_def * d = pscore_l_->paper_l_;
- sp->compression_energy_factor_f_ = d->get_var ("compression_energy_factor");
sp->default_space_f_ = d->get_var ("loose_column_distance");
sp->indent_f_ = line[LEFT];
Column_x_positions::Column_x_positions()
{
- energy_f_ = infinity_f;
satisfies_constraints_b_ = false;
force_f_ = 0;
}
pad = paper_l ()->get_var ("interline") / 2;
- width -= start_text.extent ()[X_AXIS].length ();
+ width -= start_text.extent (X_AXIS).length ();
width -= pad;
width = width >? 0;
}
Dots::do_brew_molecule () const
{
Molecule mol (lookup_l ()->blank (Box (Interval (0,0),
- Interval (0,0))));
+ Interval (0,0))));
Molecule d = lookup_l ()->afm_find (String ("dots-dot"));
- Real dw = d.dim_[X_AXIS].length ();
+ Real dw = d.extent (X_AXIS).length ();
d.translate_axis (-dw, X_AXIS);
optimal_paths.set_size (breaks.size ());
Break_node first_node ;
- first_node.line_config_.energy_f_ = 0;
optimal_paths[0] = first_node;
int break_idx=1;
Gourlay_breaking::Gourlay_breaking ()
{
- energy_bound_f_ = infinity_f;
}
void
Grace_align_item::before_line_breaking ()
{
- Real nhw = // lookup_l ()->notehead (2, "").dim_[X_AXIS].length();
+ Real nhw = // lookup_l ()->notehead (2, "")..extent (X_AXIS).length();
paper_l ()->get_var ("quartwidth");
set_elt_property ("threshold",
#include "paper-score.hh"
#include "debug.hh"
-void
-Idealspacing::print() const
-{
-#ifndef NPRINT
- DEBUG_OUT << "idealspacing {" ;
- DEBUG_OUT << "distance " << space_f_ << " strength " << hooke_f_;
- DEBUG_OUT << "left " << cols_drul_[LEFT] << " right " << cols_drul_[RIGHT] << "}\n";
-#endif
-}
Idealspacing::Idealspacing()
{
hooke_f_ = 0.0;
cols_drul_[LEFT] = cols_drul_[RIGHT] = -1;
}
-
-void
-Idealspacing::OK() const
-{
- assert (hooke_f_ >= 0);
-}
-
-Real
-Idealspacing::energy_f(Real x) const
-{
- Real dx = (space_f_ - x);
-
- Real e = sqr(dx);
- if ( dx < 0)
- e *= 4; // ugh.
-
- return hooke_f_ * e;
-}
/// helper: solve for the columns in #curline#.
void solve_line (Column_x_positions*) const;
- /// helper: approximate the energyv
- void approximate_solve_line (Column_x_positions*) const;
-
/// does curline fit on the paper?
bool feasible (Link_array<Paper_column>) const;
{
Link_array<Paper_column> cols_;
Array<Real> config_;
-
Real force_f_;
- Real energy_f_;
bool satisfies_constraints_b_;
Column_x_positions();
*/
Real relative_coordinate (Dimension_cache *d) const;
Dimension_cache*common_refpoint (Dimension_cache const* s) const;
- Dimension_cache*common_refpoint (Link_array<Dimension_cache> caches) const;
+
void set_empty (bool);
void translate (Real);
*/
struct Gourlay_breaking : public Break_algorithm
{
- Real energy_bound_f_ ;
-
Array<Column_x_positions> do_solve() const;
Gourlay_breaking();
Real combine_demerits (Column_x_positions const&,Column_x_positions const&) const;
/// the two columns
Drul_array<int> cols_drul_;
- Real energy_f (Real x) const;
- void print() const;
- void OK() const ;
Idealspacing();
};
SCM ly_offset2scm (Offset);
Offset ly_scm2offset (SCM);
+Interval ly_scm2interval (SCM);
+SCM ly_interval2scm (Interval);
+
SCM ly_parse_scm (char const* s, int* n);
SCM ly_quote_scm (SCM s);
SCM ly_type (SCM);
#include "column-x-positions.hh"
#include "spanner.hh"
-/// the columns of a score that form one line. FIXME: multiple inheritance
+/**
+ The columns of a score that form one line. The toplevel element.
+ Any element has a Line_of_score as both X and Y reference
+ point. The Paper_score contains one element of this type. Control
+ enters the Score_element dependency calculation from this single
+ Line_of_score object.
+
+
+ properties:
+
+ all-elements -- list of all score elements in this line. Needed
+ for protecting elements from GC.
+
+ columns -- list of all paper columns
+
+ */
class Line_of_score : public Spanner
{
public:
-/*
- imported the following from Super_element
-
- The toplevel element. The Paper_score contains this element, and any
- element shoud be a dependency for the super element.
- It is the entry point for the "constraint solver"/ dependency
- tracker. Every XXXX_processing () call traverses the entire
- dependency graph, and calls the appropriate
- Score_element::do_XXX_processing function on each Score_element it encounters.
- */
void post_processing();
- void output_all ();
+ /// -> SCM
int rank_i_;
Protected_scm output_;
/// is #c# contained in #*this#?
bool contains_b (Paper_column const *c) const;
- static int compare (Line_of_score* const &,Line_of_score* const &);
void break_into_pieces (Array<Column_x_positions> const&);
-
- SCM output_lines ();
-
+ void output_lines ();
Link_array<Item> broken_col_range (Item const*, Item const*) const;
Link_array<Paper_column> column_l_arr () const;
class Molecule {
/// can't alloc on heap.
void * operator new (size_t s);
-public:
Box dim_;
SCM expr_;
+
+public:
+
+ SCM get_expr () const;
Molecule (Box, SCM s);
Molecule();
*/
void align_to (Axis a, Direction d);
void translate_axis (Real,Axis);
-
-
- /// how big is #this#?
- Box extent() const;
Interval extent (Axis) const;
bool empty_b() const;
-
-
- /*******/
};
SCM fontify_atom (Font_metric*, SCM atom);
/*
ugh.
+
+ TODO:
+
+ * junk these after spacing is done.
+
+ * Put these in Scheme.
*/
- Drul_array<Array<Column_rod> > minimal_dists_arr_drul_;
- Drul_array<Array<Column_spring> > spring_arr_drul_;
+ Array<Column_rod> minimal_dists_;
+ Array<Column_spring > springs_;
/// set a minimum distance
void add_rod (Paper_column * to, Real distance);
bool musical_b () const;
void set_rank (int);
- virtual void do_print() const;
private:
/**
*/
class Paper_outputter
{
-public:
+#if 0
Protected_scm molecules_;
SCM last_cons_;
- Paper_outputter ();
+#endif
+
+ bool verbatim_scheme_b_;
+ Paper_stream * stream_p_;
+public:
+ /**
+ Assumes responsibility for deletion of P
+ */
+ Paper_outputter (Paper_stream*p);
+ ~Paper_outputter ();
+
+ void dump_scheme (SCM);
- void dump_onto (Paper_stream *);
void output_int_def (String k, int v);
void output_Real_def (String k, Real v);
void output_String_def (String k, String v);
Column_rod ();
static int compare (const Column_rod &r1, const Column_rod &r2);
- void print () const;
};
{
Drul_array <Item*> item_l_drul_;
Real distance_f_;
+
+ /**
+ translate the rod so as to refer to Paper_columns
+ */
+ void columnize ();
+
void add_to_cols ();
Rod ();
Score_element::calcalute_dependencies ()
0 means ORPHAN,
- -1 means deleted
-
*/
- int status_i_;
+ char status_i_;
+ /**
+ Set this if anyone points to me, or if I point to anyone.
+ JUNKME.
+ */
+ bool used_b_;
+
+ char const * name () const;
+
Paper_score *pscore_l_;
Score_element ();
virtual void before_line_breaking ();
/// do calculations after determining horizontal spacing
virtual void after_line_breaking ();
- virtual void output_processing ();
-
+
+ Molecule get_molecule () const;
+ void suicide ();
static Interval preset_extent (Dimension_cache const*);
static Interval molecule_extent (Dimension_cache const*);
public:
Dimension_cache *dim_cache_[NO_AXES];
- /**
- Set this if anyone points to me, or if I point to anyone.
-
- JUNKME.
- */
- bool used_b_;
-
- char const * name () const;
-
bool empty_b (Axis a) const;
Interval extent (Axis) const;
Find the group-element which has both #this# and #s#
*/
Score_element*common_refpoint (Score_element const* s, Axis a) const;
- Score_element*common_refpoint (Link_array<Score_element> elems, Axis a) const;
-
+ Score_element*common_refpoint (SCM elt_list, Axis a) const;
bool has_offset_callback_b (Offset_cache_callback, Axis)const;
void add_offset_callback (Offset_cache_callback, Axis);
Real length (Real force) const;
Spring_description ();
- Real energy_f (Real) const;
+
bool sane_b () const;
};
Real indent_f_;
Real line_len_f_;
Real default_space_f_;
- Real compression_energy_factor_f_;
+
Simple_spacer ();
Real active_blocking_force ()const;
Real configuration_length ()const;
void set_active_states ();
- Real energy_f () const;
-
bool active_b () const;
};
Column_spring ();
static int compare (const Column_spring &r1, const Column_spring &r2);
- void print () const;
};
struct Spring{
TODO
- space the `natural' signs wider
-
-
*/
Molecule
#include "debug.hh"
#include "direction.hh"
#include "offset.hh"
+#include "interval.hh"
SCM
ly_str02scm (char const*c)
return (Direction) gh_scm2int (s);
}
+Interval
+ly_scm2interval (SCM p)
+{
+ return Interval (gh_scm2double (gh_car (p)),
+ gh_scm2double (gh_cdr (p)));
+}
+SCM
+ly_interval2scm (Interval i)
+{
+ return gh_cons (gh_double2scm (i[LEFT]),
+ gh_double2scm (i[RIGHT]));
+}
bool
#include "string.hh"
#include "warn.hh"
#include "dimensions.hh"
+#include "molecule.hh"
+#include "all-font-metrics.hh"
Line_of_score::Line_of_score()
{
/*
Ugh. this is grossly hairy.
*/
-
void
Line_of_score::typeset_element (Score_element * elem_p)
{
scm_unprotect_object (elem_p->self_scm_);
}
-SCM
+void
Line_of_score::output_lines ()
{
for (SCM s = get_elt_property ("all-elements");
}
/*
- fixups must be done in broken line_of_scores, because new elements are put over there.
- */
+ fixups must be done in broken line_of_scores, because new elements
+ are put over there. */
for (int i=0; i < broken_into_l_arr_.size (); i++)
{
Score_element *se = broken_into_l_arr_[i];
progress_indication (to_str (i));
progress_indication ("]");
}
-
- SCM list = SCM_EOL;
- for (int i=broken_into_l_arr_.size (); i--;)
- {
- Line_of_score * l = dynamic_cast<Line_of_score*> (broken_into_l_arr_[i]);
- list = gh_cons (gh_cdr (l->output_), list);
- }
- return list;
}
// const?
}
else
{
- output_scheme (gh_list (ly_symbol2scm ("placebox"),
- gh_double2scm (o[X_AXIS]),
- gh_double2scm (o[Y_AXIS]),
- expr,
- SCM_UNDEFINED));
+ pscore_l_->outputter_l_->
+ output_scheme (gh_list (ly_symbol2scm ("placebox"),
+ gh_double2scm (o[X_AXIS]),
+ gh_double2scm (o[Y_AXIS]),
+ expr,
+ SCM_UNDEFINED));
}
}
void
Line_of_score::output_scheme (SCM s)
{
- gh_set_cdr_x (output_, gh_cons (s, gh_cdr (output_)));
+ pscore_l_->outputter_l_->output_scheme (s);
}
void
Link_array<Paper_column>
Line_of_score::column_l_arr ()const
{
- return Group_interface__extract_elements (this,
- (Paper_column*) 0, "columns");
-
-}
-
-int
-Line_of_score::compare (Line_of_score* const &p1,Line_of_score* const &p2)
-{
- return p1->rank_i_ - p2->rank_i_;
+ Link_array<Paper_column> acs
+ = Group_interface__extract_elements (this, (Paper_column*) 0, "columns");
+ bool bfound = false;
+ for (int i= acs.size (); i -- ; )
+ {
+ bool brb = acs[i]->breakable_b();
+ bfound = bfound || brb;
+
+ /*
+ the last column should be breakable. Weed out any columns that
+ seem empty. We need to retain breakable columns, in case
+ someone forced a breakpoint.
+ */
+ if (!bfound
+ || (acs[i]->get_elt_property ("elements") == SCM_EOL
+ && !brb))
+ acs.del (i);
+ }
+ return acs;
}
-
void
fixup_refpoints (SCM s)
{
height = 50 CM;
}
- output_ = gh_cons (SCM_EOL, SCM_EOL);
- output_scheme (gh_list (ly_symbol2scm ("stop-line"), SCM_UNDEFINED));
+ /*
+ generate all molecules to trigger all font loads.
+
+ (ugh. This is not very memory efficient.) */
for (SCM s = get_elt_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
- unsmob_element (gh_car (s))->output_processing ();
+ unsmob_element (gh_car (s))->get_molecule ();
+
+ /*
+ font defs;
+ */
+ SCM font_names = ly_quote_scm (all_fonts_global_p->font_descriptions ());
+ output_scheme (gh_list (ly_symbol2scm ("define-fonts"),
+ font_names,
+ SCM_UNDEFINED));
+
+ /*
+ line preamble.
+ */
output_scheme (gh_list (ly_symbol2scm ("start-line"),
gh_double2scm (height),
SCM_UNDEFINED));
-}
+
+ Real il = paper_l ()->get_var ("interline");
-void
-Line_of_score::output_all ()
-{
- calculate_dependencies (BREWED, BREWING, &Score_element::output_processing);
+ /*
+ all elements.
+ */
+ for (SCM s = get_elt_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
+ {
+ Score_element * sc = unsmob_element (gh_car (s));
+ Molecule m = sc->get_molecule ();
+
+ Offset o (sc->relative_coordinate (this, X_AXIS),
+ sc->relative_coordinate (this, Y_AXIS));
+
+ SCM e = sc->get_elt_property ("extra-offset");
+ if (gh_pair_p (e))
+ {
+ o[X_AXIS] += il * gh_scm2double (gh_car (e));
+ o[Y_AXIS] += il * gh_scm2double (gh_cdr (e));
+ }
+
+ output_molecule (m.get_expr (), o);
+ }
+ output_scheme (gh_list (ly_symbol2scm ("stop-line"), SCM_UNDEFINED));
}
+
Link_array<Item>
Line_of_score::broken_col_range (Item const*l, Item const*r) const
{
Molecule
Lookup::blank (Box b)
{
- Molecule m;
- m.dim_ = b;
- return m;
+ return Molecule (b, SCM_EOL);
}
(c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
-/*
- ugh. Rewrite not finished yet. Still must copy atom lists.
- */
-
-
#include <math.h>
#include "font-metric.hh"
#include "interval.hh"
#include "string.hh"
#include "molecule.hh"
-
#include "debug.hh"
#include "killing-cons.tcc"
-
-Box
-Molecule::extent() const
-{
- return dim_;
-}
-
Interval
Molecule::extent(Axis a) const
{
Molecule::Molecule (Box b, SCM func)
{
expr_ = func;
- dim_ = b ;
+ dim_ = b;
}
Molecule::Molecule()
translate_axis (-r, a);
}
-
void
Molecule::add_at_edge (Axis a, Direction d, Molecule const &m, Real padding)
{
Real my_extent= empty_b () ? 0.0 : dim_[a][d];
- Interval i (m.extent ()[a]);
+ Interval i (m.extent (a));
if (i.empty_b ())
programming_error ("Molecule::add_at_edge: adding empty molecule.");
return expr_ == SCM_EOL;
}
-
SCM
fontify_atom(Font_metric * met, SCM f)
{
return gh_list (ly_symbol2scm ("fontify"),
ly_quote_scm (met->description ()), f, SCM_UNDEFINED);
}
+
+SCM
+Molecule::get_expr () const
+{
+ return expr_;
+}
if (translator_p_dict_p_->elem_b (name))
return translator_p_dict_p_->elem (name)->access_content_Translator_group (false);
- if (global_translator_dict_p->elem_b (name))
- return global_translator_dict_p->elem(name);
+ map<String, Translator*>::const_iterator ki
+ =global_translator_dict_p->find (name);
+
+ if (ki != global_translator_dict_p->end ())
+ return (*ki).second ;
return 0;
}
Molecule *e = &endings[LEFT];
endings[RIGHT] = *e;
- Real thick = e->dim_[Y_AXIS].length();
- Real len = e->dim_[X_AXIS].length () - thick;
+ Real thick = e->extent (Y_AXIS).length();
+ Real len = e->extent (X_AXIS).length () - thick;
Molecule total;
Direction d = LEFT;
do {
- endings[d].translate_axis (xwid[d] - endings[d].dim_[X_AXIS][d], X_AXIS);
+ endings[d].translate_axis (xwid[d] - endings[d].extent (X_AXIS)[d], X_AXIS);
total.add_molecule (endings[d]);
} while ((flip(&d)) != LEFT);
ly_quote_scm(style),
SCM_UNDEFINED))));
- Box ledgerless = out.dim_;
-
if (streepjes_i)
{
Direction dir = (Direction)sign (p);
- Interval hd = out.dim_[X_AXIS];
+ Interval hd = out.extent (X_AXIS);
Real hw = hd.length ()/4;
-
Molecule ledger (ledger_line (Interval (hd[LEFT] - hw,
hd[RIGHT] + hw)));
+
+ ledger.set_empty (true);
int parity = abs(int (p)) % 2;
for (int i=0; i < streepjes_i; i++)
out.add_molecule (s);
}
}
-
- out.dim_ = ledgerless;
return out;
}
{
Direction dir = Direction (sign (p->rank_i () - rank_i ()));
- if (!dir)
+ if (dir != RIGHT)
{
- programming_error ("Must set minimum distance between differing columns.");
+ programming_error ("Must set minimum distance LTOR.");
return;
}
- for (int i=0; i < minimal_dists_arr_drul_[dir].size (); i++)
+ for (int i=0; i < minimal_dists_.size (); i++)
{
- Column_rod &rod = minimal_dists_arr_drul_[dir][i];
+ Column_rod &rod = minimal_dists_[i];
if (rod.other_l_ == p)
{
rod.distance_f_ = rod.distance_f_ >? d;
cr.distance_f_ = d;
cr.other_l_ = p;
- minimal_dists_arr_drul_[dir].push (cr);
+ minimal_dists_.push (cr);
}
void
{
Direction dir = Direction (sign (p->rank_i () - rank_i ()));
- if (!dir)
+ if (dir != RIGHT)
{
- warning (_ ("Must set spring between differing columns"));
+ programming_error ("Must set springs LTOR");
return;
}
- for (int i=0; i < spring_arr_drul_[dir].size (); i++)
+ for (int i=0; i < springs_.size (); i++)
{
- Column_spring &spring = spring_arr_drul_[dir][i];
+ Column_spring &spring = springs_[i];
if (spring.other_l_ == p)
{
spring.distance_f_ = spring.distance_f_ >? d;
cr.strength_f_ = s;
cr.other_l_ = p;
- spring_arr_drul_[dir].push (cr);
+ springs_.push (cr);
}
int
rank_i_ = i;
}
-void
-Paper_column::do_print() const
-{
-#ifndef NPRINT
- DEBUG_OUT << "rank: " << rank_i_ << '\n';
- Direction d = LEFT;
- do
- {
- for (int i=0; i < minimal_dists_arr_drul_[d].size (); i++)
- {
- minimal_dists_arr_drul_[d][i].print ();
- }
- for (int i=0; i < spring_arr_drul_[d].size (); i++)
- {
- spring_arr_drul_[d][i].print ();
- }
-
- }
- while ((flip (&d))!=LEFT);
- Item::do_print ();
-#endif
-}
+
Line_of_score*
Paper_column::line_l() const
Ugh, this is messy.
*/
-Paper_outputter::Paper_outputter ()
+Paper_outputter::Paper_outputter (Paper_stream * ps )
{
+#if 0
molecules_ = gh_cons (SCM_EOL, SCM_EOL);
last_cons_ = molecules_;
+#endif
+
+ /*
+ lilypond -f scm x.ly
+ guile -s x.scm
+ */
+ verbatim_scheme_b_ = output_global_ch == String ("scm");
+
+ if (verbatim_scheme_b_)
+ {
+ *ps << ""
+ ";;; Usage: guile -s x.scm > x.tex\n"
+ "(primitive-load-path 'lily.scm)\n"
+ "(scm-tex-output)\n"
+ ";(scm-ps-output)\n"
+ "(map (lambda (x) (display (eval x))) '(\n"
+ ;
+ }
+
+ stream_p_ = ps;
+}
+
+Paper_outputter::~Paper_outputter ()
+{
+ if (verbatim_scheme_b_)
+ {
+ *stream_p_ << "))";
+ }
+ delete stream_p_;
}
void
Paper_outputter::output_scheme (SCM scm)
{
+#if 0
SCM c = gh_cons (scm,gh_cdr (last_cons_));
gh_set_cdr_x(last_cons_, c);
last_cons_ = c;
+#endif
+
+ dump_scheme (scm);
}
+#if 0
void
-Paper_outputter::dump_onto (Paper_stream *ps)
+Paper_outputter::dump ()
{
- if (String (output_global_ch) == "scm")
-#if 1 // both are fine
+
+ for (SCM s = gh_cdr (molecules_); gh_pair_p (s); s = gh_cdr (s))
{
- /*
- default to stdin
- */
- int fd = 1;
- if (ofstream* of = dynamic_cast<ofstream*> (ps->os))
- fd = of->rdbuf ()->fd ();
- SCM port = scm_fdes_to_port (fd, "a", SCM_EOL);
-
- /*
- lilypond -f scm x.ly
- guile -s x.scm
- */
- scm_display (gh_str02scm (
- ";;; Usage: guile -s x.scm > x.tex\n"
- "(primitive-load-path 'lily.scm)\n"
- "(scm-as-output)\n"
- ";(scm-tex-output)\n"
- ";(scm-ps-output)\n"
- "(map (lambda (x) (display (eval x))) '(\n"
- ), port);
-
- SCM newline = gh_str02scm ("\n");
- for (SCM s = gh_cdr (molecules_); gh_pair_p (s); s = gh_cdr (s))
- {
- scm_write (gh_car (s), port);
- scm_display (newline, port);
- scm_flush (port);
- }
- scm_display (gh_str02scm ("))"), port);
- scm_display (newline, port);
- scm_flush (port);
- scm_close_port (port);
+ dump_scheme (gh_car (s));
}
-#else
+}
+#endif
+
+void
+Paper_outputter::dump_scheme (SCM s)
+{
+ if (verbatim_scheme_b_)
{
- /*
- lilypond -f scm x.ly
- guile -s x.scm
- */
- if (output_global_ch == String ("scm"))
- *ps << ""
- ";;; Usage: guile -s x.scm > x.tex\n"
- "(primitive-load-path 'lily.scm)\n"
- "(scm-tex-output)\n"
- ";(scm-ps-output)\n"
- "(map (lambda (x) (display (eval x))) '(\n"
- ;
- for (SCM s = gh_cdr (molecules_); gh_pair_p (s); s = gh_cdr (s))
- {
- SCM result = scm_eval (scm_listify (ly_symbol2scm ("scm->string"),
- ly_quote_scm (gh_car (s)), SCM_UNDEFINED));
+ SCM result = scm_eval (scm_listify (ly_symbol2scm ("scm->string"),
+ ly_quote_scm (gh_car (s)), SCM_UNDEFINED));
- *ps << ly_scm2string (result);
- }
- *ps << "))";
+ *stream_p_ << ly_scm2string (result);
}
-#endif
-
else
{
- for (SCM s = gh_cdr (molecules_); gh_pair_p (s); s = gh_cdr (s))
- {
- SCM result = scm_eval (gh_car (s));
- char *c=gh_scm2newstr (result, NULL);
-
- *ps << c;
- free (c);
- }
- }
+ SCM result = scm_eval (s);
+ char *c=gh_scm2newstr (result, NULL);
+
+ *stream_p_ << c;
+ free (c);
+ }
}
-
void
Paper_outputter::output_scope (Scope *scope, String prefix)
{
ly_str02scm (to_str(v).ch_l ()),
SCM_UNDEFINED);
output_scheme (scm);
-
- // gh_define (k.ch_l (), gh_double2scm (v));
}
void
ly_str02scm (v.ch_l ()),
SCM_UNDEFINED);
output_scheme (scm);
-
- // gh_define (k.ch_l (), ly_str02scm (v.ch_l ()));
}
void
ly_str02scm (to_str (v).ch_l ()),
SCM_UNDEFINED);
output_scheme (scm);
-
- // gh_define (k.ch_l (), gh_int2scm (v));
}
Array<Column_x_positions> breaking = calc_breaking ();
line_l_->break_into_pieces (breaking);
- SCM lines = line_l_->output_lines ();
- outputter_l_ = new Paper_outputter ;
+ outputter_l_ = new Paper_outputter (paper_l_->paper_stream_p ());
+;
outputter_l_->output_header ();
outputter_l_->output_version();
scm = gh_list (ly_symbol2scm ("header-end"), SCM_UNDEFINED);
outputter_l_->output_scheme (scm);
- SCM font_names = ly_quote_scm (all_fonts_global_p->font_descriptions ());
- outputter_l_->output_scheme (gh_list (ly_symbol2scm ("define-fonts"),
- font_names,
- SCM_UNDEFINED));
-
- for (SCM i = lines ; gh_pair_p (i); i = gh_cdr (i))
- for (SCM j = gh_car (i) ; gh_pair_p (j); j = gh_cdr (j))
- outputter_l_->output_scheme (gh_car (j));
+ line_l_->output_lines ();
+
scm = gh_list (ly_symbol2scm ("end-output"), SCM_UNDEFINED);
outputter_l_->output_scheme (scm);
-
- Paper_stream* psp = paper_l_->paper_stream_p ();
- outputter_l_->dump_onto (psp);
// huh?
delete outputter_l_;
outputter_l_ = 0;
- delete psp;
}
item_l_drul_[LEFT] = item_l_drul_[RIGHT] =0;
}
-void
-Column_rod::print () const
-{
-#ifndef NDEBUG
- DEBUG_OUT << "Column_rod { rank = "
- << other_l_->rank_i () << ", dist = " << distance_f_ << "}\n";
-#endif
-}
Column_rod::Column_rod ()
{
return r1.other_l_->rank_i() - r2.other_l_->rank_i();
}
+
void
-Rod::add_to_cols ()
+Rod::columnize ()
{
Direction d = LEFT;
- Drul_array<Paper_column*> cols;
- Real extra_dist = 0.0;
do {
- cols[d] = item_l_drul_[d]->column_l ();
- extra_dist += item_l_drul_[d]->relative_coordinate (cols[d], X_AXIS);
+ Paper_column * pc = item_l_drul_[d]->column_l ();
+ distance_f_ += - d * item_l_drul_[d]->relative_coordinate (pc, X_AXIS);
+ item_l_drul_[d] = pc;
} while ((flip (&d))!=LEFT);
- if (cols[LEFT] != cols[RIGHT])
- do
- {
- cols[-d]->add_rod(cols[d], distance_f_ + extra_dist);
- }
- while ((flip (&d))!=LEFT);
+}
+
+void
+Rod::add_to_cols ()
+{
+ columnize();
+ if (item_l_drul_[LEFT] != item_l_drul_[RIGHT])
+ dynamic_cast<Paper_column*> (item_l_drul_[LEFT])->
+ add_rod(dynamic_cast<Paper_column*>(item_l_drul_[RIGHT]), distance_f_ );
}
make_rod (Single_malt_grouping_item *l, Single_malt_grouping_item *r)
{
Rod rod;
- rod.item_l_drul_[LEFT] =l;
- rod.item_l_drul_[RIGHT]=r;
Interval li (l->my_width ());
Interval ri (r->my_width ());
-
+
+ rod.item_l_drul_[LEFT] =l;
+ rod.item_l_drul_[RIGHT]=r;
+
if (li.empty_b () || ri.empty_b ())
rod.distance_f_ = 0;
else
rod.distance_f_ = li[RIGHT] - ri[LEFT];
+ rod.columnize ();
return rod;
}
a.push (rod);
}
}
-
+
+ /*
+ We've done our job, so we get lost.
+ */
+ for (SCM s = get_elt_property ("elements"); gh_pair_p (s); s = gh_cdr (s))
+ {
+ Item * it =dynamic_cast<Item*>(unsmob_element (gh_car (s)));
+ if (it && it->broken_b ())
+ {
+ it->find_prebroken_piece (LEFT) ->suicide ();
+ it->find_prebroken_piece (RIGHT)->suicide ();
+ }
+ it->suicide ();
+ }
+
+ ((Separating_group_spanner *)this)->suicide ();
+
return a;
}
TODO:
- add support for different stretch/shrink constants?
- - Use force as a minimizing function, and use it to discourage mixes of
- wide and tight lines.
*/
force_f_ = 0.;
indent_f_ =0.0;
default_space_f_ = 20 PT;
- compression_energy_factor_f_ = 3.0;
}
void
{
Paper_column * c = cols [i];
Column_spring *to_next = 0;
- for (int j =0; !to_next && j < c->spring_arr_drul_[RIGHT].size( ); j++)
+ for (int j =0; !to_next && j < c->springs_.size( ); j++)
{
- Column_spring &sp = c->spring_arr_drul_[RIGHT] [j];
+ Column_spring &sp = c->springs_ [j];
if (sp.other_l_ != cols[i+1])
continue;
if (!desc.sane_b ())
{
- programming_error ("Insane spring.");
- continue;
+ programming_error ("Insane spring found. Setting to unit spring.");
+ desc.hooke_f_ = 1.0;
+ desc.ideal_f_ = 1.0;
}
desc.block_force_f_ = - desc.hooke_f_ * desc.ideal_f_; // block at distance 0
for (int i=0; i < cols.size () - 1; i++)
{
- Array<Column_rod> * rods = &cols [i]->minimal_dists_arr_drul_[RIGHT];
+ Array<Column_rod> * rods = &cols [i]->minimal_dists_;
for (int j =0; j < rods->size( ); j++)
{
int oi = cols.find_i (rods->elem (j).other_l_ );
}
}
+ /*
+ TODO: should support natural length on only the last line.
+ */
if (line_len_f_ < 0)
my_solve_natural_len ();
else
void
Simple_spacer::solve (Column_x_positions *positions) const
{
- positions->energy_f_ = energy_f (); // abs (force_f_);
positions->force_f_ = force_f_;
positions->config_.push (indent_f_);
block_force_f_ = 0.0;
}
-Real
-Spring_description::energy_f (Real force) const
-{
- Real stretch = (force >? block_force_f_) / hooke_f_;
- Real e = 0.5 * stretch * stretch * hooke_f_;
- return e;
-}
bool
Spring_description::sane_b () const
}
-Real
-Simple_spacer::energy_f () const
-{
- Real e =0.;
-
- for (int i=0; i <springs_.size (); i++)
- {
- e += springs_[i].energy_f (force_f_);
- }
-
- if (force_f_ < 0)
- e *= compression_energy_factor_f_;
-
- return e;
-}
stretch_dist += right_dist;
if (s.distance_f_ <0)
- programming_error("negative dist");
-
+ {
+ programming_error("Negative dist, setting to 1.0 PT");
+ s.distance_f_ = 1.0;
+ }
if (stretch_dist == 0.0)
{
/*
Spacing_spanner::get_springs () const
{
Array<Spring> springs;
-
- SCM last_col = pscore_l_->line_l_->get_elt_property ("columns");
- Link_array<Paper_column> measure;
- for (SCM s = last_col; gh_pair_p (s); s = gh_cdr (s))
+
+ Link_array<Paper_column> all (pscore_l_->line_l_->column_l_arr ()) ;
+
+ int j = 0;
+
+ for (int i = 1; i < all.size (); i++)
{
- Score_element * elt = unsmob_element (gh_car (s));
- Paper_column* sc = dynamic_cast<Paper_column*> (elt);
- measure.push (sc);
+ Paper_column* sc = dynamic_cast<Paper_column*> (all[i]);
if (sc->breakable_b ())
{
- measure.reverse ();
+ Link_array<Paper_column> measure (all.slice (j, i+1));
springs.concat (do_measure (measure));
- measure.clear ();
- measure.push (sc);
+ j = i;
}
}
+
+ /*
+ farewell, cruel world
+ */
+ ((Spacing_spanner*)this)->suicide ();
+
return springs;
}
void
Spring::add_to_cols ()
{
- Direction d = LEFT;
- do
- {
- item_l_drul_[-d]->column_l ()->add_spring
- (item_l_drul_[d]->column_l (),
- distance_f_, strength_f_);
- }
- while ((flip (&d))!=LEFT);
+ item_l_drul_[LEFT]->column_l ()->add_spring (item_l_drul_[RIGHT]->column_l (), distance_f_, strength_f_);
}
return r1.other_l_->rank_i() - r2.other_l_->rank_i();
}
-void
-Column_spring::print () const
-{
-#ifndef NPRINT
- DEBUG_OUT << "Column_spring { rank = "
- << other_l_->rank_i () << ", dist = " << distance_f_ << "}\n";
-
-#endif
-}
mol.add_molecule (b);
}
if (tremolo_flags)
- mol.translate_axis (-mol.extent ()[Y_AXIS].center (), Y_AXIS);
+ mol.translate_axis (-mol.extent (Y_AXIS).center (), Y_AXIS);
Real half_space = Staff_symbol_referencer_interface (stem).staff_space ()
/ 2;
Beams should intersect one beamthickness below stem end
*/
Real dy = stem->stem_end_position () * half_space;
- dy -= mol.extent ()[Y_AXIS].length () / 2 * stem->get_direction ();
+ dy -= mol.extent (Y_AXIS).length () / 2 * stem->get_direction ();
/*
uhg. Should use relative coords and placement
; // TODO!
else
{
- r = s->flag ().dim_.x ();
+ r = s->flag ().extent (X_AXIS);
}
return r;
}
Real h = height + 2 * arc_height;
Box b (Interval (0, 1.5 * staff_space), Interval (-h/2, h/2));
Molecule mol (b, at);
-
- mol.translate_axis (- mol.dim_[X_AXIS].length () / 2, X_AXIS);
+ mol.align_to (X_AXIS, CENTER);
return mol;
}
SCM s = get_elt_property ("word-space");
if (gh_number_p (s))
- mol.dim_.interval_a_[X_AXIS][RIGHT] += gh_scm2double (s)
- * staff_symbol_referencer (this).staff_space ();
-
+ {
+ Molecule m;
+ m.set_empty (false);
+ mol.add_at_edge (X_AXIS, RIGHT, m, gh_scm2double (s)*
+ staff_symbol_referencer (this).staff_space ());
+ }
return mol;
}
if (!global_translator_dict_p)
global_translator_dict_p = new Dictionary<Translator*>;
- global_translator_dict_p->elem (classname (t)) = t;
+ (*global_translator_dict_p)[classname (t)] = t;
}
Translator*
Link_array<Note_column> column_arr=
Group_interface__extract_elements (this, (Note_column*)0, "columns");
-
+
+ Score_element * common = common_refpoint (get_elt_property ("columns"), Y_AXIS);
+
Direction d = directional_element (this).get ();
/*
if (l < r)
{
- *dy = column_arr[r]->extent (Y_AXIS) [d]
- - column_arr[l]->extent (Y_AXIS) [d];
+ *dy = column_arr[r]->extent (Y_AXIS) [d] + column_arr[r]->relative_coordinate (common, Y_AXIS)
+ - column_arr[l]->extent (Y_AXIS) [d] - column_arr[l]->relative_coordinate (common, Y_AXIS);
}
else
* dy = 0;
for (int i = 0; i < column_arr.size (); i++)
{
- Real notey = column_arr[i]->extent (Y_AXIS)[d];
+ Real notey = column_arr[i]->extent (Y_AXIS)[d] +
+ column_arr[i]->relative_coordinate (common, Y_AXIS)
+ ;
Real x = column_arr[i]->relative_coordinate (0, X_AXIS) - x0;
Real tuplety = *dy * x * factor;
projects / lilypond.git / commitdiff