/media/hdb5/canorusNightlyBuildSystem/trunk/src/core/keysignature.cpp

Go to the documentation of this file.

#include "core/keysignature.h"
#include "core/staff.h"
#include "core/mark.h"

CAKeySignature::CAKeySignature(CAKeySignatureType type, signed char accs, CAMajorMinorGender gender, CAStaff *staff, int timeStart)
 : CAMusElement(staff, timeStart) {
        _musElementType = CAMusElement::KeySignature;
        
        setKeySignatureType(type, accs, gender);
}

void CAKeySignature::setKeySignatureType(CAKeySignatureType type, signed char accs, CAMajorMinorGender gender) {
        _keySignatureType = type;
        
        if (type == MajorMinor) {
                _majorMinorGender = gender;
                
                for (int i=0; i<7; i++) // clean up the _accidentals array
                        _accidentals[i] = 0;
                
                // generate the _accidentals array according to the given number of the accidentals
                // eg. _accidentals[3] = -1; means flat on the 3rd note (counting from 0), this means this key signature has Fes instead of F.
                int idx = 3;
                for (int i=0; i<accs; i++) {    // key signatures with sharps
                        _accidentals[idx] = 1;
                        idx = (idx+4)%7;        // the circle of fifths in positive direction - add a Fifth
                }
                
                idx = 6;
                for (int i=0; i>accs; i--) {    // key signatures with flats
                        _accidentals[idx] = -1;
                        idx = (idx+3)%7;        // the circle of fifths in negative direction - add a Fourth
                }
        }
}

CAKeySignature::~CAKeySignature() {
}

CAKeySignature* CAKeySignature::clone() {
        CAKeySignature *k = new CAKeySignature(_keySignatureType, numberOfAccidentals(), _majorMinorGender, (CAStaff*)_context, _timeStart);
        
        for (int i=0; i<markList().size(); i++) {
                CAMark *m = static_cast<CAMark*>(markList()[i]->clone());
                m->setAssociatedElement(k);
                k->addMark( m );
        }
        
        return k;
}

signed char CAKeySignature::numberOfAccidentals() {
        signed char sum=0;
        for (int i=0; i<7; i++)
                sum += _accidentals[i];
        
        return sum;
}

int CAKeySignature::compare(CAMusElement *elt) {
        if (elt->musElementType()!=CAMusElement::KeySignature)
                return -1;
        
        int diffs=0;
        if (_keySignatureType!=((CAKeySignature*)elt)->keySignatureType()) diffs++;
        else {
                if (_majorMinorGender!=((CAKeySignature*)elt)->majorMinorGender()) diffs++;
                if (numberOfAccidentals()!=((CAKeySignature*)elt)->numberOfAccidentals()) diffs++;
        }
        
        return diffs;
}

const QString CAKeySignature::keySignatureToString( signed char numberOfAccs, CAMajorMinorGender gender ) {
        // calculate key signature pitch from number of accidentals
        int pitch = ((4*numberOfAccs) % 7) + ((numberOfAccs < 0) ? 7 : 0);
        
        if (gender==CAKeySignature::Minor)      // find the parallel minor key
                pitch = (pitch + 5) % 7;
        
        signed char accs = 0;
        
        if (numberOfAccs>5 && gender==CAKeySignature::Major)
                accs = (numberOfAccs-5)/7+1;
        else
        if (numberOfAccs>2 && gender==CAKeySignature::Minor)
                accs = (numberOfAccs-2)/7 + 1;
        else
        if (numberOfAccs<-1 && gender==CAKeySignature::Major)
                accs = (numberOfAccs+1)/7-1;
        else
        if (numberOfAccs<-4 && gender==CAKeySignature::Minor)
                accs = (numberOfAccs+4)/7 - 1;
        
        QString name;
        
        name = (char)((pitch+2)%7 + 'a');
        
        for (int i=0; i < accs; i++)
                name += "is";   // append as many -is-es as necessary
        
        for (int i=0; i > accs; i--) {
                if ( (name == "e") || (name == "a") )
                        name += "s";    // for pitches E and A, only append single -s the first time
                else if (name[0]=='a')
                        name += "as";   // for pitch A, append -as instead of -es
                else
                        name += "es";   // otherwise, append normally as many es-es as necessary
        }
        
        if (gender==CAKeySignature::Major)
                name[0] = name[0].toUpper();
        
        return name;
}

signed char CAKeySignature::keySigAccsFromString( QString keySig ) {
        CAMajorMinorGender gender = keySigGenderFromString(keySig);
        keySig[0] = keySig[0].toLower();
        signed char accs = static_cast<signed char>( ((keySig[0].toAscii() - 'a') * 2 + 4) % 7 - 4 );
        
        QString key(keySig);
        accs -= 7*keySig.count("as");
        accs -= 7*keySig.count("es");
        accs += 7*keySig.count("is");
        
        if (gender==CAKeySignature::Major)
                accs += 3;
        
        return accs;
}

CAKeySignature::CAMajorMinorGender CAKeySignature::keySigGenderFromString( const QString keySig ) {
        if (keySig[0].isUpper())
                return CAKeySignature::Major;
        else
                return CAKeySignature::Minor;
}

const QString CAKeySignature::keySignatureTypeToString(CAKeySignatureType type) {
        switch (type) {
                case MajorMinor: return "major-minor";
                case Modus: return "modus";
                case Custom: return "custom";
                default: return "";
        } 
}

CAKeySignature::CAKeySignatureType CAKeySignature::keySignatureTypeFromString(const QString type) {
        if (type=="major-minor") {
                return MajorMinor;
        } else
        if (type=="modus") {
                return Modus;
        } else
        if (type=="custom") {
                return Custom;
        } else
                return Custom;
}

const QString CAKeySignature::majorMinorGenderToString(CAMajorMinorGender gender) {
        switch (gender) {
                case Major: return "major";
                case Minor: return "minor";
                default: return "";
        }
}

CAKeySignature::CAMajorMinorGender CAKeySignature::majorMinorGenderFromString(const QString gender) {
        if (gender=="major") return Major; else
        if (gender=="minor") return Minor;
        else return Major;
}

const QString CAKeySignature::modusToString(CAModus modus) {
        switch (modus) {
                case Ionian: return "ionian";
                case Dorian: return "dorian";
                case Phrygian: return "phrygian";
                case Lydian: return "lydian";
                case Mixolydian: return "mixolydian";
                case Aeolian: return "aeolian";
                case Locrian: return "locrian";
                case Hypodorian: return "hypodorian";
                case Hypolydian: return "hypolydian";
                case Hypomixolydian: return "hypomixolydian";
                case Hypophrygian: return "hypophrygian";
                default: return "";
        }
}

CAKeySignature::CAModus CAKeySignature::modusFromString(const QString modus) {
        if (modus=="ionian") return Ionian; else
        if (modus=="dorian") return Dorian; else
        if (modus=="phrygian") return Phrygian; else
        if (modus=="lydian") return Lydian; else
        if (modus=="mixolydian") return Mixolydian; else
        if (modus=="aeolian") return Aeolian; else
        if (modus=="locrian") return Locrian; else
        if (modus=="hypodorian") return Hypodorian; else
        if (modus=="hypolydian") return Hypolydian; else
        if (modus=="hypomixolydian") return Hypomixolydian; else
        if (modus=="hypophrygian") return Hypophrygian;
        else return Ionian;
}

---