1 files changed, 294 insertions, 0 deletions

diff --git a/src/FbTk/Slot.hh b/src/FbTk/Slot.hh
new file mode 100644
index 0000000..ba3cfc4
--- /dev/null
+++ b/src/FbTk/Slot.hh
@@ -0,0 +1,294 @@
+// 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