major design changes: use glib event loop for MIDI thread/UI; rework design of BaseUI...

[ardour.git] / libs / surfaces / control_protocol / basic_ui.cc

diff --git a/libs/surfaces/control_protocol/basic_ui.cc b/libs/surfaces/control_protocol/basic_ui.cc
index 3dc93cc64ad980070886d6215a613b25a5288260..d53c44b0a87b9a800c21d942e4b8b883cd506386 100644 (file)
--- a/libs/surfaces/control_protocol/basic_ui.cc
+++ b/libs/surfaces/control_protocol/basic_ui.cc
@@ -16,19 +16,21 @@
     along with this program; if not, write to the Free Software
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
-    $Id$
 */
 
-#include <pbd/pthread_utils.h>
+#include "pbd/pthread_utils.h"
 
-#include <ardour/session.h>
-#include <ardour/location.h>
+#include "ardour/session.h"
+#include "ardour/location.h"
 
-#include <control_protocol/basic_ui.h>
+#include "control_protocol/basic_ui.h"
 
 #include "i18n.h"
 
 using namespace ARDOUR;
+using ARDOUR::nframes_t;
+
+sigc::signal<void,std::string,std::string> BasicUI::AccessAction;
 
 BasicUI::BasicUI (Session& s)
        : session (&s)
@@ -48,16 +50,29 @@ BasicUI::~BasicUI ()
 void
 BasicUI::register_thread (std::string name)
 {
-       PBD::ThreadCreated (pthread_self(), name);
+       std::string pool_name = name;
+       pool_name += " events";
+
+       SessionEvent::create_per_thread_pool (pool_name, 64);
+}
+
+void
+BasicUI::access_action ( std::string action_path ) 
+{
+       int split_at = action_path.find( "/" );
+       std::string group = action_path.substr( 0, split_at );
+       std::string item = action_path.substr( split_at + 1 );
+
+       AccessAction( group, item );
 }
 
 void
 BasicUI::loop_toggle () 
 {
-       if (session->get_auto_loop()) {
-               session->request_auto_loop (false);
+       if (session->get_play_loop()) {
+               session->request_play_loop (false);
        } else {
-               session->request_auto_loop (true);
+               session->request_play_loop (true);
                if (!session->transport_rolling()) {
                        session->request_transport_speed (1.0);
                }
@@ -79,7 +94,7 @@ BasicUI::goto_end ()
 void       
 BasicUI::add_marker ()
 {
-       jack_nframes_t when = session->audible_frame();
+       nframes_t when = session->audible_frame();
        session->locations()->add (new Location (when, when, _("unnamed"), Location::IsMark));
 }
 
@@ -106,8 +121,8 @@ BasicUI::transport_play (bool from_last_start)
 {
        bool rolling = session->transport_rolling ();
 
-       if (session->get_auto_loop()) {
-               session->request_auto_loop (false);
+       if (session->get_play_loop()) {
+               session->request_play_loop (false);
        } 
 
        if (session->get_play_range ()) {
@@ -172,12 +187,12 @@ BasicUI::next_marker ()
 }
 
 void
-BasicUI::set_transport_speed (float speed)
+BasicUI::set_transport_speed (double speed)
 {
        session->request_transport_speed (speed);
 }
 
-float
+double
 BasicUI::get_transport_speed ()
 {
        return session->transport_speed ();
@@ -199,22 +214,22 @@ void
 BasicUI::toggle_all_rec_enables ()
 {
        if (session->get_record_enabled()) {
-               session->record_disenable_all ();
+               // session->record_disenable_all ();
        } else {
-               session->record_enable_all ();
+               // session->record_enable_all ();
        }
 }
 
 void
 BasicUI::toggle_punch_in ()
 {
-       session->set_punch_in (!session->get_punch_in());
+       session->config.set_punch_in (!session->config.get_punch_in());
 }
 
 void
 BasicUI::toggle_punch_out ()
 {
-       session->set_punch_out (!session->get_punch_out());
+       session->config.set_punch_out (!session->config.get_punch_out());
 }
 
 bool
@@ -233,14 +248,14 @@ BasicUI::set_record_enable (bool yn)
        }
 }
 
-jack_nframes_t
+nframes_t
 BasicUI::transport_frame ()
 {
        return session->transport_frame();
 }
 
 void
-BasicUI::locate (jack_nframes_t where, bool roll_after_locate)
+BasicUI::locate (nframes_t where, bool roll_after_locate)
 {
        session->request_locate (where, roll_after_locate);
 }
@@ -257,26 +272,26 @@ BasicUI::locked ()
        return session->transport_locked ();
 }
 
-jack_nframes_t
-BasicUI::smpte_frames_per_hour ()
+nframes_t
+BasicUI::timecode_frames_per_hour ()
 {
-       return session->smpte_frames_per_hour ();
+       return session->timecode_frames_per_hour ();
 }
 
 void
-BasicUI::smpte_time (jack_nframes_t where, SMPTE::Time& smpte)
+BasicUI::timecode_time (nframes_t where, Timecode::Time& timecode)
 {
-       session->smpte_time (where, *((SMPTE::Time *) &smpte));
+       session->timecode_time (where, *((Timecode::Time *) &timecode));
 }
 
 void 
-BasicUI::smpte_to_sample (SMPTE::Time& smpte, jack_nframes_t& sample, bool use_offset, bool use_subframes) const
+BasicUI::timecode_to_sample (Timecode::Time& timecode, nframes_t& sample, bool use_offset, bool use_subframes) const
 {
-       session->smpte_to_sample (*((SMPTE::Time*)&smpte), sample, use_offset, use_subframes);
+       session->timecode_to_sample (*((Timecode::Time*)&timecode), sample, use_offset, use_subframes);
 }
 
 void 
-BasicUI::sample_to_smpte (jack_nframes_t sample, SMPTE::Time& smpte, bool use_offset, bool use_subframes) const
+BasicUI::sample_to_timecode (nframes_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes) const
 {
-       session->sample_to_smpte (sample, *((SMPTE::Time*)&smpte), use_offset, use_subframes);
+       session->sample_to_timecode (sample, *((Timecode::Time*)&timecode), use_offset, use_subframes);
 }