/home/pete/Work/TSE3.svn/tse3/src/tse3/util/PowerQuantise.h

Go to the documentation of this file.

/*
 * @(#)util/PowerQuantise.h 3.00 2 April 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_UTIL_POWERQUANTISE_H
#define TSE3_UTIL_POWERQUANTISE_H

#include "tse3/Midi.h"

#include <vector>
#include <cstddef>

namespace TSE3
{
    class PhraseEdit;

    namespace Util
    {
        class PowerQuantise
        {
            public:

                PowerQuantise();

                class Pattern
                {
                    public:

                        Pattern();

                        TSE3::Clock length() const { return _length; }

                        void setLength(TSE3::Clock length);

                        size_t size() const { return points.size(); }

                        TSE3::Clock const &operator[](size_t n) const
                        {
                            return points[n];
                        }

                        void insert(TSE3::Clock point);

                        void erase(size_t n);

                        void erase(TSE3::Clock point);

                    private:

                        std::vector<TSE3::Clock> points;
                        TSE3::Clock              _length;
                };

                Pattern &pattern() { return _pattern; }

                int by() const { return _by; }

                void setBy(int by);

                int window() const { return _window; }

                void setWindow(int window);

                bool onlySelected() const { return _onlySelected; }

                void setOnlySelected(bool s);

                bool onlyNotes() const { return _onlyNotes; }

                void setOnlyNotes(bool n);

                bool spreadCtrl() const { return _spreadCtrl; }

                void setSpreadCtrl(bool s);

                enum Direction
                {
                    nearest,
                    backwards,
                    forwards
                };

                Direction direction() const { return _direction; }

                void setDirection(Direction d);

                enum Length
                {
                    quantiseOffTime,
                    quantiseLength
                };

                Length length() const { return _length; }

                void setLength(Length l);

                int lengthBy() const { return _lengthBy; }

                void setLengthBy(int by);

                TSE3::Clock humanise() const { return _humanise; }

                void setHumanise(TSE3::Clock h);

                TSE3::Clock lengthHumanise() const { return _lengthHumanise; }

                void setLengthHumanise(TSE3::Clock h);

                void go(TSE3::PhraseEdit *phraseEdit);

            private:

                bool shouldBeQuantised(TSE3::MidiEvent e)
                {
                    using namespace TSE3;
                    return (!_onlyNotes || e.data.status == MidiCommand_NoteOn)
                           && (!_onlySelected || e.data.selected)
                           && !shouldBeSpread(e);
                }

                bool shouldBeSpread(TSE3::MidiEvent e)
                {
                    return (_spreadCtrl && isContinuous(e))
                           && (!_onlySelected || e.data.selected);
                }

                bool isContinuous(TSE3::MidiEvent e)
                {
                    using namespace TSE3;
                    bool b = false;
                    switch (e.data.status)
                    {
                        case MidiCommand_KeyPressure:
                        case MidiCommand_ControlChange:
                        case MidiCommand_ChannelPressure:
                        case MidiCommand_PitchBend:
                            b = true;
                    }
                    return b;
                }

                TSE3::Clock quantise(TSE3::Clock time, int percentage);

                TSE3::Clock humanise(TSE3::Clock time,
                                     TSE3::Clock maxVal);

                TSE3::Clock spreadContinuous(
                    TSE3::PhraseEdit *phraseEdit,
                    size_t pos,
                    TSE3::Clock lastNonCont_Original,
                    TSE3::Clock lastNonCont_Quantised);

                Pattern         _pattern;
                int             _by;
                int             _window;
                bool            _onlySelected;
                bool            _onlyNotes;
                bool            _spreadCtrl;
                Direction       _direction;
                Length          _length;
                int             _lengthBy;
                TSE3::Clock     _humanise;
                TSE3::Clock     _lengthHumanise;
        };
    }
}

#endif

---