lua/signalconnect.h

   1 #ifndef AWFUL_LUA_SIGNALCONNECT_H
   2 #define AWFUL_LUA_SIGNALCONNECT_H
   3
   4 //#include <iostream>
   5
   6 // TODO: be able to delete a signal connection (connect() should return a bundle of a signalref + slot handle
   7 // wrapped in a userdata object with a disconnect method - or just a handle to the slot and
   8 // then use object.FuckingSignal::disconnect(handle) - it would bring symmetry and harmony to the world
   9 // at least.
  10
  11 namespace awful { namespace LuaImpl
  12 {
  13         struct LuaSlotCallContext
  14         {
  15                 LuaSlotCallContext() :
  16                         m_pLS( NULL ),
  17                         m_ParamCount( 0 )
  18                 {
  19                 }
  20
  21                 void prepare()
  22                 {
  23                         m_ParamCount = 0;
  24                         lua_pushlightuserdata( m_pLS, this );
  25                         lua_gettable( m_pLS, LUA_REGISTRYINDEX );
  26                 }
  27
  28                 template< typename category, typename T > void addParam( const T& Param_ )
  29                 {
  30                         //std::cout << "lol add param: " << Param_ << std::endl;
  31                         TypeConverter< category, T > tc( m_pLS );
  32                         tc.ConvertToLua( Param_ );
  33                         ++m_ParamCount;
  34                 }
  35
  36                 void call()
  37                 {
  38                         //std::cout << "lol call\n";
  39                         lua_call( m_pLS, m_ParamCount, 0 );
  40                 }
  41
  42                 lua_State*      m_pLS;
  43                 int                     m_ParamCount;
  44         };
  45
  46         template< class C, typename SigTag > struct LuaSignalConnectWrapper
  47         {
  48                 static int LuaCFunc( lua_State* pLS )
  49                 {
  50                         try
  51                         {
  52                                 typedef typename signal_traits< C, SigTag >::type signal_type;
  53                                 signal_type* pSignal;
  54
  55                                 try
  56                                 {
  57                                         TypeConverter< NormalType, signal_type > tc( pLS );
  58                                         tc.template ConvertFromLua< C >( 1, pSignal );
  59                                 }
  60                                 catch( const Error::TypeMismatch& error )
  61                                 {
  62                                         throw Error::BadMethodCall();
  63                                 }
  64
  65                                 luaL_checktype( pLS, 2, LUA_TFUNCTION );
  66
  67                                 typedef typename
  68                                                 signal_traits< C, SigTag >::template SlotWrapper< LuaSlotCallContext >
  69                                                 wrapper_type;
  70
  71                                 Pointer< wrapper_type > pWrapper = new wrapper_type;
  72                                 pWrapper->m_CallContext.m_pLS = pLS;
  73
  74                                 // Copy the lua function in the lua registry so we can retrieve it
  75                                 // when the signal is triggered.
  76                                 lua_pushlightuserdata( pLS, &pWrapper->m_CallContext );
  77                                 lua_pushvalue( pLS, 2 );
  78                                 lua_settable( pLS, LUA_REGISTRYINDEX );
  79
  80                                 pSignal->connect( static_cast< wrapper_type*>( pWrapper ), &wrapper_type::Call );
  81
  82                                 //std::cout << "lol connect\n";
  83                         }
  84                         catch( Error::Base& error )
  85                         {
  86                                 error.ConvertToLua( pLS );
  87                                 return 0;
  88                         }
  89
  90                         return 0;
  91                 }
  92         };
  93 }}
  94
  95 #endif