scoreelements.h

Go to the documentation of this file.

/*
 * scoreelements.h, Author: Andrea Rizzi <[email protected]>
 *
 * Copyright (C) 2001-2013 Atomic Blue ([email protected], http://www.atomicblue.org) 
 *
 *
 * 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 (version 2 of the License)
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */

#ifndef SCORE_ELEMENTS_H
#define SCORE_ELEMENTS_H


//====================================================================================
// Crystal Space Includes
//====================================================================================
#include <cssysdef.h>
#include <csutil/hash.h>

//====================================================================================
// Project Includes
//====================================================================================

//====================================================================================
// Local Includes
//====================================================================================
#include "musicutil.h"

//------------------------------------------------------------------------------------
// Forward Declarations
//------------------------------------------------------------------------------------
// A chord rarely have more than 6 notes
#define MEAS_ELEM_NOTES_CAPACITY_GROWTH 4
#define UNDEFINED_MEASURE_ATTRIBUTE -100

class ScoreContext;
class MeasureElement;

class Note
{
public:
    class NoteContext
    {
    public:
        NoteContext();

        psMusic::Accidental GetPreviousAccidental(const Note &note) const;

        void ResetContext();

        void UpdateContext(const MeasureElement &element);

        void UpdateContext(const Note &note);

    private:
        csHash<csHash<psMusic::Accidental, char>, int> prevAccidentals;
    };

    Note();

    Note(char name, int octave, psMusic::Accidental writtenAccidental);

    char GetName() const { return name; }

    int GetOctave() const { return octave; }

    psMusic::Accidental GetPlayedAccidental(const ScoreContext &context) const;

    psMusic::Accidental GetWrittenAccidental() const { return writtenAccidental; }

    bool operator==(const Note &note) const;

    void SetName(char name);

    void SetOctave(int octave);

    void SetWrittenAccidental(psMusic::Accidental accidental);

private:
    char name; 
    int octave; 

    psMusic::Accidental writtenAccidental;
};

//--------------------------------------------------

class MeasureElement
{
public:
    MeasureElement(psMusic::Duration duration);

    bool AddNote(char name, int octave, psMusic::Accidental writtenAccidental);

    psMusic::Duration GetDuration() { return duration; }

    size_t GetNNotes() const { return notes.GetSize(); }

    Note &GetNote(size_t n) { return notes[n]; }

    const Note &GetNote(size_t n) const { return notes[n]; }

    bool IsRest() const { return notes.GetSize() == 0; }

    bool RemoveNote(char name, int octave);

    void SetDuration(psMusic::Duration duration) { this->duration = duration; }

    void SetRest() { notes.Empty(); }

private:
    psMusic::Duration duration; 

    typedef csArrayCapacityFixedGrow<MEAS_ELEM_NOTES_CAPACITY_GROWTH> NotesArrayCapacity;
    csArray<Note, csArrayElementHandler<Note>, CS::Container::ArrayAllocDefault,
        NotesArrayCapacity> notes; 
};

//--------------------------------------------------

template<typename MeasureElementType>
class Measure
{
public:
    
    class MeasureAttributes
    {
    public:
        MeasureAttributes();

        int GetBeats() const { return beats; }

        int GetBeatType() const { return beatType; }

        int GetFifths() const { return fifths; }

        int GetTempo() const { return tempo; }

        bool IsUndefined() const;

        void SetBeats(int beats) { this->beats = beats; }

        void SetBeatType(int beatType) { this->beatType = beatType; }

        void SetFifths(int fifths) { this->fifths = fifths; }

        void SetTempo(int tempo) { this->tempo = tempo; }

        void UpdateAttributes(const MeasureAttributes &attributes);

    private:
        int tempo; 
        int beats; 
        int beatType; 

        int fifths;
    };

    Measure();

    ~Measure();

    void DeleteElement(size_t n) { elements.DeleteIndex(n); }

    void DeleteAllElements() { elements.Empty(); }

    void Fit(const MeasureAttributes* const attributes);

    MeasureAttributes GetAttributes() const;

    MeasureElementType &GetElement(size_t n) { return elements[n]; }

    const MeasureElementType &GetElement(size_t n) const { return elements[n]; }

    size_t GetNElements() const { return elements.GetSize(); }

    int GetNEndRepeat() const { return nEndRepeat; }

    void InsertElement(size_t n, const MeasureElementType &element);

    bool IsEmpty() const { return elements.GetSize() == 0; }

    bool IsEnding() const { return isEnding; }

    bool IsEndRepeat() const { return nEndRepeat > 0; }

    bool IsStartRepeat() const { return isStartRepeat; }

    size_t PushElement(const MeasureElementType &element)
    {
        return elements.Push(element);
    }

    void SetBeat(int beats, int beatType);

    void SetEnding(bool isEnding);

    void SetFifths(int fifths);

    void SetNEndRepeat(int nEndRepeat);

    void SetStartRepeat(bool isStartRepeat);

    void SetTempo(int tempo);

private:
    bool isEnding; 
    bool isStartRepeat; 
    int nEndRepeat; 
    csArray<MeasureElementType> elements; 

    MeasureAttributes* attributes;

    void CreateAttributes();

    void DeleteAttributes();

    void UpdateAttributes();
};

//--------------------------------------------------

class ScoreContext
{
public:
    Note::NoteContext noteContext;

    Measure<MeasureElement>::MeasureAttributes measureAttributes;

    ScoreContext();

    int GetNPerformedRepeats(int measureID) const;

    int RestoreLastStartRepeat();

    void Update(int measureID, const Measure<MeasureElement> &measure);

    void Update(const MeasureElement &element);

private:
    int lastStartRepeatID; 

    Measure<MeasureElement>::MeasureAttributes lastStartRepeatAttributes;

    csHash<int, int> repeatsDone;
};

#include "scoreelements.hpp"

#endif // SCORE_ELEMENTS_H