sigslot.h 中文文档

1
2
3
4
5
6
7
8
9
10
11
12
class Switch
{
public:
    virtual void Clicked() = 0;
};
class Light
{
public:
    void ToggleState();
    void TurnOn();
    void TurnOff();
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class ToggleSwitch : public Switch
{
public:
ToggleSwitch(Light& lp)
{
    m_lp = lp;
}
virtual void Clicked()
{
    m_lp.ToggleState();
}
private:
    Light& m_lp;
};
Light lp1, lp2;
ToggleSwitch tsw1(lp1), tsw2(lp2);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Switch
{
public:
    signal0<> Clicked;
};
class Light : public has_slots<>
{
public:
    void ToggleState();
    void TurnOn();
    void TurnOff();
};
Switch sw1, sw2;
Light lp1, lp2;

1
2
sw1.Clicked.connect(&lp1, &Light::ToggleState);
sw2.Clicked.connect(&lp2, &Light::ToggleState);

1
2
3
4
5
6
7
8
9
10
11
12
Switch sw3, sw4, all_on, all_off;
Light lp3, lp4;
sw3.Clicked.connect(&lp3, &Light::ToggleState);
sw4.Clicked.connect(&lp4, &Light::ToggleState);
all_on.Clicked.connect(&lp1, &Light::TurnOn());
all_on.Clicked.connect(&lp2, &Light::TurnOn());
all_on.Clicked.connect(&lp3, &Light::TurnOn());
all_on.Clicked.connect(&lp4, &Light::TurnOn());
all_off.Clicked.connect(&lp1, &Light::TurnOff());
all_off.Clicked.connect(&lp2, &Light::TurnOff());
all_off.Clicked.connect(&lp3, &Light::TurnOff());
all_off.Clicked.connect(&lp4, &Light::TurnOff());

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Window
{
public:
    enum WindowState { Minimised, Normal, Maximised };
    signal1<WindowState> StateChanged;
    signal2<int, int> MovedTo;
    signal2<int, int> Resized;
};
 
class MyControl : public Control, public has_slots<>
{
public:
    void OnStateChanged(WindowState ws);
    void OnMovedTo(int x, int y);
    void OnResize(int x, int y);
};
 
Window w;
MyControl c;
w.StateChanged.connect(&c, &MyControl::OnStateChanged);
w.MovedTo.connect(&c, &MyControl::OnMovedTo);
w.Resized.connect(&c, &MyControl::OnResize);

1
2
3
4
5
6
7
8
9
signal1<int> Bang;
...
Bang.connect(&someobj, &SomeObj::OnBang);
...
Bang(123); // Calls someobj.OnBang()
...
Bang.disconnect(&someobj);
...
Bang(321); // No longer calls someobj.OnBang()

1
2
3
4
5
6
signal0<> Bang();
Bang.connect(&bomb, &Bomb::Explode);
Bang.connect(&bomb2, &Bomb::Explode);
Bang.connect(&secret_base, &SecretBase::SelfDestruct);
Bang.disconnect_all();
Bang(); // Safely defused!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class MyClass : public has_slots<>
{
public:
    void OnSpeedChange(double mph);
    void OnBrakesApplied(bool brakestate);
};
MyClass car;
signal1<double> Speed;
signal2<bool> Brakes;
Speed.connect(&car, &MyClass::OnSpeedChange);
Brakes.connect(&car, &MyClass::OnBrakesApplied);
Speed(50.0); // This one gets through
Brakes(true); // So does this
car.disconnect_all();
Speed(31.5); // This one doesn’t get through

1
2
3
4
5
6
7
8
9
10
11
class StringEdit : public has_slots<>
{
public:
    signal0<> OnReturnPressed;
    signal0<> OnTabPressed;
    signal1<char> OnKeyPressed;
    signal1<char *> OnTextChanged;
    void SetText(char* text); // Slot
    void ClearText(); // Slot
    ...
};

1
2
3
4
if(OnReturnPressed.is_connected())
{
    OnReturnPressed();
}

1
2
3
4
5
6
// Single-threaded
signal1<int, single_threaded> Sig1;
// Multithreaded Global
signal1<int, multi_threaded_global> Sig2;
// Multithreaded Local
signal1<int, multi_threaded_local> Sig3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class MyMultithreadedClass
: public has_slots<multi_threaded_local>
{
public:
void Entry1() // Slot
{
    lock();
    ...
    unlock();
}
void Entry2() // Slot
{
    lock();
    ...
    unlock();
}
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class MyMultithreadedClass
: public has_slots<multi_threaded_local>
{
public:
void Entry1() // Slot
{
    lock_block<multi_threaded_local> lock(this);
    ...
}
void Entry2()
{
    lock_block<multi_threaded_local> lock(this);
        ...
}
};

1
2
#include <sigslot.h>
using namespace sigslot;