convert from Glib:: to Glib::Threads for all thread-related API

git-svn-id: svn://localhost/ardour2/branches/3.0@13084 d708f5d6-7413-0410-9779-e7cbd77b26cf

6 files changed, 49 insertions, 49 deletions

diff --git a/libs/evoral/evoral/ControlList.hpp b/libs/evoral/evoral/ControlList.hpp
index 74d4e5b982..ffddd9d6e5 100644
--- a/libs/evoral/evoral/ControlList.hpp
+++ b/libs/evoral/evoral/ControlList.hpp
@@ -23,7 +23,7 @@
 #include <list>
 #include <boost/pool/pool.hpp>
 #include <boost/pool/pool_alloc.hpp>
-#include <glibmm/thread.h>
+#include <glibmm/threads.h>
 #include "pbd/signals.h"
 #include "evoral/types.hpp"
 #include "evoral/Range.hpp"
@@ -107,7 +107,7 @@ public:
 
 	EventList::size_type size() const { return _events.size(); }
         double length() const { 		
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 		return _events.empty() ? 0.0 : _events.back()->when;
 	}
 	bool empty() const { return _events.empty(); }
@@ -165,18 +165,18 @@ public:
 	std::pair<ControlList::iterator,ControlList::iterator> control_points_adjacent (double when);
 
 	template<class T> void apply_to_points (T& obj, void (T::*method)(const ControlList&)) {
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 		(obj.*method)(*this);
 	}
 
 	double eval (double where) {
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 		return unlocked_eval (where);
 	}
 
 	double rt_safe_eval (double where, bool& ok) {
 
-		Glib::Mutex::Lock lm (_lock, Glib::TRY_LOCK);
+		Glib::Threads::Mutex::Lock lm (_lock, Glib::Threads::TRY_LOCK);
 
 		if ((ok = lm.locked())) {
 			return unlocked_eval (where);
@@ -207,7 +207,7 @@ public:
 	double default_value() const { return _parameter.normal(); }
 
 	// FIXME: const violations for Curve
-	Glib::Mutex& lock()         const { return _lock; }
+	Glib::Threads::Mutex& lock()         const { return _lock; }
 	LookupCache& lookup_cache() const { return _lookup_cache; }
 	SearchCache& search_cache() const { return _search_cache; }
 
@@ -280,7 +280,7 @@ protected:
 	Parameter             _parameter;
 	InterpolationStyle    _interpolation;
 	EventList             _events;
-	mutable Glib::Mutex   _lock;
+	mutable Glib::Threads::Mutex   _lock;
 	int8_t                _frozen;
 	bool                  _changed_when_thawed;
 	double                _min_yval;
diff --git a/libs/evoral/evoral/ControlSet.hpp b/libs/evoral/evoral/ControlSet.hpp
index 8df942b31f..431885112b 100644
--- a/libs/evoral/evoral/ControlSet.hpp
+++ b/libs/evoral/evoral/ControlSet.hpp
@@ -23,7 +23,7 @@
 #include <map>
 #include <boost/shared_ptr.hpp>
 #include <boost/utility.hpp>
-#include <glibmm/thread.h>
+#include <glibmm/threads.h>
 #include "pbd/signals.h"
 #include "evoral/types.hpp"
 #include "evoral/Parameter.hpp"
@@ -65,13 +65,13 @@ public:
 
 	void what_has_data(std::set<Parameter>&) const;
 
-	Glib::Mutex& control_lock() const { return _control_lock; }
+	Glib::Threads::Mutex& control_lock() const { return _control_lock; }
 
 protected:
 	virtual void control_list_marked_dirty () {}
 	virtual void control_list_interpolation_changed (Parameter, ControlList::InterpolationStyle) {}
 
-	mutable Glib::Mutex _control_lock;
+	mutable Glib::Threads::Mutex _control_lock;
 	Controls            _controls;
 
 	PBD::ScopedConnectionList _list_connections;
diff --git a/libs/evoral/evoral/Sequence.hpp b/libs/evoral/evoral/Sequence.hpp
index ab3e3bd41b..cb851cf2f6 100644
--- a/libs/evoral/evoral/Sequence.hpp
+++ b/libs/evoral/evoral/Sequence.hpp
@@ -25,7 +25,7 @@
 #include <list>
 #include <utility>
 #include <boost/shared_ptr.hpp>
-#include <glibmm/thread.h>
+#include <glibmm/threads.h>
 #include "evoral/types.hpp"
 #include "evoral/Note.hpp"
 #include "evoral/Parameter.hpp"
@@ -67,16 +67,16 @@ public:
 
 protected:
 	struct WriteLockImpl {
-		WriteLockImpl(Glib::RWLock& s, Glib::Mutex& c)
-			: sequence_lock(new Glib::RWLock::WriterLock(s))
-			, control_lock(new Glib::Mutex::Lock(c))
+		WriteLockImpl(Glib::Threads::RWLock& s, Glib::Threads::Mutex& c)
+			: sequence_lock(new Glib::Threads::RWLock::WriterLock(s))
+			, control_lock(new Glib::Threads::Mutex::Lock(c))
 		{ }
 		~WriteLockImpl() {
 			delete sequence_lock;
 			delete control_lock;
 		}
-		Glib::RWLock::WriterLock* sequence_lock;
-		Glib::Mutex::Lock*        control_lock;
+		Glib::Threads::RWLock::WriterLock* sequence_lock;
+		Glib::Threads::Mutex::Lock*        control_lock;
 	};
 
 public:
@@ -84,10 +84,10 @@ public:
 	typedef typename boost::shared_ptr<Evoral::Note<Time> >  NotePtr;
 	typedef typename boost::shared_ptr<const Evoral::Note<Time> >  constNotePtr;
 
-	typedef boost::shared_ptr<Glib::RWLock::ReaderLock> ReadLock;
+	typedef boost::shared_ptr<Glib::Threads::RWLock::ReaderLock> ReadLock;
 	typedef boost::shared_ptr<WriteLockImpl>            WriteLock;
 
-	virtual ReadLock  read_lock() const { return ReadLock(new Glib::RWLock::ReaderLock(_lock)); }
+	virtual ReadLock  read_lock() const { return ReadLock(new Glib::Threads::RWLock::ReaderLock(_lock)); }
 	virtual WriteLock write_lock()      { return WriteLock(new WriteLockImpl(_lock, _control_lock)); }
 
 	void clear();
@@ -287,7 +287,7 @@ protected:
 	bool                   _edited;
 	bool                   _overlapping_pitches_accepted;
 	OverlapPitchResolution _overlap_pitch_resolution;
-	mutable Glib::RWLock   _lock;
+	mutable Glib::Threads::RWLock   _lock;
 	bool                   _writing;
 
 	virtual int resolve_overlaps_unlocked (const NotePtr, void* /* arg */ = 0) {
diff --git a/libs/evoral/src/ControlList.cpp b/libs/evoral/src/ControlList.cpp
index f25f988ec0..c4495485de 100644
--- a/libs/evoral/src/ControlList.cpp
+++ b/libs/evoral/src/ControlList.cpp
@@ -168,7 +168,7 @@ void
 ControlList::copy_events (const ControlList& other)
 {
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 		_events.clear ();
 		for (const_iterator i = other.begin(); i != other.end(); ++i) {
 			_events.push_back (new ControlEvent ((*i)->when, (*i)->value));
@@ -206,7 +206,7 @@ void
 ControlList::clear ()
 {
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 		_events.clear ();
 		unlocked_invalidate_insert_iterator ();
 		mark_dirty ();
@@ -218,14 +218,14 @@ ControlList::clear ()
 void
 ControlList::x_scale (double factor)
 {
-	Glib::Mutex::Lock lm (_lock);
+	Glib::Threads::Mutex::Lock lm (_lock);
 	_x_scale (factor);
 }
 
 bool
 ControlList::extend_to (double when)
 {
-	Glib::Mutex::Lock lm (_lock);
+	Glib::Threads::Mutex::Lock lm (_lock);
 	if (_events.empty() || _events.back()->when == when) {
 		return false;
 	}
@@ -256,7 +256,7 @@ void
 ControlList::merge_nascent (double when)
 {
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 
 		if (nascent.empty()) {
 			return;
@@ -449,7 +449,7 @@ ControlList::thin ()
 	bool changed = false;
 
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 		
 		ControlEvent* prevprev = 0;
 		ControlEvent* cur = 0;
@@ -509,7 +509,7 @@ ControlList::thin ()
 void
 ControlList::fast_simple_add (double when, double value)
 {
-	Glib::Mutex::Lock lm (_lock);
+	Glib::Threads::Mutex::Lock lm (_lock);
 	/* to be used only for loading pre-sorted data from saved state */
 	_events.insert (_events.end(), new ControlEvent (when, value));
 	assert(_events.back());
@@ -520,7 +520,7 @@ ControlList::fast_simple_add (double when, double value)
 void
 ControlList::invalidate_insert_iterator ()
 {
-	Glib::Mutex::Lock lm (_lock);
+	Glib::Threads::Mutex::Lock lm (_lock);
 	unlocked_invalidate_insert_iterator ();
 }
 
@@ -533,7 +533,7 @@ ControlList::unlocked_invalidate_insert_iterator ()
 void
 ControlList::start_write_pass (double when)
 {
-	Glib::Mutex::Lock lm (_lock);
+	Glib::Threads::Mutex::Lock lm (_lock);
 
 	new_write_pass = true;
 	did_write_during_pass = false;
@@ -585,7 +585,7 @@ ControlList::add (double when, double value)
 							 this, value, when, _in_write_pass, (most_recent_insert_iterator == _events.end())));
 
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 		ControlEvent cp (when, 0.0f);
 		iterator insertion_point;
 
@@ -847,7 +847,7 @@ void
 ControlList::erase (iterator i)
 {
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 		if (most_recent_insert_iterator == i) {
 			unlocked_invalidate_insert_iterator ();
 		}
@@ -861,7 +861,7 @@ void
 ControlList::erase (iterator start, iterator end)
 {
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 		_events.erase (start, end);
 		unlocked_invalidate_insert_iterator ();
 		mark_dirty ();
@@ -874,7 +874,7 @@ void
 ControlList::erase (double when, double value)
 {
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 
 		iterator i = begin ();
 		while (i != end() && ((*i)->when != when || (*i)->value != value)) {
@@ -900,7 +900,7 @@ ControlList::erase_range (double start, double endt)
 	bool erased = false;
 
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 		erased = erase_range_internal (start, endt, _events);
 
 		if (erased) {
@@ -939,7 +939,7 @@ void
 ControlList::slide (iterator before, double distance)
 {
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 
 		if (before == _events.end()) {
 			return;
@@ -960,7 +960,7 @@ void
 ControlList::shift (double pos, double frames)
 {
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 
 		for (iterator i = _events.begin(); i != _events.end(); ++i) {
 			if ((*i)->when >= pos) {
@@ -983,7 +983,7 @@ ControlList::modify (iterator iter, double when, double val)
 	*/
 
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 
 		(*iter)->when = when;
 		(*iter)->value = val;
@@ -1008,7 +1008,7 @@ ControlList::modify (iterator iter, double when, double val)
 std::pair<ControlList::iterator,ControlList::iterator>
 ControlList::control_points_adjacent (double xval)
 {
-	Glib::Mutex::Lock lm (_lock);
+	Glib::Threads::Mutex::Lock lm (_lock);
 	iterator i;
 	ControlEvent cp (xval, 0.0f);
 	std::pair<iterator,iterator> ret;
@@ -1054,7 +1054,7 @@ ControlList::thaw ()
 	}
 
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 
 		if (_sort_pending) {
 			_events.sort (event_time_less_than);
@@ -1081,7 +1081,7 @@ void
 ControlList::truncate_end (double last_coordinate)
 {
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 		ControlEvent cp (last_coordinate, 0);
 		ControlList::reverse_iterator i;
 		double last_val;
@@ -1184,7 +1184,7 @@ void
 ControlList::truncate_start (double overall_length)
 {
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 		iterator i;
 		double first_legal_value;
 		double first_legal_coordinate;
@@ -1439,7 +1439,7 @@ bool
 ControlList::rt_safe_earliest_event (double start, double& x, double& y, bool inclusive) const
 {
 	// FIXME: It would be nice if this was unnecessary..
-	Glib::Mutex::Lock lm(_lock, Glib::TRY_LOCK);
+	Glib::Threads::Mutex::Lock lm(_lock, Glib::Threads::TRY_LOCK);
 	if (!lm.locked()) {
 		return false;
 	}
@@ -1638,7 +1638,7 @@ ControlList::cut_copy_clear (double start, double end, int op)
 	ControlEvent cp (start, 0.0);
 
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 
 		/* first, determine s & e, two iterators that define the range of points
 		   affected by this operation
@@ -1754,7 +1754,7 @@ ControlList::paste (ControlList& alist, double pos, float /*times*/)
 	}
 
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 		iterator where;
 		iterator prev;
 		double end = 0;
@@ -1802,7 +1802,7 @@ ControlList::move_ranges (const list< RangeMove<double> >& movements)
 	typedef list< RangeMove<double> > RangeMoveList;
 
 	{
-		Glib::Mutex::Lock lm (_lock);
+		Glib::Threads::Mutex::Lock lm (_lock);
 
 		/* a copy of the events list before we started moving stuff around */
 		EventList old_events = _events;
diff --git a/libs/evoral/src/ControlSet.cpp b/libs/evoral/src/ControlSet.cpp
index d4480c2897..393b819146 100644
--- a/libs/evoral/src/ControlSet.cpp
+++ b/libs/evoral/src/ControlSet.cpp
@@ -53,7 +53,7 @@ ControlSet::add_control(boost::shared_ptr<Control> ac)
 void
 ControlSet::what_has_data (set<Parameter>& s) const
 {
-	Glib::Mutex::Lock lm (_control_lock);
+	Glib::Threads::Mutex::Lock lm (_control_lock);
 
 	for (Controls::const_iterator li = _controls.begin(); li != _controls.end(); ++li) {
 		if (li->second->list() && !li->second->list()->empty()) {
@@ -116,7 +116,7 @@ ControlSet::find_next_event (double now, double end, ControlEvent& next_event) c
 void
 ControlSet::clear_controls ()
 {
-	Glib::Mutex::Lock lm (_control_lock);
+	Glib::Threads::Mutex::Lock lm (_control_lock);
 
 	_control_connections.drop_connections ();
 	_list_connections.drop_connections ();
diff --git a/libs/evoral/src/Curve.cpp b/libs/evoral/src/Curve.cpp
index 81faee70d3..3f2ee361d3 100644
--- a/libs/evoral/src/Curve.cpp
+++ b/libs/evoral/src/Curve.cpp
@@ -23,7 +23,7 @@
 #include <cfloat>
 #include <cmath>
 
-#include <glibmm/thread.h>
+#include <glibmm/threads.h>
 
 #include "evoral/Curve.hpp"
 #include "evoral/ControlList.hpp"
@@ -170,7 +170,7 @@ Curve::solve ()
 bool
 Curve::rt_safe_get_vector (double x0, double x1, float *vec, int32_t veclen)
 {
-	Glib::Mutex::Lock lm(_list.lock(), Glib::TRY_LOCK);
+	Glib::Threads::Mutex::Lock lm(_list.lock(), Glib::Threads::TRY_LOCK);
 
 	if (!lm.locked()) {
 		return false;
@@ -183,7 +183,7 @@ Curve::rt_safe_get_vector (double x0, double x1, float *vec, int32_t veclen)
 void
 Curve::get_vector (double x0, double x1, float *vec, int32_t veclen)
 {
-	Glib::Mutex::Lock lm(_list.lock());
+	Glib::Threads::Mutex::Lock lm(_list.lock());
 	_get_vector (x0, x1, vec, veclen);
 }