dssiuiclient.hpp

/****************************************************************************
    
    dssiuiclient.hpp - a class that makes writing DSSI GUIs easier
    
    Copyright (C) 2005  Lars Luthman <larsl@users.sourceforge.net>
    
    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
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 01222-1307  USA

****************************************************************************/

#ifndef DSSIUICLIENT_HPP
#define DSSIUICLIENT_HPP

#include <queue>
#include <string>
#include <utility>
#include <vector>

#include <glibmm.h>
#include <gtkmm.h>
#include <lo/lo.h>
#include <sigc++/sigc++.h>


using namespace Glib;
using namespace Gtk;
using namespace sigc;
using namespace std;


class DSSIUIClient {
public:
  
  DSSIUIClient(int argc, char** argv);
  
  ~DSSIUIClient();
  
  
  bool is_valid() const;
  
  const string& get_identifier() const;
  
  /* XXX This function should be moved to a subclass (DSSIGladeClient?) so
         we get rid of all libglademm dependencies in this class. */
  // void connect_gui(RefPtr<Xml> xml);
  
  /* XXX This function should be moved to a subclass (DSSIGTKClient?) so
         we get rid of all gtkmm dependencies in this class. */
  void connect_adjustment(Adjustment* adj, int port);

  
  // C++ wrappers for OSC methods specified in the DSSI RFC:
  
  // UI to host
  
  void send_control(int port, float value);
  
  void send_program(int bank, int program);
  
  void send_update_request();
  
  void send_configure(const string& key, const string& value);
  
  void send_midi(const char event[4]);
  
  void send_exiting();
  
  
  // Host to UI
  
  signal<void, int, float> control_received;
  
  signal<void, int, int> program_received;
  
  signal<void, const string, const string> configure_received;
  
  Dispatcher show_received;
  
  Dispatcher hide_received;
  
  Dispatcher quit_received;
  
  
  // Shared memory handling
  
  void* allocate_shared_memory(int bytes);
  
  template <class T> T* create_shared_object() {
    T* ptr = reinterpret_cast<T*>(allocate_shared_memory(sizeof(T)));
    if (ptr)
      new (ptr) T();
    return ptr;
  }
  
  signal<void> plugin_attached;
  
  bool plugin_has_attached();
  
private:
  
  // Adjustment connection handling (for host->UI messages)
  void update_adjustments(int port, float value);
  
  // Static callbacks for OSC method calls (liblo is not C++)
  static int control_handler(const char *path, const char *types,
                             lo_arg **argv, int argc, 
                             void *data, void *user_data);
  static int program_handler(const char *path, const char *types,
                             lo_arg **argv, int argc, 
                             void *data, void *user_data);
  static int configure_handler(const char *path, const char *types,
                               lo_arg **argv, int argc, 
                               void *data, void *user_data);
  static int show_handler(const char *path, const char *types,
                          lo_arg **argv, int argc, 
                          void *data, void *user_data);
  static int hide_handler(const char *path, const char *types,
                          lo_arg **argv, int argc, 
                          void *data, void *user_data);
  static int quit_handler(const char *path, const char *types,
                          lo_arg **argv, int argc, 
                          void *data, void *user_data);
  
  // Dispatchers that get the signals from the OSC thread to the GUI thread
  // (the queues and receiver functions are needed for passing data since 
  // Dispatchers don't take parameters)
  Dispatcher m_control_dispatcher;
  queue<pair<int, float> > m_control_queue;
  void control_receiver() {
    int port = m_control_queue.front().first;
    float value = m_control_queue.front().second;
    m_control_queue.pop();
    if (unsigned(port) < m_adjustments.size() && m_adjustments[port] != NULL)
      m_adjustments[port]->set_value(value);
    control_received(port, value);
  }
  Dispatcher m_program_dispatcher;
  queue<pair<int, int> > m_program_queue;
  void program_receiver() {
    /* The plugin should update all it's control widgets when it receives
       a program change, but it should NOT send all those control changes
       back to the host. We block all /control and /program messages
       while the UI is handling the program change. */
    m_blocking = true;
    int bank = m_program_queue.front().first;
    int program = m_program_queue.front().second;
    m_program_queue.pop();
    program_received(bank, program);
    m_blocking = false;
  }
  Dispatcher m_configure_dispatcher;
  queue<pair<string, string> > m_configure_queue;
  void configure_receiver() {
    string key = m_configure_queue.front().first;
    string value = m_configure_queue.front().second;
    m_configure_queue.pop();
    configure_received(key, value);
  }
  
  bool check_shared_memory();
  
  lo_address m_plugin_address;
  string m_plugin_path;
  lo_server_thread m_server_thread;
  string m_shm_key;
  char* m_plugin_flag;
  
  bool m_valid;
  string m_identifier;
  
  vector<Adjustment*> m_adjustments;
  bool m_blocking;
};


#endif

---