// Slot.hh for FbTk, Fluxbox Toolkit // Copyright (c) 2008 Henrik Kinnunen (fluxgen at fluxbox dot org) // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the "Software"), // to deal in the Software without restriction, including without limitation // the rights to use, copy, modify, merge, publish, distribute, sublicense, // and/or sell copies of the Software, and to permit persons to whom the // Software is furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL // THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // DEALINGS IN THE SOFTWARE. #ifndef FBTK_SLOT_HH #define FBTK_SLOT_HH namespace FbTk { /// \namespace Implementation details for signals, do not use anything in this namespace namespace SigImpl { class CallbackHolder; /// Placeholder type for typed callbacks typedef void* (*CallbackFunc)(void *); /// Clone function callback type for cloning typed callback holders typedef CallbackHolder* (*CloneFunc)(CallbackHolder*); /// Kill function callback type for destroying type specific information in /// FunctorHolder typedef void (*KillFunc)(CallbackHolder*); /// Holds clone, functor callback, and the kill function for FunctorHolder. class CallbackHolder { public: /** * @param callback The callback to call when a slot receives a signal. * @param clone The callback to use for cloning a type specific instance of * this classinstance. * @param kill The callback that knows how to free the memory in type * specific instance of this class. */ CallbackHolder(CallbackFunc callback, CloneFunc clone, KillFunc kill): m_callback(callback), m_kill(kill), m_clone(clone) { } ~CallbackHolder() { (*m_kill)(this); } /// @return a clone of this instance CallbackHolder* clone() { return (*m_clone)(this); } /// \c Callback to \c Functor specific callback CallbackFunc m_callback; protected: CallbackHolder& operator = (const CallbackHolder& other) { if ( this == &other ) { return *this; } m_callback = other.m_callback; m_clone = other.m_clone; m_kill = other.m_kill; return *this; } CallbackHolder(const CallbackHolder& other) { *this = other; } private: /// This function is called to kill this instance KillFunc m_kill; /// Functions that knows how to clone a specific \c Functor type CloneFunc m_clone; }; /// Holds the functor and creates a clone callback for \c Functor specific type template <typename Functor> class FunctorHolder: public CallbackHolder { public: /// This type. typedef FunctorHolder<Functor> Self; /** * @param functor The functor to be used when a signal is emitted. * @param callback The callback to call when a signal is emitted. */ FunctorHolder(const Functor& functor, CallbackFunc callback): CallbackHolder(callback, &clone, &kill), m_functor(functor) { } /// Specific clone for this Functor type static CallbackHolder* clone(CallbackHolder* self) { return new Self( static_cast<Self&>(*self)); } static void kill(CallbackHolder* self) { // Destroy functor static_cast<Self*>( self )->m_functor.~Functor(); } Functor m_functor; ///< the functor to use when a signal is emitted. }; /// Callback with no arguments. template <typename Functor, typename ReturnType > struct Callback0 { static ReturnType callback(CallbackHolder* base) { static_cast< FunctorHolder<Functor>* >( base )->m_functor(); return ReturnType(); } static CallbackFunc functionAddress() { return reinterpret_cast<CallbackFunc>(&callback); } }; /// Callback with one argument template <typename Functor, typename ReturnType, typename Arg1> struct Callback1 { typedef ReturnType (Functor::* CallbackType)(CallbackHolder*, Arg1); static ReturnType callback(CallbackHolder* base, Arg1 arg1) { static_cast< FunctorHolder<Functor>* >( base )->m_functor(arg1); return ReturnType(); } static CallbackFunc functionAddress() { return reinterpret_cast<CallbackFunc>(&callback); } }; /// Callback with two arguments template <typename Functor, typename ReturnType, typename Arg1, typename Arg2> struct Callback2 { typedef ReturnType (Functor::* CallbackType)(CallbackHolder*, Arg1, Arg2); static ReturnType callback(CallbackHolder* base, Arg1 arg1, Arg2 arg2) { static_cast< FunctorHolder<Functor>* >( base )->m_functor(arg1, arg2); return ReturnType(); } static CallbackFunc functionAddress() { return reinterpret_cast<CallbackFunc>(&callback); } }; /// Callback with three arguments template <typename Functor, typename ReturnType, typename Arg1, typename Arg2, typename Arg3> struct Callback3 { typedef ReturnType (Functor::* CallbackType)(CallbackHolder*, Arg1, Arg2, Arg3); static ReturnType callback(CallbackHolder* base, Arg1 arg1, Arg2 arg2, Arg3 arg3) { static_cast< FunctorHolder<Functor>* >( base )->m_functor( arg1, arg2, arg3 ); return ReturnType(); } static CallbackFunc functionAddress() { return reinterpret_cast<CallbackFunc>(&callback); } }; /// Holds callback holder and handles the copying of callback holders for the /// \c Slots. class SlotHolder { public: SlotHolder(const SlotHolder& other): m_holder( other.m_holder ? other.m_holder->clone() : 0 ) { } ~SlotHolder() { delete m_holder; } SlotHolder& operator = (const SlotHolder& other) { if ( &other == this ) { return *this; } delete m_holder; if ( other.m_holder ) { m_holder = other.m_holder->clone(); } else { m_holder = 0; } return *this; } SlotHolder():m_holder( 0 ) { } protected: explicit SlotHolder(CallbackHolder* holder): m_holder( holder ) { } CallbackHolder* m_holder; }; /// Slot with no argument. template <typename ReturnType> class Slot0: public SlotHolder { public: typedef ReturnType (*CallbackType)(CallbackHolder*); template <typename Functor> Slot0( const Functor& functor ): SlotHolder( new FunctorHolder<Functor> (functor, Callback0<Functor, ReturnType>::functionAddress())) { } void operator()() { reinterpret_cast<CallbackType>(m_holder->m_callback)( m_holder ); } }; /// Slot with one argument. template <typename ReturnType, typename Arg1> class Slot1:public SlotHolder { public: typedef ReturnType (*CallbackType)(CallbackHolder*, Arg1); template <typename Functor> Slot1( const Functor& functor ): SlotHolder( new FunctorHolder<Functor> (functor, Callback1<Functor, ReturnType, Arg1>::functionAddress())){ } void operator()(Arg1 arg) { reinterpret_cast<CallbackType>(m_holder->m_callback)(m_holder, arg); } }; /// Slot with two arguments template <typename ReturnType, typename Arg1, typename Arg2> class Slot2: public SlotHolder { public: typedef ReturnType (*CallbackType)(CallbackHolder*, Arg1, Arg2); template <typename Functor> Slot2( const Functor& functor ): SlotHolder( new FunctorHolder<Functor> (functor, Callback2<Functor, ReturnType, Arg1, Arg2>::functionAddress())){ } void operator()(Arg1 arg1, Arg2 arg2) { reinterpret_cast<CallbackType>(m_holder->m_callback)(m_holder, arg1, arg2); } }; /// Slot with three arguments template <typename ReturnType, typename Arg1, typename Arg2, typename Arg3> class Slot3: public SlotHolder { public: typedef ReturnType (*CallbackType)(CallbackHolder*, Arg1, Arg2, Arg3); template <typename Functor> Slot3( const Functor& functor ): SlotHolder( new FunctorHolder<Functor> (functor, Callback3<Functor, ReturnType, Arg1, Arg2, Arg3>::functionAddress())){ } void operator()(Arg1 arg1, Arg2 arg2, Arg3 arg3) { reinterpret_cast<CallbackType>(m_holder->m_callback) ( m_holder, arg1, arg2, arg3 ); } }; } // namespace SigImpl } // namespace FbTk #endif // FBTK_SLOT_H