forked from KolibriOS/kolibrios
1186 lines
33 KiB
C++
1186 lines
33 KiB
C++
// -*- c++ -*-
|
|
/* This is a generated file, do not edit. Generated from ../sigc++/macros/basic_signal.h.m4 */
|
|
|
|
#ifndef SIGCXX_BASIC_SIGNAL_H
|
|
#define SIGCXX_BASIC_SIGNAL_H
|
|
#include <sigc++/marshal.h>
|
|
#include <sigc++/slot.h>
|
|
|
|
// Qt steals a method name.
|
|
#ifdef SIGC_QT
|
|
#undef emit
|
|
#endif
|
|
|
|
#ifdef emit
|
|
#define SIGC_QT
|
|
#undef emit
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef SIGC_CXX_NAMESPACES
|
|
namespace SigC
|
|
{
|
|
#endif
|
|
|
|
/****************************************************************
|
|
***** Signals (build by macros)
|
|
****************************************************************/
|
|
|
|
// common part to all signals
|
|
class LIBSIGC_API Signal_
|
|
{
|
|
private:
|
|
Signal_(const Signal_&);
|
|
|
|
protected:
|
|
typedef ScopeList List;
|
|
|
|
struct LIBSIGC_API Impl
|
|
{
|
|
typedef ScopeList List;
|
|
List incoming_;
|
|
List outgoing_;
|
|
Impl();
|
|
~Impl();
|
|
};
|
|
|
|
Impl *impl;
|
|
|
|
SlotData* in_connect();
|
|
SlotData* out_connect(SlotData *s);
|
|
|
|
Signal_();
|
|
~Signal_();
|
|
|
|
public:
|
|
bool empty() const;
|
|
void clear();
|
|
};
|
|
|
|
|
|
/****************************************************************
|
|
***** Signal 0
|
|
****************************************************************/
|
|
|
|
template <class R,typename Marsh=class Marshal<R> >
|
|
class Signal0:public Signal_
|
|
{
|
|
public:
|
|
typedef Slot0<R> InSlotType;
|
|
typedef Slot0<typename Marsh::OutType> OutSlotType;
|
|
|
|
private:
|
|
#ifdef SIGC_CXX_PARTIAL_SPEC
|
|
typedef typename Marsh::OutType SType;
|
|
typedef R RType;
|
|
#else
|
|
typedef Trait<typename Marsh::OutType>::type SType;
|
|
typedef Trait<R>::type RType;
|
|
#endif
|
|
typedef typename InSlotType::Callback Callback;
|
|
typedef Signal0<R,Marsh> Self;
|
|
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
|
|
|
|
static SType callback(void* d)
|
|
{
|
|
CallData* data=(CallData*)d;
|
|
return data->obj->emit();
|
|
}
|
|
|
|
public:
|
|
OutSlotType slot()
|
|
{
|
|
SlotData* tmp=in_connect();
|
|
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
|
|
data.callback=(typename OutSlotType::Func)callback;
|
|
data.obj=this;
|
|
return tmp;
|
|
}
|
|
|
|
Connection connect(const InSlotType &s)
|
|
{
|
|
return out_connect(s.data());
|
|
}
|
|
|
|
SType emit();
|
|
SType operator()()
|
|
{return emit();}
|
|
|
|
Signal0() {}
|
|
Signal0(const InSlotType &s) {connect(s);}
|
|
~Signal0() {}
|
|
};
|
|
|
|
|
|
// emit
|
|
template <class R,class Marsh>
|
|
typename Signal0<R,Marsh>::SType Signal0<R,Marsh>::
|
|
emit()
|
|
{
|
|
if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
|
|
List &out=impl->outgoing_;
|
|
Marsh rc;
|
|
SlotData *data;
|
|
List::Iterator i=out.begin();
|
|
while (i!=out.end())
|
|
{
|
|
data=((SlotDependent*)(i.node()))->parent();
|
|
++i;
|
|
Callback& s=(Callback&)(data->callback());
|
|
if (rc.marshal(s.call())) return rc.value();
|
|
}
|
|
return rc.value();
|
|
}
|
|
|
|
#ifdef SIGC_CXX_PARTIAL_SPEC
|
|
template <class Marsh>
|
|
class Signal0<void,Marsh>
|
|
:public Signal_
|
|
{
|
|
public:
|
|
typedef Slot0<void> InSlotType;
|
|
typedef Slot0<void> OutSlotType;
|
|
private:
|
|
typedef InSlotType::Callback Callback;
|
|
typedef Signal0<void,Marsh> Self;
|
|
typedef CallDataObj2<OutSlotType::Func,Self> CallData;
|
|
|
|
static void callback(void* d)
|
|
{
|
|
CallData* data=(CallData*)d;
|
|
data->obj->emit();
|
|
}
|
|
|
|
public:
|
|
OutSlotType slot()
|
|
{
|
|
SlotData* tmp=in_connect();
|
|
CallData& data=reinterpret_cast<CallData&>(tmp->data_);
|
|
data.callback=callback;
|
|
data.obj=this;
|
|
return tmp;
|
|
}
|
|
|
|
Connection connect(const InSlotType &s)
|
|
{
|
|
return out_connect(s.data());
|
|
}
|
|
|
|
void emit();
|
|
void operator()()
|
|
{emit();}
|
|
|
|
Signal0() {}
|
|
Signal0(const InSlotType &s) {connect(s);}
|
|
~Signal0() {}
|
|
};
|
|
|
|
|
|
// emit
|
|
template <class Marsh>
|
|
void Signal0<void,Marsh>::
|
|
emit()
|
|
{
|
|
if (!impl||impl->outgoing_.empty()) return;
|
|
List &out=impl->outgoing_;
|
|
SlotData *data;
|
|
List::Iterator i=out.begin();
|
|
while (i!=out.end())
|
|
{
|
|
data=((SlotDependent*)(i.node()))->parent();
|
|
++i;
|
|
Callback& s=(Callback&)(data->callback());
|
|
s.call();
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/****************************************************************
|
|
***** Signal 1
|
|
****************************************************************/
|
|
|
|
template <class R,class P1,typename Marsh=class Marshal<R> >
|
|
class Signal1:public Signal_
|
|
{
|
|
public:
|
|
typedef Slot1<R,P1> InSlotType;
|
|
typedef Slot1<typename Marsh::OutType,P1> OutSlotType;
|
|
|
|
private:
|
|
#ifdef SIGC_CXX_PARTIAL_SPEC
|
|
typedef typename Marsh::OutType SType;
|
|
typedef R RType;
|
|
#else
|
|
typedef Trait<typename Marsh::OutType>::type SType;
|
|
typedef Trait<R>::type RType;
|
|
#endif
|
|
typedef typename InSlotType::Callback Callback;
|
|
typedef Signal1<R,P1,Marsh> Self;
|
|
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
|
|
|
|
static SType callback(void* d,P1 p1)
|
|
{
|
|
CallData* data=(CallData*)d;
|
|
return data->obj->emit(p1);
|
|
}
|
|
|
|
public:
|
|
OutSlotType slot()
|
|
{
|
|
SlotData* tmp=in_connect();
|
|
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
|
|
data.callback=(typename OutSlotType::Func)callback;
|
|
data.obj=this;
|
|
return tmp;
|
|
}
|
|
|
|
Connection connect(const InSlotType &s)
|
|
{
|
|
return out_connect(s.data());
|
|
}
|
|
|
|
SType emit(typename Trait<P1>::ref p1);
|
|
SType operator()(typename Trait<P1>::ref p1)
|
|
{return emit(p1);}
|
|
|
|
Signal1() {}
|
|
Signal1(const InSlotType &s) {connect(s);}
|
|
~Signal1() {}
|
|
};
|
|
|
|
|
|
// emit
|
|
template <class R,class P1,class Marsh>
|
|
typename Signal1<R,P1,Marsh>::SType Signal1<R,P1,Marsh>::
|
|
emit(typename Trait<P1>::ref p1)
|
|
{
|
|
if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
|
|
List &out=impl->outgoing_;
|
|
Marsh rc;
|
|
SlotData *data;
|
|
List::Iterator i=out.begin();
|
|
while (i!=out.end())
|
|
{
|
|
data=((SlotDependent*)(i.node()))->parent();
|
|
++i;
|
|
Callback& s=(Callback&)(data->callback());
|
|
if (rc.marshal(s.call(p1))) return rc.value();
|
|
}
|
|
return rc.value();
|
|
}
|
|
|
|
#ifdef SIGC_CXX_PARTIAL_SPEC
|
|
template <class P1,class Marsh>
|
|
class Signal1<void,P1,Marsh>
|
|
:public Signal_
|
|
{
|
|
public:
|
|
typedef Slot1<void,P1> InSlotType;
|
|
typedef Slot1<void,P1> OutSlotType;
|
|
private:
|
|
typedef typename InSlotType::Callback Callback;
|
|
typedef Signal1<void,P1,Marsh> Self;
|
|
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
|
|
|
|
static void callback(void* d,P1 p1)
|
|
{
|
|
CallData* data=(CallData*)d;
|
|
data->obj->emit(p1);
|
|
}
|
|
|
|
public:
|
|
OutSlotType slot()
|
|
{
|
|
SlotData* tmp=in_connect();
|
|
CallData& data=reinterpret_cast<CallData&>(tmp->data_);
|
|
data.callback=callback;
|
|
data.obj=this;
|
|
return tmp;
|
|
}
|
|
|
|
Connection connect(const InSlotType &s)
|
|
{
|
|
return out_connect(s.data());
|
|
}
|
|
|
|
void emit(typename Trait<P1>::ref p1);
|
|
void operator()(typename Trait<P1>::ref p1)
|
|
{emit(p1);}
|
|
|
|
Signal1() {}
|
|
Signal1(const InSlotType &s) {connect(s);}
|
|
~Signal1() {}
|
|
};
|
|
|
|
|
|
// emit
|
|
template <class P1,class Marsh>
|
|
void Signal1<void,P1,Marsh>::
|
|
emit(typename Trait<P1>::ref p1)
|
|
{
|
|
if (!impl||impl->outgoing_.empty()) return;
|
|
List &out=impl->outgoing_;
|
|
SlotData *data;
|
|
List::Iterator i=out.begin();
|
|
while (i!=out.end())
|
|
{
|
|
data=((SlotDependent*)(i.node()))->parent();
|
|
++i;
|
|
Callback& s=(Callback&)(data->callback());
|
|
s.call(p1);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/****************************************************************
|
|
***** Signal 2
|
|
****************************************************************/
|
|
|
|
template <class R,class P1,class P2,typename Marsh=class Marshal<R> >
|
|
class Signal2:public Signal_
|
|
{
|
|
public:
|
|
typedef Slot2<R,P1,P2> InSlotType;
|
|
typedef Slot2<typename Marsh::OutType,P1,P2> OutSlotType;
|
|
|
|
private:
|
|
#ifdef SIGC_CXX_PARTIAL_SPEC
|
|
typedef typename Marsh::OutType SType;
|
|
typedef R RType;
|
|
#else
|
|
typedef Trait<typename Marsh::OutType>::type SType;
|
|
typedef Trait<R>::type RType;
|
|
#endif
|
|
typedef typename InSlotType::Callback Callback;
|
|
typedef Signal2<R,P1,P2,Marsh> Self;
|
|
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
|
|
|
|
static SType callback(void* d,P1 p1,P2 p2)
|
|
{
|
|
CallData* data=(CallData*)d;
|
|
return data->obj->emit(p1,p2);
|
|
}
|
|
|
|
public:
|
|
OutSlotType slot()
|
|
{
|
|
SlotData* tmp=in_connect();
|
|
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
|
|
data.callback=(typename OutSlotType::Func)callback;
|
|
data.obj=this;
|
|
return tmp;
|
|
}
|
|
|
|
Connection connect(const InSlotType &s)
|
|
{
|
|
return out_connect(s.data());
|
|
}
|
|
|
|
SType emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2);
|
|
SType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2)
|
|
{return emit(p1,p2);}
|
|
|
|
Signal2() {}
|
|
Signal2(const InSlotType &s) {connect(s);}
|
|
~Signal2() {}
|
|
};
|
|
|
|
|
|
// emit
|
|
template <class R,class P1,class P2,class Marsh>
|
|
typename Signal2<R,P1,P2,Marsh>::SType Signal2<R,P1,P2,Marsh>::
|
|
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2)
|
|
{
|
|
if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
|
|
List &out=impl->outgoing_;
|
|
Marsh rc;
|
|
SlotData *data;
|
|
List::Iterator i=out.begin();
|
|
while (i!=out.end())
|
|
{
|
|
data=((SlotDependent*)(i.node()))->parent();
|
|
++i;
|
|
Callback& s=(Callback&)(data->callback());
|
|
if (rc.marshal(s.call(p1,p2))) return rc.value();
|
|
}
|
|
return rc.value();
|
|
}
|
|
|
|
#ifdef SIGC_CXX_PARTIAL_SPEC
|
|
template <class P1,class P2,class Marsh>
|
|
class Signal2<void,P1,P2,Marsh>
|
|
:public Signal_
|
|
{
|
|
public:
|
|
typedef Slot2<void,P1,P2> InSlotType;
|
|
typedef Slot2<void,P1,P2> OutSlotType;
|
|
private:
|
|
typedef typename InSlotType::Callback Callback;
|
|
typedef Signal2<void,P1,P2,Marsh> Self;
|
|
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
|
|
|
|
static void callback(void* d,P1 p1,P2 p2)
|
|
{
|
|
CallData* data=(CallData*)d;
|
|
data->obj->emit(p1,p2);
|
|
}
|
|
|
|
public:
|
|
OutSlotType slot()
|
|
{
|
|
SlotData* tmp=in_connect();
|
|
CallData& data=reinterpret_cast<CallData&>(tmp->data_);
|
|
data.callback=callback;
|
|
data.obj=this;
|
|
return tmp;
|
|
}
|
|
|
|
Connection connect(const InSlotType &s)
|
|
{
|
|
return out_connect(s.data());
|
|
}
|
|
|
|
void emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2);
|
|
void operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2)
|
|
{emit(p1,p2);}
|
|
|
|
Signal2() {}
|
|
Signal2(const InSlotType &s) {connect(s);}
|
|
~Signal2() {}
|
|
};
|
|
|
|
|
|
// emit
|
|
template <class P1,class P2,class Marsh>
|
|
void Signal2<void,P1,P2,Marsh>::
|
|
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2)
|
|
{
|
|
if (!impl||impl->outgoing_.empty()) return;
|
|
List &out=impl->outgoing_;
|
|
SlotData *data;
|
|
List::Iterator i=out.begin();
|
|
while (i!=out.end())
|
|
{
|
|
data=((SlotDependent*)(i.node()))->parent();
|
|
++i;
|
|
Callback& s=(Callback&)(data->callback());
|
|
s.call(p1,p2);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/****************************************************************
|
|
***** Signal 3
|
|
****************************************************************/
|
|
|
|
template <class R,class P1,class P2,class P3,typename Marsh=class Marshal<R> >
|
|
class Signal3:public Signal_
|
|
{
|
|
public:
|
|
typedef Slot3<R,P1,P2,P3> InSlotType;
|
|
typedef Slot3<typename Marsh::OutType,P1,P2,P3> OutSlotType;
|
|
|
|
private:
|
|
#ifdef SIGC_CXX_PARTIAL_SPEC
|
|
typedef typename Marsh::OutType SType;
|
|
typedef R RType;
|
|
#else
|
|
typedef Trait<typename Marsh::OutType>::type SType;
|
|
typedef Trait<R>::type RType;
|
|
#endif
|
|
typedef typename InSlotType::Callback Callback;
|
|
typedef Signal3<R,P1,P2,P3,Marsh> Self;
|
|
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
|
|
|
|
static SType callback(void* d,P1 p1,P2 p2,P3 p3)
|
|
{
|
|
CallData* data=(CallData*)d;
|
|
return data->obj->emit(p1,p2,p3);
|
|
}
|
|
|
|
public:
|
|
OutSlotType slot()
|
|
{
|
|
SlotData* tmp=in_connect();
|
|
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
|
|
data.callback=(typename OutSlotType::Func)callback;
|
|
data.obj=this;
|
|
return tmp;
|
|
}
|
|
|
|
Connection connect(const InSlotType &s)
|
|
{
|
|
return out_connect(s.data());
|
|
}
|
|
|
|
SType emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3);
|
|
SType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3)
|
|
{return emit(p1,p2,p3);}
|
|
|
|
Signal3() {}
|
|
Signal3(const InSlotType &s) {connect(s);}
|
|
~Signal3() {}
|
|
};
|
|
|
|
|
|
// emit
|
|
template <class R,class P1,class P2,class P3,class Marsh>
|
|
typename Signal3<R,P1,P2,P3,Marsh>::SType Signal3<R,P1,P2,P3,Marsh>::
|
|
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3)
|
|
{
|
|
if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
|
|
List &out=impl->outgoing_;
|
|
Marsh rc;
|
|
SlotData *data;
|
|
List::Iterator i=out.begin();
|
|
while (i!=out.end())
|
|
{
|
|
data=((SlotDependent*)(i.node()))->parent();
|
|
++i;
|
|
Callback& s=(Callback&)(data->callback());
|
|
if (rc.marshal(s.call(p1,p2,p3))) return rc.value();
|
|
}
|
|
return rc.value();
|
|
}
|
|
|
|
#ifdef SIGC_CXX_PARTIAL_SPEC
|
|
template <class P1,class P2,class P3,class Marsh>
|
|
class Signal3<void,P1,P2,P3,Marsh>
|
|
:public Signal_
|
|
{
|
|
public:
|
|
typedef Slot3<void,P1,P2,P3> InSlotType;
|
|
typedef Slot3<void,P1,P2,P3> OutSlotType;
|
|
private:
|
|
typedef typename InSlotType::Callback Callback;
|
|
typedef Signal3<void,P1,P2,P3,Marsh> Self;
|
|
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
|
|
|
|
static void callback(void* d,P1 p1,P2 p2,P3 p3)
|
|
{
|
|
CallData* data=(CallData*)d;
|
|
data->obj->emit(p1,p2,p3);
|
|
}
|
|
|
|
public:
|
|
OutSlotType slot()
|
|
{
|
|
SlotData* tmp=in_connect();
|
|
CallData& data=reinterpret_cast<CallData&>(tmp->data_);
|
|
data.callback=callback;
|
|
data.obj=this;
|
|
return tmp;
|
|
}
|
|
|
|
Connection connect(const InSlotType &s)
|
|
{
|
|
return out_connect(s.data());
|
|
}
|
|
|
|
void emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3);
|
|
void operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3)
|
|
{emit(p1,p2,p3);}
|
|
|
|
Signal3() {}
|
|
Signal3(const InSlotType &s) {connect(s);}
|
|
~Signal3() {}
|
|
};
|
|
|
|
|
|
// emit
|
|
template <class P1,class P2,class P3,class Marsh>
|
|
void Signal3<void,P1,P2,P3,Marsh>::
|
|
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3)
|
|
{
|
|
if (!impl||impl->outgoing_.empty()) return;
|
|
List &out=impl->outgoing_;
|
|
SlotData *data;
|
|
List::Iterator i=out.begin();
|
|
while (i!=out.end())
|
|
{
|
|
data=((SlotDependent*)(i.node()))->parent();
|
|
++i;
|
|
Callback& s=(Callback&)(data->callback());
|
|
s.call(p1,p2,p3);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/****************************************************************
|
|
***** Signal 4
|
|
****************************************************************/
|
|
|
|
template <class R,class P1,class P2,class P3,class P4,typename Marsh=class Marshal<R> >
|
|
class Signal4:public Signal_
|
|
{
|
|
public:
|
|
typedef Slot4<R,P1,P2,P3,P4> InSlotType;
|
|
typedef Slot4<typename Marsh::OutType,P1,P2,P3,P4> OutSlotType;
|
|
|
|
private:
|
|
#ifdef SIGC_CXX_PARTIAL_SPEC
|
|
typedef typename Marsh::OutType SType;
|
|
typedef R RType;
|
|
#else
|
|
typedef Trait<typename Marsh::OutType>::type SType;
|
|
typedef Trait<R>::type RType;
|
|
#endif
|
|
typedef typename InSlotType::Callback Callback;
|
|
typedef Signal4<R,P1,P2,P3,P4,Marsh> Self;
|
|
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
|
|
|
|
static SType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
|
|
{
|
|
CallData* data=(CallData*)d;
|
|
return data->obj->emit(p1,p2,p3,p4);
|
|
}
|
|
|
|
public:
|
|
OutSlotType slot()
|
|
{
|
|
SlotData* tmp=in_connect();
|
|
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
|
|
data.callback=(typename OutSlotType::Func)callback;
|
|
data.obj=this;
|
|
return tmp;
|
|
}
|
|
|
|
Connection connect(const InSlotType &s)
|
|
{
|
|
return out_connect(s.data());
|
|
}
|
|
|
|
SType emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4);
|
|
SType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4)
|
|
{return emit(p1,p2,p3,p4);}
|
|
|
|
Signal4() {}
|
|
Signal4(const InSlotType &s) {connect(s);}
|
|
~Signal4() {}
|
|
};
|
|
|
|
|
|
// emit
|
|
template <class R,class P1,class P2,class P3,class P4,class Marsh>
|
|
typename Signal4<R,P1,P2,P3,P4,Marsh>::SType Signal4<R,P1,P2,P3,P4,Marsh>::
|
|
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4)
|
|
{
|
|
if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
|
|
List &out=impl->outgoing_;
|
|
Marsh rc;
|
|
SlotData *data;
|
|
List::Iterator i=out.begin();
|
|
while (i!=out.end())
|
|
{
|
|
data=((SlotDependent*)(i.node()))->parent();
|
|
++i;
|
|
Callback& s=(Callback&)(data->callback());
|
|
if (rc.marshal(s.call(p1,p2,p3,p4))) return rc.value();
|
|
}
|
|
return rc.value();
|
|
}
|
|
|
|
#ifdef SIGC_CXX_PARTIAL_SPEC
|
|
template <class P1,class P2,class P3,class P4,class Marsh>
|
|
class Signal4<void,P1,P2,P3,P4,Marsh>
|
|
:public Signal_
|
|
{
|
|
public:
|
|
typedef Slot4<void,P1,P2,P3,P4> InSlotType;
|
|
typedef Slot4<void,P1,P2,P3,P4> OutSlotType;
|
|
private:
|
|
typedef typename InSlotType::Callback Callback;
|
|
typedef Signal4<void,P1,P2,P3,P4,Marsh> Self;
|
|
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
|
|
|
|
static void callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
|
|
{
|
|
CallData* data=(CallData*)d;
|
|
data->obj->emit(p1,p2,p3,p4);
|
|
}
|
|
|
|
public:
|
|
OutSlotType slot()
|
|
{
|
|
SlotData* tmp=in_connect();
|
|
CallData& data=reinterpret_cast<CallData&>(tmp->data_);
|
|
data.callback=callback;
|
|
data.obj=this;
|
|
return tmp;
|
|
}
|
|
|
|
Connection connect(const InSlotType &s)
|
|
{
|
|
return out_connect(s.data());
|
|
}
|
|
|
|
void emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4);
|
|
void operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4)
|
|
{emit(p1,p2,p3,p4);}
|
|
|
|
Signal4() {}
|
|
Signal4(const InSlotType &s) {connect(s);}
|
|
~Signal4() {}
|
|
};
|
|
|
|
|
|
// emit
|
|
template <class P1,class P2,class P3,class P4,class Marsh>
|
|
void Signal4<void,P1,P2,P3,P4,Marsh>::
|
|
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4)
|
|
{
|
|
if (!impl||impl->outgoing_.empty()) return;
|
|
List &out=impl->outgoing_;
|
|
SlotData *data;
|
|
List::Iterator i=out.begin();
|
|
while (i!=out.end())
|
|
{
|
|
data=((SlotDependent*)(i.node()))->parent();
|
|
++i;
|
|
Callback& s=(Callback&)(data->callback());
|
|
s.call(p1,p2,p3,p4);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/****************************************************************
|
|
***** Signal 5
|
|
****************************************************************/
|
|
|
|
template <class R,class P1,class P2,class P3,class P4,class P5,typename Marsh=class Marshal<R> >
|
|
class Signal5:public Signal_
|
|
{
|
|
public:
|
|
typedef Slot5<R,P1,P2,P3,P4,P5> InSlotType;
|
|
typedef Slot5<typename Marsh::OutType,P1,P2,P3,P4,P5> OutSlotType;
|
|
|
|
private:
|
|
#ifdef SIGC_CXX_PARTIAL_SPEC
|
|
typedef typename Marsh::OutType SType;
|
|
typedef R RType;
|
|
#else
|
|
typedef Trait<typename Marsh::OutType>::type SType;
|
|
typedef Trait<R>::type RType;
|
|
#endif
|
|
typedef typename InSlotType::Callback Callback;
|
|
typedef Signal5<R,P1,P2,P3,P4,P5,Marsh> Self;
|
|
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
|
|
|
|
static SType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
|
|
{
|
|
CallData* data=(CallData*)d;
|
|
return data->obj->emit(p1,p2,p3,p4,p5);
|
|
}
|
|
|
|
public:
|
|
OutSlotType slot()
|
|
{
|
|
SlotData* tmp=in_connect();
|
|
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
|
|
data.callback=(typename OutSlotType::Func)callback;
|
|
data.obj=this;
|
|
return tmp;
|
|
}
|
|
|
|
Connection connect(const InSlotType &s)
|
|
{
|
|
return out_connect(s.data());
|
|
}
|
|
|
|
SType emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5);
|
|
SType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5)
|
|
{return emit(p1,p2,p3,p4,p5);}
|
|
|
|
Signal5() {}
|
|
Signal5(const InSlotType &s) {connect(s);}
|
|
~Signal5() {}
|
|
};
|
|
|
|
|
|
// emit
|
|
template <class R,class P1,class P2,class P3,class P4,class P5,class Marsh>
|
|
typename Signal5<R,P1,P2,P3,P4,P5,Marsh>::SType Signal5<R,P1,P2,P3,P4,P5,Marsh>::
|
|
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5)
|
|
{
|
|
if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
|
|
List &out=impl->outgoing_;
|
|
Marsh rc;
|
|
SlotData *data;
|
|
List::Iterator i=out.begin();
|
|
while (i!=out.end())
|
|
{
|
|
data=((SlotDependent*)(i.node()))->parent();
|
|
++i;
|
|
Callback& s=(Callback&)(data->callback());
|
|
if (rc.marshal(s.call(p1,p2,p3,p4,p5))) return rc.value();
|
|
}
|
|
return rc.value();
|
|
}
|
|
|
|
#ifdef SIGC_CXX_PARTIAL_SPEC
|
|
template <class P1,class P2,class P3,class P4,class P5,class Marsh>
|
|
class Signal5<void,P1,P2,P3,P4,P5,Marsh>
|
|
:public Signal_
|
|
{
|
|
public:
|
|
typedef Slot5<void,P1,P2,P3,P4,P5> InSlotType;
|
|
typedef Slot5<void,P1,P2,P3,P4,P5> OutSlotType;
|
|
private:
|
|
typedef typename InSlotType::Callback Callback;
|
|
typedef Signal5<void,P1,P2,P3,P4,P5,Marsh> Self;
|
|
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
|
|
|
|
static void callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
|
|
{
|
|
CallData* data=(CallData*)d;
|
|
data->obj->emit(p1,p2,p3,p4,p5);
|
|
}
|
|
|
|
public:
|
|
OutSlotType slot()
|
|
{
|
|
SlotData* tmp=in_connect();
|
|
CallData& data=reinterpret_cast<CallData&>(tmp->data_);
|
|
data.callback=callback;
|
|
data.obj=this;
|
|
return tmp;
|
|
}
|
|
|
|
Connection connect(const InSlotType &s)
|
|
{
|
|
return out_connect(s.data());
|
|
}
|
|
|
|
void emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5);
|
|
void operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5)
|
|
{emit(p1,p2,p3,p4,p5);}
|
|
|
|
Signal5() {}
|
|
Signal5(const InSlotType &s) {connect(s);}
|
|
~Signal5() {}
|
|
};
|
|
|
|
|
|
// emit
|
|
template <class P1,class P2,class P3,class P4,class P5,class Marsh>
|
|
void Signal5<void,P1,P2,P3,P4,P5,Marsh>::
|
|
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5)
|
|
{
|
|
if (!impl||impl->outgoing_.empty()) return;
|
|
List &out=impl->outgoing_;
|
|
SlotData *data;
|
|
List::Iterator i=out.begin();
|
|
while (i!=out.end())
|
|
{
|
|
data=((SlotDependent*)(i.node()))->parent();
|
|
++i;
|
|
Callback& s=(Callback&)(data->callback());
|
|
s.call(p1,p2,p3,p4,p5);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/****************************************************************
|
|
***** Signal 6
|
|
****************************************************************/
|
|
|
|
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,typename Marsh=class Marshal<R> >
|
|
class Signal6:public Signal_
|
|
{
|
|
public:
|
|
typedef Slot6<R,P1,P2,P3,P4,P5,P6> InSlotType;
|
|
typedef Slot6<typename Marsh::OutType,P1,P2,P3,P4,P5,P6> OutSlotType;
|
|
|
|
private:
|
|
#ifdef SIGC_CXX_PARTIAL_SPEC
|
|
typedef typename Marsh::OutType SType;
|
|
typedef R RType;
|
|
#else
|
|
typedef Trait<typename Marsh::OutType>::type SType;
|
|
typedef Trait<R>::type RType;
|
|
#endif
|
|
typedef typename InSlotType::Callback Callback;
|
|
typedef Signal6<R,P1,P2,P3,P4,P5,P6,Marsh> Self;
|
|
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
|
|
|
|
static SType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
|
|
{
|
|
CallData* data=(CallData*)d;
|
|
return data->obj->emit(p1,p2,p3,p4,p5,p6);
|
|
}
|
|
|
|
public:
|
|
OutSlotType slot()
|
|
{
|
|
SlotData* tmp=in_connect();
|
|
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
|
|
data.callback=(typename OutSlotType::Func)callback;
|
|
data.obj=this;
|
|
return tmp;
|
|
}
|
|
|
|
Connection connect(const InSlotType &s)
|
|
{
|
|
return out_connect(s.data());
|
|
}
|
|
|
|
SType emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5,typename Trait<P6>::ref p6);
|
|
SType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5,typename Trait<P6>::ref p6)
|
|
{return emit(p1,p2,p3,p4,p5,p6);}
|
|
|
|
Signal6() {}
|
|
Signal6(const InSlotType &s) {connect(s);}
|
|
~Signal6() {}
|
|
};
|
|
|
|
|
|
// emit
|
|
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class Marsh>
|
|
typename Signal6<R,P1,P2,P3,P4,P5,P6,Marsh>::SType Signal6<R,P1,P2,P3,P4,P5,P6,Marsh>::
|
|
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5,typename Trait<P6>::ref p6)
|
|
{
|
|
if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
|
|
List &out=impl->outgoing_;
|
|
Marsh rc;
|
|
SlotData *data;
|
|
List::Iterator i=out.begin();
|
|
while (i!=out.end())
|
|
{
|
|
data=((SlotDependent*)(i.node()))->parent();
|
|
++i;
|
|
Callback& s=(Callback&)(data->callback());
|
|
if (rc.marshal(s.call(p1,p2,p3,p4,p5,p6))) return rc.value();
|
|
}
|
|
return rc.value();
|
|
}
|
|
|
|
#ifdef SIGC_CXX_PARTIAL_SPEC
|
|
template <class P1,class P2,class P3,class P4,class P5,class P6,class Marsh>
|
|
class Signal6<void,P1,P2,P3,P4,P5,P6,Marsh>
|
|
:public Signal_
|
|
{
|
|
public:
|
|
typedef Slot6<void,P1,P2,P3,P4,P5,P6> InSlotType;
|
|
typedef Slot6<void,P1,P2,P3,P4,P5,P6> OutSlotType;
|
|
private:
|
|
typedef typename InSlotType::Callback Callback;
|
|
typedef Signal6<void,P1,P2,P3,P4,P5,P6,Marsh> Self;
|
|
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
|
|
|
|
static void callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
|
|
{
|
|
CallData* data=(CallData*)d;
|
|
data->obj->emit(p1,p2,p3,p4,p5,p6);
|
|
}
|
|
|
|
public:
|
|
OutSlotType slot()
|
|
{
|
|
SlotData* tmp=in_connect();
|
|
CallData& data=reinterpret_cast<CallData&>(tmp->data_);
|
|
data.callback=callback;
|
|
data.obj=this;
|
|
return tmp;
|
|
}
|
|
|
|
Connection connect(const InSlotType &s)
|
|
{
|
|
return out_connect(s.data());
|
|
}
|
|
|
|
void emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5,typename Trait<P6>::ref p6);
|
|
void operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5,typename Trait<P6>::ref p6)
|
|
{emit(p1,p2,p3,p4,p5,p6);}
|
|
|
|
Signal6() {}
|
|
Signal6(const InSlotType &s) {connect(s);}
|
|
~Signal6() {}
|
|
};
|
|
|
|
|
|
// emit
|
|
template <class P1,class P2,class P3,class P4,class P5,class P6,class Marsh>
|
|
void Signal6<void,P1,P2,P3,P4,P5,P6,Marsh>::
|
|
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5,typename Trait<P6>::ref p6)
|
|
{
|
|
if (!impl||impl->outgoing_.empty()) return;
|
|
List &out=impl->outgoing_;
|
|
SlotData *data;
|
|
List::Iterator i=out.begin();
|
|
while (i!=out.end())
|
|
{
|
|
data=((SlotDependent*)(i.node()))->parent();
|
|
++i;
|
|
Callback& s=(Callback&)(data->callback());
|
|
s.call(p1,p2,p3,p4,p5,p6);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
/****************************************************************
|
|
***** Signal 7
|
|
****************************************************************/
|
|
|
|
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,typename Marsh=class Marshal<R> >
|
|
class Signal7:public Signal_
|
|
{
|
|
public:
|
|
typedef Slot7<R,P1,P2,P3,P4,P5,P6,P7> InSlotType;
|
|
typedef Slot7<typename Marsh::OutType,P1,P2,P3,P4,P5,P6,P7> OutSlotType;
|
|
|
|
private:
|
|
#ifdef SIGC_CXX_PARTIAL_SPEC
|
|
typedef typename Marsh::OutType SType;
|
|
typedef R RType;
|
|
#else
|
|
typedef Trait<typename Marsh::OutType>::type SType;
|
|
typedef Trait<R>::type RType;
|
|
#endif
|
|
typedef typename InSlotType::Callback Callback;
|
|
typedef Signal7<R,P1,P2,P3,P4,P5,P6,P7,Marsh> Self;
|
|
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
|
|
|
|
static SType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
|
|
{
|
|
CallData* data=(CallData*)d;
|
|
return data->obj->emit(p1,p2,p3,p4,p5,p6,p7);
|
|
}
|
|
|
|
public:
|
|
OutSlotType slot()
|
|
{
|
|
SlotData* tmp=in_connect();
|
|
CallData &data=reinterpret_cast<CallData&>(tmp->data_);
|
|
data.callback=(typename OutSlotType::Func)callback;
|
|
data.obj=this;
|
|
return tmp;
|
|
}
|
|
|
|
Connection connect(const InSlotType &s)
|
|
{
|
|
return out_connect(s.data());
|
|
}
|
|
|
|
SType emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5,typename Trait<P6>::ref p6,typename Trait<P7>::ref p7);
|
|
SType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5,typename Trait<P6>::ref p6,typename Trait<P7>::ref p7)
|
|
{return emit(p1,p2,p3,p4,p5,p6,p7);}
|
|
|
|
Signal7() {}
|
|
Signal7(const InSlotType &s) {connect(s);}
|
|
~Signal7() {}
|
|
};
|
|
|
|
|
|
// emit
|
|
template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Marsh>
|
|
typename Signal7<R,P1,P2,P3,P4,P5,P6,P7,Marsh>::SType Signal7<R,P1,P2,P3,P4,P5,P6,P7,Marsh>::
|
|
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5,typename Trait<P6>::ref p6,typename Trait<P7>::ref p7)
|
|
{
|
|
if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
|
|
List &out=impl->outgoing_;
|
|
Marsh rc;
|
|
SlotData *data;
|
|
List::Iterator i=out.begin();
|
|
while (i!=out.end())
|
|
{
|
|
data=((SlotDependent*)(i.node()))->parent();
|
|
++i;
|
|
Callback& s=(Callback&)(data->callback());
|
|
if (rc.marshal(s.call(p1,p2,p3,p4,p5,p6,p7))) return rc.value();
|
|
}
|
|
return rc.value();
|
|
}
|
|
|
|
#ifdef SIGC_CXX_PARTIAL_SPEC
|
|
template <class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Marsh>
|
|
class Signal7<void,P1,P2,P3,P4,P5,P6,P7,Marsh>
|
|
:public Signal_
|
|
{
|
|
public:
|
|
typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> InSlotType;
|
|
typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> OutSlotType;
|
|
private:
|
|
typedef typename InSlotType::Callback Callback;
|
|
typedef Signal7<void,P1,P2,P3,P4,P5,P6,P7,Marsh> Self;
|
|
typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
|
|
|
|
static void callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
|
|
{
|
|
CallData* data=(CallData*)d;
|
|
data->obj->emit(p1,p2,p3,p4,p5,p6,p7);
|
|
}
|
|
|
|
public:
|
|
OutSlotType slot()
|
|
{
|
|
SlotData* tmp=in_connect();
|
|
CallData& data=reinterpret_cast<CallData&>(tmp->data_);
|
|
data.callback=callback;
|
|
data.obj=this;
|
|
return tmp;
|
|
}
|
|
|
|
Connection connect(const InSlotType &s)
|
|
{
|
|
return out_connect(s.data());
|
|
}
|
|
|
|
void emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5,typename Trait<P6>::ref p6,typename Trait<P7>::ref p7);
|
|
void operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5,typename Trait<P6>::ref p6,typename Trait<P7>::ref p7)
|
|
{emit(p1,p2,p3,p4,p5,p6,p7);}
|
|
|
|
Signal7() {}
|
|
Signal7(const InSlotType &s) {connect(s);}
|
|
~Signal7() {}
|
|
};
|
|
|
|
|
|
// emit
|
|
template <class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Marsh>
|
|
void Signal7<void,P1,P2,P3,P4,P5,P6,P7,Marsh>::
|
|
emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4,typename Trait<P5>::ref p5,typename Trait<P6>::ref p6,typename Trait<P7>::ref p7)
|
|
{
|
|
if (!impl||impl->outgoing_.empty()) return;
|
|
List &out=impl->outgoing_;
|
|
SlotData *data;
|
|
List::Iterator i=out.begin();
|
|
while (i!=out.end())
|
|
{
|
|
data=((SlotDependent*)(i.node()))->parent();
|
|
++i;
|
|
Callback& s=(Callback&)(data->callback());
|
|
s.call(p1,p2,p3,p4,p5,p6,p7);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef SIGC_CXX_NAMESPACES
|
|
} // namespace
|
|
#endif
|
|
|
|
#ifdef SIGC_QT
|
|
#define emit
|
|
#endif
|
|
|
|
|
|
#endif // SIGCXX_BASIC_SIGNAL_H
|
|
|