Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. // -*- c++ -*-
  2. /* This is a generated file, do not edit.  Generated from ../sigc++/macros/basic_signal.h.m4 */
  3.  
  4. #ifndef SIGCXX_BASIC_SIGNAL_H
  5. #define SIGCXX_BASIC_SIGNAL_H
  6. #include <sigc++/marshal.h>
  7. #include <sigc++/slot.h>
  8.  
  9. // Qt steals a method name.
  10. #ifdef SIGC_QT
  11. #undef emit
  12. #endif
  13.  
  14. #ifdef emit
  15. #define SIGC_QT
  16. #undef emit
  17. #endif
  18.  
  19.  
  20.  
  21. #ifdef SIGC_CXX_NAMESPACES
  22. namespace SigC
  23. {
  24. #endif
  25.  
  26. /****************************************************************
  27. *****  Signals (build by macros)
  28. ****************************************************************/
  29.  
  30. // common part to all signals
  31. class LIBSIGC_API Signal_
  32.   {
  33.     private:
  34.       Signal_(const Signal_&);
  35.  
  36.     protected:
  37.       typedef ScopeList List;
  38.    
  39.       struct LIBSIGC_API Impl
  40.         {
  41.           typedef ScopeList List;
  42.           List incoming_;
  43.           List outgoing_;
  44.           Impl();
  45.           ~Impl();
  46.         };
  47.  
  48.       Impl *impl;
  49.  
  50.       SlotData* in_connect();
  51.       SlotData* out_connect(SlotData *s);
  52.  
  53.       Signal_();
  54.       ~Signal_();
  55.  
  56.     public:
  57.       bool empty() const;
  58.       void clear();
  59.   };
  60.  
  61.  
  62. /****************************************************************
  63. *****  Signal 0
  64. ****************************************************************/
  65.  
  66. template <class R,typename Marsh=class Marshal<R> >
  67.   class Signal0:public Signal_
  68.   {
  69.    public:
  70.      typedef Slot0<R>                       InSlotType;
  71.      typedef Slot0<typename Marsh::OutType> OutSlotType;
  72.  
  73.    private:
  74. #ifdef SIGC_CXX_PARTIAL_SPEC
  75.      typedef typename Marsh::OutType SType;
  76.      typedef R RType;
  77. #else
  78.      typedef Trait<typename Marsh::OutType>::type SType;
  79.      typedef Trait<R>::type RType;
  80. #endif
  81.      typedef typename InSlotType::Callback Callback;
  82.      typedef Signal0<R,Marsh> Self;
  83.      typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
  84.  
  85.      static SType callback(void* d)
  86.        {
  87.         CallData* data=(CallData*)d;
  88.         return data->obj->emit();
  89.        }
  90.  
  91.    public:
  92.      OutSlotType slot()
  93.        {
  94.         SlotData* tmp=in_connect();
  95.         CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  96.         data.callback=(typename OutSlotType::Func)callback;
  97.         data.obj=this;
  98.         return tmp;
  99.        }
  100.  
  101.      Connection connect(const InSlotType &s)
  102.        {
  103.         return out_connect(s.data());
  104.        }
  105.  
  106.      SType emit();
  107.      SType operator()()
  108.        {return emit();}
  109.  
  110.      Signal0() {}
  111.      Signal0(const InSlotType &s) {connect(s);}
  112.      ~Signal0() {}
  113.   };
  114.  
  115.  
  116. // emit
  117. template <class R,class Marsh>
  118. typename  Signal0<R,Marsh>::SType Signal0<R,Marsh>::
  119.   emit()
  120.   {
  121.    if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
  122.    List &out=impl->outgoing_;
  123.    Marsh rc;
  124.    SlotData *data;
  125.    List::Iterator i=out.begin();
  126.    while (i!=out.end())
  127.      {
  128.       data=((SlotDependent*)(i.node()))->parent();
  129.       ++i;
  130.       Callback& s=(Callback&)(data->callback());
  131.       if (rc.marshal(s.call())) return rc.value();
  132.      }
  133.    return rc.value();
  134.   }
  135.  
  136. #ifdef SIGC_CXX_PARTIAL_SPEC
  137. template <class Marsh>
  138. class Signal0<void,Marsh>
  139.   :public Signal_
  140.   {
  141.    public:
  142.      typedef Slot0<void> InSlotType;
  143.      typedef Slot0<void> OutSlotType;
  144.    private:
  145.      typedef InSlotType::Callback Callback;
  146.      typedef Signal0<void,Marsh> Self;
  147.      typedef CallDataObj2<OutSlotType::Func,Self> CallData;
  148.  
  149.      static void callback(void* d)
  150.        {
  151.         CallData* data=(CallData*)d;
  152.         data->obj->emit();
  153.        }
  154.  
  155.    public:
  156.      OutSlotType slot()
  157.        {
  158.         SlotData* tmp=in_connect();
  159.         CallData& data=reinterpret_cast<CallData&>(tmp->data_);
  160.         data.callback=callback;
  161.         data.obj=this;
  162.         return tmp;
  163.        }
  164.  
  165.      Connection connect(const InSlotType &s)
  166.        {
  167.         return out_connect(s.data());
  168.        }
  169.  
  170.      void emit();
  171.      void operator()()
  172.        {emit();}
  173.  
  174.      Signal0() {}
  175.      Signal0(const InSlotType &s) {connect(s);}
  176.      ~Signal0() {}
  177.   };
  178.  
  179.  
  180. // emit
  181. template <class Marsh>
  182. void Signal0<void,Marsh>::
  183.   emit()
  184.   {
  185.    if (!impl||impl->outgoing_.empty()) return;
  186.    List &out=impl->outgoing_;
  187.    SlotData *data;
  188.    List::Iterator i=out.begin();
  189.    while (i!=out.end())
  190.      {
  191.       data=((SlotDependent*)(i.node()))->parent();
  192.       ++i;
  193.       Callback& s=(Callback&)(data->callback());
  194.       s.call();
  195.      }
  196.   }
  197.  
  198. #endif
  199.  
  200.  
  201. /****************************************************************
  202. *****  Signal 1
  203. ****************************************************************/
  204.  
  205. template <class R,class P1,typename Marsh=class Marshal<R> >
  206.   class Signal1:public Signal_
  207.   {
  208.    public:
  209.      typedef Slot1<R,P1>                       InSlotType;
  210.      typedef Slot1<typename Marsh::OutType,P1> OutSlotType;
  211.  
  212.    private:
  213. #ifdef SIGC_CXX_PARTIAL_SPEC
  214.      typedef typename Marsh::OutType SType;
  215.      typedef R RType;
  216. #else
  217.      typedef Trait<typename Marsh::OutType>::type SType;
  218.      typedef Trait<R>::type RType;
  219. #endif
  220.      typedef typename InSlotType::Callback Callback;
  221.      typedef Signal1<R,P1,Marsh> Self;
  222.      typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
  223.  
  224.      static SType callback(void* d,P1 p1)
  225.        {
  226.         CallData* data=(CallData*)d;
  227.         return data->obj->emit(p1);
  228.        }
  229.  
  230.    public:
  231.      OutSlotType slot()
  232.        {
  233.         SlotData* tmp=in_connect();
  234.         CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  235.         data.callback=(typename OutSlotType::Func)callback;
  236.         data.obj=this;
  237.         return tmp;
  238.        }
  239.  
  240.      Connection connect(const InSlotType &s)
  241.        {
  242.         return out_connect(s.data());
  243.        }
  244.  
  245.      SType emit(typename Trait<P1>::ref p1);
  246.      SType operator()(typename Trait<P1>::ref p1)
  247.        {return emit(p1);}
  248.  
  249.      Signal1() {}
  250.      Signal1(const InSlotType &s) {connect(s);}
  251.      ~Signal1() {}
  252.   };
  253.  
  254.  
  255. // emit
  256. template <class R,class P1,class Marsh>
  257. typename  Signal1<R,P1,Marsh>::SType Signal1<R,P1,Marsh>::
  258.   emit(typename Trait<P1>::ref p1)
  259.   {
  260.    if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
  261.    List &out=impl->outgoing_;
  262.    Marsh rc;
  263.    SlotData *data;
  264.    List::Iterator i=out.begin();
  265.    while (i!=out.end())
  266.      {
  267.       data=((SlotDependent*)(i.node()))->parent();
  268.       ++i;
  269.       Callback& s=(Callback&)(data->callback());
  270.       if (rc.marshal(s.call(p1))) return rc.value();
  271.      }
  272.    return rc.value();
  273.   }
  274.  
  275. #ifdef SIGC_CXX_PARTIAL_SPEC
  276. template <class P1,class Marsh>
  277. class Signal1<void,P1,Marsh>
  278.   :public Signal_
  279.   {
  280.    public:
  281.      typedef Slot1<void,P1> InSlotType;
  282.      typedef Slot1<void,P1> OutSlotType;
  283.    private:
  284.      typedef typename InSlotType::Callback Callback;
  285.      typedef Signal1<void,P1,Marsh> Self;
  286.      typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
  287.  
  288.      static void callback(void* d,P1 p1)
  289.        {
  290.         CallData* data=(CallData*)d;
  291.         data->obj->emit(p1);
  292.        }
  293.  
  294.    public:
  295.      OutSlotType slot()
  296.        {
  297.         SlotData* tmp=in_connect();
  298.         CallData& data=reinterpret_cast<CallData&>(tmp->data_);
  299.         data.callback=callback;
  300.         data.obj=this;
  301.         return tmp;
  302.        }
  303.  
  304.      Connection connect(const InSlotType &s)
  305.        {
  306.         return out_connect(s.data());
  307.        }
  308.  
  309.      void emit(typename Trait<P1>::ref p1);
  310.      void operator()(typename Trait<P1>::ref p1)
  311.        {emit(p1);}
  312.  
  313.      Signal1() {}
  314.      Signal1(const InSlotType &s) {connect(s);}
  315.      ~Signal1() {}
  316.   };
  317.  
  318.  
  319. // emit
  320. template <class P1,class Marsh>
  321. void Signal1<void,P1,Marsh>::
  322.   emit(typename Trait<P1>::ref p1)
  323.   {
  324.    if (!impl||impl->outgoing_.empty()) return;
  325.    List &out=impl->outgoing_;
  326.    SlotData *data;
  327.    List::Iterator i=out.begin();
  328.    while (i!=out.end())
  329.      {
  330.       data=((SlotDependent*)(i.node()))->parent();
  331.       ++i;
  332.       Callback& s=(Callback&)(data->callback());
  333.       s.call(p1);
  334.      }
  335.   }
  336.  
  337. #endif
  338.  
  339.  
  340. /****************************************************************
  341. *****  Signal 2
  342. ****************************************************************/
  343.  
  344. template <class R,class P1,class P2,typename Marsh=class Marshal<R> >
  345.   class Signal2:public Signal_
  346.   {
  347.    public:
  348.      typedef Slot2<R,P1,P2>                       InSlotType;
  349.      typedef Slot2<typename Marsh::OutType,P1,P2> OutSlotType;
  350.  
  351.    private:
  352. #ifdef SIGC_CXX_PARTIAL_SPEC
  353.      typedef typename Marsh::OutType SType;
  354.      typedef R RType;
  355. #else
  356.      typedef Trait<typename Marsh::OutType>::type SType;
  357.      typedef Trait<R>::type RType;
  358. #endif
  359.      typedef typename InSlotType::Callback Callback;
  360.      typedef Signal2<R,P1,P2,Marsh> Self;
  361.      typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
  362.  
  363.      static SType callback(void* d,P1 p1,P2 p2)
  364.        {
  365.         CallData* data=(CallData*)d;
  366.         return data->obj->emit(p1,p2);
  367.        }
  368.  
  369.    public:
  370.      OutSlotType slot()
  371.        {
  372.         SlotData* tmp=in_connect();
  373.         CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  374.         data.callback=(typename OutSlotType::Func)callback;
  375.         data.obj=this;
  376.         return tmp;
  377.        }
  378.  
  379.      Connection connect(const InSlotType &s)
  380.        {
  381.         return out_connect(s.data());
  382.        }
  383.  
  384.      SType emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2);
  385.      SType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2)
  386.        {return emit(p1,p2);}
  387.  
  388.      Signal2() {}
  389.      Signal2(const InSlotType &s) {connect(s);}
  390.      ~Signal2() {}
  391.   };
  392.  
  393.  
  394. // emit
  395. template <class R,class P1,class P2,class Marsh>
  396. typename  Signal2<R,P1,P2,Marsh>::SType Signal2<R,P1,P2,Marsh>::
  397.   emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2)
  398.   {
  399.    if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
  400.    List &out=impl->outgoing_;
  401.    Marsh rc;
  402.    SlotData *data;
  403.    List::Iterator i=out.begin();
  404.    while (i!=out.end())
  405.      {
  406.       data=((SlotDependent*)(i.node()))->parent();
  407.       ++i;
  408.       Callback& s=(Callback&)(data->callback());
  409.       if (rc.marshal(s.call(p1,p2))) return rc.value();
  410.      }
  411.    return rc.value();
  412.   }
  413.  
  414. #ifdef SIGC_CXX_PARTIAL_SPEC
  415. template <class P1,class P2,class Marsh>
  416. class Signal2<void,P1,P2,Marsh>
  417.   :public Signal_
  418.   {
  419.    public:
  420.      typedef Slot2<void,P1,P2> InSlotType;
  421.      typedef Slot2<void,P1,P2> OutSlotType;
  422.    private:
  423.      typedef typename InSlotType::Callback Callback;
  424.      typedef Signal2<void,P1,P2,Marsh> Self;
  425.      typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
  426.  
  427.      static void callback(void* d,P1 p1,P2 p2)
  428.        {
  429.         CallData* data=(CallData*)d;
  430.         data->obj->emit(p1,p2);
  431.        }
  432.  
  433.    public:
  434.      OutSlotType slot()
  435.        {
  436.         SlotData* tmp=in_connect();
  437.         CallData& data=reinterpret_cast<CallData&>(tmp->data_);
  438.         data.callback=callback;
  439.         data.obj=this;
  440.         return tmp;
  441.        }
  442.  
  443.      Connection connect(const InSlotType &s)
  444.        {
  445.         return out_connect(s.data());
  446.        }
  447.  
  448.      void emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2);
  449.      void operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2)
  450.        {emit(p1,p2);}
  451.  
  452.      Signal2() {}
  453.      Signal2(const InSlotType &s) {connect(s);}
  454.      ~Signal2() {}
  455.   };
  456.  
  457.  
  458. // emit
  459. template <class P1,class P2,class Marsh>
  460. void Signal2<void,P1,P2,Marsh>::
  461.   emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2)
  462.   {
  463.    if (!impl||impl->outgoing_.empty()) return;
  464.    List &out=impl->outgoing_;
  465.    SlotData *data;
  466.    List::Iterator i=out.begin();
  467.    while (i!=out.end())
  468.      {
  469.       data=((SlotDependent*)(i.node()))->parent();
  470.       ++i;
  471.       Callback& s=(Callback&)(data->callback());
  472.       s.call(p1,p2);
  473.      }
  474.   }
  475.  
  476. #endif
  477.  
  478.  
  479. /****************************************************************
  480. *****  Signal 3
  481. ****************************************************************/
  482.  
  483. template <class R,class P1,class P2,class P3,typename Marsh=class Marshal<R> >
  484.   class Signal3:public Signal_
  485.   {
  486.    public:
  487.      typedef Slot3<R,P1,P2,P3>                       InSlotType;
  488.      typedef Slot3<typename Marsh::OutType,P1,P2,P3> OutSlotType;
  489.  
  490.    private:
  491. #ifdef SIGC_CXX_PARTIAL_SPEC
  492.      typedef typename Marsh::OutType SType;
  493.      typedef R RType;
  494. #else
  495.      typedef Trait<typename Marsh::OutType>::type SType;
  496.      typedef Trait<R>::type RType;
  497. #endif
  498.      typedef typename InSlotType::Callback Callback;
  499.      typedef Signal3<R,P1,P2,P3,Marsh> Self;
  500.      typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
  501.  
  502.      static SType callback(void* d,P1 p1,P2 p2,P3 p3)
  503.        {
  504.         CallData* data=(CallData*)d;
  505.         return data->obj->emit(p1,p2,p3);
  506.        }
  507.  
  508.    public:
  509.      OutSlotType slot()
  510.        {
  511.         SlotData* tmp=in_connect();
  512.         CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  513.         data.callback=(typename OutSlotType::Func)callback;
  514.         data.obj=this;
  515.         return tmp;
  516.        }
  517.  
  518.      Connection connect(const InSlotType &s)
  519.        {
  520.         return out_connect(s.data());
  521.        }
  522.  
  523.      SType emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3);
  524.      SType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3)
  525.        {return emit(p1,p2,p3);}
  526.  
  527.      Signal3() {}
  528.      Signal3(const InSlotType &s) {connect(s);}
  529.      ~Signal3() {}
  530.   };
  531.  
  532.  
  533. // emit
  534. template <class R,class P1,class P2,class P3,class Marsh>
  535. typename  Signal3<R,P1,P2,P3,Marsh>::SType Signal3<R,P1,P2,P3,Marsh>::
  536.   emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3)
  537.   {
  538.    if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
  539.    List &out=impl->outgoing_;
  540.    Marsh rc;
  541.    SlotData *data;
  542.    List::Iterator i=out.begin();
  543.    while (i!=out.end())
  544.      {
  545.       data=((SlotDependent*)(i.node()))->parent();
  546.       ++i;
  547.       Callback& s=(Callback&)(data->callback());
  548.       if (rc.marshal(s.call(p1,p2,p3))) return rc.value();
  549.      }
  550.    return rc.value();
  551.   }
  552.  
  553. #ifdef SIGC_CXX_PARTIAL_SPEC
  554. template <class P1,class P2,class P3,class Marsh>
  555. class Signal3<void,P1,P2,P3,Marsh>
  556.   :public Signal_
  557.   {
  558.    public:
  559.      typedef Slot3<void,P1,P2,P3> InSlotType;
  560.      typedef Slot3<void,P1,P2,P3> OutSlotType;
  561.    private:
  562.      typedef typename InSlotType::Callback Callback;
  563.      typedef Signal3<void,P1,P2,P3,Marsh> Self;
  564.      typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
  565.  
  566.      static void callback(void* d,P1 p1,P2 p2,P3 p3)
  567.        {
  568.         CallData* data=(CallData*)d;
  569.         data->obj->emit(p1,p2,p3);
  570.        }
  571.  
  572.    public:
  573.      OutSlotType slot()
  574.        {
  575.         SlotData* tmp=in_connect();
  576.         CallData& data=reinterpret_cast<CallData&>(tmp->data_);
  577.         data.callback=callback;
  578.         data.obj=this;
  579.         return tmp;
  580.        }
  581.  
  582.      Connection connect(const InSlotType &s)
  583.        {
  584.         return out_connect(s.data());
  585.        }
  586.  
  587.      void emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3);
  588.      void operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3)
  589.        {emit(p1,p2,p3);}
  590.  
  591.      Signal3() {}
  592.      Signal3(const InSlotType &s) {connect(s);}
  593.      ~Signal3() {}
  594.   };
  595.  
  596.  
  597. // emit
  598. template <class P1,class P2,class P3,class Marsh>
  599. void Signal3<void,P1,P2,P3,Marsh>::
  600.   emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3)
  601.   {
  602.    if (!impl||impl->outgoing_.empty()) return;
  603.    List &out=impl->outgoing_;
  604.    SlotData *data;
  605.    List::Iterator i=out.begin();
  606.    while (i!=out.end())
  607.      {
  608.       data=((SlotDependent*)(i.node()))->parent();
  609.       ++i;
  610.       Callback& s=(Callback&)(data->callback());
  611.       s.call(p1,p2,p3);
  612.      }
  613.   }
  614.  
  615. #endif
  616.  
  617.  
  618. /****************************************************************
  619. *****  Signal 4
  620. ****************************************************************/
  621.  
  622. template <class R,class P1,class P2,class P3,class P4,typename Marsh=class Marshal<R> >
  623.   class Signal4:public Signal_
  624.   {
  625.    public:
  626.      typedef Slot4<R,P1,P2,P3,P4>                       InSlotType;
  627.      typedef Slot4<typename Marsh::OutType,P1,P2,P3,P4> OutSlotType;
  628.  
  629.    private:
  630. #ifdef SIGC_CXX_PARTIAL_SPEC
  631.      typedef typename Marsh::OutType SType;
  632.      typedef R RType;
  633. #else
  634.      typedef Trait<typename Marsh::OutType>::type SType;
  635.      typedef Trait<R>::type RType;
  636. #endif
  637.      typedef typename InSlotType::Callback Callback;
  638.      typedef Signal4<R,P1,P2,P3,P4,Marsh> Self;
  639.      typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
  640.  
  641.      static SType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
  642.        {
  643.         CallData* data=(CallData*)d;
  644.         return data->obj->emit(p1,p2,p3,p4);
  645.        }
  646.  
  647.    public:
  648.      OutSlotType slot()
  649.        {
  650.         SlotData* tmp=in_connect();
  651.         CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  652.         data.callback=(typename OutSlotType::Func)callback;
  653.         data.obj=this;
  654.         return tmp;
  655.        }
  656.  
  657.      Connection connect(const InSlotType &s)
  658.        {
  659.         return out_connect(s.data());
  660.        }
  661.  
  662.      SType emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4);
  663.      SType operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4)
  664.        {return emit(p1,p2,p3,p4);}
  665.  
  666.      Signal4() {}
  667.      Signal4(const InSlotType &s) {connect(s);}
  668.      ~Signal4() {}
  669.   };
  670.  
  671.  
  672. // emit
  673. template <class R,class P1,class P2,class P3,class P4,class Marsh>
  674. typename  Signal4<R,P1,P2,P3,P4,Marsh>::SType Signal4<R,P1,P2,P3,P4,Marsh>::
  675.   emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4)
  676.   {
  677.    if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
  678.    List &out=impl->outgoing_;
  679.    Marsh rc;
  680.    SlotData *data;
  681.    List::Iterator i=out.begin();
  682.    while (i!=out.end())
  683.      {
  684.       data=((SlotDependent*)(i.node()))->parent();
  685.       ++i;
  686.       Callback& s=(Callback&)(data->callback());
  687.       if (rc.marshal(s.call(p1,p2,p3,p4))) return rc.value();
  688.      }
  689.    return rc.value();
  690.   }
  691.  
  692. #ifdef SIGC_CXX_PARTIAL_SPEC
  693. template <class P1,class P2,class P3,class P4,class Marsh>
  694. class Signal4<void,P1,P2,P3,P4,Marsh>
  695.   :public Signal_
  696.   {
  697.    public:
  698.      typedef Slot4<void,P1,P2,P3,P4> InSlotType;
  699.      typedef Slot4<void,P1,P2,P3,P4> OutSlotType;
  700.    private:
  701.      typedef typename InSlotType::Callback Callback;
  702.      typedef Signal4<void,P1,P2,P3,P4,Marsh> Self;
  703.      typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
  704.  
  705.      static void callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
  706.        {
  707.         CallData* data=(CallData*)d;
  708.         data->obj->emit(p1,p2,p3,p4);
  709.        }
  710.  
  711.    public:
  712.      OutSlotType slot()
  713.        {
  714.         SlotData* tmp=in_connect();
  715.         CallData& data=reinterpret_cast<CallData&>(tmp->data_);
  716.         data.callback=callback;
  717.         data.obj=this;
  718.         return tmp;
  719.        }
  720.  
  721.      Connection connect(const InSlotType &s)
  722.        {
  723.         return out_connect(s.data());
  724.        }
  725.  
  726.      void emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4);
  727.      void operator()(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4)
  728.        {emit(p1,p2,p3,p4);}
  729.  
  730.      Signal4() {}
  731.      Signal4(const InSlotType &s) {connect(s);}
  732.      ~Signal4() {}
  733.   };
  734.  
  735.  
  736. // emit
  737. template <class P1,class P2,class P3,class P4,class Marsh>
  738. void Signal4<void,P1,P2,P3,P4,Marsh>::
  739.   emit(typename Trait<P1>::ref p1,typename Trait<P2>::ref p2,typename Trait<P3>::ref p3,typename Trait<P4>::ref p4)
  740.   {
  741.    if (!impl||impl->outgoing_.empty()) return;
  742.    List &out=impl->outgoing_;
  743.    SlotData *data;
  744.    List::Iterator i=out.begin();
  745.    while (i!=out.end())
  746.      {
  747.       data=((SlotDependent*)(i.node()))->parent();
  748.       ++i;
  749.       Callback& s=(Callback&)(data->callback());
  750.       s.call(p1,p2,p3,p4);
  751.      }
  752.   }
  753.  
  754. #endif
  755.  
  756.  
  757. /****************************************************************
  758. *****  Signal 5
  759. ****************************************************************/
  760.  
  761. template <class R,class P1,class P2,class P3,class P4,class P5,typename Marsh=class Marshal<R> >
  762.   class Signal5:public Signal_
  763.   {
  764.    public:
  765.      typedef Slot5<R,P1,P2,P3,P4,P5>                       InSlotType;
  766.      typedef Slot5<typename Marsh::OutType,P1,P2,P3,P4,P5> OutSlotType;
  767.  
  768.    private:
  769. #ifdef SIGC_CXX_PARTIAL_SPEC
  770.      typedef typename Marsh::OutType SType;
  771.      typedef R RType;
  772. #else
  773.      typedef Trait<typename Marsh::OutType>::type SType;
  774.      typedef Trait<R>::type RType;
  775. #endif
  776.      typedef typename InSlotType::Callback Callback;
  777.      typedef Signal5<R,P1,P2,P3,P4,P5,Marsh> Self;
  778.      typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
  779.  
  780.      static SType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
  781.        {
  782.         CallData* data=(CallData*)d;
  783.         return data->obj->emit(p1,p2,p3,p4,p5);
  784.        }
  785.  
  786.    public:
  787.      OutSlotType slot()
  788.        {
  789.         SlotData* tmp=in_connect();
  790.         CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  791.         data.callback=(typename OutSlotType::Func)callback;
  792.         data.obj=this;
  793.         return tmp;
  794.        }
  795.  
  796.      Connection connect(const InSlotType &s)
  797.        {
  798.         return out_connect(s.data());
  799.        }
  800.  
  801.      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);
  802.      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)
  803.        {return emit(p1,p2,p3,p4,p5);}
  804.  
  805.      Signal5() {}
  806.      Signal5(const InSlotType &s) {connect(s);}
  807.      ~Signal5() {}
  808.   };
  809.  
  810.  
  811. // emit
  812. template <class R,class P1,class P2,class P3,class P4,class P5,class Marsh>
  813. typename  Signal5<R,P1,P2,P3,P4,P5,Marsh>::SType Signal5<R,P1,P2,P3,P4,P5,Marsh>::
  814.   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)
  815.   {
  816.    if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
  817.    List &out=impl->outgoing_;
  818.    Marsh rc;
  819.    SlotData *data;
  820.    List::Iterator i=out.begin();
  821.    while (i!=out.end())
  822.      {
  823.       data=((SlotDependent*)(i.node()))->parent();
  824.       ++i;
  825.       Callback& s=(Callback&)(data->callback());
  826.       if (rc.marshal(s.call(p1,p2,p3,p4,p5))) return rc.value();
  827.      }
  828.    return rc.value();
  829.   }
  830.  
  831. #ifdef SIGC_CXX_PARTIAL_SPEC
  832. template <class P1,class P2,class P3,class P4,class P5,class Marsh>
  833. class Signal5<void,P1,P2,P3,P4,P5,Marsh>
  834.   :public Signal_
  835.   {
  836.    public:
  837.      typedef Slot5<void,P1,P2,P3,P4,P5> InSlotType;
  838.      typedef Slot5<void,P1,P2,P3,P4,P5> OutSlotType;
  839.    private:
  840.      typedef typename InSlotType::Callback Callback;
  841.      typedef Signal5<void,P1,P2,P3,P4,P5,Marsh> Self;
  842.      typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
  843.  
  844.      static void callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
  845.        {
  846.         CallData* data=(CallData*)d;
  847.         data->obj->emit(p1,p2,p3,p4,p5);
  848.        }
  849.  
  850.    public:
  851.      OutSlotType slot()
  852.        {
  853.         SlotData* tmp=in_connect();
  854.         CallData& data=reinterpret_cast<CallData&>(tmp->data_);
  855.         data.callback=callback;
  856.         data.obj=this;
  857.         return tmp;
  858.        }
  859.  
  860.      Connection connect(const InSlotType &s)
  861.        {
  862.         return out_connect(s.data());
  863.        }
  864.  
  865.      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);
  866.      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)
  867.        {emit(p1,p2,p3,p4,p5);}
  868.  
  869.      Signal5() {}
  870.      Signal5(const InSlotType &s) {connect(s);}
  871.      ~Signal5() {}
  872.   };
  873.  
  874.  
  875. // emit
  876. template <class P1,class P2,class P3,class P4,class P5,class Marsh>
  877. void Signal5<void,P1,P2,P3,P4,P5,Marsh>::
  878.   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)
  879.   {
  880.    if (!impl||impl->outgoing_.empty()) return;
  881.    List &out=impl->outgoing_;
  882.    SlotData *data;
  883.    List::Iterator i=out.begin();
  884.    while (i!=out.end())
  885.      {
  886.       data=((SlotDependent*)(i.node()))->parent();
  887.       ++i;
  888.       Callback& s=(Callback&)(data->callback());
  889.       s.call(p1,p2,p3,p4,p5);
  890.      }
  891.   }
  892.  
  893. #endif
  894.  
  895.  
  896. /****************************************************************
  897. *****  Signal 6
  898. ****************************************************************/
  899.  
  900. template <class R,class P1,class P2,class P3,class P4,class P5,class P6,typename Marsh=class Marshal<R> >
  901.   class Signal6:public Signal_
  902.   {
  903.    public:
  904.      typedef Slot6<R,P1,P2,P3,P4,P5,P6>                       InSlotType;
  905.      typedef Slot6<typename Marsh::OutType,P1,P2,P3,P4,P5,P6> OutSlotType;
  906.  
  907.    private:
  908. #ifdef SIGC_CXX_PARTIAL_SPEC
  909.      typedef typename Marsh::OutType SType;
  910.      typedef R RType;
  911. #else
  912.      typedef Trait<typename Marsh::OutType>::type SType;
  913.      typedef Trait<R>::type RType;
  914. #endif
  915.      typedef typename InSlotType::Callback Callback;
  916.      typedef Signal6<R,P1,P2,P3,P4,P5,P6,Marsh> Self;
  917.      typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
  918.  
  919.      static SType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
  920.        {
  921.         CallData* data=(CallData*)d;
  922.         return data->obj->emit(p1,p2,p3,p4,p5,p6);
  923.        }
  924.  
  925.    public:
  926.      OutSlotType slot()
  927.        {
  928.         SlotData* tmp=in_connect();
  929.         CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  930.         data.callback=(typename OutSlotType::Func)callback;
  931.         data.obj=this;
  932.         return tmp;
  933.        }
  934.  
  935.      Connection connect(const InSlotType &s)
  936.        {
  937.         return out_connect(s.data());
  938.        }
  939.  
  940.      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);
  941.      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)
  942.        {return emit(p1,p2,p3,p4,p5,p6);}
  943.  
  944.      Signal6() {}
  945.      Signal6(const InSlotType &s) {connect(s);}
  946.      ~Signal6() {}
  947.   };
  948.  
  949.  
  950. // emit
  951. template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class Marsh>
  952. typename  Signal6<R,P1,P2,P3,P4,P5,P6,Marsh>::SType Signal6<R,P1,P2,P3,P4,P5,P6,Marsh>::
  953.   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)
  954.   {
  955.    if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
  956.    List &out=impl->outgoing_;
  957.    Marsh rc;
  958.    SlotData *data;
  959.    List::Iterator i=out.begin();
  960.    while (i!=out.end())
  961.      {
  962.       data=((SlotDependent*)(i.node()))->parent();
  963.       ++i;
  964.       Callback& s=(Callback&)(data->callback());
  965.       if (rc.marshal(s.call(p1,p2,p3,p4,p5,p6))) return rc.value();
  966.      }
  967.    return rc.value();
  968.   }
  969.  
  970. #ifdef SIGC_CXX_PARTIAL_SPEC
  971. template <class P1,class P2,class P3,class P4,class P5,class P6,class Marsh>
  972. class Signal6<void,P1,P2,P3,P4,P5,P6,Marsh>
  973.   :public Signal_
  974.   {
  975.    public:
  976.      typedef Slot6<void,P1,P2,P3,P4,P5,P6> InSlotType;
  977.      typedef Slot6<void,P1,P2,P3,P4,P5,P6> OutSlotType;
  978.    private:
  979.      typedef typename InSlotType::Callback Callback;
  980.      typedef Signal6<void,P1,P2,P3,P4,P5,P6,Marsh> Self;
  981.      typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
  982.  
  983.      static void callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
  984.        {
  985.         CallData* data=(CallData*)d;
  986.         data->obj->emit(p1,p2,p3,p4,p5,p6);
  987.        }
  988.  
  989.    public:
  990.      OutSlotType slot()
  991.        {
  992.         SlotData* tmp=in_connect();
  993.         CallData& data=reinterpret_cast<CallData&>(tmp->data_);
  994.         data.callback=callback;
  995.         data.obj=this;
  996.         return tmp;
  997.        }
  998.  
  999.      Connection connect(const InSlotType &s)
  1000.        {
  1001.         return out_connect(s.data());
  1002.        }
  1003.  
  1004.      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);
  1005.      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)
  1006.        {emit(p1,p2,p3,p4,p5,p6);}
  1007.  
  1008.      Signal6() {}
  1009.      Signal6(const InSlotType &s) {connect(s);}
  1010.      ~Signal6() {}
  1011.   };
  1012.  
  1013.  
  1014. // emit
  1015. template <class P1,class P2,class P3,class P4,class P5,class P6,class Marsh>
  1016. void Signal6<void,P1,P2,P3,P4,P5,P6,Marsh>::
  1017.   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)
  1018.   {
  1019.    if (!impl||impl->outgoing_.empty()) return;
  1020.    List &out=impl->outgoing_;
  1021.    SlotData *data;
  1022.    List::Iterator i=out.begin();
  1023.    while (i!=out.end())
  1024.      {
  1025.       data=((SlotDependent*)(i.node()))->parent();
  1026.       ++i;
  1027.       Callback& s=(Callback&)(data->callback());
  1028.       s.call(p1,p2,p3,p4,p5,p6);
  1029.      }
  1030.   }
  1031.  
  1032. #endif
  1033.  
  1034.  
  1035. /****************************************************************
  1036. *****  Signal 7
  1037. ****************************************************************/
  1038.  
  1039. template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,typename Marsh=class Marshal<R> >
  1040.   class Signal7:public Signal_
  1041.   {
  1042.    public:
  1043.      typedef Slot7<R,P1,P2,P3,P4,P5,P6,P7>                       InSlotType;
  1044.      typedef Slot7<typename Marsh::OutType,P1,P2,P3,P4,P5,P6,P7> OutSlotType;
  1045.  
  1046.    private:
  1047. #ifdef SIGC_CXX_PARTIAL_SPEC
  1048.      typedef typename Marsh::OutType SType;
  1049.      typedef R RType;
  1050. #else
  1051.      typedef Trait<typename Marsh::OutType>::type SType;
  1052.      typedef Trait<R>::type RType;
  1053. #endif
  1054.      typedef typename InSlotType::Callback Callback;
  1055.      typedef Signal7<R,P1,P2,P3,P4,P5,P6,P7,Marsh> Self;
  1056.      typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
  1057.  
  1058.      static SType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
  1059.        {
  1060.         CallData* data=(CallData*)d;
  1061.         return data->obj->emit(p1,p2,p3,p4,p5,p6,p7);
  1062.        }
  1063.  
  1064.    public:
  1065.      OutSlotType slot()
  1066.        {
  1067.         SlotData* tmp=in_connect();
  1068.         CallData &data=reinterpret_cast<CallData&>(tmp->data_);
  1069.         data.callback=(typename OutSlotType::Func)callback;
  1070.         data.obj=this;
  1071.         return tmp;
  1072.        }
  1073.  
  1074.      Connection connect(const InSlotType &s)
  1075.        {
  1076.         return out_connect(s.data());
  1077.        }
  1078.  
  1079.      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);
  1080.      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)
  1081.        {return emit(p1,p2,p3,p4,p5,p6,p7);}
  1082.  
  1083.      Signal7() {}
  1084.      Signal7(const InSlotType &s) {connect(s);}
  1085.      ~Signal7() {}
  1086.   };
  1087.  
  1088.  
  1089. // emit
  1090. template <class R,class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Marsh>
  1091. typename  Signal7<R,P1,P2,P3,P4,P5,P6,P7,Marsh>::SType Signal7<R,P1,P2,P3,P4,P5,P6,P7,Marsh>::
  1092.   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)
  1093.   {
  1094.    if (!impl||impl->outgoing_.empty()) return Marsh::default_value();
  1095.    List &out=impl->outgoing_;
  1096.    Marsh rc;
  1097.    SlotData *data;
  1098.    List::Iterator i=out.begin();
  1099.    while (i!=out.end())
  1100.      {
  1101.       data=((SlotDependent*)(i.node()))->parent();
  1102.       ++i;
  1103.       Callback& s=(Callback&)(data->callback());
  1104.       if (rc.marshal(s.call(p1,p2,p3,p4,p5,p6,p7))) return rc.value();
  1105.      }
  1106.    return rc.value();
  1107.   }
  1108.  
  1109. #ifdef SIGC_CXX_PARTIAL_SPEC
  1110. template <class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Marsh>
  1111. class Signal7<void,P1,P2,P3,P4,P5,P6,P7,Marsh>
  1112.   :public Signal_
  1113.   {
  1114.    public:
  1115.      typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> InSlotType;
  1116.      typedef Slot7<void,P1,P2,P3,P4,P5,P6,P7> OutSlotType;
  1117.    private:
  1118.      typedef typename InSlotType::Callback Callback;
  1119.      typedef Signal7<void,P1,P2,P3,P4,P5,P6,P7,Marsh> Self;
  1120.      typedef CallDataObj2<typename OutSlotType::Func,Self> CallData;
  1121.  
  1122.      static void callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6,P7 p7)
  1123.        {
  1124.         CallData* data=(CallData*)d;
  1125.         data->obj->emit(p1,p2,p3,p4,p5,p6,p7);
  1126.        }
  1127.  
  1128.    public:
  1129.      OutSlotType slot()
  1130.        {
  1131.         SlotData* tmp=in_connect();
  1132.         CallData& data=reinterpret_cast<CallData&>(tmp->data_);
  1133.         data.callback=callback;
  1134.         data.obj=this;
  1135.         return tmp;
  1136.        }
  1137.  
  1138.      Connection connect(const InSlotType &s)
  1139.        {
  1140.         return out_connect(s.data());
  1141.        }
  1142.  
  1143.      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);
  1144.      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)
  1145.        {emit(p1,p2,p3,p4,p5,p6,p7);}
  1146.  
  1147.      Signal7() {}
  1148.      Signal7(const InSlotType &s) {connect(s);}
  1149.      ~Signal7() {}
  1150.   };
  1151.  
  1152.  
  1153. // emit
  1154. template <class P1,class P2,class P3,class P4,class P5,class P6,class P7,class Marsh>
  1155. void Signal7<void,P1,P2,P3,P4,P5,P6,P7,Marsh>::
  1156.   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)
  1157.   {
  1158.    if (!impl||impl->outgoing_.empty()) return;
  1159.    List &out=impl->outgoing_;
  1160.    SlotData *data;
  1161.    List::Iterator i=out.begin();
  1162.    while (i!=out.end())
  1163.      {
  1164.       data=((SlotDependent*)(i.node()))->parent();
  1165.       ++i;
  1166.       Callback& s=(Callback&)(data->callback());
  1167.       s.call(p1,p2,p3,p4,p5,p6,p7);
  1168.      }
  1169.   }
  1170.  
  1171. #endif
  1172.  
  1173.  
  1174.  
  1175. #ifdef SIGC_CXX_NAMESPACES
  1176. } // namespace
  1177. #endif
  1178.  
  1179. #ifdef SIGC_QT
  1180. #define emit
  1181. #endif
  1182.  
  1183.  
  1184. #endif // SIGCXX_BASIC_SIGNAL_H
  1185.  
  1186.