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

Go to the documentation of this file.

/*
 * @(#)MidiFilter.h 3.00 8 June 1999
 *
 * 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_EVENTFILTER_H
#define TSE3_EVENTFILTER_H

#include "tse3/listen/MidiFilter.h"

#include "tse3/Notifier.h"
#include "tse3/Filter.h"
#include "tse3/Serializable.h"
#include "tse3/Midi.h"

namespace TSE3
{
    class MidiFilter : public Filter,
                       public Serializable,
                       public Notifier<MidiFilterListener>
    {
        public:

            MidiFilter();
            MidiFilter(const MidiFilter &);
            virtual ~MidiFilter();
            MidiFilter &operator=(const MidiFilter &);

            bool status() const { return _status; }

            void setStatus(bool s);

            bool channelFilter(int c) const { return _channelFilter & (1<<c); }

            void setChannelFilter(int c, bool val);

            int channel() const { return _channel; }

            void setChannel(int c);

            int port() const { return _port; }

            void setPort(int p);

            Clock offset() const { return _offset; }

            void setOffset(Clock o);

            int timeScale() const { return _timeScale; }

            void setTimeScale(int t);

            Clock quantise() const { return _quantise; }

            void setQuantise(Clock q);

            Clock minLength() const { return _minLength; }

            void setMinLength(Clock ml);

            Clock maxLength() const { return _maxLength; }

            void setMaxLength(Clock ml);

            int transpose() const { return _transpose; }

            void setTranspose(int t);

            int minVelocity() const { return _minVelocity; }

            void setMinVelocity(int v);

            int maxVelocity() const { return _maxVelocity; }

            void setMaxVelocity(int v);

            Clock velocityScale() const { return _velocityScale; }

            void setVelocityScale(int v);

            virtual MidiEvent filter(const MidiEvent &e) const;

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

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

        private:

            void setChannelFilter(int c) { _channelFilter = c; }

            bool         _status;
            unsigned int _channelFilter;
            int          _channel;
            int          _port;
            Clock        _offset;
            int          _timeScale;
            Clock        _quantise;
            Clock        _minLength;
            Clock        _maxLength;
            int          _transpose;
            int          _minVelocity;
            int          _maxVelocity;
            int          _velocityScale;
    };
}

#endif

---