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

Go to the documentation of this file.

/*
 * @(#)app/PartSelection.h 1.00 18 June 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_APP_PARTSELECTION_H
#define TSE3_APP_PARTSELECTION_H

#include "tse3/listen/app/PartSelection.h"

#include "tse3/Notifier.h"
#include "tse3/Part.h"
#include "tse3/Midi.h"
#include "tse3/listen/app/TrackSelection.h"

#include <vector>
#include <cstddef>

namespace TSE3
{
    class Phrase;
    class Song;
    class Track;

    namespace App
    {
        class PartSelection : public TSE3::Listener<TSE3::PartListener>,
                              public TSE3::Listener<TrackSelectionListener>,
                              public TSE3::Notifier<PartSelectionListener>
        {
            public:

                PartSelection();
                ~PartSelection();
                PartSelection(const PartSelection &);

                /**************************************************************
                 * Setting the selection
                 *************************************************************/

                TSE3::Clock earliest() const { return _earliest; }

                TSE3::Clock latest() const { return _latest; }

                size_t minTrack() const { return _minTrack; }

                size_t maxTrack() const { return _maxTrack; }

                void select(TSE3::Part *part, bool add);

                void deselect(TSE3::Part *part);

                void clear();

                void selectAll(TSE3::Song *song);

                void selectAll(TSE3::Track *track);

                void invert(TSE3::Song *song);

                void selectBetween(TSE3::Song *song,
                                   TSE3::Clock start, TSE3::Clock end,
                                   bool inside = true);

                void selectBetween(TSE3::Track *track,
                                   TSE3::Clock start, TSE3::Clock end,
                                   bool inside = true);

                PartSelection &operator=(const PartSelection &);

                /**************************************************************
                 * Access to the selected Parts
                 *************************************************************/

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

                bool isSelected(TSE3::Part *part) const;

                typedef std::vector<TSE3::Part*>::const_iterator iterator_t;

                Part *front() const
                {
                    return parts.size() ? parts.front() : 0;
                }

                Part *back() const
                {
                    return parts.size() ? parts.back() : 0;
                }

                iterator_t begin() const { return parts.begin(); }

                iterator_t end() const { return parts.end(); }

                virtual void Part_StartAltered(Part *, Clock start);

                virtual void Part_EndAltered(Part *, Clock end);

                virtual void Part_Reparented(Part *);

                virtual void Notifier_Deleted(Part *);

                virtual void TrackSelection_Selected
                    (TrackSelection *, TSE3::Track *, bool);

            private:

                void addPart(TSE3::Part *part);

                void removePart(TSE3::Part *part);

                void recalculateEnds();

                std::vector<TSE3::Part*> parts;
                bool        timesValid;
                TSE3::Clock _earliest;
                TSE3::Clock _latest;
                bool        tracksValid;
                size_t      _minTrack;
                size_t      _maxTrack;
        };
    }
}

#endif

---