Fix the horrible mess that was anything related to sources and paths.

[ardour.git] / libs / ardour / ardour / track.h

diff --git a/libs/ardour/ardour/track.h b/libs/ardour/ardour/track.h
index 4e2af5c80eb9b1b035b357d03c51a701832f9933..566153d02f82eb8ad9529ef1868c2238d809b0c6 100644 (file)
--- a/libs/ardour/ardour/track.h
+++ b/libs/ardour/ardour/track.h
@@ -19,6 +19,8 @@
 #ifndef __ardour_track_h__
 #define __ardour_track_h__
 
+#include <boost/shared_ptr.hpp>
+
 #include <ardour/route.h>
 
 namespace ARDOUR {
@@ -27,6 +29,7 @@ class Session;
 class Diskstream;
 class Playlist;
 class RouteGroup;
+class Region;
 
 class Track : public Route
 {
@@ -35,31 +38,33 @@ class Track : public Route
 
        virtual ~Track ();
        
-       int set_name (string str, void *src);
+       bool set_name (const std::string& str);
+
+       TrackMode mode () const { return _mode; }
+       virtual int set_mode (TrackMode m) { return false; }
+       virtual bool can_use_mode (TrackMode m, bool& bounce_required) { return false; }
+       sigc::signal<void> TrackModeChanged;
 
-       virtual int roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, 
-               jack_nframes_t offset, int declick, bool can_record, bool rec_monitors_input) = 0;
+       virtual int roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, 
+               nframes_t offset, int declick, bool can_record, bool rec_monitors_input) = 0;
        
-       virtual int no_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, 
-               jack_nframes_t offset, bool state_changing, bool can_record, bool rec_monitors_input) = 0;
+       virtual int no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, 
+               nframes_t offset, bool state_changing, bool can_record, bool rec_monitors_input) = 0;
        
-       virtual int silent_roll (jack_nframes_t nframes, jack_nframes_t start_frame, jack_nframes_t end_frame, 
-               jack_nframes_t offset, bool can_record, bool rec_monitors_input) = 0;
+       virtual int silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame, 
+               nframes_t offset, bool can_record, bool rec_monitors_input) = 0;
 
        void toggle_monitor_input ();
 
-       virtual bool can_record();
+       bool can_record();
 
-       Diskstream& diskstream() const { return *_diskstream; }
+       boost::shared_ptr<Diskstream> diskstream() const { return _diskstream; }
 
        virtual int use_diskstream (string name) = 0;
        virtual int use_diskstream (const PBD::ID& id) = 0;
 
-       TrackMode mode() const { return _mode; }
-       void      set_mode (TrackMode m);
-
-       jack_nframes_t update_total_latency();
-       void           set_latency_delay (jack_nframes_t);
+       nframes_t update_total_latency();
+       void           set_latency_delay (nframes_t);
 
        enum FreezeState {
                NoFreeze,
@@ -72,21 +77,20 @@ class Track : public Route
        virtual void freeze (InterThreadInfo&) = 0;
        virtual void unfreeze () = 0;
 
-       virtual void bounce (InterThreadInfo&) = 0;
-       virtual void bounce_range (jack_nframes_t start, jack_nframes_t end, InterThreadInfo&) = 0;
+       virtual boost::shared_ptr<Region> bounce (InterThreadInfo&) = 0;
+       virtual boost::shared_ptr<Region> bounce_range (nframes_t start, nframes_t end, InterThreadInfo&) = 0;
 
        XMLNode&    get_state();
        XMLNode&    get_template();
        virtual int set_state(const XMLNode& node) = 0;
 
-       PBD::Controllable& rec_enable_control() { return _rec_enable_control; }
+       boost::shared_ptr<PBD::Controllable> rec_enable_control() { return _rec_enable_control; }
 
        bool record_enabled() const;
        void set_record_enable (bool yn, void *src);
        
        void set_meter_point (MeterPoint, void* src);
        
-       sigc::signal<void> ModeChanged;
        sigc::signal<void> DiskstreamChanged;
        sigc::signal<void> FreezeChange;
 
@@ -95,38 +99,35 @@ class Track : public Route
 
        virtual XMLNode& state (bool full) = 0;
 
-       virtual void passthru_silence (jack_nframes_t start_frame, jack_nframes_t end_frame, 
-               jack_nframes_t nframes, jack_nframes_t offset, int declick, bool meter) = 0;
-
-       virtual uint32_t n_process_buffers () = 0;
-       
-       Diskstream *_diskstream;
+       boost::shared_ptr<Diskstream> _diskstream;
        MeterPoint  _saved_meter_point;
        TrackMode   _mode;
 
        //private: (FIXME)
-       struct FreezeRecordInsertInfo {
-           FreezeRecordInsertInfo(XMLNode& st, boost::shared_ptr<Insert> ins) 
-                   : state (st), insert (ins) {}
-
-           XMLNode                   state;
-           boost::shared_ptr<Insert> insert;
-           PBD::ID                   id;
-           UndoAction                memento;
+       struct FreezeRecordProcessorInfo {
+           FreezeRecordProcessorInfo(XMLNode& st, boost::shared_ptr<Processor> proc) 
+                   : state (st), processor (proc) {}
+
+           XMLNode                      state;
+           boost::shared_ptr<Processor> processor;
+           PBD::ID                      id;
+           UndoAction                   memento;
        };
 
        struct FreezeRecord {
            FreezeRecord()
-               : playlist(0)
-               , have_mementos(false)
+               : have_mementos(false)
            {}
 
            ~FreezeRecord();
 
-           Playlist*                       playlist;
-           vector<FreezeRecordInsertInfo*> insert_info;
-           bool                            have_mementos;
-           FreezeState                     state;
+           boost::shared_ptr<Playlist>        playlist;
+           vector<FreezeRecordProcessorInfo*> processor_info;
+           bool                               have_mementos;
+           FreezeState                        state;
+           gain_t                          gain;
+           AutoState                       gain_automation_state;
+           AutoState                       pan_automation_state;
        };
 
        struct RecEnableControllable : public PBD::Controllable {
@@ -138,19 +139,15 @@ class Track : public Route
            Track& track;
        };
 
-       //virtual void diskstream_record_enable_changed (void *src) = 0;
-       //virtual void diskstream_input_channel_changed (void *src) = 0;
-
-       //virtual void input_change_handler (void *src) = 0;
-
        virtual void set_state_part_two () = 0;
 
        FreezeRecord          _freeze_record;
        XMLNode*              pending_state;
        sigc::connection      recenable_connection;
        sigc::connection      ic_connection;
-       RecEnableControllable _rec_enable_control;
        bool                  _destructive;
+       
+       boost::shared_ptr<RecEnableControllable> _rec_enable_control;
 };
 
 }; /* namespace ARDOUR*/