MuseScore/libmscore/instrchange.cpp

//=============================================================================
//  MuseScore
//  Music Composition & Notation
//
//  Copyright (C) 2008-2011 Werner Schweer
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License version 2
//  as published by the Free Software Foundation and appearing in
//  the file LICENCE.GPL
//=============================================================================

#include "instrchange.h"
#include "score.h"
#include "segment.h"
#include "staff.h"
#include "part.h"
#include "undo.h"
#include "mscore.h"
#include "xml.h"
#include "measure.h"
#include "system.h"
#include "chord.h"
#include "keysig.h"

namespace Ms {
//---------------------------------------------------------
//   instrumentChangeStyle
//---------------------------------------------------------

static const ElementStyle instrumentChangeStyle {
    { Sid::instrumentChangePlacement,          Pid::PLACEMENT },
    { Sid::instrumentChangeMinDistance,        Pid::MIN_DISTANCE },
};

//---------------------------------------------------------
//   InstrumentChange
//---------------------------------------------------------

InstrumentChange::InstrumentChange(Score* s)
    : TextBase(s, Tid::INSTRUMENT_CHANGE, ElementFlag::MOVABLE | ElementFlag::ON_STAFF)
{
    initElementStyle(&instrumentChangeStyle);
    _instrument = new Instrument();
}

InstrumentChange::InstrumentChange(const Instrument& i, Score* s)
    : TextBase(s, Tid::INSTRUMENT_CHANGE, ElementFlag::MOVABLE | ElementFlag::ON_STAFF)
{
    initElementStyle(&instrumentChangeStyle);
    _instrument = new Instrument(i);
}

InstrumentChange::InstrumentChange(const InstrumentChange& is)
    : TextBase(is)
{
    _instrument = new Instrument(*is._instrument);
    _init = is._init;
}

InstrumentChange::~InstrumentChange()
{
    delete _instrument;
}

void InstrumentChange::setInstrument(const Instrument& i)
{
    *_instrument = i;
    //delete _instrument;
    //_instrument = new Instrument(i);
}

void InstrumentChange::setupInstrument(const Instrument* instrument)
{
    if (_init) {
        Fraction tickStart = segment()->tick();
        Part* part = staff()->part();
        Interval oldV = part->instrument(tickStart)->transpose();

        // change the clef for each staff
        for (int i = 0; i < part->nstaves(); i++) {
            if (part->instrument(tickStart)->clefType(i) != instrument->clefType(i)) {
                ClefType clefType
                    = score()->styleB(Sid::concertPitch) ? instrument->clefType(i)._concertClef : instrument->clefType(i)
                      ._transposingClef;
                // If instrument change is at the start of a measure, use the measure as the element, as this will place the instrument change before the barline.
                Element* element = rtick().isZero() ? toElement(findMeasure()) : toElement(this);
                score()->undoChangeClef(part->staff(i), element, clefType, true);
            }
        }

        // Change key signature if necessary
        if (instrument->transpose() != oldV) {
            for (int i = 0; i < part->nstaves(); i++) {
                if (!part->staff(i)->keySigEvent(tickStart).isAtonal()) {
                    KeySigEvent ks;
                    ks.setForInstrumentChange(true);
                    Key key = part->staff(i)->key(tickStart);
                    if (!score()->styleB(Sid::concertPitch)) {
                        key = transposeKey(key, oldV);
                    }
                    ks.setKey(key);
                    score()->undoChangeKeySig(part->staff(i), tickStart, ks);
                }
            }
        }

        // change instrument in all linked scores
        for (ScoreElement* se : linkList()) {
            InstrumentChange* lic = static_cast<InstrumentChange*>(se);
            Instrument* newInstrument = new Instrument(*instrument);
            lic->score()->undo(new ChangeInstrument(lic, newInstrument));
        }

        // transpose for current score only
        // this automatically propagates to linked scores
        if (part->instrument(tickStart)->transpose() != oldV) {
            auto i = part->instruments()->upper_bound(tickStart.ticks());          // find(), ++i
            Fraction tickEnd;
            if (i == part->instruments()->end()) {
                tickEnd = Fraction(-1, 1);
            } else {
                tickEnd = Fraction::fromTicks(i->first);
            }
            score()->transpositionChanged(part, oldV, tickStart, tickEnd);
        }

        const QString newInstrChangeText = tr("To %1").arg(instrument->trackName());
        undoChangeProperty(Pid::TEXT, TextBase::plainToXmlText(newInstrChangeText));
    }
}

//---------------------------------------------------------
//   keySigs
//---------------------------------------------------------

std::vector<KeySig*> InstrumentChange::keySigs() const
{
    std::vector<KeySig*> keysigs;
    Segment* seg = segment()->prev1(SegmentType::KeySig);
    if (seg) {
        int startVoice = part()->staff(0)->idx() * VOICES;
        int endVoice = part()->staff(part()->nstaves() - 1)->idx() * VOICES;
        Fraction t = tick();
        for (int i = startVoice; i <= endVoice; i += VOICES) {
            KeySig* ks = toKeySig(seg->element(i));
            if (ks && ks->forInstrumentChange() && ks->tick() == t) {
                keysigs.push_back(ks);
            }
        }
    }
    return keysigs;
}

//---------------------------------------------------------
//   clefs
//---------------------------------------------------------

std::vector<Clef*> InstrumentChange::clefs() const
{
    std::vector<Clef*> clefs;
    Segment* seg = segment()->prev1(SegmentType::Clef);
    if (seg) {
        int startVoice = part()->staff(0)->idx() * VOICES;
        int endVoice = part()->staff(part()->nstaves() - 1)->idx() * VOICES;
        Fraction t = tick();
        for (int i = startVoice; i <= endVoice; i += VOICES) {
            Clef* clef = toClef(seg->element(i));
            if (clef && clef->forInstrumentChange() && clef->tick() == t) {
                clefs.push_back(clef);
            }
        }
    }
    return clefs;
}

//---------------------------------------------------------
//   write
//---------------------------------------------------------

void InstrumentChange::write(XmlWriter& xml) const
{
    xml.stag(this);
    _instrument->write(xml, part());
    if (_init) {
        xml.tag("init", _init);
    }
    TextBase::writeProperties(xml);
    xml.etag();
}

//---------------------------------------------------------
//   read
//---------------------------------------------------------

void InstrumentChange::read(XmlReader& e)
{
    while (e.readNextStartElement()) {
        const QStringRef& tag(e.name());
        if (tag == "Instrument") {
            _instrument->read(e, part());
        } else if (tag == "init") {
            _init = e.readBool();
        } else if (!TextBase::readProperties(e)) {
            e.unknown();
        }
    }
    if (score()->mscVersion() < 206) {
        // previous versions did not honor transposition of instrument change
        // except in ways that it should not have
        // notes entered before the instrument change was added would not be altered,
        // so original transposition remained in effect
        // notes added afterwards would be transposed by both intervals, resulting in tpc corruption
        // here we set the instrument change to inherit the staff transposition to emulate previous versions
        // in Note::read(), we attempt to fix the tpc corruption
        // There is also code in read206 to try to deal with this, but it is out of date and therefore disabled
        // What this means is, scores created in 2.1 or later should be fine, scores created in 2.0 maybe not so much

        Interval v = staff() ? staff()->part()->instrument()->transpose() : 0;
        _instrument->setTranspose(v);
    }
}

//---------------------------------------------------------
//   propertyDefault
//---------------------------------------------------------

QVariant InstrumentChange::propertyDefault(Pid propertyId) const
{
    switch (propertyId) {
    case Pid::SUB_STYLE:
        return int(Tid::INSTRUMENT_CHANGE);
    default:
        return TextBase::propertyDefault(propertyId);
    }
}

//---------------------------------------------------------
//   layout
//---------------------------------------------------------

void InstrumentChange::layout()
{
    TextBase::layout();
    autoplaceSegmentElement();
}
}