libraries/lv2gui/lv2gui.hpp

/****************************************************************************
    
    lv2gui.hpp - Wrapper library to make it easier to write LV2 GUIs in C++
    
    Copyright (C) 2006-2008 Lars Luthman <lars.luthman@gmail.com>
    Modified by Dave Robillard, 2008 (URI map mixin)
    
    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 3 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., 51 Franklin Street, Fifth Floor,
    Boston, MA  02110-1301  USA

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

#ifndef LV2GUI_HPP
#define LV2GUI_HPP

#include <cstdlib>
#include <cstring>
#include <map>

#include <gtkmm/box.h>
#include <gtkmm/main.h>
#include <gtkmm/widget.h>

#include <lv2_ui.h>
#include <lv2_ui_presets.h>
#include <lv2_uri_map.h>
#include <lv2_event_helpers.h>
#include <lv2_osc.h>
#include <lv2types.hpp>


namespace LV2 {

  
  typedef std::vector<LV2UI_Descriptor*> GUIDescList;
    
  
  GUIDescList& get_lv2g2g_descriptors();
  
  
  template <bool Required = true>
  struct NoUserResize {
    
    template <class Derived> struct I : public Extension<Required> {
      
      static void map_feature_handlers(FeatureHandlerMap& hmap) {
        hmap["http://ll-plugins.nongnu.org/lv2/dev/ui#noUserResize"] = 
          &I<Derived>::handle_feature;
      }
      
      static void handle_feature(void* instance, void* data) { 
        Derived* d = reinterpret_cast<Derived*>(instance);
        I<Derived>* e = static_cast<I<Derived>*>(d);
        e->m_ok = true;
      }
      
    };
    
  };


  template <bool Required = true>
  struct FixedSize {
    
    template <class Derived> struct I : public Extension<Required> {
      
      static void map_feature_handlers(FeatureHandlerMap& hmap) {
        hmap["http://ll-plugins.nongnu.org/lv2/dev/ui#fixedSize"] = 
          &I<Derived>::handle_feature;
      }
      
      static void handle_feature(void* instance, void* data) {
        Derived* d = reinterpret_cast<Derived*>(instance);
        I<Derived>* e = static_cast<I<Derived>*>(d);
        e->m_ok = true;
      }
    
    };
    
  };


  template <bool Required = true>
  struct Presets {
    
    template <class Derived> struct I : public Extension<Required> {
      
      I() : m_hdesc(0), m_host_support(false) { }
        
        static void map_feature_handlers(FeatureHandlerMap& hmap) {
          hmap[LV2_UI_PRESETS_URI] = &I<Derived>::handle_feature;
        }
        
        static void handle_feature(void* instance, void* data) {
          Derived* d = reinterpret_cast<Derived*>(instance);
          I<Derived>* e = static_cast<I<Derived>*>(d);
          e->m_hdesc = static_cast<LV2UI_Presets_Feature*>(data);
          e->m_ok = (e->m_hdesc != 0);
          e->m_host_support = (e->m_hdesc != 0);
        }
        
        
        void preset_added(uint32_t    number, 
                           char const* name) {
          
        }
        
        void preset_removed(uint32_t number) {
          
        }
        
        void presets_cleared() {
          
        }
        
        void current_preset_changed(uint32_t number) {
          
        }
        
        static void const* extension_data(char const* uri) {
          static LV2UI_Presets_GDesc desc = { &_preset_added,
                                              &_preset_removed,
                                              &_presets_cleared,
                                              &_current_preset_changed };
          if (!std::strcmp(uri, LV2_UI_PRESETS_URI))
            return &desc;
          return 0;
        }
        
    protected:
        
        void change_preset(uint32_t preset) {
          if (m_hdesc)
            m_hdesc->change_preset(static_cast<Derived*>(this)->controller(), 
                                   preset);
        }
        
        void save_preset(uint32_t preset, char const* name) {
          if (m_hdesc)
            m_hdesc->save_preset(static_cast<Derived*>(this)->controller(), 
                                 preset, name);
        }
      
        bool host_supports_presets() const {
          return m_host_support;
        }
        
    private:
        
        static void _preset_added(LV2UI_Handle gui, 
                                   uint32_t     number, 
                                   char const*  name) {
          static_cast<Derived*>(gui)->preset_added(number, name);
        }
        
        static void _preset_removed(LV2UI_Handle gui, 
                                     uint32_t     number) {
          static_cast<Derived*>(gui)->preset_removed(number);
        }
        
        static void _presets_cleared(LV2UI_Handle gui) {
          static_cast<Derived*>(gui)->presets_cleared();
        }
        
        static void _current_preset_changed(LV2UI_Handle gui, 
                                             uint32_t     number) {
          static_cast<Derived*>(gui)->current_preset_changed(number);
        }
        
        
        LV2UI_Presets_Feature* m_hdesc;
        bool m_host_support;
        
    };

  };

  
  template <bool Required = true>
  struct WriteMIDI {
    
    enum {
      EVENT_BUFFER_SIZE = 4
    };
    
    template <class Derived> struct I : Extension<Required> {

      I() : m_midi_type(0) {
        m_buffer = lv2_event_buffer_new(sizeof(LV2_Event) + EVENT_BUFFER_SIZE, 
                                        0);
      }
      
      bool check_ok() {
        Derived* d = static_cast<Derived*>(this);
        m_midi_type = d->
          uri_to_id(LV2_EVENT_URI, "http://lv2plug.in/ns/ext/midi#MidiEvent");
        m_event_buffer_format = d->
          uri_to_id(LV2_UI_URI, "http://lv2plug.in/ns/extensions/ui#Events");
        return !Required || (m_midi_type && m_event_buffer_format);
      }
      
    protected:
      
      bool write_midi(uint32_t port, uint32_t size, const uint8_t* data) {
        if (m_midi_type == 0)
          return false;
        LV2_Event_Buffer* buffer;
        if (size <= 4)
          buffer = m_buffer;
        else
          buffer = lv2_event_buffer_new(sizeof(LV2_Event) + size, 0);
        lv2_event_buffer_reset(m_buffer, 0, m_buffer->data);
        LV2_Event_Iterator iter;
        lv2_event_begin(&iter, m_buffer);
        lv2_event_write(&iter, 0, 0, m_midi_type, size, data);
        static_cast<Derived*>(this)->
          write(port, m_buffer->header_size + m_buffer->capacity, 
                m_event_buffer_format, m_buffer);
        if (size > 4)
          std::free(buffer);
        return true;
      }
      
      uint32_t m_midi_type;
      uint32_t m_event_buffer_format;
      LV2_Event_Buffer* m_buffer;
      
    };
    
  };  
  
  
  template <bool Required = true>
  struct WriteOSC {
    
    template <class Derived> struct I : Extension<Required> {
      
      I() : m_osc_type(0) {
        m_buffer = lv2_event_buffer_new(sizeof(LV2_Event) + 256, 0);
      }
      
      bool check_ok() {
        Derived* d = static_cast<Derived*>(this);
        m_osc_type = d->
          uri_to_id(LV2_EVENT_URI, "http://lv2plug.in/ns/ext/osc#OscEvent");
        m_event_buffer_format = d->
          uri_to_id(LV2_UI_URI, "http://lv2plug.in/ns/extensions/ui#Events");
        return !Required || (m_osc_type && m_event_buffer_format);
      }
      
    protected:
      
      bool write_osc(uint32_t port, const char* path, const char* types, ...) {
        if (m_osc_type == 0)
          return false;
        // XXX handle all sizes here - this is dangerous
        lv2_event_buffer_reset(m_buffer, 0, m_buffer->data);
        LV2_Event_Iterator iter;
        lv2_event_begin(&iter, m_buffer);
        va_list ap;
        va_start(ap, types);
        uint32_t size = lv2_osc_event_vsize(path, types, ap);
        va_end(ap);
        if (!size)
          return false;
        va_start(ap, types);
        bool success = lv2_osc_buffer_vappend(&iter, 0, 0, m_osc_type, 
                                              path, types, size, ap);
        va_end(ap);
        if (success) {
          static_cast<Derived*>(this)->
            write(port, m_buffer->header_size + m_buffer->capacity, 
                  m_event_buffer_format, m_buffer);
          return true;
        }
        return false;
      }
      
      uint32_t m_osc_type;
      uint32_t m_event_buffer_format;
      LV2_Event_Buffer* m_buffer;
      
    };
    
  };  
  
  
  template<class Derived, class Ext1 = End, class Ext2 = End, class Ext3 = End,
           class Ext4 = End, class Ext5 = End, class Ext6 = End,
           class Ext7 = End, class Ext8 = End, class Ext9 = End>
  class GUI : public Gtk::HBox, public MixinTree<Derived, 
                                                 Ext1, Ext2, Ext3, Ext4, 
                                                 Ext5, Ext6, Ext7, Ext8, Ext9> {
  public:
    
    inline GUI() {
      m_ctrl = s_ctrl;
      m_wfunc = s_wfunc;
      m_features = s_features;
      m_bundle_path = s_bundle_path;
      s_ctrl = 0;
      s_wfunc = 0;
      s_features = 0;
      s_bundle_path = 0;
      if (m_features) {
        FeatureHandlerMap hmap;
        Derived::map_feature_handlers(hmap);
        for (const Feature* const* iter = m_features; *iter != 0; ++iter) {
          FeatureHandlerMap::iterator miter;
          miter = hmap.find((*iter)->URI);
          if (miter != hmap.end())
            miter->second(static_cast<Derived*>(this), (*iter)->data);
        }
      }
    }
    
    inline void port_event(uint32_t port, uint32_t buffer_size, 
                           uint32_t format, void const* buffer) { }
    
    static int register_class(char const* uri) {
      LV2UI_Descriptor* desc = new LV2UI_Descriptor;
      std::memset(desc, 0, sizeof(LV2UI_Descriptor));
      desc->URI = strdup(uri);
      desc->instantiate = &Derived::create_ui_instance;
      desc->cleanup = &Derived::delete_ui_instance;
      desc->port_event = &Derived::_port_event;
      desc->extension_data = &Derived::extension_data;
      get_lv2g2g_descriptors().push_back(desc);
      return get_lv2g2g_descriptors().size() - 1;
    }
    
  protected:
    
    inline void write(uint32_t port, uint32_t buffer_size, 
                      uint32_t format, void const* buffer) {
      (*m_wfunc)(m_ctrl, port, buffer_size, format, buffer);
    }
    
    inline void write_control(uint32_t port, float value) {
      write(port, sizeof(float), 0, &value);
    }
    
    inline LV2::Feature const* const* features() {
      return m_features;
    }
    
    inline char const* bundle_path() const {
      return m_bundle_path;
    }
    
  public:
    inline void* controller() {
      return m_ctrl;
    }
    
    
  private:
    
    // This is quite ugly but needed to allow these mixins to call 
    // protected functions in the GUI class, which we want.
    friend class WriteMIDI<true>::I<Derived>;
    friend class WriteMIDI<false>::I<Derived>;
    friend class WriteOSC<true>::I<Derived>;
    friend class WriteOSC<false>::I<Derived>;
    
    static LV2UI_Handle create_ui_instance(struct _LV2UI_Descriptor const* 
                                           descriptor,
                                           char const* plugin_uri,
                                           char const* bundle_path,
                                           LV2UI_Write_Function write_func,
                                           LV2UI_Controller ctrl,
                                           LV2UI_Widget* widget,
                                           Feature const* const* features) {
      
      // copy some data to static variables so the subclasses don't have to
      // bother with it - this is threadsafe since hosts are not allowed
      // to instantiate the same plugin concurrently
      s_ctrl = ctrl;
      s_wfunc = write_func;
      s_features = features;
      s_bundle_path = bundle_path;
      
      // this is needed to initialise gtkmm stuff in case we're running in
      // a Gtk+ or PyGtk host or some other language
      Gtk::Main::init_gtkmm_internals();
      
      // create the GUI object
      Derived* t = new Derived(plugin_uri);
      *widget = static_cast<Gtk::Widget*>(t)->gobj();
      
      // check that everything is OK
      if (t->check_ok())
        return reinterpret_cast<LV2UI_Handle>(t);
      delete t;
      return 0;
    }
    

    static void delete_ui_instance(LV2UI_Handle instance) {
      delete static_cast<Derived*>(instance);
    }
    
    
    static void _port_event(LV2UI_Handle instance, uint32_t port, 
                            uint32_t buffer_size, uint32_t format, 
                            void const* buffer) {
      static_cast<Derived*>(instance)->port_event(port, buffer_size, 
                                                  format, buffer);
    }
    

    void* m_ctrl;
    LV2UI_Write_Function m_wfunc;
    LV2::Feature const* const* m_features;
    char const* m_bundle_path;
    
    static void* s_ctrl;
    static LV2UI_Write_Function s_wfunc;
    static LV2::Feature const* const* s_features;
    static char const* s_bundle_path;
    
  };

  
  /* Yes, static variables are messy. */
  template<class Derived, class Ext1, class Ext2, class Ext3, class Ext4,
           class Ext5, class Ext6, class Ext7, class Ext8, class Ext9>
  void* GUI<Derived, Ext1, Ext2, Ext3, Ext4, 
            Ext5, Ext6, Ext7, Ext8, Ext9>::s_ctrl = 0; 
  
  template<class Derived, class Ext1, class Ext2, class Ext3, class Ext4,
           class Ext5, class Ext6, class Ext7, class Ext8, class Ext9>
  LV2UI_Write_Function GUI<Derived, Ext1, Ext2, Ext3, Ext4, 
                           Ext5, Ext6, Ext7, Ext8, Ext9>::s_wfunc = 0;
  
  template<class Derived, class Ext1, class Ext2, class Ext3, class Ext4,
           class Ext5, class Ext6, class Ext7, class Ext8, class Ext9>
  LV2::Feature const* const* GUI<Derived, Ext1, Ext2, Ext3, Ext4, 
                                 Ext5, Ext6, Ext7, Ext8, Ext9>::s_features = 0;
  
  template<class Derived, class Ext1, class Ext2, class Ext3, class Ext4,
           class Ext5, class Ext6, class Ext7, class Ext8, class Ext9>
  char const* GUI<Derived, Ext1, Ext2, Ext3, Ext4, 
                  Ext5, Ext6, Ext7, Ext8, Ext9>::s_bundle_path = 0;
  

}


#endif