event.hpp

#ifndef LVTK_EVENT_HPP
#define LVTK_EVENT_HPP

#include <lv2/lv2plug.in/ns/ext/event/event.h>
#include <lv2/lv2plug.in/ns/ext/event/event-helpers.h>

#warning "this header uses the deprecated lv2 extension event. \
    please use Atoms instead."

#include "lvtk/private/types.hpp"

namespace lvtk {

   template <bool Required = true>
   struct EventRef
   {
      template <class Derived>
      struct I : Extension<Required>
      {
         typedef I<Derived> Mixin;

         I() : m_callback_data(0), m_ref_func(0), m_unref_func(0) { }

         static void
         map_feature_handlers(FeatureHandlerMap& hmap)
         {
            hmap[LV2_EVENT_URI] = &Mixin::handle_feature;
         }

         static void
         handle_feature(void* instance, void* data)
         {
            Derived* derived = reinterpret_cast<Derived*>(instance);
            I<Derived>* mixin = static_cast<I<Derived>*>(derived);

            LV2_Event_Feature* edata =
                        reinterpret_cast<LV2_Event_Feature*>(data);

            mixin->m_callback_data = edata->callback_data;
            mixin->m_ref_func      = edata->lv2_event_ref;
            mixin->m_unref_func    = edata->lv2_event_unref;

            mixin->m_ok = true;
         }

       bool
       check_ok() {
         if (LVTK_DEBUG) {
           std::clog<<"    [LV2::EventRef] Validation "
                    <<(this->m_ok ? "succeeded" : "failed")<<"."<<std::endl;
         }
         return this->m_ok;
       }

     protected:

       uint32_t
       event_ref(LV2_Event* event) {
         return m_ref_func(m_callback_data, event);
       }

       uint32_t
       event_unref(LV2_Event* event) {
         return m_unref_func(m_callback_data, event);
       }

       LV2_Event_Callback_Data m_callback_data;
       uint32_t (*m_ref_func)(LV2_Event_Callback_Data, LV2_Event*);
       uint32_t (*m_unref_func)(LV2_Event_Callback_Data, LV2_Event*);

     };

   };

} /* namespace lvtk */

#endif /* LVTK_EVENT_HPP */