Add glue / lock buttons to the location window.

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

diff --git a/libs/ardour/ardour/location.h b/libs/ardour/ardour/location.h
index f23d2e382a272bb7b8a6f82533f1875b046136c9..429fac177cae710bfbf054c85889c8d9e2e0c050 100644 (file)
--- a/libs/ardour/ardour/location.h
+++ b/libs/ardour/ardour/location.h
@@ -34,10 +34,11 @@
 #include "pbd/statefuldestructible.h"
 
 #include "ardour/ardour.h"
+#include "ardour/session_handle.h"
 
 namespace ARDOUR {
 
-class Location : public PBD::StatefulDestructible
+class Location : public SessionHandleRef, public PBD::StatefulDestructible
 {
   public:
        enum Flags {
@@ -50,39 +51,23 @@ class Location : public PBD::StatefulDestructible
                IsSessionRange = 0x40
        };
 
-       Location (nframes64_t sample_start,
-                       nframes64_t sample_end,
-                       const std::string &name,
-                       Flags bits = Flags(0))
-
-               : _name (name),
-               _start (sample_start),
-               _end (sample_end),
-               _flags (bits),
-               _locked (false) { }
-
-       Location () {
-               _start = 0;
-               _end = 0;
-               _flags = Flags (0);
-               _locked = false;
-       }
-
+       Location (Session &);
+       Location (Session &, nframes64_t, nframes64_t, const std::string &, Flags bits = Flags(0));
        Location (const Location& other);
-       Location (const XMLNode&);
+       Location (Session &, const XMLNode&);
        Location* operator= (const Location& other);
 
        bool locked() const { return _locked; }
-       void lock() { _locked = true; changed (this); }
-       void unlock() { _locked = false; changed (this); }
+       void lock() { _locked = true; LockChanged (this); }
+       void unlock() { _locked = false; LockChanged (this); }
 
        nframes64_t start() const  { return _start; }
        nframes64_t end() const { return _end; }
        nframes64_t length() const { return _end - _start; }
 
-       int set_start (nframes64_t s);
-       int set_end (nframes64_t e);
-       int set (nframes64_t start, nframes64_t end);
+       int set_start (nframes64_t s, bool force = false, bool allow_bbt_recompute = true);
+       int set_end (nframes64_t e, bool force = false, bool allow_bbt_recompute = true);
+       int set (nframes64_t start, nframes64_t end, bool allow_bbt_recompute = true);
 
        int move_to (nframes64_t pos);
 
@@ -104,14 +89,17 @@ class Location : public PBD::StatefulDestructible
        bool is_range_marker() const { return _flags & IsRangeMarker; }
        bool matches (Flags f) const { return _flags & f; }
 
+       Flags flags () const { return _flags; }
+
        PBD::Signal1<void,Location*> name_changed;
        PBD::Signal1<void,Location*> end_changed;
        PBD::Signal1<void,Location*> start_changed;
 
+       PBD::Signal1<void,Location*> LockChanged;
        PBD::Signal2<void,Location*,void*> FlagsChanged;
+       PBD::Signal1<void,Location*> PositionLockStyleChanged;
 
-       /* this is sent only when both start&end change at the same time */
-
+       /* this is sent only when both start and end change at the same time */
        PBD::Signal1<void,Location*> changed;
 
        /* CD Track / CD-Text info */
@@ -122,23 +110,31 @@ class Location : public PBD::StatefulDestructible
        XMLNode& get_state (void);
        int set_state (const XMLNode&, int version);
 
+       PositionLockStyle position_lock_style() const { return _position_lock_style; }
+       void set_position_lock_style (PositionLockStyle ps);
+       void recompute_frames_from_bbt ();
+
   private:
        std::string   _name;
        nframes64_t   _start;
+       BBT_Time      _bbt_start;
        nframes64_t   _end;
+       BBT_Time      _bbt_end;
        Flags         _flags;
        bool          _locked;
+       PositionLockStyle _position_lock_style;
 
        void set_mark (bool yn);
        bool set_flag_internal (bool yn, Flags flag);
+       void recompute_bbt_from_frames ();
 };
 
-class Locations : public PBD::StatefulDestructible
+class Locations : public SessionHandleRef, public PBD::StatefulDestructible
 {
   public:
        typedef std::list<Location *> LocationList;
 
-       Locations ();
+       Locations (Session &);
        ~Locations ();
 
        const LocationList& list() { return locations; }
@@ -163,15 +159,23 @@ class Locations : public PBD::StatefulDestructible
        int set_current (Location *, bool want_lock = true);
        Location *current () const { return current_location; }
 
-       Location *first_location_before (nframes64_t, bool include_special_ranges = false);
-       Location *first_location_after (nframes64_t, bool include_special_ranges = false);
+       Location* first_location_before (nframes64_t, bool include_special_ranges = false);
+       Location* first_location_after (nframes64_t, bool include_special_ranges = false);
 
        void marks_either_side (nframes64_t const, nframes64_t &, nframes64_t &) const;
 
        void find_all_between (nframes64_t start, nframes64_t, LocationList&, Location::Flags);
 
+       enum Change {
+               ADDITION, ///< a location was added, but nothing else changed
+               REMOVAL, ///< a location was removed, but nothing else changed
+               OTHER ///< something more complicated happened
+       };
+
        PBD::Signal1<void,Location*> current_changed;
-       PBD::Signal0<void>           changed;
+       /** something changed about the location list; the parameter gives some idea as to what */
+       PBD::Signal1<void,Change>    changed;
+       /** a location has been added to the end of the list */
        PBD::Signal1<void,Location*> added;
        PBD::Signal1<void,Location*> removed;
        PBD::Signal1<void,const PBD::PropertyChange&>    StateChanged;