/home/pete/Work/TSE3.svn/tse3/src/tse3/app/Choices.h

Go to the documentation of this file.

/*
 * @(#)app/Choices.h 1.00 16 Nov 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_APP_CHOICES_H
#define TSE3_APP_CHOICES_H

#include "tse3/Notifier.h"
#include "tse3/Serializable.h"
#include "tse3/FileBlockParser.h"

#include <string>
#include <list>

namespace TSE3
{
    class Metronome;
    class Transport;
    class Panic;
    class MidiMapper;
    class MidiScheduler;

    namespace Ins
    {
        class Destination;
    }

    namespace App
    {
        class Application;

        class ChoiceHandler : public TSE3::Serializable
        {
            public:

                ChoiceHandler(const std::string &choicename);
                virtual ~ChoiceHandler();

                const std::string &name() const { return _name; }

            protected:

                std::string _name;
        };

        class ChoicesManager// : public Listener
        {
            public:

                ChoicesManager();
                ~ChoicesManager();

                void add(ChoiceHandler *ch) { handler.add(ch); }

                void remove(ChoiceHandler *ch) { handler.remove(ch); }

                void save(const std::string &filename);

                void load(const std::string &filename);

            private:

                class ChoicesChoiceHandler : public ChoiceHandler
                {
                    public:
                        ChoicesChoiceHandler();
                        ~ChoicesChoiceHandler();
                        void add(ChoiceHandler *ch);
                        void remove(ChoiceHandler *ch);
                        virtual void save(std::ostream &out, int indent) const;
                        virtual void load(std::istream &in,
                                          TSE3::SerializableLoadInfo &info);
                    private:
                        std::list<ChoiceHandler *> handlers;
                };
                ChoicesChoiceHandler handler;

        };

        /**********************************************************************
         * ChoiceHandlers
         **********************************************************************/

        class ApplicationChoiceHandler : public ChoiceHandler
        {
            public:
                ApplicationChoiceHandler(Application *a);
                ~ApplicationChoiceHandler();
                virtual void save(std::ostream &out, int indent) const;
                virtual void load(std::istream &in,
                                  TSE3::SerializableLoadInfo &info);
            private:
                Application *a;
        };

        class MetronomeChoiceHandler : public ChoiceHandler
        {
            public:
                MetronomeChoiceHandler(TSE3::Metronome *m);
                ~MetronomeChoiceHandler();
                virtual void save(std::ostream &out, int indent) const;
                virtual void load(std::istream &in,
                                  TSE3::SerializableLoadInfo &info);
            private:
                TSE3::Metronome *m;
        };

        class PanicChoiceHandler : public ChoiceHandler
        {
            public:
                PanicChoiceHandler(TSE3::Panic *p);
                ~PanicChoiceHandler();
                virtual void save(std::ostream &out, int indent) const;
                virtual void load(std::istream &in,
                                  TSE3::SerializableLoadInfo &info);
            private:
                TSE3::Panic *p;
        };

        class MidiMapperChoiceHandler : public ChoiceHandler
        {
            public:
                MidiMapperChoiceHandler(TSE3::MidiMapper *m);
                ~MidiMapperChoiceHandler();
                virtual void save(std::ostream &out, int indent) const;
                virtual void load(std::istream &in,
                                  TSE3::SerializableLoadInfo &info);
            private:
                TSE3::MidiMapper *m;
        };

        class TransportChoiceHandler : public ChoiceHandler
        {
            public:
                TransportChoiceHandler(TSE3::Transport *t);
                ~TransportChoiceHandler();
                virtual void save(std::ostream &out, int indent) const;
                virtual void load(std::istream &in,
                                  TSE3::SerializableLoadInfo &info);
            private:
                TSE3::Transport         *t;
                PanicChoiceHandler       startPanicHandler;
                PanicChoiceHandler       endPanicHandler;
                MidiMapperChoiceHandler  mapperHandler;
        };

        class DestinationChoiceHandler : public ChoiceHandler
        {
            public:
                DestinationChoiceHandler(TSE3::Ins::Destination *d,
                                         TSE3::MidiScheduler    *ms);
                ~DestinationChoiceHandler();
                virtual void save(std::ostream &out, int indent) const;
                virtual void load(std::istream &in,
                                  TSE3::SerializableLoadInfo &info);
            private:
                TSE3::Ins::Destination *d;
                TSE3::MidiScheduler    *ms;
        };
    }
}

#endif

---