~macslow/unity/backported-remote-add-to-5.0

// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-

/*

* Copyright (C) 2011 Canonical Ltd

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License version 3 as

* published by the Free Software Foundation.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program.  If not, see <http://www.gnu.org/licenses/>.

*

* Authored by: Neil Jagdish Patel <neil.patel@canonical.com>

*/

#ifndef UNITY_GLIB_SIGNAL_H

#define UNITY_GLIB_SIGNAL_H

#include <string>

#include <vector>

#include <boost/noncopyable.hpp>

#include <boost/shared_ptr.hpp>

#include <glib-object.h>

#include <sigc++/sigc++.h>

namespace unity

{

namespace glib

{

using sigc::nil;

class SignalBase

{

public:

  typedef boost::shared_ptr<SignalBase> Ptr;

  SignalBase();

  virtual ~SignalBase();

  void Disconnect();

  GObject* object() const;

  std::string const& name() const;

protected:

  GObject* object_;

  guint32 connection_id_;

  std::string name_;

};

template <typename R, typename G>

class Signal0 : public SignalBase

{

public:

  typedef sigc::slot<R, G> SignalCallback;

  Signal0();

  void Connect(G Object,

               std::string const& signal_name,

               SignalCallback     cb);

private:

  static R Callback(G object, Signal0* self);

private:

  SignalCallback callback_;

};

template <typename R, typename G, typename T>

class Signal1 : public SignalBase

{

public:

  typedef sigc::slot<R, G, T> SignalCallback;

  Signal1();

  void Connect(G Object,

               std::string const& signal_name,

               SignalCallback callback);

private:

  static R Callback(G object, T data1, Signal1* self);

private:

  SignalCallback callback_;

};

template <typename R, typename G, typename T1, typename T2>

class Signal2 : public SignalBase

{

public:

  typedef sigc::slot<R, G, T1, T2> SignalCallback;

  Signal2();

  void Connect(G Object,

               std::string const& signal_name,

               SignalCallback callback);

private:

  static R Callback(G Object,

                    T1 data1,

                    T2 data2,

                    Signal2* self);

private:

  SignalCallback callback_;

};

template <typename R, typename G, typename T1, typename T2, typename T3>

class Signal3 : public SignalBase

{

public:

  typedef sigc::slot<R, G, T1, T2, T3> SignalCallback;

  Signal3();

  void Connect(G Object,

               std::string const& signal_name,

               SignalCallback callback);

private:

  static R Callback(G Object,

                    T1 data1,

                    T2 data2,

                    T3 data3,

                    Signal3* self);

private:

  SignalCallback callback_;

};

template <typename R, typename G, typename T1, typename T2, typename T3, typename T4>

class Signal4 : public SignalBase

{

public:

  typedef sigc::slot<R, G, T1, T2, T3, T4> SignalCallback;

  Signal4();

  void Connect(G Object,

               std::string const& signal_name,

               SignalCallback callback);

private:

  static R Callback(G Object,

                    T1 data1,

                    T2 data2,

                    T3 data3,

                    T4 data4,

                    Signal4* self);

private:

  SignalCallback callback_;

};

template < typename R, typename G, typename T1, typename T2,

         typename T3, typename T4, typename T5 >

class Signal5 : public SignalBase

{

public:

  typedef sigc::slot<R, G, T1, T2, T3, T4, T5> SignalCallback;

  Signal5();

  void Connect(G Object,

               std::string const& signal_name,

               SignalCallback callback);

private:

  static R Callback(G Object,

                    T1 data1,

                    T2 data2,

                    T3 data3,

                    T4 data4,

                    T5 data5,

                    Signal5* self);

private:

  SignalCallback callback_;

};

template < typename R, typename G, typename T1, typename T2,

         typename T3, typename T4, typename T5, typename T6 >

class Signal6 : public SignalBase

{

public:

  typedef sigc::slot<R, G, T1, T2, T3, T4, T5, T6> SignalCallback;

  Signal6();

  void Connect(G Object,

               std::string const& signal_name,

               SignalCallback callback);

private:

  static R Callback(G Object,

                    T1 data1,

                    T2 data2,

                    T3 data3,

                    T4 data4,

                    T5 data5,

                    T6 data6,

                    Signal6* self);

private:

  SignalCallback callback_;

};

template < typename R, typename G,

         typename T1 = nil, typename T2 = nil,

         typename T3 = nil, typename T4 = nil,

         typename T5 = nil, typename T6 = nil >

class Signal : public Signal6<R, G, T1, T2, T3, T4, T5, T6>

{

public:

  typedef sigc::slot<R, G, T1, T2, T3, T4, T5, T6> SignalCallback;

  inline Signal();

  inline Signal(G Object,

                std::string const& signal_name,

                SignalCallback callback);

};

template <typename R, typename G>

class Signal<R, G, nil, nil, nil, nil, nil, nil> : public Signal0<R, G>

{

public:

  typedef sigc::slot<R, G> SignalCallback;

  inline Signal();

  inline Signal(G Object,

                std::string const& signal_name,

                SignalCallback callback);

};

template <typename R, typename G, typename T1>

class Signal<R, G, T1, nil, nil, nil, nil, nil> : public Signal1<R, G, T1>

{

public:

  typedef sigc::slot<R, G, T1> SignalCallback;

  inline Signal();

  inline Signal(G Object,

                std::string const& signal_name,

                SignalCallback callback);

};

template <typename R, typename G, typename T1, typename T2>

class Signal<R, G, T1, T2, nil, nil, nil, nil> : public Signal2<R, G, T1, T2>

{

public:

  typedef sigc::slot<R, G, T1, T2> SignalCallback;

  inline Signal();

  inline Signal(G Object,

                std::string const& signal_name,

                SignalCallback callback);

};

template <typename R, typename G, typename T1, typename T2, typename T3>

class Signal<R, G, T1, T2, T3, nil, nil, nil> : public Signal3<R, G, T1, T2 , T3>

{

public:

  typedef sigc::slot<R, G, T1, T2, T3> SignalCallback;

  inline Signal();

  inline Signal(G Object,

                std::string const& signal_name,

                SignalCallback callback);

};

template <typename R, typename G, typename T1, typename T2, typename T3, typename T4>

class Signal<R, G, T1, T2, T3, T4, nil, nil>

  : public Signal4<R, G, T1, T2 , T3, T4>

{

public:

  typedef sigc::slot<R, G, T1, T2, T3, T4> SignalCallback;

  inline Signal();

  inline Signal(G Object,

                std::string const& signal_name,

                SignalCallback callback);

};

template <typename R, typename G, typename T1, typename T2, typename T3, typename T4, typename T5>

class Signal<R, G, T1, T2, T3, T4, T5, nil>

  : public Signal5<R, G, T1, T2 , T3, T4, T5>

{

public:

  typedef sigc::slot<R, G, T1, T2, T3, T4, T5> SignalCallback;

  inline Signal();

  inline Signal(G Object,

                std::string const& signal_name,

                SignalCallback callback);

};

class SignalManager : public boost::noncopyable

{

public:

  typedef std::vector<SignalBase::Ptr> ConnectionVector;

  SignalManager();

  void Add(SignalBase* signal);

  void Disconnect(void* object, std::string const& signal_name = "");

private:

  ConnectionVector connections_;

};

}

}

#include "GLibSignal-inl.h"

#endif