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/bind.h.m4 */
  3.  
  4. #ifndef SIGCXX_BIND_H
  5. #define SIGCXX_BIND_H
  6.  
  7. /*
  8.   SigC::bind
  9.   -------------
  10.   bind() alters a Slot by fixing arguments to certain values.
  11.  
  12.   Argument fixing starts from the last argument.  The slot is
  13.   destroyed in the process and a new one is created, so references
  14.   holding onto the slot will no longer be valid.
  15.  
  16.   Up to two arguments can be bound at a time with the default
  17.   header.
  18.  
  19.   Simple Sample usage:
  20.  
  21.     void f(int,int);
  22.     Slot2<void,int,int> s1=slot(f);
  23.  
  24.     Slot1<void,int>  s2=bind(s1,1);  // s1 is invalid
  25.     s2(2);  // call f with arguments 2,1
  26.  
  27.   Multibinding usage:
  28.  
  29.     void f(int,int);
  30.     Slot2<void,int,int> s1=slot(f);
  31.  
  32.     Slot0<void>  s2=bind(s1,1,2);  // s1 is invalid
  33.     s2();  // call f with arguments 1,2
  34.  
  35.   Type specified usage:
  36.    
  37.     struct A {};
  38.     struct B :public A {};
  39.     B* b;
  40.     Slot0<void, A*> s1;
  41.  
  42.     Slot0<void> s2=bind(s1, b);  // B* converted to A*
  43.      
  44. */
  45.  
  46. #include <sigc++/adaptor.h>
  47. #include <sigc++/scope.h>
  48.  
  49. #ifdef SIGC_CXX_NAMESPACES
  50. namespace SigC
  51. {
  52. #endif
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59.  
  60.  
  61.  
  62.  
  63.  
  64.  
  65. /****************************************************************
  66. ***** Adaptor Bind Slot 0 arguments, 1 hidden arguments
  67. ****************************************************************/
  68. template <class R,
  69.    class C1>
  70. struct AdaptorBindSlot0_1: public AdaptorSlot_
  71.   {
  72. #ifdef SIGC_CXX_PARTIAL_SPEC
  73.    typedef R RType;
  74. #else
  75.    typedef typename Trait<R>::type RType;
  76. #endif
  77.    typedef Slot0<R> SlotType;
  78.    typedef Slot1<R,C1> InSlotType;
  79.  
  80.    struct Node:public AdaptorNode
  81.      {
  82.       C1 c1_;
  83.  
  84.       Node(C1 c1)
  85.         : c1_(c1)
  86.         { }
  87.      };
  88.  
  89.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  90.  
  91.    static RType callback(void* d)
  92.      {
  93.       CallData* data=(CallData*)d;
  94.       Node* node=data->obj;
  95.       return ((typename InSlotType::Callback&)(node->data_))(
  96.                                      node->c1_);
  97.      }
  98.    static SlotData* create(SlotData *s,C1 c1)
  99.      {
  100.       Node *node=new Node(c1);
  101.       copy_callback(s,node);
  102.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  103.       data.callback=&callback;
  104.       data.obj=node;
  105.       return s;
  106.      }
  107.   };
  108.  
  109.  
  110. #ifndef SIGC_CXX_VOID_RETURN
  111. #ifdef SIGC_CXX_PARTIAL_SPEC
  112. template <
  113.    class C1>
  114. struct AdaptorBindSlot0_1
  115.    <void,
  116.     C1> : public AdaptorSlot_
  117.   {
  118.    typedef void RType;
  119.    typedef Slot0<void> SlotType;
  120.    typedef Slot1<void,C1> InSlotType;
  121.  
  122.    struct Node:public AdaptorNode
  123.      {
  124.       C1 c1_;
  125.  
  126.       Node(C1 c1)
  127.         : c1_(c1)
  128.         { }
  129.      };
  130.  
  131.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  132.  
  133.    static RType callback(void* d)
  134.      {
  135.       CallData* data=(CallData*)d;
  136.       Node* node=data->obj;
  137.        ((typename InSlotType::Callback&)(node->data_))(
  138.                                      node->c1_);
  139.      }
  140.    static SlotData* create(SlotData *s,C1 c1)
  141.      {
  142.       Node *node=new Node(c1);
  143.       copy_callback(s,node);
  144.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  145.       data.callback=&callback;
  146.       data.obj=node;
  147.       return s;
  148.      }
  149.   };
  150.  
  151. #endif
  152. #endif
  153.  
  154. template <class A1,
  155.     class R,
  156.     class C1>
  157. inline
  158. Slot0<R>
  159.   bind(const Slot1<R,C1> &s,
  160.        A1 a1)
  161.   {return AdaptorBindSlot0_1<R,
  162.            C1>::create(s.data(),a1);
  163.   }
  164.  
  165.  
  166. /****************************************************************
  167. ***** Adaptor Bind Slot 1 arguments, 1 hidden arguments
  168. ****************************************************************/
  169. template <class R,
  170.    class P1,
  171.    class C1>
  172. struct AdaptorBindSlot1_1: public AdaptorSlot_
  173.   {
  174. #ifdef SIGC_CXX_PARTIAL_SPEC
  175.    typedef R RType;
  176. #else
  177.    typedef typename Trait<R>::type RType;
  178. #endif
  179.    typedef Slot1<R,P1> SlotType;
  180.    typedef Slot2<R,P1,C1> InSlotType;
  181.  
  182.    struct Node:public AdaptorNode
  183.      {
  184.       C1 c1_;
  185.  
  186.       Node(C1 c1)
  187.         : c1_(c1)
  188.         { }
  189.      };
  190.  
  191.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  192.  
  193.    static RType callback(void* d,P1 p1)
  194.      {
  195.       CallData* data=(CallData*)d;
  196.       Node* node=data->obj;
  197.       return ((typename InSlotType::Callback&)(node->data_))(p1,
  198.                                      node->c1_);
  199.      }
  200.    static SlotData* create(SlotData *s,C1 c1)
  201.      {
  202.       Node *node=new Node(c1);
  203.       copy_callback(s,node);
  204.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  205.       data.callback=&callback;
  206.       data.obj=node;
  207.       return s;
  208.      }
  209.   };
  210.  
  211.  
  212. #ifndef SIGC_CXX_VOID_RETURN
  213. #ifdef SIGC_CXX_PARTIAL_SPEC
  214. template <class P1,
  215.    class C1>
  216. struct AdaptorBindSlot1_1
  217.    <void,P1,
  218.     C1> : public AdaptorSlot_
  219.   {
  220.    typedef void RType;
  221.    typedef Slot1<void,P1> SlotType;
  222.    typedef Slot2<void,P1,C1> InSlotType;
  223.  
  224.    struct Node:public AdaptorNode
  225.      {
  226.       C1 c1_;
  227.  
  228.       Node(C1 c1)
  229.         : c1_(c1)
  230.         { }
  231.      };
  232.  
  233.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  234.  
  235.    static RType callback(void* d,P1 p1)
  236.      {
  237.       CallData* data=(CallData*)d;
  238.       Node* node=data->obj;
  239.        ((typename InSlotType::Callback&)(node->data_))(p1,
  240.                                      node->c1_);
  241.      }
  242.    static SlotData* create(SlotData *s,C1 c1)
  243.      {
  244.       Node *node=new Node(c1);
  245.       copy_callback(s,node);
  246.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  247.       data.callback=&callback;
  248.       data.obj=node;
  249.       return s;
  250.      }
  251.   };
  252.  
  253. #endif
  254. #endif
  255.  
  256. template <class A1,
  257.     class R,
  258.     class P1,
  259.     class C1>
  260. inline
  261. Slot1<R,P1>
  262.   bind(const Slot2<R,P1,C1> &s,
  263.        A1 a1)
  264.   {return AdaptorBindSlot1_1<R,
  265.            P1,
  266.            C1>::create(s.data(),a1);
  267.   }
  268.  
  269.  
  270. /****************************************************************
  271. ***** Adaptor Bind Slot 2 arguments, 1 hidden arguments
  272. ****************************************************************/
  273. template <class R,
  274.    class P1,class P2,
  275.    class C1>
  276. struct AdaptorBindSlot2_1: public AdaptorSlot_
  277.   {
  278. #ifdef SIGC_CXX_PARTIAL_SPEC
  279.    typedef R RType;
  280. #else
  281.    typedef typename Trait<R>::type RType;
  282. #endif
  283.    typedef Slot2<R,P1,P2> SlotType;
  284.    typedef Slot3<R,P1,P2,C1> InSlotType;
  285.  
  286.    struct Node:public AdaptorNode
  287.      {
  288.       C1 c1_;
  289.  
  290.       Node(C1 c1)
  291.         : c1_(c1)
  292.         { }
  293.      };
  294.  
  295.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  296.  
  297.    static RType callback(void* d,P1 p1,P2 p2)
  298.      {
  299.       CallData* data=(CallData*)d;
  300.       Node* node=data->obj;
  301.       return ((typename InSlotType::Callback&)(node->data_))(p1,p2,
  302.                                      node->c1_);
  303.      }
  304.    static SlotData* create(SlotData *s,C1 c1)
  305.      {
  306.       Node *node=new Node(c1);
  307.       copy_callback(s,node);
  308.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  309.       data.callback=&callback;
  310.       data.obj=node;
  311.       return s;
  312.      }
  313.   };
  314.  
  315.  
  316. #ifndef SIGC_CXX_VOID_RETURN
  317. #ifdef SIGC_CXX_PARTIAL_SPEC
  318. template <class P1,class P2,
  319.    class C1>
  320. struct AdaptorBindSlot2_1
  321.    <void,P1,P2,
  322.     C1> : public AdaptorSlot_
  323.   {
  324.    typedef void RType;
  325.    typedef Slot2<void,P1,P2> SlotType;
  326.    typedef Slot3<void,P1,P2,C1> InSlotType;
  327.  
  328.    struct Node:public AdaptorNode
  329.      {
  330.       C1 c1_;
  331.  
  332.       Node(C1 c1)
  333.         : c1_(c1)
  334.         { }
  335.      };
  336.  
  337.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  338.  
  339.    static RType callback(void* d,P1 p1,P2 p2)
  340.      {
  341.       CallData* data=(CallData*)d;
  342.       Node* node=data->obj;
  343.        ((typename InSlotType::Callback&)(node->data_))(p1,p2,
  344.                                      node->c1_);
  345.      }
  346.    static SlotData* create(SlotData *s,C1 c1)
  347.      {
  348.       Node *node=new Node(c1);
  349.       copy_callback(s,node);
  350.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  351.       data.callback=&callback;
  352.       data.obj=node;
  353.       return s;
  354.      }
  355.   };
  356.  
  357. #endif
  358. #endif
  359.  
  360. template <class A1,
  361.     class R,
  362.     class P1,class P2,
  363.     class C1>
  364. inline
  365. Slot2<R,P1,P2>
  366.   bind(const Slot3<R,P1,P2,C1> &s,
  367.        A1 a1)
  368.   {return AdaptorBindSlot2_1<R,
  369.            P1,P2,
  370.            C1>::create(s.data(),a1);
  371.   }
  372.  
  373.  
  374. /****************************************************************
  375. ***** Adaptor Bind Slot 3 arguments, 1 hidden arguments
  376. ****************************************************************/
  377. template <class R,
  378.    class P1,class P2,class P3,
  379.    class C1>
  380. struct AdaptorBindSlot3_1: public AdaptorSlot_
  381.   {
  382. #ifdef SIGC_CXX_PARTIAL_SPEC
  383.    typedef R RType;
  384. #else
  385.    typedef typename Trait<R>::type RType;
  386. #endif
  387.    typedef Slot3<R,P1,P2,P3> SlotType;
  388.    typedef Slot4<R,P1,P2,P3,C1> InSlotType;
  389.  
  390.    struct Node:public AdaptorNode
  391.      {
  392.       C1 c1_;
  393.  
  394.       Node(C1 c1)
  395.         : c1_(c1)
  396.         { }
  397.      };
  398.  
  399.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  400.  
  401.    static RType callback(void* d,P1 p1,P2 p2,P3 p3)
  402.      {
  403.       CallData* data=(CallData*)d;
  404.       Node* node=data->obj;
  405.       return ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,
  406.                                      node->c1_);
  407.      }
  408.    static SlotData* create(SlotData *s,C1 c1)
  409.      {
  410.       Node *node=new Node(c1);
  411.       copy_callback(s,node);
  412.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  413.       data.callback=&callback;
  414.       data.obj=node;
  415.       return s;
  416.      }
  417.   };
  418.  
  419.  
  420. #ifndef SIGC_CXX_VOID_RETURN
  421. #ifdef SIGC_CXX_PARTIAL_SPEC
  422. template <class P1,class P2,class P3,
  423.    class C1>
  424. struct AdaptorBindSlot3_1
  425.    <void,P1,P2,P3,
  426.     C1> : public AdaptorSlot_
  427.   {
  428.    typedef void RType;
  429.    typedef Slot3<void,P1,P2,P3> SlotType;
  430.    typedef Slot4<void,P1,P2,P3,C1> InSlotType;
  431.  
  432.    struct Node:public AdaptorNode
  433.      {
  434.       C1 c1_;
  435.  
  436.       Node(C1 c1)
  437.         : c1_(c1)
  438.         { }
  439.      };
  440.  
  441.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  442.  
  443.    static RType callback(void* d,P1 p1,P2 p2,P3 p3)
  444.      {
  445.       CallData* data=(CallData*)d;
  446.       Node* node=data->obj;
  447.        ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,
  448.                                      node->c1_);
  449.      }
  450.    static SlotData* create(SlotData *s,C1 c1)
  451.      {
  452.       Node *node=new Node(c1);
  453.       copy_callback(s,node);
  454.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  455.       data.callback=&callback;
  456.       data.obj=node;
  457.       return s;
  458.      }
  459.   };
  460.  
  461. #endif
  462. #endif
  463.  
  464. template <class A1,
  465.     class R,
  466.     class P1,class P2,class P3,
  467.     class C1>
  468. inline
  469. Slot3<R,P1,P2,P3>
  470.   bind(const Slot4<R,P1,P2,P3,C1> &s,
  471.        A1 a1)
  472.   {return AdaptorBindSlot3_1<R,
  473.            P1,P2,P3,
  474.            C1>::create(s.data(),a1);
  475.   }
  476.  
  477.  
  478. /****************************************************************
  479. ***** Adaptor Bind Slot 4 arguments, 1 hidden arguments
  480. ****************************************************************/
  481. template <class R,
  482.    class P1,class P2,class P3,class P4,
  483.    class C1>
  484. struct AdaptorBindSlot4_1: public AdaptorSlot_
  485.   {
  486. #ifdef SIGC_CXX_PARTIAL_SPEC
  487.    typedef R RType;
  488. #else
  489.    typedef typename Trait<R>::type RType;
  490. #endif
  491.    typedef Slot4<R,P1,P2,P3,P4> SlotType;
  492.    typedef Slot5<R,P1,P2,P3,P4,C1> InSlotType;
  493.  
  494.    struct Node:public AdaptorNode
  495.      {
  496.       C1 c1_;
  497.  
  498.       Node(C1 c1)
  499.         : c1_(c1)
  500.         { }
  501.      };
  502.  
  503.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  504.  
  505.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
  506.      {
  507.       CallData* data=(CallData*)d;
  508.       Node* node=data->obj;
  509.       return ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,
  510.                                      node->c1_);
  511.      }
  512.    static SlotData* create(SlotData *s,C1 c1)
  513.      {
  514.       Node *node=new Node(c1);
  515.       copy_callback(s,node);
  516.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  517.       data.callback=&callback;
  518.       data.obj=node;
  519.       return s;
  520.      }
  521.   };
  522.  
  523.  
  524. #ifndef SIGC_CXX_VOID_RETURN
  525. #ifdef SIGC_CXX_PARTIAL_SPEC
  526. template <class P1,class P2,class P3,class P4,
  527.    class C1>
  528. struct AdaptorBindSlot4_1
  529.    <void,P1,P2,P3,P4,
  530.     C1> : public AdaptorSlot_
  531.   {
  532.    typedef void RType;
  533.    typedef Slot4<void,P1,P2,P3,P4> SlotType;
  534.    typedef Slot5<void,P1,P2,P3,P4,C1> InSlotType;
  535.  
  536.    struct Node:public AdaptorNode
  537.      {
  538.       C1 c1_;
  539.  
  540.       Node(C1 c1)
  541.         : c1_(c1)
  542.         { }
  543.      };
  544.  
  545.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  546.  
  547.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
  548.      {
  549.       CallData* data=(CallData*)d;
  550.       Node* node=data->obj;
  551.        ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,
  552.                                      node->c1_);
  553.      }
  554.    static SlotData* create(SlotData *s,C1 c1)
  555.      {
  556.       Node *node=new Node(c1);
  557.       copy_callback(s,node);
  558.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  559.       data.callback=&callback;
  560.       data.obj=node;
  561.       return s;
  562.      }
  563.   };
  564.  
  565. #endif
  566. #endif
  567.  
  568. template <class A1,
  569.     class R,
  570.     class P1,class P2,class P3,class P4,
  571.     class C1>
  572. inline
  573. Slot4<R,P1,P2,P3,P4>
  574.   bind(const Slot5<R,P1,P2,P3,P4,C1> &s,
  575.        A1 a1)
  576.   {return AdaptorBindSlot4_1<R,
  577.            P1,P2,P3,P4,
  578.            C1>::create(s.data(),a1);
  579.   }
  580.  
  581.  
  582. /****************************************************************
  583. ***** Adaptor Bind Slot 5 arguments, 1 hidden arguments
  584. ****************************************************************/
  585. template <class R,
  586.    class P1,class P2,class P3,class P4,class P5,
  587.    class C1>
  588. struct AdaptorBindSlot5_1: public AdaptorSlot_
  589.   {
  590. #ifdef SIGC_CXX_PARTIAL_SPEC
  591.    typedef R RType;
  592. #else
  593.    typedef typename Trait<R>::type RType;
  594. #endif
  595.    typedef Slot5<R,P1,P2,P3,P4,P5> SlotType;
  596.    typedef Slot6<R,P1,P2,P3,P4,P5,C1> InSlotType;
  597.  
  598.    struct Node:public AdaptorNode
  599.      {
  600.       C1 c1_;
  601.  
  602.       Node(C1 c1)
  603.         : c1_(c1)
  604.         { }
  605.      };
  606.  
  607.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  608.  
  609.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
  610.      {
  611.       CallData* data=(CallData*)d;
  612.       Node* node=data->obj;
  613.       return ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,
  614.                                      node->c1_);
  615.      }
  616.    static SlotData* create(SlotData *s,C1 c1)
  617.      {
  618.       Node *node=new Node(c1);
  619.       copy_callback(s,node);
  620.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  621.       data.callback=&callback;
  622.       data.obj=node;
  623.       return s;
  624.      }
  625.   };
  626.  
  627.  
  628. #ifndef SIGC_CXX_VOID_RETURN
  629. #ifdef SIGC_CXX_PARTIAL_SPEC
  630. template <class P1,class P2,class P3,class P4,class P5,
  631.    class C1>
  632. struct AdaptorBindSlot5_1
  633.    <void,P1,P2,P3,P4,P5,
  634.     C1> : public AdaptorSlot_
  635.   {
  636.    typedef void RType;
  637.    typedef Slot5<void,P1,P2,P3,P4,P5> SlotType;
  638.    typedef Slot6<void,P1,P2,P3,P4,P5,C1> InSlotType;
  639.  
  640.    struct Node:public AdaptorNode
  641.      {
  642.       C1 c1_;
  643.  
  644.       Node(C1 c1)
  645.         : c1_(c1)
  646.         { }
  647.      };
  648.  
  649.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  650.  
  651.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
  652.      {
  653.       CallData* data=(CallData*)d;
  654.       Node* node=data->obj;
  655.        ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,
  656.                                      node->c1_);
  657.      }
  658.    static SlotData* create(SlotData *s,C1 c1)
  659.      {
  660.       Node *node=new Node(c1);
  661.       copy_callback(s,node);
  662.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  663.       data.callback=&callback;
  664.       data.obj=node;
  665.       return s;
  666.      }
  667.   };
  668.  
  669. #endif
  670. #endif
  671.  
  672. template <class A1,
  673.     class R,
  674.     class P1,class P2,class P3,class P4,class P5,
  675.     class C1>
  676. inline
  677. Slot5<R,P1,P2,P3,P4,P5>
  678.   bind(const Slot6<R,P1,P2,P3,P4,P5,C1> &s,
  679.        A1 a1)
  680.   {return AdaptorBindSlot5_1<R,
  681.            P1,P2,P3,P4,P5,
  682.            C1>::create(s.data(),a1);
  683.   }
  684.  
  685.  
  686. /****************************************************************
  687. ***** Adaptor Bind Slot 6 arguments, 1 hidden arguments
  688. ****************************************************************/
  689. template <class R,
  690.    class P1,class P2,class P3,class P4,class P5,class P6,
  691.    class C1>
  692. struct AdaptorBindSlot6_1: public AdaptorSlot_
  693.   {
  694. #ifdef SIGC_CXX_PARTIAL_SPEC
  695.    typedef R RType;
  696. #else
  697.    typedef typename Trait<R>::type RType;
  698. #endif
  699.    typedef Slot6<R,P1,P2,P3,P4,P5,P6> SlotType;
  700.    typedef Slot7<R,P1,P2,P3,P4,P5,P6,C1> InSlotType;
  701.  
  702.    struct Node:public AdaptorNode
  703.      {
  704.       C1 c1_;
  705.  
  706.       Node(C1 c1)
  707.         : c1_(c1)
  708.         { }
  709.      };
  710.  
  711.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  712.  
  713.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
  714.      {
  715.       CallData* data=(CallData*)d;
  716.       Node* node=data->obj;
  717.       return ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6,
  718.                                      node->c1_);
  719.      }
  720.    static SlotData* create(SlotData *s,C1 c1)
  721.      {
  722.       Node *node=new Node(c1);
  723.       copy_callback(s,node);
  724.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  725.       data.callback=&callback;
  726.       data.obj=node;
  727.       return s;
  728.      }
  729.   };
  730.  
  731.  
  732. #ifndef SIGC_CXX_VOID_RETURN
  733. #ifdef SIGC_CXX_PARTIAL_SPEC
  734. template <class P1,class P2,class P3,class P4,class P5,class P6,
  735.    class C1>
  736. struct AdaptorBindSlot6_1
  737.    <void,P1,P2,P3,P4,P5,P6,
  738.     C1> : public AdaptorSlot_
  739.   {
  740.    typedef void RType;
  741.    typedef Slot6<void,P1,P2,P3,P4,P5,P6> SlotType;
  742.    typedef Slot7<void,P1,P2,P3,P4,P5,P6,C1> InSlotType;
  743.  
  744.    struct Node:public AdaptorNode
  745.      {
  746.       C1 c1_;
  747.  
  748.       Node(C1 c1)
  749.         : c1_(c1)
  750.         { }
  751.      };
  752.  
  753.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  754.  
  755.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5,P6 p6)
  756.      {
  757.       CallData* data=(CallData*)d;
  758.       Node* node=data->obj;
  759.        ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,p6,
  760.                                      node->c1_);
  761.      }
  762.    static SlotData* create(SlotData *s,C1 c1)
  763.      {
  764.       Node *node=new Node(c1);
  765.       copy_callback(s,node);
  766.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  767.       data.callback=&callback;
  768.       data.obj=node;
  769.       return s;
  770.      }
  771.   };
  772.  
  773. #endif
  774. #endif
  775.  
  776. template <class A1,
  777.     class R,
  778.     class P1,class P2,class P3,class P4,class P5,class P6,
  779.     class C1>
  780. inline
  781. Slot6<R,P1,P2,P3,P4,P5,P6>
  782.   bind(const Slot7<R,P1,P2,P3,P4,P5,P6,C1> &s,
  783.        A1 a1)
  784.   {return AdaptorBindSlot6_1<R,
  785.            P1,P2,P3,P4,P5,P6,
  786.            C1>::create(s.data(),a1);
  787.   }
  788.  
  789.  
  790.  
  791. /****************************************************************
  792. ***** Adaptor Bind Slot 0 arguments, 2 hidden arguments
  793. ****************************************************************/
  794. template <class R,
  795.    class C1,class C2>
  796. struct AdaptorBindSlot0_2: public AdaptorSlot_
  797.   {
  798. #ifdef SIGC_CXX_PARTIAL_SPEC
  799.    typedef R RType;
  800. #else
  801.    typedef typename Trait<R>::type RType;
  802. #endif
  803.    typedef Slot0<R> SlotType;
  804.    typedef Slot2<R,C1,C2> InSlotType;
  805.  
  806.    struct Node:public AdaptorNode
  807.      {
  808.       C1 c1_;
  809.       C2 c2_;
  810.  
  811.       Node(C1 c1,C2 c2)
  812.         : c1_(c1),c2_(c2)
  813.         { }
  814.      };
  815.  
  816.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  817.  
  818.    static RType callback(void* d)
  819.      {
  820.       CallData* data=(CallData*)d;
  821.       Node* node=data->obj;
  822.       return ((typename InSlotType::Callback&)(node->data_))(
  823.                                      node->c1_,node->c2_);
  824.      }
  825.    static SlotData* create(SlotData *s,C1 c1,C2 c2)
  826.      {
  827.       Node *node=new Node(c1,c2);
  828.       copy_callback(s,node);
  829.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  830.       data.callback=&callback;
  831.       data.obj=node;
  832.       return s;
  833.      }
  834.   };
  835.  
  836.  
  837. #ifndef SIGC_CXX_VOID_RETURN
  838. #ifdef SIGC_CXX_PARTIAL_SPEC
  839. template <
  840.    class C1,class C2>
  841. struct AdaptorBindSlot0_2
  842.    <void,
  843.     C1,C2> : public AdaptorSlot_
  844.   {
  845.    typedef void RType;
  846.    typedef Slot0<void> SlotType;
  847.    typedef Slot2<void,C1,C2> InSlotType;
  848.  
  849.    struct Node:public AdaptorNode
  850.      {
  851.       C1 c1_;
  852.       C2 c2_;
  853.  
  854.       Node(C1 c1,C2 c2)
  855.         : c1_(c1),c2_(c2)
  856.         { }
  857.      };
  858.  
  859.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  860.  
  861.    static RType callback(void* d)
  862.      {
  863.       CallData* data=(CallData*)d;
  864.       Node* node=data->obj;
  865.        ((typename InSlotType::Callback&)(node->data_))(
  866.                                      node->c1_,node->c2_);
  867.      }
  868.    static SlotData* create(SlotData *s,C1 c1,C2 c2)
  869.      {
  870.       Node *node=new Node(c1,c2);
  871.       copy_callback(s,node);
  872.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  873.       data.callback=&callback;
  874.       data.obj=node;
  875.       return s;
  876.      }
  877.   };
  878.  
  879. #endif
  880. #endif
  881.  
  882. template <class A1,class A2,
  883.     class R,
  884.     class C1,class C2>
  885. inline
  886. Slot0<R>
  887.   bind(const Slot2<R,C1,C2> &s,
  888.        A1 a1,A2 a2)
  889.   {return AdaptorBindSlot0_2<R,
  890.            C1,C2>::create(s.data(),a1,a2);
  891.   }
  892.  
  893.  
  894. /****************************************************************
  895. ***** Adaptor Bind Slot 1 arguments, 2 hidden arguments
  896. ****************************************************************/
  897. template <class R,
  898.    class P1,
  899.    class C1,class C2>
  900. struct AdaptorBindSlot1_2: public AdaptorSlot_
  901.   {
  902. #ifdef SIGC_CXX_PARTIAL_SPEC
  903.    typedef R RType;
  904. #else
  905.    typedef typename Trait<R>::type RType;
  906. #endif
  907.    typedef Slot1<R,P1> SlotType;
  908.    typedef Slot3<R,P1,C1,C2> InSlotType;
  909.  
  910.    struct Node:public AdaptorNode
  911.      {
  912.       C1 c1_;
  913.       C2 c2_;
  914.  
  915.       Node(C1 c1,C2 c2)
  916.         : c1_(c1),c2_(c2)
  917.         { }
  918.      };
  919.  
  920.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  921.  
  922.    static RType callback(void* d,P1 p1)
  923.      {
  924.       CallData* data=(CallData*)d;
  925.       Node* node=data->obj;
  926.       return ((typename InSlotType::Callback&)(node->data_))(p1,
  927.                                      node->c1_,node->c2_);
  928.      }
  929.    static SlotData* create(SlotData *s,C1 c1,C2 c2)
  930.      {
  931.       Node *node=new Node(c1,c2);
  932.       copy_callback(s,node);
  933.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  934.       data.callback=&callback;
  935.       data.obj=node;
  936.       return s;
  937.      }
  938.   };
  939.  
  940.  
  941. #ifndef SIGC_CXX_VOID_RETURN
  942. #ifdef SIGC_CXX_PARTIAL_SPEC
  943. template <class P1,
  944.    class C1,class C2>
  945. struct AdaptorBindSlot1_2
  946.    <void,P1,
  947.     C1,C2> : public AdaptorSlot_
  948.   {
  949.    typedef void RType;
  950.    typedef Slot1<void,P1> SlotType;
  951.    typedef Slot3<void,P1,C1,C2> InSlotType;
  952.  
  953.    struct Node:public AdaptorNode
  954.      {
  955.       C1 c1_;
  956.       C2 c2_;
  957.  
  958.       Node(C1 c1,C2 c2)
  959.         : c1_(c1),c2_(c2)
  960.         { }
  961.      };
  962.  
  963.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  964.  
  965.    static RType callback(void* d,P1 p1)
  966.      {
  967.       CallData* data=(CallData*)d;
  968.       Node* node=data->obj;
  969.        ((typename InSlotType::Callback&)(node->data_))(p1,
  970.                                      node->c1_,node->c2_);
  971.      }
  972.    static SlotData* create(SlotData *s,C1 c1,C2 c2)
  973.      {
  974.       Node *node=new Node(c1,c2);
  975.       copy_callback(s,node);
  976.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  977.       data.callback=&callback;
  978.       data.obj=node;
  979.       return s;
  980.      }
  981.   };
  982.  
  983. #endif
  984. #endif
  985.  
  986. template <class A1,class A2,
  987.     class R,
  988.     class P1,
  989.     class C1,class C2>
  990. inline
  991. Slot1<R,P1>
  992.   bind(const Slot3<R,P1,C1,C2> &s,
  993.        A1 a1,A2 a2)
  994.   {return AdaptorBindSlot1_2<R,
  995.            P1,
  996.            C1,C2>::create(s.data(),a1,a2);
  997.   }
  998.  
  999.  
  1000. /****************************************************************
  1001. ***** Adaptor Bind Slot 2 arguments, 2 hidden arguments
  1002. ****************************************************************/
  1003. template <class R,
  1004.    class P1,class P2,
  1005.    class C1,class C2>
  1006. struct AdaptorBindSlot2_2: public AdaptorSlot_
  1007.   {
  1008. #ifdef SIGC_CXX_PARTIAL_SPEC
  1009.    typedef R RType;
  1010. #else
  1011.    typedef typename Trait<R>::type RType;
  1012. #endif
  1013.    typedef Slot2<R,P1,P2> SlotType;
  1014.    typedef Slot4<R,P1,P2,C1,C2> InSlotType;
  1015.  
  1016.    struct Node:public AdaptorNode
  1017.      {
  1018.       C1 c1_;
  1019.       C2 c2_;
  1020.  
  1021.       Node(C1 c1,C2 c2)
  1022.         : c1_(c1),c2_(c2)
  1023.         { }
  1024.      };
  1025.  
  1026.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  1027.  
  1028.    static RType callback(void* d,P1 p1,P2 p2)
  1029.      {
  1030.       CallData* data=(CallData*)d;
  1031.       Node* node=data->obj;
  1032.       return ((typename InSlotType::Callback&)(node->data_))(p1,p2,
  1033.                                      node->c1_,node->c2_);
  1034.      }
  1035.    static SlotData* create(SlotData *s,C1 c1,C2 c2)
  1036.      {
  1037.       Node *node=new Node(c1,c2);
  1038.       copy_callback(s,node);
  1039.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  1040.       data.callback=&callback;
  1041.       data.obj=node;
  1042.       return s;
  1043.      }
  1044.   };
  1045.  
  1046.  
  1047. #ifndef SIGC_CXX_VOID_RETURN
  1048. #ifdef SIGC_CXX_PARTIAL_SPEC
  1049. template <class P1,class P2,
  1050.    class C1,class C2>
  1051. struct AdaptorBindSlot2_2
  1052.    <void,P1,P2,
  1053.     C1,C2> : public AdaptorSlot_
  1054.   {
  1055.    typedef void RType;
  1056.    typedef Slot2<void,P1,P2> SlotType;
  1057.    typedef Slot4<void,P1,P2,C1,C2> InSlotType;
  1058.  
  1059.    struct Node:public AdaptorNode
  1060.      {
  1061.       C1 c1_;
  1062.       C2 c2_;
  1063.  
  1064.       Node(C1 c1,C2 c2)
  1065.         : c1_(c1),c2_(c2)
  1066.         { }
  1067.      };
  1068.  
  1069.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  1070.  
  1071.    static RType callback(void* d,P1 p1,P2 p2)
  1072.      {
  1073.       CallData* data=(CallData*)d;
  1074.       Node* node=data->obj;
  1075.        ((typename InSlotType::Callback&)(node->data_))(p1,p2,
  1076.                                      node->c1_,node->c2_);
  1077.      }
  1078.    static SlotData* create(SlotData *s,C1 c1,C2 c2)
  1079.      {
  1080.       Node *node=new Node(c1,c2);
  1081.       copy_callback(s,node);
  1082.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  1083.       data.callback=&callback;
  1084.       data.obj=node;
  1085.       return s;
  1086.      }
  1087.   };
  1088.  
  1089. #endif
  1090. #endif
  1091.  
  1092. template <class A1,class A2,
  1093.     class R,
  1094.     class P1,class P2,
  1095.     class C1,class C2>
  1096. inline
  1097. Slot2<R,P1,P2>
  1098.   bind(const Slot4<R,P1,P2,C1,C2> &s,
  1099.        A1 a1,A2 a2)
  1100.   {return AdaptorBindSlot2_2<R,
  1101.            P1,P2,
  1102.            C1,C2>::create(s.data(),a1,a2);
  1103.   }
  1104.  
  1105.  
  1106. /****************************************************************
  1107. ***** Adaptor Bind Slot 3 arguments, 2 hidden arguments
  1108. ****************************************************************/
  1109. template <class R,
  1110.    class P1,class P2,class P3,
  1111.    class C1,class C2>
  1112. struct AdaptorBindSlot3_2: public AdaptorSlot_
  1113.   {
  1114. #ifdef SIGC_CXX_PARTIAL_SPEC
  1115.    typedef R RType;
  1116. #else
  1117.    typedef typename Trait<R>::type RType;
  1118. #endif
  1119.    typedef Slot3<R,P1,P2,P3> SlotType;
  1120.    typedef Slot5<R,P1,P2,P3,C1,C2> InSlotType;
  1121.  
  1122.    struct Node:public AdaptorNode
  1123.      {
  1124.       C1 c1_;
  1125.       C2 c2_;
  1126.  
  1127.       Node(C1 c1,C2 c2)
  1128.         : c1_(c1),c2_(c2)
  1129.         { }
  1130.      };
  1131.  
  1132.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  1133.  
  1134.    static RType callback(void* d,P1 p1,P2 p2,P3 p3)
  1135.      {
  1136.       CallData* data=(CallData*)d;
  1137.       Node* node=data->obj;
  1138.       return ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,
  1139.                                      node->c1_,node->c2_);
  1140.      }
  1141.    static SlotData* create(SlotData *s,C1 c1,C2 c2)
  1142.      {
  1143.       Node *node=new Node(c1,c2);
  1144.       copy_callback(s,node);
  1145.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  1146.       data.callback=&callback;
  1147.       data.obj=node;
  1148.       return s;
  1149.      }
  1150.   };
  1151.  
  1152.  
  1153. #ifndef SIGC_CXX_VOID_RETURN
  1154. #ifdef SIGC_CXX_PARTIAL_SPEC
  1155. template <class P1,class P2,class P3,
  1156.    class C1,class C2>
  1157. struct AdaptorBindSlot3_2
  1158.    <void,P1,P2,P3,
  1159.     C1,C2> : public AdaptorSlot_
  1160.   {
  1161.    typedef void RType;
  1162.    typedef Slot3<void,P1,P2,P3> SlotType;
  1163.    typedef Slot5<void,P1,P2,P3,C1,C2> InSlotType;
  1164.  
  1165.    struct Node:public AdaptorNode
  1166.      {
  1167.       C1 c1_;
  1168.       C2 c2_;
  1169.  
  1170.       Node(C1 c1,C2 c2)
  1171.         : c1_(c1),c2_(c2)
  1172.         { }
  1173.      };
  1174.  
  1175.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  1176.  
  1177.    static RType callback(void* d,P1 p1,P2 p2,P3 p3)
  1178.      {
  1179.       CallData* data=(CallData*)d;
  1180.       Node* node=data->obj;
  1181.        ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,
  1182.                                      node->c1_,node->c2_);
  1183.      }
  1184.    static SlotData* create(SlotData *s,C1 c1,C2 c2)
  1185.      {
  1186.       Node *node=new Node(c1,c2);
  1187.       copy_callback(s,node);
  1188.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  1189.       data.callback=&callback;
  1190.       data.obj=node;
  1191.       return s;
  1192.      }
  1193.   };
  1194.  
  1195. #endif
  1196. #endif
  1197.  
  1198. template <class A1,class A2,
  1199.     class R,
  1200.     class P1,class P2,class P3,
  1201.     class C1,class C2>
  1202. inline
  1203. Slot3<R,P1,P2,P3>
  1204.   bind(const Slot5<R,P1,P2,P3,C1,C2> &s,
  1205.        A1 a1,A2 a2)
  1206.   {return AdaptorBindSlot3_2<R,
  1207.            P1,P2,P3,
  1208.            C1,C2>::create(s.data(),a1,a2);
  1209.   }
  1210.  
  1211.  
  1212. /****************************************************************
  1213. ***** Adaptor Bind Slot 4 arguments, 2 hidden arguments
  1214. ****************************************************************/
  1215. template <class R,
  1216.    class P1,class P2,class P3,class P4,
  1217.    class C1,class C2>
  1218. struct AdaptorBindSlot4_2: public AdaptorSlot_
  1219.   {
  1220. #ifdef SIGC_CXX_PARTIAL_SPEC
  1221.    typedef R RType;
  1222. #else
  1223.    typedef typename Trait<R>::type RType;
  1224. #endif
  1225.    typedef Slot4<R,P1,P2,P3,P4> SlotType;
  1226.    typedef Slot6<R,P1,P2,P3,P4,C1,C2> InSlotType;
  1227.  
  1228.    struct Node:public AdaptorNode
  1229.      {
  1230.       C1 c1_;
  1231.       C2 c2_;
  1232.  
  1233.       Node(C1 c1,C2 c2)
  1234.         : c1_(c1),c2_(c2)
  1235.         { }
  1236.      };
  1237.  
  1238.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  1239.  
  1240.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
  1241.      {
  1242.       CallData* data=(CallData*)d;
  1243.       Node* node=data->obj;
  1244.       return ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,
  1245.                                      node->c1_,node->c2_);
  1246.      }
  1247.    static SlotData* create(SlotData *s,C1 c1,C2 c2)
  1248.      {
  1249.       Node *node=new Node(c1,c2);
  1250.       copy_callback(s,node);
  1251.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  1252.       data.callback=&callback;
  1253.       data.obj=node;
  1254.       return s;
  1255.      }
  1256.   };
  1257.  
  1258.  
  1259. #ifndef SIGC_CXX_VOID_RETURN
  1260. #ifdef SIGC_CXX_PARTIAL_SPEC
  1261. template <class P1,class P2,class P3,class P4,
  1262.    class C1,class C2>
  1263. struct AdaptorBindSlot4_2
  1264.    <void,P1,P2,P3,P4,
  1265.     C1,C2> : public AdaptorSlot_
  1266.   {
  1267.    typedef void RType;
  1268.    typedef Slot4<void,P1,P2,P3,P4> SlotType;
  1269.    typedef Slot6<void,P1,P2,P3,P4,C1,C2> InSlotType;
  1270.  
  1271.    struct Node:public AdaptorNode
  1272.      {
  1273.       C1 c1_;
  1274.       C2 c2_;
  1275.  
  1276.       Node(C1 c1,C2 c2)
  1277.         : c1_(c1),c2_(c2)
  1278.         { }
  1279.      };
  1280.  
  1281.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  1282.  
  1283.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4)
  1284.      {
  1285.       CallData* data=(CallData*)d;
  1286.       Node* node=data->obj;
  1287.        ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,
  1288.                                      node->c1_,node->c2_);
  1289.      }
  1290.    static SlotData* create(SlotData *s,C1 c1,C2 c2)
  1291.      {
  1292.       Node *node=new Node(c1,c2);
  1293.       copy_callback(s,node);
  1294.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  1295.       data.callback=&callback;
  1296.       data.obj=node;
  1297.       return s;
  1298.      }
  1299.   };
  1300.  
  1301. #endif
  1302. #endif
  1303.  
  1304. template <class A1,class A2,
  1305.     class R,
  1306.     class P1,class P2,class P3,class P4,
  1307.     class C1,class C2>
  1308. inline
  1309. Slot4<R,P1,P2,P3,P4>
  1310.   bind(const Slot6<R,P1,P2,P3,P4,C1,C2> &s,
  1311.        A1 a1,A2 a2)
  1312.   {return AdaptorBindSlot4_2<R,
  1313.            P1,P2,P3,P4,
  1314.            C1,C2>::create(s.data(),a1,a2);
  1315.   }
  1316.  
  1317.  
  1318. /****************************************************************
  1319. ***** Adaptor Bind Slot 5 arguments, 2 hidden arguments
  1320. ****************************************************************/
  1321. template <class R,
  1322.    class P1,class P2,class P3,class P4,class P5,
  1323.    class C1,class C2>
  1324. struct AdaptorBindSlot5_2: public AdaptorSlot_
  1325.   {
  1326. #ifdef SIGC_CXX_PARTIAL_SPEC
  1327.    typedef R RType;
  1328. #else
  1329.    typedef typename Trait<R>::type RType;
  1330. #endif
  1331.    typedef Slot5<R,P1,P2,P3,P4,P5> SlotType;
  1332.    typedef Slot7<R,P1,P2,P3,P4,P5,C1,C2> InSlotType;
  1333.  
  1334.    struct Node:public AdaptorNode
  1335.      {
  1336.       C1 c1_;
  1337.       C2 c2_;
  1338.  
  1339.       Node(C1 c1,C2 c2)
  1340.         : c1_(c1),c2_(c2)
  1341.         { }
  1342.      };
  1343.  
  1344.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  1345.  
  1346.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
  1347.      {
  1348.       CallData* data=(CallData*)d;
  1349.       Node* node=data->obj;
  1350.       return ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,
  1351.                                      node->c1_,node->c2_);
  1352.      }
  1353.    static SlotData* create(SlotData *s,C1 c1,C2 c2)
  1354.      {
  1355.       Node *node=new Node(c1,c2);
  1356.       copy_callback(s,node);
  1357.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  1358.       data.callback=&callback;
  1359.       data.obj=node;
  1360.       return s;
  1361.      }
  1362.   };
  1363.  
  1364.  
  1365. #ifndef SIGC_CXX_VOID_RETURN
  1366. #ifdef SIGC_CXX_PARTIAL_SPEC
  1367. template <class P1,class P2,class P3,class P4,class P5,
  1368.    class C1,class C2>
  1369. struct AdaptorBindSlot5_2
  1370.    <void,P1,P2,P3,P4,P5,
  1371.     C1,C2> : public AdaptorSlot_
  1372.   {
  1373.    typedef void RType;
  1374.    typedef Slot5<void,P1,P2,P3,P4,P5> SlotType;
  1375.    typedef Slot7<void,P1,P2,P3,P4,P5,C1,C2> InSlotType;
  1376.  
  1377.    struct Node:public AdaptorNode
  1378.      {
  1379.       C1 c1_;
  1380.       C2 c2_;
  1381.  
  1382.       Node(C1 c1,C2 c2)
  1383.         : c1_(c1),c2_(c2)
  1384.         { }
  1385.      };
  1386.  
  1387.    typedef CallDataObj2<typename SlotType::Func,Node> CallData;
  1388.  
  1389.    static RType callback(void* d,P1 p1,P2 p2,P3 p3,P4 p4,P5 p5)
  1390.      {
  1391.       CallData* data=(CallData*)d;
  1392.       Node* node=data->obj;
  1393.        ((typename InSlotType::Callback&)(node->data_))(p1,p2,p3,p4,p5,
  1394.                                      node->c1_,node->c2_);
  1395.      }
  1396.    static SlotData* create(SlotData *s,C1 c1,C2 c2)
  1397.      {
  1398.       Node *node=new Node(c1,c2);
  1399.       copy_callback(s,node);
  1400.       CallData &data=reinterpret_cast<CallData&>(s->data_);
  1401.       data.callback=&callback;
  1402.       data.obj=node;
  1403.       return s;
  1404.      }
  1405.   };
  1406.  
  1407. #endif
  1408. #endif
  1409.  
  1410. template <class A1,class A2,
  1411.     class R,
  1412.     class P1,class P2,class P3,class P4,class P5,
  1413.     class C1,class C2>
  1414. inline
  1415. Slot5<R,P1,P2,P3,P4,P5>
  1416.   bind(const Slot7<R,P1,P2,P3,P4,P5,C1,C2> &s,
  1417.        A1 a1,A2 a2)
  1418.   {return AdaptorBindSlot5_2<R,
  1419.            P1,P2,P3,P4,P5,
  1420.            C1,C2>::create(s.data(),a1,a2);
  1421.   }
  1422.  
  1423.  
  1424.  
  1425. #ifdef SIGC_CXX_NAMESPACES
  1426. } // namespace
  1427. #endif
  1428.  
  1429. #endif
  1430.