X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fplaylist.h;h=aa661b8588401a43604d5c236fd1a03458b3b7bb;hb=8713667ec1a6cc9ba56c07f763e5a422cc47fbef;hp=ad7210f48fc7f45fea511fa69d93e0da9557fff9;hpb=449aab3c465bbbf66d221fac3d7ea559f1720357;p=ardour.git

diff --git a/libs/ardour/ardour/playlist.h b/libs/ardour/ardour/playlist.h
index ad7210f48f..aa661b8588 100644
--- a/libs/ardour/ardour/playlist.h
+++ b/libs/ardour/ardour/playlist.h
@@ -1,5 +1,5 @@
 /*
-    Copyright (C) 2000 Paul Davis 
+    Copyright (C) 2000 Paul Davis
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -26,6 +26,7 @@
 #include <list>
 #include <boost/shared_ptr.hpp>
 #include <boost/enable_shared_from_this.hpp>
+#include <boost/utility.hpp>
 
 #include <sys/stat.h>
 
@@ -33,31 +34,35 @@
 
 #include <sigc++/signal.h>
 
-#include <pbd/undo.h>
-#include <pbd/stateful.h> 
-#include <pbd/statefuldestructible.h> 
+#include "pbd/undo.h"
+#include "pbd/stateful.h"
+#include "pbd/statefuldestructible.h"
 
-#include <ardour/ardour.h>
-#include <ardour/session_object.h>
-#include <ardour/crossfade_compare.h>
-#include <ardour/location.h>
-#include <ardour/data_type.h>
+#include "evoral/types.hpp"
+
+#include "ardour/ardour.h"
+#include "ardour/session_object.h"
+#include "ardour/crossfade_compare.h"
+#include "ardour/location.h"
+#include "ardour/data_type.h"
 
 namespace ARDOUR  {
 
 class Session;
 class Region;
 
-class Playlist : public SessionObject, public boost::enable_shared_from_this<Playlist> {
+class Playlist : public SessionObject,
+                 public boost::noncopyable,
+                 public boost::enable_shared_from_this<Playlist> {
   public:
-	typedef list<boost::shared_ptr<Region> >    RegionList;
+	typedef std::list<boost::shared_ptr<Region> >    RegionList;
 
 	Playlist (Session&, const XMLNode&, DataType type, bool hidden = false);
-	Playlist (Session&, string name, DataType type, bool hidden = false);
-	Playlist (boost::shared_ptr<const Playlist>, string name, bool hidden = false);
-	Playlist (boost::shared_ptr<const Playlist>, nframes_t start, nframes_t cnt, string name, bool hidden = false);
+	Playlist (Session&, std::string name, DataType type, bool hidden = false);
+	Playlist (boost::shared_ptr<const Playlist>, std::string name, bool hidden = false);
+	Playlist (boost::shared_ptr<const Playlist>, nframes_t start, nframes_t cnt, std::string name, bool hidden = false);
 
-	virtual ~Playlist ();  
+	virtual ~Playlist ();
 
 	void set_region_ownership ();
 
@@ -68,7 +73,7 @@ class Playlist : public SessionObject, public boost::enable_shared_from_this<Pla
 	void release();
 	bool used () const { return _refcnt != 0; }
 
-	bool set_name (const string& str);
+	bool set_name (const std::string& str);
 
 	const DataType& data_type() const { return _type; }
 
@@ -86,7 +91,7 @@ class Playlist : public SessionObject, public boost::enable_shared_from_this<Pla
 
 	/* Editing operations */
 
-	void add_region (boost::shared_ptr<Region>, nframes_t position, float times = 1);
+	void add_region (boost::shared_ptr<Region>, nframes_t position, float times = 1, bool auto_partition = false);
 	void remove_region (boost::shared_ptr<Region>);
 	void get_equivalent_regions (boost::shared_ptr<Region>, std::vector<boost::shared_ptr<Region> >&);
 	void get_region_list_equivalent_regions (boost::shared_ptr<Region>, std::vector<boost::shared_ptr<Region> >&);
@@ -94,14 +99,14 @@ class Playlist : public SessionObject, public boost::enable_shared_from_this<Pla
 	void split_region (boost::shared_ptr<Region>, nframes_t position);
 	void split (nframes64_t at);
 	void shift (nframes64_t at, nframes64_t distance, bool move_intersected, bool ignore_music_glue);
-	void partition (nframes_t start, nframes_t end, bool just_top_level);
+	void partition (nframes_t start, nframes_t end, bool cut = false);
 	void duplicate (boost::shared_ptr<Region>, nframes_t position, float times);
 	void nudge_after (nframes_t start, nframes_t distance, bool forwards);
 	void shuffle (boost::shared_ptr<Region>, int dir);
 	void update_after_tempo_map_change ();
 
-	boost::shared_ptr<Playlist> cut  (list<AudioRange>&, bool result_is_hidden = true);
-	boost::shared_ptr<Playlist> copy (list<AudioRange>&, bool result_is_hidden = true);
+	boost::shared_ptr<Playlist> cut  (std::list<AudioRange>&, bool result_is_hidden = true);
+	boost::shared_ptr<Playlist> copy (std::list<AudioRange>&, bool result_is_hidden = true);
 	int                         paste (boost::shared_ptr<Playlist>, nframes_t position, float times);
 
 	RegionList*                regions_at (nframes_t frame);
@@ -109,25 +114,28 @@ class Playlist : public SessionObject, public boost::enable_shared_from_this<Pla
 	RegionList*                regions_to_read (nframes_t start, nframes_t end);
 	boost::shared_ptr<Region>  find_region (const PBD::ID&) const;
 	boost::shared_ptr<Region>  top_region_at (nframes_t frame);
+	boost::shared_ptr<Region>  top_unmuted_region_at (nframes_t frame);
 	boost::shared_ptr<Region>  find_next_region (nframes_t frame, RegionPoint point, int dir);
 	nframes64_t                find_next_region_boundary (nframes64_t frame, int dir);
 	bool                       region_is_shuffle_constrained (boost::shared_ptr<Region>);
 
 	nframes64_t find_next_transient (nframes64_t position, int dir);
 
-	template<class T> void foreach_region (T *t, void (T::*func)(boost::shared_ptr<Region>, void *), void *arg);
-	template<class T> void foreach_region (T *t, void (T::*func)(boost::shared_ptr<Region>));
+	void foreach_region (sigc::slot<void, boost::shared_ptr<Region> >);
 
 	XMLNode& get_state ();
-	int set_state (const XMLNode&);
+	int set_state (const XMLNode&, int version);
 	XMLNode& get_template ();
 
 	sigc::signal<void,bool> InUse;
 	sigc::signal<void>      Modified;
+	sigc::signal<void, boost::weak_ptr<Region> > RegionAdded;
+	sigc::signal<void, boost::weak_ptr<Region> > RegionRemoved;
 	sigc::signal<void>      NameChanged;
 	sigc::signal<void>      LengthChanged;
+	sigc::signal<void, std::list< Evoral::RangeMove<nframes_t> > const &> RangesMoved;
 
-	static string bump_name (string old_name, Session&);
+	static std::string bump_name (std::string old_name, Session&);
 
 	void freeze ();
 	void thaw ();
@@ -140,10 +148,10 @@ class Playlist : public SessionObject, public boost::enable_shared_from_this<Pla
 	uint32_t read_data_count() const { return _read_data_count; }
 
 	const PBD::ID& get_orig_diskstream_id () const { return _orig_diskstream_id; }
-	void set_orig_diskstream_id (const PBD::ID& did) { _orig_diskstream_id = did; }  
+	void set_orig_diskstream_id (const PBD::ID& did) { _orig_diskstream_id = did; }
 
 	/* destructive editing */
-	
+
 	virtual bool destroy_region (boost::shared_ptr<Region>) = 0;
 
 	/* special case function used by UI selection objects, which have playlists that actually own the regions
@@ -152,42 +160,50 @@ class Playlist : public SessionObject, public boost::enable_shared_from_this<Pla
 
 	void drop_regions ();
 
+	bool explicit_relayering () const {
+		return _explicit_relayering;
+	}
+
+	void set_explicit_relayering (bool e);
+
   protected:
 	friend class Session;
 
   protected:
 	struct RegionLock {
-	    RegionLock (Playlist *pl, bool do_block_notify = true) : playlist (pl), block_notify (do_block_notify) {
-		    playlist->region_lock.lock();
-		    if (block_notify) {
-			    playlist->delay_notifications();
-		    }
-	    }
-	    ~RegionLock() { 
-		    playlist->region_lock.unlock();
-		    if (block_notify) {
-			    playlist->release_notifications ();
-		    }
-	    }
-	    Playlist *playlist;
-	    bool block_notify;
+		RegionLock (Playlist *pl, bool do_block_notify = true) : playlist (pl), block_notify (do_block_notify) {
+			playlist->region_lock.lock();
+			if (block_notify) {
+				playlist->delay_notifications();
+			}
+		}
+		~RegionLock() {
+			playlist->region_lock.unlock();
+			if (block_notify) {
+				playlist->release_notifications ();
+			}
+		}
+		Playlist *playlist;
+		bool block_notify;
 	};
 
 	friend class RegionLock;
 
 	RegionList       regions;  /* the current list of regions in the playlist */
 	std::set<boost::shared_ptr<Region> > all_regions; /* all regions ever added to this playlist */
+	std::list<sigc::connection> region_state_changed_connections;
 	DataType        _type;
 	mutable gint    block_notifications;
 	mutable gint    ignore_state_changes;
-	mutable Glib::Mutex region_lock;
+	mutable Glib::RecMutex region_lock;
 	std::set<boost::shared_ptr<Region> > pending_adds;
 	std::set<boost::shared_ptr<Region> > pending_removes;
 	RegionList       pending_bounds;
 	bool             pending_modified;
 	bool             pending_length;
+	std::list< Evoral::RangeMove<nframes_t> > pending_range_moves;
 	bool             save_on_thaw;
-	string           last_save_reason;
+	std::string      last_save_reason;
 	uint32_t         in_set_state;
 	bool             first_set_state;
 	bool            _hidden;
@@ -203,20 +219,22 @@ class Playlist : public SessionObject, public boost::enable_shared_from_this<Pla
 	uint32_t        _read_data_count;
 	PBD::ID         _orig_diskstream_id;
 	uint64_t         layer_op_counter;
-	nframes_t   freeze_length;
+	nframes_t        freeze_length;
+	bool             auto_partition;
+
+	/** true if relayering should be done using region's current layers and their `pending explicit relayer'
+	 *  flags; otherwise false if relayering should be done using the layer-model (most recently moved etc.)
+	 *  Explicit relayering is used by tracks in stacked regionview mode.
+	 */
+	bool            _explicit_relayering;
 
 	void init (bool hide);
 
-	bool holding_state () const { 
+	bool holding_state () const {
 		return g_atomic_int_get (&block_notifications) != 0 ||
 			g_atomic_int_get (&ignore_state_changes) != 0;
 	}
 
-	/* prevent the compiler from ever generating these */
-
-	Playlist (const Playlist&);
-	Playlist (Playlist&);
-
 	void delay_notifications ();
 	void release_notifications ();
 	virtual void flush_notifications ();
@@ -227,6 +245,7 @@ class Playlist : public SessionObject, public boost::enable_shared_from_this<Pla
 	void notify_layering_changed ();
 	void notify_modified ();
 	void notify_state_changed (Change);
+	void notify_region_moved (boost::shared_ptr<Region>);
 
 	void mark_session_dirty();
 
@@ -245,18 +264,18 @@ class Playlist : public SessionObject, public boost::enable_shared_from_this<Pla
 	void splice_locked (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude);
 	void splice_unlocked (nframes_t at, nframes64_t distance, boost::shared_ptr<Region> exclude);
 
-	virtual void finalize_split_region (boost::shared_ptr<Region> original, boost::shared_ptr<Region> left, boost::shared_ptr<Region> right) {}
-	
-	virtual void check_dependents (boost::shared_ptr<Region> region, bool norefresh) {}
-	virtual void refresh_dependents (boost::shared_ptr<Region> region) {}
-	virtual void remove_dependents (boost::shared_ptr<Region> region) {}
+	virtual void finalize_split_region (boost::shared_ptr<Region> /*original*/, boost::shared_ptr<Region> /*left*/, boost::shared_ptr<Region> /*right*/) {}
+
+	virtual void check_dependents (boost::shared_ptr<Region> /*region*/, bool /*norefresh*/) {}
+	virtual void refresh_dependents (boost::shared_ptr<Region> /*region*/) {}
+	virtual void remove_dependents (boost::shared_ptr<Region> /*region*/) {}
 
 	virtual XMLNode& state (bool);
 
 	boost::shared_ptr<Region> region_by_id (PBD::ID);
 
-	void add_region_internal (boost::shared_ptr<Region>, nframes_t position);
-	
+	bool add_region_internal (boost::shared_ptr<Region>, nframes_t position);
+
 	int remove_region_internal (boost::shared_ptr<Region>);
 	RegionList *find_regions_at (nframes_t frame);
 	void copy_regions (RegionList&) const;
@@ -264,14 +283,14 @@ class Playlist : public SessionObject, public boost::enable_shared_from_this<Pla
 
 	nframes_t _get_maximum_extent() const;
 
-	boost::shared_ptr<Playlist> cut_copy (boost::shared_ptr<Playlist> (Playlist::*pmf)(nframes_t, nframes_t, bool), 
-					      list<AudioRange>& ranges, bool result_is_hidden);
+	boost::shared_ptr<Playlist> cut_copy (boost::shared_ptr<Playlist> (Playlist::*pmf)(nframes_t, nframes_t, bool),
+			std::list<AudioRange>& ranges, bool result_is_hidden);
 	boost::shared_ptr<Playlist> cut (nframes_t start, nframes_t cnt, bool result_is_hidden);
 	boost::shared_ptr<Playlist> copy (nframes_t start, nframes_t cnt, bool result_is_hidden);
 
 	int move_region_to_layer (layer_t, boost::shared_ptr<Region> r, int dir);
 	void relayer ();
-	
+
 	void unset_freeze_parent (Playlist*);
 	void unset_freeze_child (Playlist*);