@code{} tags to property description.
* lily/include/line-group-group-engraver.hh (Module): remove file.
* python/convertrules.py (conv): add rule for
Engraver_group_engraver -> Engraver_group.
* lily/include/performer-group-performer.hh: analogous.
* lily/include/engraver-group-engraver.hh: rename to Engraver_group.
* lily/context-def.cc (instantiate): check for
Engraver_group_engraver and Performer_group_performer not
Engraver/Performer. Fixes crashes when doing \with { \consist .. }
2005-08-18 Han-Wen Nienhuys <hanwen@xs4all.nl>
+ * scm/define-grob-properties.scm (all-user-grob-properties): add
+ @code{} tags to property description.
+
+ * lily/include/line-group-group-engraver.hh (Module): remove file.
+
+ * python/convertrules.py (conv): add rule for
+ Engraver_group_engraver -> Engraver_group.
+
+ * lily/include/performer-group-performer.hh: analogous.
+
+ * lily/include/engraver-group-engraver.hh: rename to Engraver_group.
+
* lily/context-def.cc (instantiate): check for
Engraver_group_engraver and Performer_group_performer not
Engraver/Performer. Fixes crashes when doing \with { \consist .. }
#include "translator-group.hh"
#include "warn.hh"
+#include "engraver-group-engraver.hh"
+#include "performer-group-performer.hh"
+
Context_def::Context_def ()
{
context_aliases_ = SCM_EOL;
g->simple_trans_list_ = trans_list;
context->implementation_ = g;
- if (dynamic_cast<Engraver_group_engraver *> (g))
+ if (dynamic_cast<Engraver_group *> (g))
g->simple_trans_list_ = filter_performers (g->simple_trans_list_);
- else if (dynamic_cast<Performer_group_performer *> (g))
+ else if (dynamic_cast<Performer_group *> (g))
g->simple_trans_list_ = filter_engravers (g->simple_trans_list_);
g->context_ = context;
/*
- engraver-group-engraver.cc -- implement Engraver_group_engraver
+ engraver-group-engraver.cc -- implement Engraver_group
source file of the GNU LilyPond music typesetter
#include "translator-dispatch-list.hh"
void
-Engraver_group_engraver::announce_grob (Grob_info info)
+Engraver_group::announce_grob (Grob_info info)
{
announce_infos_.push (info);
- Engraver_group_engraver *dad_eng
+ Engraver_group *dad_eng
= context_->get_parent_context ()
- ? dynamic_cast<Engraver_group_engraver *> (context_->get_parent_context ()->implementation ())
+ ? dynamic_cast<Engraver_group *> (context_->get_parent_context ()->implementation ())
: 0;
if (dad_eng)
dad_eng->announce_grob (info);
}
void
-Engraver_group_engraver::acknowledge_grobs ()
+Engraver_group::acknowledge_grobs ()
{
if (!announce_infos_.size ())
return;
the group count?
*/
int
-Engraver_group_engraver::pending_grob_count () const
+Engraver_group::pending_grob_count () const
{
int count = announce_infos_.size ();
for (SCM s = context_->children_contexts ();
scm_is_pair (s); s = scm_cdr (s))
{
Context *c = unsmob_context (scm_car (s));
- Engraver_group_engraver *group
- = dynamic_cast<Engraver_group_engraver *> (c->implementation ());
+ Engraver_group *group
+ = dynamic_cast<Engraver_group *> (c->implementation ());
if (group)
count += group->pending_grob_count ();
}
void
-Engraver_group_engraver::do_announces ()
+Engraver_group::do_announces ()
{
do
{
scm_is_pair (s); s = scm_cdr (s))
{
Context *c = unsmob_context (scm_car (s));
- Engraver_group_engraver *group
- = dynamic_cast<Engraver_group_engraver *> (c->implementation ());
+ Engraver_group *group
+ = dynamic_cast<Engraver_group *> (c->implementation ());
if (group)
group->do_announces ();
}
while (pending_grob_count () > 0);
}
-Engraver_group_engraver::Engraver_group_engraver ()
+Engraver_group::Engraver_group ()
{
acknowledge_hash_table_ = SCM_EOL;
acknowledge_hash_table_ = scm_c_make_hash_table (61);
#include "translator.icc"
-ADD_TRANSLATOR_GROUP (Engraver_group_engraver,
+ADD_TRANSLATOR_GROUP (Engraver_group,
/* doc */ "A group of engravers taken together",
/* create */ "",
/* accept */ "",
/* write */ "");
void
-Engraver_group_engraver::derived_mark () const
+Engraver_group::derived_mark () const
{
scm_gc_mark (acknowledge_hash_table_);
}
#include "score-context.hh"
#include "lilypond-key.hh"
-Engraver_group_engraver *
+Engraver_group *
Engraver::get_daddy_engraver () const
{
- return dynamic_cast<Engraver_group_engraver *> (get_daddy_translator ());
+ return dynamic_cast<Engraver_group *> (get_daddy_translator ());
}
void
Grob_info i (this, e);
- Engraver_group_engraver *g = get_daddy_engraver ();
+ Engraver_group *g = get_daddy_engraver ();
if (g)
g->announce_grob (i);
}
-
/*
- engraver-group-engraver.hh -- declare Engraver_group_engraver
+ engraver-group-engraver.hh -- declare Engraver_group
source file of the GNU LilyPond music typesetter
#include "engraver.hh"
#include "translator-group.hh"
-class Engraver_group_engraver : public virtual Translator_group
+class Engraver_group : public virtual Translator_group
{
protected:
Array<Grob_info> announce_infos_;
SCM acknowledge_hash_table_;
public:
- VIRTUAL_COPY_CONSTRUCTOR (Translator_group, Engraver_group_engraver);
- Engraver_group_engraver ();
+ VIRTUAL_COPY_CONSTRUCTOR (Translator_group, Engraver_group);
+ Engraver_group ();
virtual void derived_mark () const;
void do_announces ();
virtual void announce_grob (Grob_info);
class Engraver : public Translator
{
- friend class Engraver_group_engraver;
+ friend class Engraver_group;
protected:
/*
take note of item/spanner
*/
virtual void acknowledge_grob (Grob_info) {}
virtual void announce_grob (Grob_info);
- Engraver_group_engraver *get_daddy_engraver () const;
+ Engraver_group *get_daddy_engraver () const;
public:
/**
class Context_specced_music;
class Engraver;
class Engraver;
-class Engraver_group_engraver;
+class Engraver_group;
class Event;
class Event_chord;
class Event_chord_iterator;
class Paper_system;
class Performance;
class Performer;
-class Performer_group_performer;
+class Performer_group;
class Piano_bar_engraver;
class Pitch;
class Pitch_squash_engraver;
+++ /dev/null
-/*
- line-group-engraver.hh -- declare Line_group_engraver
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1997--2005 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-*/
-
-#ifndef LINE_GROUP_GRAV_HH
-#define LINE_GROUP_GRAV_HH
-
-#include "engraver-group-engraver.hh"
-
-/**
- Engravers put elements on the same or lowel level in a line.
-
- DEPRECATED.
-*/
-class Line_group_engraver_group : public Engraver_group_engraver
-{
-protected:
- Spanner *staffline_;
-
- virtual void create_line_spanner ();
- virtual void initialize ();
- virtual void finalize ();
-public:
- TRANSLATOR_DECLARATIONS (Line_group_engraver_group);
-};
-
-#endif // LINE_GROUP_GRAV_HH
-
/*
- performer-group-performer.hh -- declare Performer_group_performer
+ performer-group-performer.hh -- declare Performer_group
(c) 1996--2005 Han-Wen Nienhuys <hanwen@cs.uu.nl>
Jan Nieuwenhuizen <janneke@gnu.org>
typedef void (Performer:: *Performer_method) (void);
-class Performer_group_performer : public virtual Translator_group
+class Performer_group : public virtual Translator_group
{
public:
- VIRTUAL_COPY_CONSTRUCTOR (Translator_group, Performer_group_performer);
+ VIRTUAL_COPY_CONSTRUCTOR (Translator_group, Performer_group);
void do_announces ();
virtual void announce_element (Audio_element_info);
{
public:
VIRTUAL_COPY_CONSTRUCTOR (Translator, Performer);
- friend class Performer_group_performer;
- Performer_group_performer *get_daddy_performer () const;
+ friend class Performer_group;
+ Performer_group *get_daddy_performer () const;
protected:
virtual void announce_element (Audio_element_info);
/*
- recording-group-engraver.hh -- declare
+ recording-group-engraver.hh -- declare Recording_group_engraver
source file of the GNU LilyPond music typesetter
#include "engraver-group-engraver.hh"
-class Recording_group_engraver : public Engraver_group_engraver
+class Recording_group_engraver : public Engraver_group
{
public:
VIRTUAL_COPY_CONSTRUCTOR (Translator_group, Recording_group_engraver);
#include "score-translator.hh"
class Score_engraver : public virtual Score_translator,
- public virtual Engraver_group_engraver
+ public virtual Engraver_group
{
System *system_;
/**
Top level performer. Completely takes care of MIDI output
*/
-class Score_performer : public Score_translator, public virtual Performer_group_performer
+class Score_performer : public Score_translator,
+ public virtual Performer_group
{
public:
VIRTUAL_COPY_CONSTRUCTOR (Translator_group, Score_performer);
|| key == SCM_EOL)
&& !scm_is_eq (last, key))
{
- cancellation_ = make_item ("KeyCancellation",
- key_event_
- ? key_event_->self_scm () : SCM_EOL);
-
SCM restore = SCM_EOL;
SCM *tail = &restore;
for (SCM s = last; scm_is_pair (s); s = scm_cdr (s))
}
}
- cancellation_->set_property ("alteration-alist", restore);
- cancellation_->set_property ("c0-position",
- get_property ("middleCPosition"));
+ if (scm_is_pair (restore))
+ {
+ cancellation_ = make_item ("KeyCancellation",
+ key_event_
+ ? key_event_->self_scm () : SCM_EOL);
+
+ cancellation_->set_property ("alteration-alist", restore);
+ cancellation_->set_property ("c0-position",
+ get_property ("middleCPosition"));
+ }
}
item_->set_property ("alteration-alist", key);
}
/*
- performer-group-performer.cc -- implement Performer_group_performer
+ performer-group-performer.cc -- implement Performer_group
source file of the GNU LilyPond music typesetter
#include "audio-element.hh"
#include "warn.hh"
-ADD_TRANSLATOR_GROUP (Performer_group_performer,
+ADD_TRANSLATOR_GROUP (Performer_group,
/* doc */ "",
/* create */ "",
/* accept */ "",
/* write */ "");
void
-Performer_group_performer::announce_element (Audio_element_info info)
+Performer_group::announce_element (Audio_element_info info)
{
announce_infos_.push (info);
Translator_group *t
= context ()->get_parent_context ()->implementation ();
- if (Performer_group_performer *eg = dynamic_cast<Performer_group_performer *> (t))
+ if (Performer_group *eg = dynamic_cast<Performer_group *> (t))
eg->announce_element (info);
}
void
-Performer_group_performer::acknowledge_audio_elements ()
+Performer_group::acknowledge_audio_elements ()
{
for (int j = 0; j < announce_infos_.size (); j++)
{
}
void
-Performer_group_performer::do_announces ()
+Performer_group::do_announces ()
{
while (1)
{
}
void
-Performer_group_performer::play_element (Audio_element *e)
+Performer_group::play_element (Audio_element *e)
{
Context *c = context_->get_parent_context ();
if (c)
{
- Performer_group_performer *pgp = dynamic_cast<Performer_group_performer *> (c->implementation ());
+ Performer_group *pgp = dynamic_cast<Performer_group *> (c->implementation ());
pgp->play_element (e);
}
}
int
-Performer_group_performer::get_tempo () const
+Performer_group::get_tempo () const
{
Context *c = context_->get_parent_context ();
if (c)
{
- Performer_group_performer *pgp = dynamic_cast<Performer_group_performer *> (c->implementation ());
+ Performer_group *pgp = dynamic_cast<Performer_group *> (c->implementation ());
return pgp->get_tempo ();
}
return 60;
return get_daddy_performer ()->get_tempo ();
}
-Performer_group_performer *
+Performer_group *
Performer::get_daddy_performer () const
{
return
- dynamic_cast<Performer_group_performer *> (get_daddy_translator ());
+ dynamic_cast<Performer_group *> (get_daddy_translator ());
}
void
void
Recording_group_engraver::derived_mark () const
{
- Engraver_group_engraver::derived_mark ();
+ Engraver_group::derived_mark ();
scm_gc_mark (now_events_);
scm_gc_mark (accumulator_);
}
}
ADD_TRANSLATOR_GROUP (Recording_group_engraver,
- "Engraver_group_engraver that records all music events "
+ "Engraver_group that records all music events "
"for this context. Calls the procedure "
"in @code{recordEventSequence} when finished.",
"",
if (pscore_)
scm_gc_mark (pscore_->self_scm ());
Score_translator::derived_mark ();
- Engraver_group_engraver::derived_mark ();
+ Engraver_group::derived_mark ();
}
void
system_ = pscore_->root_system ();
context ()->set_property ("rootSystem", system_->self_scm ());
- Engraver_group_engraver::initialize ();
+ Engraver_group::initialize ();
}
void
if (!to_boolean (context ()->get_property ("skipTypesetting")))
{
precomputed_recurse_over_translators (context (), PROCESS_MUSIC, UP);
- Engraver_group_engraver::do_announces ();
+ Engraver_group::do_announces ();
}
precomputed_recurse_over_translators (context (), STOP_TRANSLATION_TIMESTEP, UP);
bool
Score_engraver::try_music (Music *m)
{
- if (Engraver_group_engraver::try_music (m))
+ if (Engraver_group::try_music (m))
return true;
return false;
scm_gc_mark (performance_->self_scm ());
Score_translator::derived_mark ();
- Performer_group_performer::derived_mark ();
+ Performer_group::derived_mark ();
}
void
Translator_group *
get_translator_group (SCM sym)
{
- if (sym == ly_symbol2scm ("Engraver_group_engraver"))
- return new Engraver_group_engraver ();
- else if (sym == ly_symbol2scm ("Performer_group_performer"))
- return new Performer_group_performer ();
+ if (sym == ly_symbol2scm ("Engraver_group"))
+ return new Engraver_group ();
+ else if (sym == ly_symbol2scm ("Performer_group"))
+ return new Performer_group ();
else if (sym == ly_symbol2scm ("Score_engraver"))
return new Score_engraver ();
else if (sym == ly_symbol2scm ("Score_performer"))
'''keyAccidentalOrder->keyAlterationOrder'''))
+
+def conv (str):
+ str = re.sub('Performer_group_performer', 'Performer_group', str)
+ str = re.sub('Engraver_group_engraver', 'Engraver_group', str)
+ return str
+
+conversions.append (((2, 7, 6), conv,
+ '''Performer_group_performer -> Performer_group, Engraver_group_engraver -> Engraver_group'''))
+
+
################################################################
def str_to_tuple (s):
of note-column for horizontal shifting. This is used by
@internalsref{note-collision-interface}.")
(avoid-slur ,symbol? "Method of handling slur collisions.
-Choices are @{around}, @{inside}, @{outside}. If unset, script
+Choices are @code{around}, @code{inside}, @code{outside}. If unset, script
and slur ignore eachother.")
(inspect-quants ,number-pair? "If debugging is set,
set beam quant to this position, and print the respective scores.")