/home/pete/Work/TSE3.svn/tse3/src/tse3/KeySigTrack.h

Go to the documentation of this file.

/*
 * @(#)KeySigTrack.h 3.00 30 May 2000
 *
 * Copyright (c) 2000 Pete Goodliffe (pete@cthree.org)
 *
 * This file is part of TSE3 - the Trax Sequencer Engine version 3.00.
 *
 * This library is modifiable/redistributable under the terms of the GNU
 * General Public License.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING. If not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 */

#ifndef TSE3_KEYSIGTRACK_H
#define TSE3_KEYSIGTRACK_H

#include "tse3/listen/KeySigTrack.h"

#include "tse3/Notifier.h"
#include "tse3/Playable.h"
#include "tse3/Serializable.h"
#include "tse3/EventTrack.h"

namespace TSE3
{
    class KeySig
    {
        public:

            enum KeySigIncidentals
            {
                Cb  = -7, // Cb major, 7 flats
                Gb  = -6, // Gb major, 6 flats
                Db  = -5, // Dd major, 5 flats
                Ab  = -4, // Ab major, 4 flats
                Eb  = -3, // Eb major, 3 flats
                Bb  = -2, // Bb major, 2 flats
                F   = -1, // F major,  1 flat
                C   =  0, // C major,  0 sharps
                G   =  1, // G major,  1 sharp
                D   =  2, // D major,  2 sharps
                A   =  3, // A major,  3 sharps
                E   =  4, // E major,  4 sharps
                B   =  5, // B major,  5 sharps
                Fs  =  6, // F# major, 6 sharps
                Cs  =  7  // C# major, 7 sharps
            };

            enum KeySigIncidentalsMinor
            {
                Abm = -7, // Cb minor, 7 flats
                Fbbm= -6, // Fbb minor, 6 flats
                Bbm = -5, // Dd minor, 5 flats
                Gbm = -4, // Ab minor, 4 flats
                Cm  = -3, // Eb minor, 3 flats
                Dm  = -2, // Bb minor, 2 flats
                Fm  = -1, // F minor,  1 flat
                Am  =  0, // A minor,  0 sharps
                Em  =  1, // G minor,  1 sharp
                Bm  =  2, // D minor,  2 sharps
                Fsm =  3, // A minor,  3 sharps
                Csm =  4, // E minor,  4 sharps
                Gsm =  5, // B minor,  5 sharps
                Dsm =  6, // F# minor, 6 sharps
                Asm =  7  // C# minor, 7 sharps
            };

            enum KeySigType
            {
                Major = 0, // Represents a major key
                Minor = 1  // Represents a minor key
            };

            KeySig(int incidentals = C, int type = Major)
                : incidentals(incidentals), type(type) {}

            int incidentals;

            int type;

            int operator==(const KeySig &k) const
            {
                return (incidentals == k.incidentals) && (type == k.type);
            }
    };

    class KeySigTrack : public EventTrack<KeySig>,
                        public Serializable
    {
        public:

            KeySigTrack();
            virtual ~KeySigTrack();

            bool status() const { return _status; }

            void setStatus(bool s) { _status = s; }

            virtual PlayableIterator *iterator(Clock index);

            virtual Clock lastClock() const;

            virtual void save(std::ostream &o, int i) const;

            virtual void load(std::istream &i, SerializableLoadInfo &info);

        private:

            KeySigTrack &operator=(const KeySigTrack &);
            KeySigTrack(const KeySigTrack &);

            void loadEvents(std::istream &i, int filePPQN);

            bool _status;
    };
}

#endif

---