Added old abandoned KDE3 version of the RoseGarden MIDI tool

git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/rosegarden@1097595 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 979 insertions, 0 deletions

diff --git a/src/gui/editors/notation/NotationGroup.cpp b/src/gui/editors/notation/NotationGroup.cpp
new file mode 100644
index 0000000..78525d9
--- /dev/null
+++ b/src/gui/editors/notation/NotationGroup.cpp
@@ -0,0 +1,979 @@
+/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
+
+/*
+    Rosegarden
+    A MIDI and audio sequencer and musical notation editor.
+ 
+    This program is Copyright 2000-2008
+        Guillaume Laurent   <[email protected]>,
+        Chris Cannam        <[email protected]>,
+        Richard Bown        <[email protected]>
+ 
+    The moral rights of Guillaume Laurent, Chris Cannam, and Richard
+    Bown to claim authorship of this work have been asserted.
+ 
+    Other copyrights also apply to some parts of this work.  Please
+    see the AUTHORS file and individual file headers for details.
+ 
+    This program 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 2 of the
+    License, or (at your option) any later version.  See the file
+    COPYING included with this distribution for more information.
+*/
+
+
+#include "NotationGroup.h"
+#include "misc/Debug.h"
+
+#include "base/Equation.h"
+#include "base/Event.h"
+#include "base/NotationRules.h"
+#include "base/NotationTypes.h"
+#include "base/Quantizer.h"
+#include "NotationChord.h"
+#include "NotationElement.h"
+#include "NotationProperties.h"
+#include "NotationStaff.h"
+#include "NoteStyleFactory.h"
+#include "NotePixmapFactory.h"
+
+
+namespace Rosegarden
+{
+
+NotationGroup::NotationGroup(NotationElementList &nel,
+                             NELIterator i, const Quantizer *q,
+                             std::pair<timeT, timeT> barRange,
+                             const NotationProperties &p,
+                             const Clef &clef, const Key &key) :
+    AbstractSet<NotationElement, NotationElementList>(nel, i, q),
+    m_barRange(barRange),
+    //!!! What if the clef and/or key change in the course of the group?
+    m_clef(clef),
+    m_key(key),
+    m_weightAbove(0),
+    m_weightBelow(0),
+    m_userSamples(false),
+    m_type(Beamed),
+    m_properties(p)
+{
+    if (!(*i)->event()->get<Int>
+        (BaseProperties::BEAMED_GROUP_ID, m_groupNo)) m_groupNo = -1;
+
+    initialise();
+
+    /*
+    NOTATION_DEBUG << "NotationGroup::NotationGroup: id is " << m_groupNo << endl;
+    i = getInitialElement(); 
+    while (i != getContainer().end()) {
+        long gid = -1;
+        (*i)->event()->get<Int>(BEAMED_GROUP_ID, gid);
+        NOTATION_DEBUG << "Found element with group id "
+                             << gid << endl;
+        if (i == getFinalElement()) break;
+        ++i;
+    }
+    */
+}
+
+NotationGroup::NotationGroup(NotationElementList &nel,
+                             const Quantizer *q,
+                             const NotationProperties &p,
+                             const Clef &clef, const Key &key) :
+        AbstractSet<NotationElement, NotationElementList>(nel, nel.end(), q),
+        m_barRange(0, 0),
+        //!!! What if the clef and/or key change in the course of the group?
+        m_clef(clef),
+        m_key(key),
+        m_weightAbove(0),
+        m_weightBelow(0),
+        m_userSamples(true),
+        m_groupNo( -1),
+        m_type(Beamed),
+        m_properties(p)
+{
+    //...
+}
+
+NotationGroup::~NotationGroup()
+{}
+
+bool NotationGroup::test(const NELIterator &i)
+{
+    // An event is a candidate for being within the bounds of the
+    // set if it's simply within the same bar as the original event.
+    // (Groups may contain other groups, so our bounds may enclose
+    // events that aren't members of the group: we reject those in
+    // sample rather than test, so as to avoid erroneously ending
+    // the group too soon.)
+
+    return ((*i)->getViewAbsoluteTime() >= m_barRange.first &&
+            (*i)->getViewAbsoluteTime() < m_barRange.second);
+}
+
+bool
+NotationGroup::sample(const NELIterator &i, bool goingForwards)
+{
+    if (m_baseIterator == getContainer().end()) {
+        m_baseIterator = i;
+        if (m_userSamples)
+            m_initial = i;
+    }
+    if (m_userSamples)
+        m_final = i;
+
+    std::string t;
+    if (!(*i)->event()->get<String>(BaseProperties::BEAMED_GROUP_TYPE, t)) {
+        NOTATION_DEBUG << "NotationGroup::NotationGroup: Rejecting sample() for non-beamed element" << endl;
+        return false;
+    }
+
+    long n;
+    if (!(*i)->event()->get<Int>(BaseProperties::BEAMED_GROUP_ID, n)) return false;
+    if (m_groupNo == -1) {
+        m_groupNo = n;
+    } else if (n != m_groupNo) {
+        NOTATION_DEBUG << "NotationGroup::NotationGroup: Rejecting sample() for event with group id " << n << " (mine is " << m_groupNo << ")" << endl;
+        return false;
+    }
+
+    if (t == BaseProperties::GROUP_TYPE_BEAMED) {
+        m_type = Beamed;
+    } else if (t == BaseProperties::GROUP_TYPE_TUPLED) {
+        m_type = Tupled;
+    } else if (t == BaseProperties::GROUP_TYPE_GRACE) {
+        std::cerr << "NotationGroup::NotationGroup: WARNING: Obsolete group type Grace found" << std::endl;
+        return false;
+    } else {
+        NOTATION_DEBUG << "NotationGroup::NotationGroup: Warning: Rejecting sample() for unknown GroupType \"" << t << "\"" << endl;
+        return false;
+    }
+
+    NOTATION_DEBUG << "NotationGroup::sample: group id is " << m_groupNo << endl;
+
+    AbstractSet<NotationElement, NotationElementList>::sample
+        (i, goingForwards);
+
+    // If the sum of the distances from the middle line to the notes
+    // above the middle line exceeds the sum of the distances from the
+    // middle line to the notes below, then the beam goes below.  We
+    // can calculate the weightings here, as we construct the group.
+
+    if (!static_cast<NotationElement*>(*i)->isNote())
+        return true;
+    if (m_userSamples) {
+        if (m_initialNote == getContainer().end()) m_initialNote = i;
+        m_finalNote = i;
+    }
+
+    // The code that uses the Group should not rely on the presence of
+    // e.g. BEAM_GRADIENT to indicate that a beam should be drawn;
+    // it's possible the gradient might be left over from a previous
+    // calculation and the group might have changed since.  Instead it
+    // should test BEAMED, which may be false even if there is a
+    // gradient present.
+    (*i)->event()->setMaybe<Bool>(NotationProperties::BEAMED, false);
+
+    int h = height(i);
+    if (h > 4)
+        m_weightAbove += h - 4;
+    if (h < 4)
+        m_weightBelow += 4 - h;
+
+    return true;
+}
+
+bool
+NotationGroup::contains(const NELIterator &i) const
+{
+    NELIterator j(getInitialElement()),
+    k( getFinalElement());
+
+    for (;;) {
+        if (j == i)
+            return true;
+        if (j == k)
+            return false;
+        ++j;
+    }
+}
+
+int
+NotationGroup::height(const NELIterator &i) const
+{
+    long h = 0;
+    if ((*i)->event()->get<Int>(NotationProperties::HEIGHT_ON_STAFF, h)) {
+        return h;
+    }
+
+    //!!!    int pitch = (*i)->event()->get<Int>(PITCH);
+    //    NotationDisplayPitch p(pitch, m_clef, m_key);
+    //    h = p.getHeightOnStaff();
+
+    try {
+        Pitch pitch(*getAsEvent(i));
+        h = pitch.getHeightOnStaff(m_clef, m_key);
+    } catch (...) {
+        // no pitch!
+    }
+
+    // not setMaybe, as we know the property is absent:
+    (*i)->event()->set<Int>(NotationProperties::HEIGHT_ON_STAFF, h, false);
+    return h;
+}
+
+void
+NotationGroup::applyStemProperties()
+{
+    NotationRules rules;
+
+    NELIterator
+        initialNote(getInitialNote()),
+        finalNote(getFinalNote());
+
+    if (initialNote == getContainer().end() ||
+        initialNote == finalNote) {
+        //!!! This is not true -- if initialNote == finalNote there is
+        // one note in the group, not none.  But we still won't have a
+        // beam.
+        NOTATION_DEBUG << "NotationGroup::applyStemProperties: no notes in group"
+                       << endl;
+        return; // no notes, no case to answer
+    }
+
+    if (getHighestNote() == getContainer().end()) {
+        std::cerr << "ERROR: NotationGroup::applyStemProperties: no highest note!" << std::endl;
+        abort();
+    }
+
+    if (getLowestNote() == getContainer().end()) {
+        std::cerr << "ERROR: NotationGroup::applyStemProperties: no lowest note!" << std::endl;
+        abort();
+    }
+
+    int up = 0, down = 0;
+
+    for (NELIterator i = initialNote; i != getContainer().end(); ++i) {
+        NotationElement* el = static_cast<NotationElement*>(*i);
+        if (el->isNote()) {
+            if (el->event()->has(NotationProperties::STEM_UP)) {
+                if (el->event()->get<Bool>(NotationProperties::STEM_UP)) ++up;
+                else ++down;
+            }
+        }
+
+        if (i == finalNote) break;
+    }
+
+    NOTATION_DEBUG << "NotationGroup::applyStemProperties: weightAbove "
+                   << m_weightAbove << ", weightBelow " << m_weightBelow
+                   << ", up " << up << ", down " << down << endl;
+
+    bool aboveNotes = rules.isBeamAbove(height(getHighestNote()),
+                                        height(getLowestNote()),
+                                        m_weightAbove,
+                                        m_weightBelow);
+    if (up != down) {
+        if (up > down) aboveNotes = true;
+        else aboveNotes = false;
+    }
+
+    NOTATION_DEBUG << "NotationGroup::applyStemProperties: hence aboveNotes "
+                   << aboveNotes << endl;
+
+    /*!!!
+        if ((*initialNote)->event()->has(STEM_UP) &&
+    	(*initialNote)->event()->isPersistent<Bool>(STEM_UP)) {
+    	aboveNotes = (*initialNote)->event()->get<Bool>(STEM_UP);
+        }
+     
+        if ((*initialNote)->event()->has(NotationProperties::BEAM_ABOVE) &&
+    	(*initialNote)->event()->isPersistent<Bool>(NotationProperties::BEAM_ABOVE)) {
+    	aboveNotes = (*initialNote)->event()->get<Bool>
+    	    (NotationProperties::BEAM_ABOVE);
+        }
+    */
+    for (NELIterator i = initialNote; i != getContainer().end(); ++i) {
+
+        NotationElement* el = static_cast<NotationElement*>(*i);
+
+        el->event()->setMaybe<Bool>(NotationProperties::BEAM_ABOVE, aboveNotes);
+
+        if (el->isNote() &&
+            el->event()->has(BaseProperties::NOTE_TYPE) &&
+            el->event()->get<Int>(BaseProperties::NOTE_TYPE) < Note::Crotchet &&
+            el->event()->has(BaseProperties::BEAMED_GROUP_ID) &&
+            el->event()->get<Int>(BaseProperties::BEAMED_GROUP_ID) == m_groupNo) {
+
+            el->event()->setMaybe<Bool>(NotationProperties::BEAMED, true);
+            //	    el->event()->setMaybe<Bool>(m_properties.VIEW_LOCAL_STEM_UP, aboveNotes);
+
+        } else if (el->isNote()) {
+
+            if (i == initialNote || i == finalNote) {
+                (*i)->event()->setMaybe<Bool>
+                    (m_properties.VIEW_LOCAL_STEM_UP, aboveNotes);
+            } else {
+                (*i)->event()->setMaybe<Bool>
+                    (m_properties.VIEW_LOCAL_STEM_UP, !aboveNotes);
+            }
+        }
+
+        if (i == finalNote) break;
+    }
+}
+
+bool
+NotationGroup::haveInternalRest()
+const
+{
+    bool inside = false;
+    bool found = false;
+
+    for (NELIterator i = getInitialNote(); i != getContainer().end(); ++i) {
+        NotationElement* el = static_cast<NotationElement*>(*i);
+
+        if (el->isNote() &&
+                el->event()->has(BaseProperties::NOTE_TYPE) &&
+                el->event()->get<Int>(BaseProperties::NOTE_TYPE) < Note::Crotchet &&
+                el->event()->has(BaseProperties::BEAMED_GROUP_ID) &&
+                el->event()->get<Int>(BaseProperties::BEAMED_GROUP_ID) == m_groupNo) {
+            if (found) return true; // a rest is wholly enclosed by beamed notes
+            inside = true;
+        }
+
+        if (el->isRest() && inside) found = true;
+
+        if (i == getFinalNote()) break;
+    }
+
+    return false;
+}
+
+NotationGroup::Beam
+NotationGroup::calculateBeam(NotationStaff &staff)
+{
+    NotationRules rules;
+
+    Beam beam;
+    beam.aboveNotes = true;
+    beam.startY = 0;
+    beam.gradient = 0;
+    beam.necessary = false;
+
+    NELIterator 
+        initialNote(getInitialNote()),
+        finalNote(getFinalNote());
+
+    if (initialNote == getContainer().end() ||
+        initialNote == finalNote) {
+        return beam; // no notes, or at most one: no case to answer
+    }
+
+    beam.aboveNotes = rules.isBeamAbove(height(getHighestNote()),
+                                        height(getLowestNote()),
+                                        m_weightAbove,
+                                        m_weightBelow);
+
+    if ((*initialNote)->event()->has(NotationProperties::BEAM_ABOVE)) {
+        beam.aboveNotes = (*initialNote)->event()->get
+                          <Bool>
+                          (NotationProperties::BEAM_ABOVE);
+    }
+
+    timeT crotchet = Note(Note::Crotchet).getDuration();
+
+    beam.necessary =
+        (*initialNote)->getViewDuration() < crotchet &&
+        (*finalNote)->getViewDuration() < crotchet;
+
+    beam.necessary = beam.necessary &&
+        (((*finalNote)->getViewAbsoluteTime() >
+          (*initialNote)->getViewAbsoluteTime()) ||
+         (((*finalNote)->getViewAbsoluteTime() ==
+           (*initialNote)->getViewAbsoluteTime()) &&
+          ((*finalNote)->event()->getSubOrdering() >
+           (*initialNote)->event()->getSubOrdering())));
+
+    // We continue even if the beam is not necessary, because the
+    // same data is used to generate the tupling line in tupled
+    // groups that do not have beams
+
+    // if (!beam.necessary) return beam;
+
+    NOTATION_DEBUG << "NotationGroup::calculateBeam: beam necessariness: " << beam.necessary << endl;
+
+    NotationChord initialChord(getContainer(), initialNote, &getQuantizer(),
+                               m_properties, m_clef, m_key),
+    finalChord(getContainer(), finalNote, &getQuantizer(),
+               m_properties, m_clef, m_key);
+
+    if (initialChord.getInitialElement() == finalChord.getInitialElement()) {
+        return beam;
+    }
+
+    bool isGrace =
+        (*initialNote)->event()->has(BaseProperties::IS_GRACE_NOTE) &&
+        (*initialNote)->event()->get<Bool>(BaseProperties::IS_GRACE_NOTE);
+
+    int initialHeight, finalHeight, extremeHeight;
+    NELIterator extremeNote;
+
+    if (beam.aboveNotes) {
+
+        initialHeight = height(initialChord.getHighestNote());
+        finalHeight = height( finalChord.getHighestNote());
+        extremeHeight = height( getHighestNote());
+        extremeNote = getHighestNote();
+
+    } else {
+        initialHeight = height(initialChord.getLowestNote());
+        finalHeight = height( finalChord.getLowestNote());
+        extremeHeight = height( getLowestNote());
+        extremeNote = getLowestNote();
+    }
+
+    int diff = initialHeight - finalHeight;
+    if (diff < 0) diff = -diff;
+
+    bool linear =
+        (beam.aboveNotes ?
+         (extremeHeight <= std::max(initialHeight, finalHeight)) :
+         (extremeHeight >= std::min(initialHeight, finalHeight)));
+
+    if (!linear) {
+        if (diff > 2)
+            diff = 1;
+        else
+            diff = 0;
+    }
+
+    // Now, we need to judge the height of the beam such that the
+    // nearest note of the whole group, the nearest note of the first
+    // chord and the nearest note of the final chord are all at least
+    // two note-body-heights away from it, and at least one of the
+    // start and end points is at least the usual note stem-length
+    // away from it.  This is a straight-line equation y = mx + c,
+    // where we have m and two x,y pairs and need to find c.
+
+    //!!! If we find that making one extreme a sensible distance from
+    //the note head makes the other extreme way too far away from it
+    //in the direction of the gradient, then we should flatten the
+    //gradient.  There may be a better heuristic for this.
+
+    int initialX = (int)(*initialNote)->getLayoutX();
+    int finalDX = (int) (*finalNote)->getLayoutX() - initialX;
+    int extremeDX = (int)(*extremeNote)->getLayoutX() - initialX;
+
+    int spacing = staff.getNotePixmapFactory(isGrace).getLineSpacing();
+
+    beam.gradient = 0;
+    if (finalDX > 0) {
+        do {
+            if (diff == 0)
+                break;
+            else if (diff > 3)
+                diff = 3;
+            else
+                --diff;
+            beam.gradient = (diff * spacing * 100) / (finalDX * 2);
+        } while (beam.gradient > 18);
+    } else {
+        beam.gradient = 0;
+    }
+    if (initialHeight < finalHeight)
+        beam.gradient = -beam.gradient;
+
+    int finalY = staff.getLayoutYForHeight(finalHeight);
+    int extremeY = staff.getLayoutYForHeight(extremeHeight);
+
+    int c0 = staff.getLayoutYForHeight(initialHeight), c1, c2;
+    double dgrad = (double)beam.gradient / 100.0;
+
+    Equation::solve(Equation::C, extremeY, dgrad, extremeDX, c1);
+    Equation::solve(Equation::C, finalY, dgrad, finalDX, c2);
+
+    using std::max;
+    using std::min;
+    long shortestNoteType = Note::Quaver;
+    if (!(*getShortestElement())->event()->get
+            <Int>(BaseProperties::NOTE_TYPE,
+                  shortestNoteType)) {
+        NOTATION_DEBUG << "NotationGroup::calculateBeam: WARNING: Shortest element has no note-type; should this be possible?" << endl;
+        NOTATION_DEBUG << "(Event dump follows)" << endl;
+        (*getShortestElement())->event()->dump(std::cerr);
+    }
+
+    // minimal stem lengths at start, middle-extreme and end of beam
+    int sl = staff.getNotePixmapFactory(isGrace).getStemLength();
+    int ml = spacing * 2;
+    int el = sl;
+
+    NOTATION_DEBUG << "c0: " << c0 << ", c1: " << c1 << ", c2: " << c2 << endl;
+    NOTATION_DEBUG << "sl: " << sl << ", ml: " << ml << ", el: " << el << endl;
+
+    // If the stems are down, we will need to ensure they end at
+    // heights lower than 0 if there's an internal rest -- likewise
+    // with stems up and an internal rest we need to ensure they end
+    // at higher than 8.
+    // [Avoid doing expensive haveInternalRest() test where possible]
+
+    if (beam.aboveNotes) {
+
+        int topY = staff.getLayoutYForHeight(8);
+
+        if ((c0 - sl > topY) || (c1 - ml > topY) || (c2 - el > topY)) {
+            if (haveInternalRest()) {
+                if (c0 - sl > topY) sl = c0 - topY;
+                if (c1 - ml > topY) ml = c1 - topY;
+                if (c2 - el > topY) el = c2 - topY;
+                NOTATION_DEBUG << "made internal rest adjustment for above notes" << endl;
+                NOTATION_DEBUG << "sl: " << sl << ", ml: " << ml << ", el: " << el << endl;
+            }
+        }
+    } else {
+        int bottomY = staff.getLayoutYForHeight(0);
+
+        if ((c0 + sl < bottomY) || (c1 + ml < bottomY) || (c2 + el < bottomY)) {
+            if (haveInternalRest()) {
+                if (c0 + sl < bottomY) sl = bottomY - c0;
+                if (c1 + ml < bottomY) ml = bottomY - c1;
+                if (c2 + el < bottomY) el = bottomY - c2;
+                NOTATION_DEBUG << "made internal rest adjustment for below notes" << endl;
+                NOTATION_DEBUG << "sl: " << sl << ", ml: " << ml << ", el: " << el << endl;
+            }
+        }
+    }
+
+
+    if (shortestNoteType < Note::Semiquaver) {
+        int off = spacing * (Note::Semiquaver - shortestNoteType);
+        sl += off;
+        el += off;
+    }
+
+    if (shortestNoteType < Note::Quaver) {
+        int off = spacing * (Note::Quaver - shortestNoteType);
+        ml += off;
+    }
+
+
+    int midY = staff.getLayoutYForHeight(4);
+
+    // ensure extended to middle line if necessary, and assign suitable stem length
+    if (beam.aboveNotes) {
+        if (c0 - sl > midY) sl = c0 - midY;
+        if (c1 - ml > midY) ml = c1 - midY;
+        if (c2 - el > midY) el = c2 - midY;
+        if (extremeDX > 1.0 || extremeDX < -1.0) {
+            //	    beam.gradient = int(100 * double(c2 - c0) / double(extremeDX));
+        }
+        beam.startY = min(min(c0 - sl, c1 - ml), c2 - el);
+    } else {
+        if (c0 + sl < midY) sl = midY - c0;
+        if (c1 + ml < midY) ml = midY - c1;
+        if (c2 + el < midY) el = midY - c2;
+        if (extremeDX > 1.0 || extremeDX < -1.0) {
+            //	    beam.gradient = int(100 * double(c2 - c0) / double(extremeDX));
+        }
+        beam.startY = max(max(c0 + sl, c1 + ml), c2 + el);
+    }
+    /*
+        NOTATION_DEBUG << "NotationGroup::calculateBeam: beam data:" << endl
+    		   << "gradient: " << beam.gradient << endl
+    		   << "(c0 " << c0 << ", c2 " << c2 << ", extremeDX " << extremeDX << ")" << endl
+    		   << "startY: " << beam.startY << endl
+    		   << "aboveNotes: " << beam.aboveNotes << endl
+    		   << "shortestNoteType: " << shortestNoteType << endl
+    		   << "necessary: " << beam.necessary << endl;
+    */ 
+    return beam;
+}
+
+void
+NotationGroup::applyBeam(NotationStaff &staff)
+{
+    //    NOTATION_DEBUG << "NotationGroup::applyBeam, group no is " << m_groupNo << endl;
+    /*
+        NOTATION_DEBUG << "\nNotationGroup::applyBeam" << endl;
+        NOTATION_DEBUG << "Group id: " << m_groupNo << ", type " << m_type << endl;
+        NOTATION_DEBUG << "Coverage:" << endl;
+        int i = 0;
+        for (NELIterator i = getInitialElement(); i != getContainer().end(); ++i) {
+    	(*i)->event()->dump(cerr);
+    	if (i == getFinalElement()) break;
+        }
+        {
+    	NELIterator i(getInitialNote());
+    	NOTATION_DEBUG << "Initial note: " << (i == getContainer().end() ? -1 : (*i)->event()->getAbsoluteTime()) << endl;
+        }
+        {
+    	NELIterator i(getFinalNote());
+    	NOTATION_DEBUG << "Final note: " << (i == getContainer().end() ? -1 : (*i)->event()->getAbsoluteTime()) << endl;
+        }
+        {
+    	NELIterator i(getHighestNote());
+    	NOTATION_DEBUG << "Highest note: " << (i == getContainer().end() ? -1 : (*i)->event()->getAbsoluteTime()) << endl;
+        }
+        {
+    	NELIterator i(getLowestNote());
+    	NOTATION_DEBUG << "Lowest note: " << (i == getContainer().end() ? -1 : (*i)->event()->getAbsoluteTime()) << endl;
+        }
+    */
+    Beam beam(calculateBeam(staff));
+    if (!beam.necessary) {
+        for (NELIterator i = getInitialNote(); i != getContainer().end(); ++i) {
+            (*i)->event()->unset(NotationProperties::BEAMED);
+            (*i)->event()->unset(m_properties.TUPLING_LINE_MY_Y);
+            if (i == getFinalNote())
+                break;
+        }
+        return ;
+    }
+
+    //    NOTATION_DEBUG << "NotationGroup::applyBeam: Beam is necessary" << endl;
+
+    NELIterator initialNote(getInitialNote()),
+    finalNote( getFinalNote());
+    int initialX = (int)(*initialNote)->getLayoutX();
+    timeT finalTime = (*finalNote)->getViewAbsoluteTime();
+
+    // For each chord in the group, we nominate the note head furthest
+    // from the beam as the primary note, the one that "owns" the stem
+    // and the section of beam up to the following chord.  For this
+    // note, we need to:
+    //
+    // * Set the start height, start x-coord and gradient of the beam
+    //   (we can't set the stem length for this note directly, because
+    //   we don't know its y-coordinate yet)
+    //
+    // * Set width of this section of beam
+    //
+    // * Set the number of beams required for the following note (one
+    //   slight complication here: a beamed group in which the very
+    //   first chord is shorter than the following one.  Here the first
+    //   chord needs to know it's the first, or else it can't draw the
+    //   part-beams immediately to its right correctly.)
+    //
+    // For the rest of the notes in the chord, we just need to
+    // indicate that they aren't part of the beam-drawing process and
+    // don't need to draw a stem.
+
+    NELIterator prev = getContainer().end(), prevprev = getContainer().end();
+    double gradient = (double)beam.gradient / 100.0;
+
+    //    NOTATION_DEBUG << "NotationGroup::applyBeam starting for group "<< this << endl;
+
+    for (NELIterator i = getInitialNote(); i != getContainer().end(); ++i) {
+        NotationElement* el = static_cast<NotationElement*>(*i);
+
+        // Clear tuplingness for all events in the group, to be
+        // reinstated by any subsequent call to applyTuplingLine.  We
+        // do this because applyTuplingLine doesn't clear these
+        // properties from notes that don't need them; it only applies
+        // them to notes that do.
+        el->event()->unset(m_properties.TUPLING_LINE_MY_Y);
+
+        if (el->isNote() &&
+                el->event()->has(BaseProperties::NOTE_TYPE) &&
+                el->event()->get
+                <Int>(BaseProperties::NOTE_TYPE) < Note::Crotchet &&
+                el->event()->has(BaseProperties::BEAMED_GROUP_ID) &&
+                el->event()->get<Int>(BaseProperties::BEAMED_GROUP_ID) == m_groupNo) {
+
+            NotationChord chord(getContainer(), i, &getQuantizer(),
+                                m_properties, m_clef, m_key);
+            unsigned int j;
+
+            //            NOTATION_DEBUG << "NotationGroup::applyBeam: Found chord" << endl;
+
+            bool hasShifted = chord.hasNoteHeadShifted();
+
+            for (j = 0; j < chord.size(); ++j) {
+                NotationElement *el = static_cast<NotationElement*>(*chord[j]);
+
+                el->event()->setMaybe<Bool>
+                (m_properties.CHORD_PRIMARY_NOTE, false);
+
+                el->event()->setMaybe<Bool>
+                (m_properties.DRAW_FLAG, false);
+
+                el->event()->setMaybe<Bool>
+                (NotationProperties::BEAMED, true);
+
+                el->event()->setMaybe<Bool>
+                (NotationProperties::BEAM_ABOVE, beam.aboveNotes);
+
+                el->event()->setMaybe<Bool>
+                (m_properties.VIEW_LOCAL_STEM_UP, beam.aboveNotes);
+
+                bool shifted = chord.isNoteHeadShifted(chord[j]);
+                el->event()->setMaybe<Bool>
+                (m_properties.NOTE_HEAD_SHIFTED, shifted);
+
+                long dots = 0;
+                (void)el->event()->get
+                <Int>(BaseProperties::NOTE_DOTS, dots);
+
+                el->event()->setMaybe<Bool>
+                (m_properties.NOTE_DOT_SHIFTED, false);
+                if (hasShifted && beam.aboveNotes) {
+                    long dots = 0;
+                    (void)el->event()->get
+                    <Int>(BaseProperties::NOTE_DOTS, dots);
+                    if (dots > 0) {
+                        el->event()->setMaybe<Bool>
+                        (m_properties.NOTE_DOT_SHIFTED, true);
+                    }
+                }
+
+                el->event()->setMaybe<Bool>
+                (m_properties.NEEDS_EXTRA_SHIFT_SPACE,
+                 chord.hasNoteHeadShifted() && !beam.aboveNotes);
+            }
+
+            if (beam.aboveNotes)
+                j = 0;
+            else
+                j = chord.size() - 1;
+
+            NotationElement *el = static_cast<NotationElement*>(*chord[j]);
+            el->event()->setMaybe<Bool>(NotationProperties::BEAMED, false); // set later
+            el->event()->setMaybe<Bool>(m_properties.DRAW_FLAG, true); // set later
+
+            int x = (int)el->getLayoutX();
+            int myY = (int)(gradient * (x - initialX)) + beam.startY;
+
+            int beamCount =
+                NoteStyleFactory::getStyleForEvent(el->event())->
+                getFlagCount(el->event()->get
+                             <Int>(BaseProperties::NOTE_TYPE));
+
+            // If THIS_PART_BEAMS is true, then when drawing the
+            // chord, if it requires more beams than the following
+            // chord then they should be added as partial beams to the
+            // right of the stem.
+
+            // If NEXT_PART_BEAMS is true, then when drawing the
+            // chord, if it requires fewer beams than the following
+            // chord then the difference should be added as partial
+            // beams to the left of the following chord's stem.
+
+            // Procedure for setting these: If we have more beams than
+            // the preceding chord, then the preceding chord should
+            // have NEXT_PART_BEAMS set, until possibly unset again on
+            // the next iteration.  If we have at least as many beams
+            // as the preceding chord, then the preceding chord should
+            // have THIS_PART_BEAMS unset and the one before it should
+            // have NEXT_PART_BEAMS unset.  The first chord should
+            // have THIS_PART_BEAMS set, until possibly unset again on
+            // the next iteration.
+
+            if (prev != getContainer().end()) {
+
+                NotationElement *prevEl = static_cast<NotationElement*>(*prev);
+                int secWidth = x - (int)prevEl->getLayoutX();
+
+                //		prevEl->event()->setMaybe<Int>(BEAM_NEXT_Y, myY);
+
+                prevEl->event()->setMaybe<Int>
+                (m_properties.BEAM_SECTION_WIDTH, secWidth);
+                prevEl->event()->setMaybe<Int>
+                (m_properties.BEAM_NEXT_BEAM_COUNT, beamCount);
+
+                int prevBeamCount =
+                    NoteStyleFactory::getStyleForEvent(prevEl->event())->
+                    getFlagCount(prevEl->event()->get
+                                 <Int>(BaseProperties::NOTE_TYPE));
+
+                if ((beamCount > 0) && (prevBeamCount > 0)) {
+                    el->event()->setMaybe<Bool>(m_properties.BEAMED, true);
+                    el->event()->setMaybe<Bool>(m_properties.DRAW_FLAG, false);
+                    prevEl->event()->setMaybe<Bool>(m_properties.BEAMED, true);
+                    prevEl->event()->setMaybe<Bool>(m_properties.DRAW_FLAG, false);
+                }
+
+                if (beamCount >= prevBeamCount) {
+                    prevEl->event()->setMaybe<Bool>
+                    (m_properties.BEAM_THIS_PART_BEAMS, false);
+                    if (prevprev != getContainer().end()) {
+                        (*prevprev)->event()->setMaybe<Bool>
+                        (m_properties.BEAM_NEXT_PART_BEAMS, false);
+                    }
+                }
+
+                if (beamCount > prevBeamCount) {
+                    prevEl->event()->setMaybe<Bool>
+                    (m_properties.BEAM_NEXT_PART_BEAMS, true);
+                }
+
+            } else {
+                el->event()->setMaybe<Bool>(m_properties.BEAM_THIS_PART_BEAMS, true);
+            }
+
+            el->event()->setMaybe<Bool>(m_properties.CHORD_PRIMARY_NOTE, true);
+
+            el->event()->setMaybe<Int>(m_properties.BEAM_MY_Y, myY);
+            el->event()->setMaybe<Int>(m_properties.BEAM_GRADIENT, beam.gradient);
+
+            // until they're set next time around the loop, as (*prev)->...
+            //	    el->event()->setMaybe<Int>(m_properties.BEAM_NEXT_Y, myY);
+            el->event()->setMaybe<Int>(m_properties.BEAM_SECTION_WIDTH, 0);
+            el->event()->setMaybe<Int>(m_properties.BEAM_NEXT_BEAM_COUNT, 1);
+
+            prevprev = prev;
+            prev = chord[j];
+            i = chord.getFinalElement();
+
+        }
+        else if (el->isNote()) {
+
+            //!!! should we really be setting these here as well as in
+            // applyStemProperties?
+            /*
+            	    if (i == initialNote || i == finalNote) {
+            		(*i)->event()->setMaybe<Bool>(m_properties.VIEW_LOCAL_STEM_UP,  beam.aboveNotes);
+            	    } else {
+            		(*i)->event()->setMaybe<Bool>(m_properties.VIEW_LOCAL_STEM_UP, !beam.aboveNotes);
+            	    }
+            */
+        }
+
+        if (i == finalNote || el->getViewAbsoluteTime() > finalTime) break;
+    }
+}
+
+void
+NotationGroup::applyTuplingLine(NotationStaff &staff)
+{
+    //    NOTATION_DEBUG << "NotationGroup::applyTuplingLine, group no is " << m_groupNo << ", group type is " << m_type << endl;
+
+    if (m_type != Tupled)
+        return ;
+
+    //    NOTATION_DEBUG << "NotationGroup::applyTuplingLine: line is necessary" << endl;
+
+    Beam beam(calculateBeam(staff));
+
+    NELIterator
+        initialNote(getInitialNote()),
+        finalNote(getFinalNote()),
+        initialElement(getInitialElement()),
+        finalElement(getFinalElement());
+    
+    NELIterator initialNoteOrRest(initialElement);
+    NotationElement* initialNoteOrRestEl = static_cast<NotationElement*>(*initialNoteOrRest);
+
+    while (initialNoteOrRest != finalElement &&
+            !(initialNoteOrRestEl->isNote() ||
+              initialNoteOrRestEl->isRest())) {
+        ++initialNoteOrRest;
+        initialNoteOrRestEl = static_cast<NotationElement*>(*initialNoteOrRest);
+    }
+
+    if (!initialNoteOrRestEl->isRest()) {
+        initialNoteOrRest = initialNote;
+        initialNoteOrRestEl = static_cast<NotationElement*>(*initialNoteOrRest);
+    }
+
+    if (initialNoteOrRest == staff.getViewElementList()->end()) return;
+
+    bool isGrace = false;
+    if (initialNote != staff.getViewElementList()->end()) {
+        isGrace =
+            (*initialNote)->event()->has(BaseProperties::IS_GRACE_NOTE) &&
+            (*initialNote)->event()->get<Bool>(BaseProperties::IS_GRACE_NOTE);
+    }
+
+    //    NOTATION_DEBUG << "NotationGroup::applyTuplingLine: first element is " << (initialNoteOrRestEl->isNote() ? "Note" : "Non-Note") << ", last is " << (static_cast<NotationElement*>(*finalElement)->isNote() ? "Note" : "Non-Note") << endl;
+
+    int initialX = (int)(*initialNoteOrRest)->getLayoutX();
+    int finalX = (int)(*finalElement)->getLayoutX();
+
+    if (initialNote == staff.getViewElementList()->end() &&
+          finalNote == staff.getViewElementList()->end()) {
+
+        Event *e = (*initialNoteOrRest)->event();
+        e->setMaybe<Int>(m_properties.TUPLING_LINE_MY_Y,
+                         staff.getLayoutYForHeight(12));
+        e->setMaybe<Int>(m_properties.TUPLING_LINE_WIDTH, finalX - initialX);
+        e->setMaybe<Int>(m_properties.TUPLING_LINE_GRADIENT, 0);
+
+    } else {
+
+        // only notes have height
+        int initialY = staff.getLayoutYForHeight(height(initialNote));
+        int finalY = staff.getLayoutYForHeight(height( finalNote));
+
+        // if we have a beam and both end-points of it are notes,
+        // place the tupling number over it (that is, make the tupling
+        // line follow the beam and say so); otherwise make the line
+        // follow the gradient a beam would have, but on the other
+        // side of the notes
+        bool followBeam =
+            (beam.necessary &&
+             (*initialNoteOrRest)->event()->isa(Note::EventType) &&
+             (finalNote == finalElement));
+
+        int startY = (followBeam ? beam.startY :
+                      initialY - (beam.startY - initialY));
+
+        int endY = startY + (int)((finalX - initialX) *
+                                  ((double)beam.gradient / 100.0));
+
+        //	NOTATION_DEBUG << "applyTuplingLine: beam.startY is " << beam.startY << ", initialY is " << initialY << " so my startY is " << startY << ", endY " << endY << ", beam.gradient " << beam.gradient << endl;
+
+        int nh = staff.getNotePixmapFactory(isGrace).getNoteBodyHeight();
+
+        if (followBeam) { // adjust to move text slightly away from beam
+
+            int maxEndBeamCount = 1;
+            long bc;
+            if ((*initialNoteOrRest)->event()->get<Int>
+                (m_properties.BEAM_NEXT_BEAM_COUNT, bc)) {
+                if (bc > maxEndBeamCount)
+                    maxEndBeamCount = bc;
+            }
+            if ((*finalNote)->event()->get<Int>
+                (m_properties.BEAM_NEXT_BEAM_COUNT, bc)) {
+                if (bc > maxEndBeamCount)
+                    maxEndBeamCount = bc;
+            }
+
+            int extraBeamSpace = maxEndBeamCount * nh + nh / 2;
+
+            if (beam.aboveNotes) {
+                startY -= extraBeamSpace;
+                endY -= extraBeamSpace;
+                finalX += nh;
+            } else {
+                startY += extraBeamSpace;
+                endY += extraBeamSpace;
+                finalX -= nh;
+            }
+
+        } else { // adjust to place close to note heads
+
+            if (startY < initialY) {
+                if (initialY - startY > nh * 3)
+                    startY = initialY - nh * 3;
+                if ( finalY - endY < nh * 2)
+                    startY -= nh * 2 - (finalY - endY);
+            } else {
+                if (startY - initialY > nh * 3)
+                    startY = initialY + nh * 3;
+                if ( endY - finalY < nh * 2)
+                    startY += nh * 2 - (endY - finalY);
+            }
+        }
+
+        Event *e = (*initialNoteOrRest)->event();
+        e->setMaybe<Int>(m_properties.TUPLING_LINE_MY_Y, startY);
+        e->setMaybe<Int>(m_properties.TUPLING_LINE_WIDTH, finalX - initialX);
+        e->setMaybe<Int>(m_properties.TUPLING_LINE_GRADIENT, beam.gradient);
+        e->setMaybe<Bool>(m_properties.TUPLING_LINE_FOLLOWS_BEAM, followBeam);
+    }
+}
+
+}