Unigine::Viewport Class
Header: | #include <UnigineViewport.h> |
The Viewport class is used to render a scene with the specified settings.
The main use cases of the Viewport class are as follows:
-
Integrate the engine to a 3rd party renderer (or vice versa) and render the image anywhere (via the render() method): to the external library, CustomSystemProxy interface, RenderTarget interface (a frame buffers abstraction), etc.
-
To render the image to the RenderTarget interface, do the following:
// mono rendering ViewportPtr viewport; TexturePtr texture; CameraPtr camera; int AppWorldLogic::init() { viewport = Viewport::create(); texture = Texture::create(); // create 512 x 512 render target texture->create2D(512, 512, Texture::FORMAT_RGBA8, Texture::FORMAT_USAGE_RENDER); camera = Camera::create(); return 1; } int AppWorldLogic::update() { // set modelview & projection matrices to camera instance // ... // rendering RenderTargetPtr render_target = Render::getTemporaryRenderTarget(); render_target->bindColorTexture(0, texture); render_target->enable(); { viewport->render(camera); } render_target->disable(); render_target->unbindAll(); Render::releaseTemporaryRenderTarget(render_target); return 1; }
To render the image to the RenderTarget interface in the stereo mode, do the following:
// stereo rendering ViewportPtr viewport; TexturePtr left_texture; TexturePtr right_texture; CameraPtr left_eye; CameraPtr right_eye; int AppWorldLogic::init() { viewport = Viewport::create(); left_texture = Texture::create(); right_texture = Texture::create(); // create two 512 x 512 render target for each eye left_texture->create2D(512, 512, Texture::FORMAT_RGBA8, Texture::FORMAT_USAGE_RENDER); right_texture->create2D(512, 512, Texture::FORMAT_RGBA8, Texture::FORMAT_USAGE_RENDER); left_eye = Camera::create(); right_eye = Camera::create(); return 1; } int AppWorldLogic::update() { // set modelview & projection matrices to camera instance // ... // rendering RenderTargetPtr render_target = Render::getTemporaryRenderTarget(); render_target->bindColorTexture(0, left_texture); render_target->bindColorTexture(1, right_texture); render_target->enable(); { // use "post_stereo_separate" material in order to render to both textures viewport->renderStereo(left_eye, right_eye, "Unigine::post_stereo_separate"); } render_target->disable(); render_target->unbindAll(); Render::releaseTemporaryRenderTarget(render_target); return 1; }
-
To render the image to the CustomSystemProxy interface, check the 3rd Party samples: source -> samples -> 3rdparty -> ViewportQt.
ViewportQt sample is available only for the Engineering and Sim editions of UNIGINE SDKs.
-
-
Render a scene to a texture (data stays in the GPU memory).
-
To render the scene to a Texture interface, use the following methods:
- renderTexture2D(camera,texture)
- renderTexture2D(camera,texture,width,height,hdr)
- renderTextureCube(camera,texture,local_space)
- renderTextureCube(camera,texture,size,hdr,local_space)
ViewportPtr viewport; TexturePtr texture; CameraPtr camera; int AppWorldLogic::init() { // initialization viewport = Viewport::create(); texture = Texture::create(); // create 512 x 512 render target texture->create2D(512, 512, Texture::FORMAT_RGBA8, Texture::FORMAT_USAGE_RENDER); camera = Camera::create(); return 1; } int AppWorldLogic::update() { // set modelview & projection matrices to camera instance // ... // rendering // // saving current render state and clearing it RenderState::saveState(); RenderState::clearStates(); { viewport->renderTexture2D(camera, texture); } RenderState::restoreState(); return 1; }
-
-
Render a node to a texture (data stays in the GPU memory).
- To render a node (or nodes) to a Texture interface, use the following methods:
You can subscribe to events before and after any rendering pass using the getEvent***(): thus, getting access to the intermediate state of rendering buffers and matrices. Some of them are read-only, but most of them can be modified ad hoc. The event handler can get a Renderer pointer.
Thanks to this feature you can get direct access to G-Buffer, SSAO, lights or any other effect. One more example: you can create a custom post-process and apply it before TAA, thus, getting correct antialiased image as a result. You can even create your own custom light sources, decals, etc. The feature can also be useful for custom sensors view.
Viewport class has different rendering modes: RENDER_DEPTH (depth only), RENDER_DEPTH_GBUFFER (depth + G-buffer), RENDER_DEPTH_GBUFFER_FINAL (depth + G-buffer + final image). This can give you extra performance boost if you need only depth info, for example.
To set any viewport as a main, use the setViewport() method of the Render class.
A single viewport should be used with a single camera, otherwise it may cause visual artefacts. To avoid artefacts, when using several cameras with a single viewport, all post effects must be disabled using the setSkipFlags() method with the SKIP_POSTEFFECTS flag. See the usage example below.
See also#
-
See the following C++/C# samples:
- source/samples/Api/Render/GBufferWrite
- source/samples/Api/Render/GBufferRead
- Render to Texture sample in CPP Samples suite
- Weapon Clipping sample in C# Component Samples suite
-
See the following C++/C# usage example:
Viewport Class
Members
isStereo() const#
Return value
CurrentisPanorama() const#
Return value
CurrentgetID() const#
Return value
Currentvoid setLifetime ( int lifetime ) #
Arguments
- int lifetime - The number of frames during which temporary viewport resources are available after the viewport stops rendering
int getLifetime() const#
Return value
Current number of frames during which temporary viewport resources are available after the viewport stops renderingEvent<> getEventEnd() const#
Usage Example
// implement the End event handler
void end_event_handler()
{
Log::message("\Handling End event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections end_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEnd().connect(end_event_connections, end_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEnd().connect(end_event_connections, []() {
Log::message("\Handling End event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
end_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection end_event_connection;
// subscribe to the End event with a handler function keeping the connection
publisher->getEventEnd().connect(end_event_connection, end_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
end_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
end_event_connection.setEnabled(true);
// ...
// remove subscription to the End event via the connection
end_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A End event handler implemented as a class member
void event_handler()
{
Log::message("\Handling End event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEnd().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the End event with a handler function
publisher->getEventEnd().connect(end_event_handler);
// remove subscription to the End event later by the handler function
publisher->getEventEnd().disconnect(end_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId end_handler_id;
// subscribe to the End event with a lambda handler function and keeping connection ID
end_handler_id = publisher->getEventEnd().connect([]() {
Log::message("\Handling End event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEnd().disconnect(end_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all End events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEnd().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEnd().setEnabled(true);
Return value
Event reference.Event<> getEventEndScreen() const#
Usage Example
// implement the EndScreen event handler
void endscreen_event_handler()
{
Log::message("\Handling EndScreen event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endscreen_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndScreen().connect(endscreen_event_connections, endscreen_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndScreen().connect(endscreen_event_connections, []() {
Log::message("\Handling EndScreen event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endscreen_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endscreen_event_connection;
// subscribe to the EndScreen event with a handler function keeping the connection
publisher->getEventEndScreen().connect(endscreen_event_connection, endscreen_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endscreen_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endscreen_event_connection.setEnabled(true);
// ...
// remove subscription to the EndScreen event via the connection
endscreen_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndScreen event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndScreen event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndScreen().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndScreen event with a handler function
publisher->getEventEndScreen().connect(endscreen_event_handler);
// remove subscription to the EndScreen event later by the handler function
publisher->getEventEndScreen().disconnect(endscreen_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endscreen_handler_id;
// subscribe to the EndScreen event with a lambda handler function and keeping connection ID
endscreen_handler_id = publisher->getEventEndScreen().connect([]() {
Log::message("\Handling EndScreen event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndScreen().disconnect(endscreen_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndScreen events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndScreen().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndScreen().setEnabled(true);
Return value
Event reference.Event<> getEventEndVisualizer() const#
Usage Example
// implement the EndVisualizer event handler
void endvisualizer_event_handler()
{
Log::message("\Handling EndVisualizer event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endvisualizer_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndVisualizer().connect(endvisualizer_event_connections, endvisualizer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndVisualizer().connect(endvisualizer_event_connections, []() {
Log::message("\Handling EndVisualizer event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endvisualizer_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endvisualizer_event_connection;
// subscribe to the EndVisualizer event with a handler function keeping the connection
publisher->getEventEndVisualizer().connect(endvisualizer_event_connection, endvisualizer_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endvisualizer_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endvisualizer_event_connection.setEnabled(true);
// ...
// remove subscription to the EndVisualizer event via the connection
endvisualizer_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndVisualizer event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndVisualizer event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndVisualizer().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndVisualizer event with a handler function
publisher->getEventEndVisualizer().connect(endvisualizer_event_handler);
// remove subscription to the EndVisualizer event later by the handler function
publisher->getEventEndVisualizer().disconnect(endvisualizer_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endvisualizer_handler_id;
// subscribe to the EndVisualizer event with a lambda handler function and keeping connection ID
endvisualizer_handler_id = publisher->getEventEndVisualizer().connect([]() {
Log::message("\Handling EndVisualizer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndVisualizer().disconnect(endvisualizer_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndVisualizer events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndVisualizer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndVisualizer().setEnabled(true);
Return value
Event reference.Event<> getEventBeginVisualizer() const#
Usage Example
// implement the BeginVisualizer event handler
void beginvisualizer_event_handler()
{
Log::message("\Handling BeginVisualizer event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginvisualizer_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginVisualizer().connect(beginvisualizer_event_connections, beginvisualizer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginVisualizer().connect(beginvisualizer_event_connections, []() {
Log::message("\Handling BeginVisualizer event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginvisualizer_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginvisualizer_event_connection;
// subscribe to the BeginVisualizer event with a handler function keeping the connection
publisher->getEventBeginVisualizer().connect(beginvisualizer_event_connection, beginvisualizer_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginvisualizer_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginvisualizer_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginVisualizer event via the connection
beginvisualizer_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginVisualizer event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginVisualizer event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginVisualizer().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginVisualizer event with a handler function
publisher->getEventBeginVisualizer().connect(beginvisualizer_event_handler);
// remove subscription to the BeginVisualizer event later by the handler function
publisher->getEventBeginVisualizer().disconnect(beginvisualizer_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginvisualizer_handler_id;
// subscribe to the BeginVisualizer event with a lambda handler function and keeping connection ID
beginvisualizer_handler_id = publisher->getEventBeginVisualizer().connect([]() {
Log::message("\Handling BeginVisualizer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginVisualizer().disconnect(beginvisualizer_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginVisualizer events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginVisualizer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginVisualizer().setEnabled(true);
Return value
Event reference.Event<> getEventEndDebugMaterials() const#
Usage Example
// implement the EndDebugMaterials event handler
void enddebugmaterials_event_handler()
{
Log::message("\Handling EndDebugMaterials event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections enddebugmaterials_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndDebugMaterials().connect(enddebugmaterials_event_connections, enddebugmaterials_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndDebugMaterials().connect(enddebugmaterials_event_connections, []() {
Log::message("\Handling EndDebugMaterials event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
enddebugmaterials_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection enddebugmaterials_event_connection;
// subscribe to the EndDebugMaterials event with a handler function keeping the connection
publisher->getEventEndDebugMaterials().connect(enddebugmaterials_event_connection, enddebugmaterials_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
enddebugmaterials_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
enddebugmaterials_event_connection.setEnabled(true);
// ...
// remove subscription to the EndDebugMaterials event via the connection
enddebugmaterials_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndDebugMaterials event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndDebugMaterials event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndDebugMaterials().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndDebugMaterials event with a handler function
publisher->getEventEndDebugMaterials().connect(enddebugmaterials_event_handler);
// remove subscription to the EndDebugMaterials event later by the handler function
publisher->getEventEndDebugMaterials().disconnect(enddebugmaterials_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId enddebugmaterials_handler_id;
// subscribe to the EndDebugMaterials event with a lambda handler function and keeping connection ID
enddebugmaterials_handler_id = publisher->getEventEndDebugMaterials().connect([]() {
Log::message("\Handling EndDebugMaterials event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndDebugMaterials().disconnect(enddebugmaterials_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndDebugMaterials events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndDebugMaterials().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndDebugMaterials().setEnabled(true);
Return value
Event reference.Event<> getEventBeginDebugMaterials() const#
Usage Example
// implement the BeginDebugMaterials event handler
void begindebugmaterials_event_handler()
{
Log::message("\Handling BeginDebugMaterials event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections begindebugmaterials_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginDebugMaterials().connect(begindebugmaterials_event_connections, begindebugmaterials_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginDebugMaterials().connect(begindebugmaterials_event_connections, []() {
Log::message("\Handling BeginDebugMaterials event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
begindebugmaterials_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection begindebugmaterials_event_connection;
// subscribe to the BeginDebugMaterials event with a handler function keeping the connection
publisher->getEventBeginDebugMaterials().connect(begindebugmaterials_event_connection, begindebugmaterials_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
begindebugmaterials_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
begindebugmaterials_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginDebugMaterials event via the connection
begindebugmaterials_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginDebugMaterials event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginDebugMaterials event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginDebugMaterials().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginDebugMaterials event with a handler function
publisher->getEventBeginDebugMaterials().connect(begindebugmaterials_event_handler);
// remove subscription to the BeginDebugMaterials event later by the handler function
publisher->getEventBeginDebugMaterials().disconnect(begindebugmaterials_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId begindebugmaterials_handler_id;
// subscribe to the BeginDebugMaterials event with a lambda handler function and keeping connection ID
begindebugmaterials_handler_id = publisher->getEventBeginDebugMaterials().connect([]() {
Log::message("\Handling BeginDebugMaterials event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginDebugMaterials().disconnect(begindebugmaterials_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginDebugMaterials events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginDebugMaterials().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginDebugMaterials().setEnabled(true);
Return value
Event reference.Event<> getEventEndPostMaterials() const#
Usage Example
// implement the EndPostMaterials event handler
void endpostmaterials_event_handler()
{
Log::message("\Handling EndPostMaterials event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endpostmaterials_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndPostMaterials().connect(endpostmaterials_event_connections, endpostmaterials_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndPostMaterials().connect(endpostmaterials_event_connections, []() {
Log::message("\Handling EndPostMaterials event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endpostmaterials_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endpostmaterials_event_connection;
// subscribe to the EndPostMaterials event with a handler function keeping the connection
publisher->getEventEndPostMaterials().connect(endpostmaterials_event_connection, endpostmaterials_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endpostmaterials_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endpostmaterials_event_connection.setEnabled(true);
// ...
// remove subscription to the EndPostMaterials event via the connection
endpostmaterials_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndPostMaterials event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndPostMaterials event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndPostMaterials().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndPostMaterials event with a handler function
publisher->getEventEndPostMaterials().connect(endpostmaterials_event_handler);
// remove subscription to the EndPostMaterials event later by the handler function
publisher->getEventEndPostMaterials().disconnect(endpostmaterials_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endpostmaterials_handler_id;
// subscribe to the EndPostMaterials event with a lambda handler function and keeping connection ID
endpostmaterials_handler_id = publisher->getEventEndPostMaterials().connect([]() {
Log::message("\Handling EndPostMaterials event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndPostMaterials().disconnect(endpostmaterials_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndPostMaterials events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndPostMaterials().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndPostMaterials().setEnabled(true);
Return value
Event reference.Event<> getEventBeginPostMaterials() const#
Usage Example
// implement the BeginPostMaterials event handler
void beginpostmaterials_event_handler()
{
Log::message("\Handling BeginPostMaterials event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginpostmaterials_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginPostMaterials().connect(beginpostmaterials_event_connections, beginpostmaterials_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginPostMaterials().connect(beginpostmaterials_event_connections, []() {
Log::message("\Handling BeginPostMaterials event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginpostmaterials_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginpostmaterials_event_connection;
// subscribe to the BeginPostMaterials event with a handler function keeping the connection
publisher->getEventBeginPostMaterials().connect(beginpostmaterials_event_connection, beginpostmaterials_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginpostmaterials_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginpostmaterials_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginPostMaterials event via the connection
beginpostmaterials_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginPostMaterials event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginPostMaterials event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginPostMaterials().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginPostMaterials event with a handler function
publisher->getEventBeginPostMaterials().connect(beginpostmaterials_event_handler);
// remove subscription to the BeginPostMaterials event later by the handler function
publisher->getEventBeginPostMaterials().disconnect(beginpostmaterials_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginpostmaterials_handler_id;
// subscribe to the BeginPostMaterials event with a lambda handler function and keeping connection ID
beginpostmaterials_handler_id = publisher->getEventBeginPostMaterials().connect([]() {
Log::message("\Handling BeginPostMaterials event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginPostMaterials().disconnect(beginpostmaterials_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginPostMaterials events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginPostMaterials().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginPostMaterials().setEnabled(true);
Return value
Event reference.Event<> getEventEndCameraEffects() const#
Usage Example
// implement the EndCameraEffects event handler
void endcameraeffects_event_handler()
{
Log::message("\Handling EndCameraEffects event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endcameraeffects_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndCameraEffects().connect(endcameraeffects_event_connections, endcameraeffects_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndCameraEffects().connect(endcameraeffects_event_connections, []() {
Log::message("\Handling EndCameraEffects event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endcameraeffects_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endcameraeffects_event_connection;
// subscribe to the EndCameraEffects event with a handler function keeping the connection
publisher->getEventEndCameraEffects().connect(endcameraeffects_event_connection, endcameraeffects_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endcameraeffects_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endcameraeffects_event_connection.setEnabled(true);
// ...
// remove subscription to the EndCameraEffects event via the connection
endcameraeffects_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndCameraEffects event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndCameraEffects event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndCameraEffects().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndCameraEffects event with a handler function
publisher->getEventEndCameraEffects().connect(endcameraeffects_event_handler);
// remove subscription to the EndCameraEffects event later by the handler function
publisher->getEventEndCameraEffects().disconnect(endcameraeffects_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endcameraeffects_handler_id;
// subscribe to the EndCameraEffects event with a lambda handler function and keeping connection ID
endcameraeffects_handler_id = publisher->getEventEndCameraEffects().connect([]() {
Log::message("\Handling EndCameraEffects event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndCameraEffects().disconnect(endcameraeffects_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndCameraEffects events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndCameraEffects().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndCameraEffects().setEnabled(true);
Return value
Event reference.Event<> getEventBeginCameraEffects() const#
Usage Example
// implement the BeginCameraEffects event handler
void begincameraeffects_event_handler()
{
Log::message("\Handling BeginCameraEffects event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections begincameraeffects_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginCameraEffects().connect(begincameraeffects_event_connections, begincameraeffects_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginCameraEffects().connect(begincameraeffects_event_connections, []() {
Log::message("\Handling BeginCameraEffects event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
begincameraeffects_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection begincameraeffects_event_connection;
// subscribe to the BeginCameraEffects event with a handler function keeping the connection
publisher->getEventBeginCameraEffects().connect(begincameraeffects_event_connection, begincameraeffects_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
begincameraeffects_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
begincameraeffects_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginCameraEffects event via the connection
begincameraeffects_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginCameraEffects event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginCameraEffects event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginCameraEffects().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginCameraEffects event with a handler function
publisher->getEventBeginCameraEffects().connect(begincameraeffects_event_handler);
// remove subscription to the BeginCameraEffects event later by the handler function
publisher->getEventBeginCameraEffects().disconnect(begincameraeffects_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId begincameraeffects_handler_id;
// subscribe to the BeginCameraEffects event with a lambda handler function and keeping connection ID
begincameraeffects_handler_id = publisher->getEventBeginCameraEffects().connect([]() {
Log::message("\Handling BeginCameraEffects event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginCameraEffects().disconnect(begincameraeffects_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginCameraEffects events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginCameraEffects().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginCameraEffects().setEnabled(true);
Return value
Event reference.Event<> getEventEndTAA() const#
Usage Example
// implement the EndTAA event handler
void endtaa_event_handler()
{
Log::message("\Handling EndTAA event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endtaa_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndTAA().connect(endtaa_event_connections, endtaa_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndTAA().connect(endtaa_event_connections, []() {
Log::message("\Handling EndTAA event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endtaa_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endtaa_event_connection;
// subscribe to the EndTAA event with a handler function keeping the connection
publisher->getEventEndTAA().connect(endtaa_event_connection, endtaa_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endtaa_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endtaa_event_connection.setEnabled(true);
// ...
// remove subscription to the EndTAA event via the connection
endtaa_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndTAA event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndTAA event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndTAA().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndTAA event with a handler function
publisher->getEventEndTAA().connect(endtaa_event_handler);
// remove subscription to the EndTAA event later by the handler function
publisher->getEventEndTAA().disconnect(endtaa_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endtaa_handler_id;
// subscribe to the EndTAA event with a lambda handler function and keeping connection ID
endtaa_handler_id = publisher->getEventEndTAA().connect([]() {
Log::message("\Handling EndTAA event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndTAA().disconnect(endtaa_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndTAA events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndTAA().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndTAA().setEnabled(true);
Return value
Event reference.Event<> getEventBeginTAA() const#
Usage Example
// implement the BeginTAA event handler
void begintaa_event_handler()
{
Log::message("\Handling BeginTAA event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections begintaa_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginTAA().connect(begintaa_event_connections, begintaa_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginTAA().connect(begintaa_event_connections, []() {
Log::message("\Handling BeginTAA event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
begintaa_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection begintaa_event_connection;
// subscribe to the BeginTAA event with a handler function keeping the connection
publisher->getEventBeginTAA().connect(begintaa_event_connection, begintaa_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
begintaa_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
begintaa_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginTAA event via the connection
begintaa_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginTAA event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginTAA event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginTAA().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginTAA event with a handler function
publisher->getEventBeginTAA().connect(begintaa_event_handler);
// remove subscription to the BeginTAA event later by the handler function
publisher->getEventBeginTAA().disconnect(begintaa_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId begintaa_handler_id;
// subscribe to the BeginTAA event with a lambda handler function and keeping connection ID
begintaa_handler_id = publisher->getEventBeginTAA().connect([]() {
Log::message("\Handling BeginTAA event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginTAA().disconnect(begintaa_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginTAA events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginTAA().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginTAA().setEnabled(true);
Return value
Event reference.Event<> getEventEndAdaptationColor() const#
Usage Example
// implement the EndAdaptationColor event handler
void endadaptationcolor_event_handler()
{
Log::message("\Handling EndAdaptationColor event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endadaptationcolor_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndAdaptationColor().connect(endadaptationcolor_event_connections, endadaptationcolor_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndAdaptationColor().connect(endadaptationcolor_event_connections, []() {
Log::message("\Handling EndAdaptationColor event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endadaptationcolor_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endadaptationcolor_event_connection;
// subscribe to the EndAdaptationColor event with a handler function keeping the connection
publisher->getEventEndAdaptationColor().connect(endadaptationcolor_event_connection, endadaptationcolor_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endadaptationcolor_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endadaptationcolor_event_connection.setEnabled(true);
// ...
// remove subscription to the EndAdaptationColor event via the connection
endadaptationcolor_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndAdaptationColor event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndAdaptationColor event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndAdaptationColor().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndAdaptationColor event with a handler function
publisher->getEventEndAdaptationColor().connect(endadaptationcolor_event_handler);
// remove subscription to the EndAdaptationColor event later by the handler function
publisher->getEventEndAdaptationColor().disconnect(endadaptationcolor_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endadaptationcolor_handler_id;
// subscribe to the EndAdaptationColor event with a lambda handler function and keeping connection ID
endadaptationcolor_handler_id = publisher->getEventEndAdaptationColor().connect([]() {
Log::message("\Handling EndAdaptationColor event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndAdaptationColor().disconnect(endadaptationcolor_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndAdaptationColor events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndAdaptationColor().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndAdaptationColor().setEnabled(true);
Return value
Event reference.Event<> getEventBeginAdaptationColor() const#
Usage Example
// implement the BeginAdaptationColor event handler
void beginadaptationcolor_event_handler()
{
Log::message("\Handling BeginAdaptationColor event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginadaptationcolor_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginAdaptationColor().connect(beginadaptationcolor_event_connections, beginadaptationcolor_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginAdaptationColor().connect(beginadaptationcolor_event_connections, []() {
Log::message("\Handling BeginAdaptationColor event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginadaptationcolor_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginadaptationcolor_event_connection;
// subscribe to the BeginAdaptationColor event with a handler function keeping the connection
publisher->getEventBeginAdaptationColor().connect(beginadaptationcolor_event_connection, beginadaptationcolor_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginadaptationcolor_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginadaptationcolor_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginAdaptationColor event via the connection
beginadaptationcolor_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginAdaptationColor event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginAdaptationColor event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginAdaptationColor().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginAdaptationColor event with a handler function
publisher->getEventBeginAdaptationColor().connect(beginadaptationcolor_event_handler);
// remove subscription to the BeginAdaptationColor event later by the handler function
publisher->getEventBeginAdaptationColor().disconnect(beginadaptationcolor_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginadaptationcolor_handler_id;
// subscribe to the BeginAdaptationColor event with a lambda handler function and keeping connection ID
beginadaptationcolor_handler_id = publisher->getEventBeginAdaptationColor().connect([]() {
Log::message("\Handling BeginAdaptationColor event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginAdaptationColor().disconnect(beginadaptationcolor_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginAdaptationColor events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginAdaptationColor().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginAdaptationColor().setEnabled(true);
Return value
Event reference.Event<> getEventEndAdaptationColorAverage() const#
Usage Example
// implement the EndAdaptationColorAverage event handler
void endadaptationcoloraverage_event_handler()
{
Log::message("\Handling EndAdaptationColorAverage event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endadaptationcoloraverage_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndAdaptationColorAverage().connect(endadaptationcoloraverage_event_connections, endadaptationcoloraverage_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndAdaptationColorAverage().connect(endadaptationcoloraverage_event_connections, []() {
Log::message("\Handling EndAdaptationColorAverage event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endadaptationcoloraverage_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endadaptationcoloraverage_event_connection;
// subscribe to the EndAdaptationColorAverage event with a handler function keeping the connection
publisher->getEventEndAdaptationColorAverage().connect(endadaptationcoloraverage_event_connection, endadaptationcoloraverage_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endadaptationcoloraverage_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endadaptationcoloraverage_event_connection.setEnabled(true);
// ...
// remove subscription to the EndAdaptationColorAverage event via the connection
endadaptationcoloraverage_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndAdaptationColorAverage event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndAdaptationColorAverage event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndAdaptationColorAverage().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndAdaptationColorAverage event with a handler function
publisher->getEventEndAdaptationColorAverage().connect(endadaptationcoloraverage_event_handler);
// remove subscription to the EndAdaptationColorAverage event later by the handler function
publisher->getEventEndAdaptationColorAverage().disconnect(endadaptationcoloraverage_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endadaptationcoloraverage_handler_id;
// subscribe to the EndAdaptationColorAverage event with a lambda handler function and keeping connection ID
endadaptationcoloraverage_handler_id = publisher->getEventEndAdaptationColorAverage().connect([]() {
Log::message("\Handling EndAdaptationColorAverage event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndAdaptationColorAverage().disconnect(endadaptationcoloraverage_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndAdaptationColorAverage events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndAdaptationColorAverage().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndAdaptationColorAverage().setEnabled(true);
Return value
Event reference.Event<> getEventBeginAdaptationColorAverage() const#
Usage Example
// implement the BeginAdaptationColorAverage event handler
void beginadaptationcoloraverage_event_handler()
{
Log::message("\Handling BeginAdaptationColorAverage event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginadaptationcoloraverage_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginAdaptationColorAverage().connect(beginadaptationcoloraverage_event_connections, beginadaptationcoloraverage_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginAdaptationColorAverage().connect(beginadaptationcoloraverage_event_connections, []() {
Log::message("\Handling BeginAdaptationColorAverage event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginadaptationcoloraverage_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginadaptationcoloraverage_event_connection;
// subscribe to the BeginAdaptationColorAverage event with a handler function keeping the connection
publisher->getEventBeginAdaptationColorAverage().connect(beginadaptationcoloraverage_event_connection, beginadaptationcoloraverage_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginadaptationcoloraverage_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginadaptationcoloraverage_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginAdaptationColorAverage event via the connection
beginadaptationcoloraverage_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginAdaptationColorAverage event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginAdaptationColorAverage event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginAdaptationColorAverage().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginAdaptationColorAverage event with a handler function
publisher->getEventBeginAdaptationColorAverage().connect(beginadaptationcoloraverage_event_handler);
// remove subscription to the BeginAdaptationColorAverage event later by the handler function
publisher->getEventBeginAdaptationColorAverage().disconnect(beginadaptationcoloraverage_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginadaptationcoloraverage_handler_id;
// subscribe to the BeginAdaptationColorAverage event with a lambda handler function and keeping connection ID
beginadaptationcoloraverage_handler_id = publisher->getEventBeginAdaptationColorAverage().connect([]() {
Log::message("\Handling BeginAdaptationColorAverage event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginAdaptationColorAverage().disconnect(beginadaptationcoloraverage_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginAdaptationColorAverage events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginAdaptationColorAverage().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginAdaptationColorAverage().setEnabled(true);
Return value
Event reference.Event<> getEventEndSrgbCorrection() const#
Usage Example
// implement the EndSrgbCorrection event handler
void endsrgbcorrection_event_handler()
{
Log::message("\Handling EndSrgbCorrection event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endsrgbcorrection_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSrgbCorrection().connect(endsrgbcorrection_event_connections, endsrgbcorrection_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSrgbCorrection().connect(endsrgbcorrection_event_connections, []() {
Log::message("\Handling EndSrgbCorrection event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endsrgbcorrection_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endsrgbcorrection_event_connection;
// subscribe to the EndSrgbCorrection event with a handler function keeping the connection
publisher->getEventEndSrgbCorrection().connect(endsrgbcorrection_event_connection, endsrgbcorrection_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endsrgbcorrection_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endsrgbcorrection_event_connection.setEnabled(true);
// ...
// remove subscription to the EndSrgbCorrection event via the connection
endsrgbcorrection_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndSrgbCorrection event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndSrgbCorrection event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSrgbCorrection().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndSrgbCorrection event with a handler function
publisher->getEventEndSrgbCorrection().connect(endsrgbcorrection_event_handler);
// remove subscription to the EndSrgbCorrection event later by the handler function
publisher->getEventEndSrgbCorrection().disconnect(endsrgbcorrection_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endsrgbcorrection_handler_id;
// subscribe to the EndSrgbCorrection event with a lambda handler function and keeping connection ID
endsrgbcorrection_handler_id = publisher->getEventEndSrgbCorrection().connect([]() {
Log::message("\Handling EndSrgbCorrection event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndSrgbCorrection().disconnect(endsrgbcorrection_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndSrgbCorrection events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSrgbCorrection().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndSrgbCorrection().setEnabled(true);
Return value
Event reference.Event<> getEventBeginSrgbCorrection() const#
Usage Example
// implement the BeginSrgbCorrection event handler
void beginsrgbcorrection_event_handler()
{
Log::message("\Handling BeginSrgbCorrection event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginsrgbcorrection_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSrgbCorrection().connect(beginsrgbcorrection_event_connections, beginsrgbcorrection_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSrgbCorrection().connect(beginsrgbcorrection_event_connections, []() {
Log::message("\Handling BeginSrgbCorrection event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginsrgbcorrection_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginsrgbcorrection_event_connection;
// subscribe to the BeginSrgbCorrection event with a handler function keeping the connection
publisher->getEventBeginSrgbCorrection().connect(beginsrgbcorrection_event_connection, beginsrgbcorrection_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginsrgbcorrection_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginsrgbcorrection_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginSrgbCorrection event via the connection
beginsrgbcorrection_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginSrgbCorrection event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginSrgbCorrection event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSrgbCorrection().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginSrgbCorrection event with a handler function
publisher->getEventBeginSrgbCorrection().connect(beginsrgbcorrection_event_handler);
// remove subscription to the BeginSrgbCorrection event later by the handler function
publisher->getEventBeginSrgbCorrection().disconnect(beginsrgbcorrection_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginsrgbcorrection_handler_id;
// subscribe to the BeginSrgbCorrection event with a lambda handler function and keeping connection ID
beginsrgbcorrection_handler_id = publisher->getEventBeginSrgbCorrection().connect([]() {
Log::message("\Handling BeginSrgbCorrection event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginSrgbCorrection().disconnect(beginsrgbcorrection_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginSrgbCorrection events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSrgbCorrection().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginSrgbCorrection().setEnabled(true);
Return value
Event reference.Event<> getEventEndTransparent() const#
Usage Example
// implement the EndTransparent event handler
void endtransparent_event_handler()
{
Log::message("\Handling EndTransparent event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endtransparent_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndTransparent().connect(endtransparent_event_connections, endtransparent_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndTransparent().connect(endtransparent_event_connections, []() {
Log::message("\Handling EndTransparent event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endtransparent_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endtransparent_event_connection;
// subscribe to the EndTransparent event with a handler function keeping the connection
publisher->getEventEndTransparent().connect(endtransparent_event_connection, endtransparent_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endtransparent_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endtransparent_event_connection.setEnabled(true);
// ...
// remove subscription to the EndTransparent event via the connection
endtransparent_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndTransparent event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndTransparent event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndTransparent().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndTransparent event with a handler function
publisher->getEventEndTransparent().connect(endtransparent_event_handler);
// remove subscription to the EndTransparent event later by the handler function
publisher->getEventEndTransparent().disconnect(endtransparent_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endtransparent_handler_id;
// subscribe to the EndTransparent event with a lambda handler function and keeping connection ID
endtransparent_handler_id = publisher->getEventEndTransparent().connect([]() {
Log::message("\Handling EndTransparent event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndTransparent().disconnect(endtransparent_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndTransparent events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndTransparent().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndTransparent().setEnabled(true);
Return value
Event reference.Event<> getEventEndWater() const#
Usage Example
// implement the EndWater event handler
void endwater_event_handler()
{
Log::message("\Handling EndWater event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endwater_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWater().connect(endwater_event_connections, endwater_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWater().connect(endwater_event_connections, []() {
Log::message("\Handling EndWater event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endwater_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endwater_event_connection;
// subscribe to the EndWater event with a handler function keeping the connection
publisher->getEventEndWater().connect(endwater_event_connection, endwater_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endwater_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endwater_event_connection.setEnabled(true);
// ...
// remove subscription to the EndWater event via the connection
endwater_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndWater event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndWater event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWater().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndWater event with a handler function
publisher->getEventEndWater().connect(endwater_event_handler);
// remove subscription to the EndWater event later by the handler function
publisher->getEventEndWater().disconnect(endwater_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endwater_handler_id;
// subscribe to the EndWater event with a lambda handler function and keeping connection ID
endwater_handler_id = publisher->getEventEndWater().connect([]() {
Log::message("\Handling EndWater event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndWater().disconnect(endwater_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndWater events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWater().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndWater().setEnabled(true);
Return value
Event reference.Event<> getEventEndWaterPlanarProbes() const#
Usage Example
// implement the EndWaterPlanarProbes event handler
void endwaterplanarprobes_event_handler()
{
Log::message("\Handling EndWaterPlanarProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endwaterplanarprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWaterPlanarProbes().connect(endwaterplanarprobes_event_connections, endwaterplanarprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWaterPlanarProbes().connect(endwaterplanarprobes_event_connections, []() {
Log::message("\Handling EndWaterPlanarProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endwaterplanarprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endwaterplanarprobes_event_connection;
// subscribe to the EndWaterPlanarProbes event with a handler function keeping the connection
publisher->getEventEndWaterPlanarProbes().connect(endwaterplanarprobes_event_connection, endwaterplanarprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endwaterplanarprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endwaterplanarprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the EndWaterPlanarProbes event via the connection
endwaterplanarprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndWaterPlanarProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndWaterPlanarProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWaterPlanarProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndWaterPlanarProbes event with a handler function
publisher->getEventEndWaterPlanarProbes().connect(endwaterplanarprobes_event_handler);
// remove subscription to the EndWaterPlanarProbes event later by the handler function
publisher->getEventEndWaterPlanarProbes().disconnect(endwaterplanarprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endwaterplanarprobes_handler_id;
// subscribe to the EndWaterPlanarProbes event with a lambda handler function and keeping connection ID
endwaterplanarprobes_handler_id = publisher->getEventEndWaterPlanarProbes().connect([]() {
Log::message("\Handling EndWaterPlanarProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndWaterPlanarProbes().disconnect(endwaterplanarprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndWaterPlanarProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWaterPlanarProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndWaterPlanarProbes().setEnabled(true);
Return value
Event reference.Event<> getEventBeginWaterPlanarProbes() const#
Usage Example
// implement the BeginWaterPlanarProbes event handler
void beginwaterplanarprobes_event_handler()
{
Log::message("\Handling BeginWaterPlanarProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginwaterplanarprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWaterPlanarProbes().connect(beginwaterplanarprobes_event_connections, beginwaterplanarprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWaterPlanarProbes().connect(beginwaterplanarprobes_event_connections, []() {
Log::message("\Handling BeginWaterPlanarProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginwaterplanarprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginwaterplanarprobes_event_connection;
// subscribe to the BeginWaterPlanarProbes event with a handler function keeping the connection
publisher->getEventBeginWaterPlanarProbes().connect(beginwaterplanarprobes_event_connection, beginwaterplanarprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginwaterplanarprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginwaterplanarprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginWaterPlanarProbes event via the connection
beginwaterplanarprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginWaterPlanarProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginWaterPlanarProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWaterPlanarProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginWaterPlanarProbes event with a handler function
publisher->getEventBeginWaterPlanarProbes().connect(beginwaterplanarprobes_event_handler);
// remove subscription to the BeginWaterPlanarProbes event later by the handler function
publisher->getEventBeginWaterPlanarProbes().disconnect(beginwaterplanarprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginwaterplanarprobes_handler_id;
// subscribe to the BeginWaterPlanarProbes event with a lambda handler function and keeping connection ID
beginwaterplanarprobes_handler_id = publisher->getEventBeginWaterPlanarProbes().connect([]() {
Log::message("\Handling BeginWaterPlanarProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginWaterPlanarProbes().disconnect(beginwaterplanarprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginWaterPlanarProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWaterPlanarProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginWaterPlanarProbes().setEnabled(true);
Return value
Event reference.Event<> getEventEndWaterEnvironmentProbes() const#
Usage Example
// implement the EndWaterEnvironmentProbes event handler
void endwaterenvironmentprobes_event_handler()
{
Log::message("\Handling EndWaterEnvironmentProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endwaterenvironmentprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWaterEnvironmentProbes().connect(endwaterenvironmentprobes_event_connections, endwaterenvironmentprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWaterEnvironmentProbes().connect(endwaterenvironmentprobes_event_connections, []() {
Log::message("\Handling EndWaterEnvironmentProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endwaterenvironmentprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endwaterenvironmentprobes_event_connection;
// subscribe to the EndWaterEnvironmentProbes event with a handler function keeping the connection
publisher->getEventEndWaterEnvironmentProbes().connect(endwaterenvironmentprobes_event_connection, endwaterenvironmentprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endwaterenvironmentprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endwaterenvironmentprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the EndWaterEnvironmentProbes event via the connection
endwaterenvironmentprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndWaterEnvironmentProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndWaterEnvironmentProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWaterEnvironmentProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndWaterEnvironmentProbes event with a handler function
publisher->getEventEndWaterEnvironmentProbes().connect(endwaterenvironmentprobes_event_handler);
// remove subscription to the EndWaterEnvironmentProbes event later by the handler function
publisher->getEventEndWaterEnvironmentProbes().disconnect(endwaterenvironmentprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endwaterenvironmentprobes_handler_id;
// subscribe to the EndWaterEnvironmentProbes event with a lambda handler function and keeping connection ID
endwaterenvironmentprobes_handler_id = publisher->getEventEndWaterEnvironmentProbes().connect([]() {
Log::message("\Handling EndWaterEnvironmentProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndWaterEnvironmentProbes().disconnect(endwaterenvironmentprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndWaterEnvironmentProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWaterEnvironmentProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndWaterEnvironmentProbes().setEnabled(true);
Return value
Event reference.Event<> getEventBeginWaterEnvironmentProbes() const#
Usage Example
// implement the BeginWaterEnvironmentProbes event handler
void beginwaterenvironmentprobes_event_handler()
{
Log::message("\Handling BeginWaterEnvironmentProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginwaterenvironmentprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWaterEnvironmentProbes().connect(beginwaterenvironmentprobes_event_connections, beginwaterenvironmentprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWaterEnvironmentProbes().connect(beginwaterenvironmentprobes_event_connections, []() {
Log::message("\Handling BeginWaterEnvironmentProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginwaterenvironmentprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginwaterenvironmentprobes_event_connection;
// subscribe to the BeginWaterEnvironmentProbes event with a handler function keeping the connection
publisher->getEventBeginWaterEnvironmentProbes().connect(beginwaterenvironmentprobes_event_connection, beginwaterenvironmentprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginwaterenvironmentprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginwaterenvironmentprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginWaterEnvironmentProbes event via the connection
beginwaterenvironmentprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginWaterEnvironmentProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginWaterEnvironmentProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWaterEnvironmentProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginWaterEnvironmentProbes event with a handler function
publisher->getEventBeginWaterEnvironmentProbes().connect(beginwaterenvironmentprobes_event_handler);
// remove subscription to the BeginWaterEnvironmentProbes event later by the handler function
publisher->getEventBeginWaterEnvironmentProbes().disconnect(beginwaterenvironmentprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginwaterenvironmentprobes_handler_id;
// subscribe to the BeginWaterEnvironmentProbes event with a lambda handler function and keeping connection ID
beginwaterenvironmentprobes_handler_id = publisher->getEventBeginWaterEnvironmentProbes().connect([]() {
Log::message("\Handling BeginWaterEnvironmentProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginWaterEnvironmentProbes().disconnect(beginwaterenvironmentprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginWaterEnvironmentProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWaterEnvironmentProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginWaterEnvironmentProbes().setEnabled(true);
Return value
Event reference.Event<> getEventEndWaterVoxelProbes() const#
Usage Example
// implement the EndWaterVoxelProbes event handler
void endwatervoxelprobes_event_handler()
{
Log::message("\Handling EndWaterVoxelProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endwatervoxelprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWaterVoxelProbes().connect(endwatervoxelprobes_event_connections, endwatervoxelprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWaterVoxelProbes().connect(endwatervoxelprobes_event_connections, []() {
Log::message("\Handling EndWaterVoxelProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endwatervoxelprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endwatervoxelprobes_event_connection;
// subscribe to the EndWaterVoxelProbes event with a handler function keeping the connection
publisher->getEventEndWaterVoxelProbes().connect(endwatervoxelprobes_event_connection, endwatervoxelprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endwatervoxelprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endwatervoxelprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the EndWaterVoxelProbes event via the connection
endwatervoxelprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndWaterVoxelProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndWaterVoxelProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWaterVoxelProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndWaterVoxelProbes event with a handler function
publisher->getEventEndWaterVoxelProbes().connect(endwatervoxelprobes_event_handler);
// remove subscription to the EndWaterVoxelProbes event later by the handler function
publisher->getEventEndWaterVoxelProbes().disconnect(endwatervoxelprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endwatervoxelprobes_handler_id;
// subscribe to the EndWaterVoxelProbes event with a lambda handler function and keeping connection ID
endwatervoxelprobes_handler_id = publisher->getEventEndWaterVoxelProbes().connect([]() {
Log::message("\Handling EndWaterVoxelProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndWaterVoxelProbes().disconnect(endwatervoxelprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndWaterVoxelProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWaterVoxelProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndWaterVoxelProbes().setEnabled(true);
Return value
Event reference.Event<> getEventBeginWaterVoxelProbes() const#
Usage Example
// implement the BeginWaterVoxelProbes event handler
void beginwatervoxelprobes_event_handler()
{
Log::message("\Handling BeginWaterVoxelProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginwatervoxelprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWaterVoxelProbes().connect(beginwatervoxelprobes_event_connections, beginwatervoxelprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWaterVoxelProbes().connect(beginwatervoxelprobes_event_connections, []() {
Log::message("\Handling BeginWaterVoxelProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginwatervoxelprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginwatervoxelprobes_event_connection;
// subscribe to the BeginWaterVoxelProbes event with a handler function keeping the connection
publisher->getEventBeginWaterVoxelProbes().connect(beginwatervoxelprobes_event_connection, beginwatervoxelprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginwatervoxelprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginwatervoxelprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginWaterVoxelProbes event via the connection
beginwatervoxelprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginWaterVoxelProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginWaterVoxelProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWaterVoxelProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginWaterVoxelProbes event with a handler function
publisher->getEventBeginWaterVoxelProbes().connect(beginwatervoxelprobes_event_handler);
// remove subscription to the BeginWaterVoxelProbes event later by the handler function
publisher->getEventBeginWaterVoxelProbes().disconnect(beginwatervoxelprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginwatervoxelprobes_handler_id;
// subscribe to the BeginWaterVoxelProbes event with a lambda handler function and keeping connection ID
beginwatervoxelprobes_handler_id = publisher->getEventBeginWaterVoxelProbes().connect([]() {
Log::message("\Handling BeginWaterVoxelProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginWaterVoxelProbes().disconnect(beginwatervoxelprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginWaterVoxelProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWaterVoxelProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginWaterVoxelProbes().setEnabled(true);
Return value
Event reference.Event<> getEventEndWaterLights() const#
Usage Example
// implement the EndWaterLights event handler
void endwaterlights_event_handler()
{
Log::message("\Handling EndWaterLights event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endwaterlights_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWaterLights().connect(endwaterlights_event_connections, endwaterlights_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWaterLights().connect(endwaterlights_event_connections, []() {
Log::message("\Handling EndWaterLights event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endwaterlights_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endwaterlights_event_connection;
// subscribe to the EndWaterLights event with a handler function keeping the connection
publisher->getEventEndWaterLights().connect(endwaterlights_event_connection, endwaterlights_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endwaterlights_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endwaterlights_event_connection.setEnabled(true);
// ...
// remove subscription to the EndWaterLights event via the connection
endwaterlights_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndWaterLights event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndWaterLights event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWaterLights().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndWaterLights event with a handler function
publisher->getEventEndWaterLights().connect(endwaterlights_event_handler);
// remove subscription to the EndWaterLights event later by the handler function
publisher->getEventEndWaterLights().disconnect(endwaterlights_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endwaterlights_handler_id;
// subscribe to the EndWaterLights event with a lambda handler function and keeping connection ID
endwaterlights_handler_id = publisher->getEventEndWaterLights().connect([]() {
Log::message("\Handling EndWaterLights event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndWaterLights().disconnect(endwaterlights_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndWaterLights events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWaterLights().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndWaterLights().setEnabled(true);
Return value
Event reference.Event<> getEventBeginWaterLights() const#
Usage Example
// implement the BeginWaterLights event handler
void beginwaterlights_event_handler()
{
Log::message("\Handling BeginWaterLights event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginwaterlights_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWaterLights().connect(beginwaterlights_event_connections, beginwaterlights_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWaterLights().connect(beginwaterlights_event_connections, []() {
Log::message("\Handling BeginWaterLights event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginwaterlights_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginwaterlights_event_connection;
// subscribe to the BeginWaterLights event with a handler function keeping the connection
publisher->getEventBeginWaterLights().connect(beginwaterlights_event_connection, beginwaterlights_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginwaterlights_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginwaterlights_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginWaterLights event via the connection
beginwaterlights_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginWaterLights event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginWaterLights event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWaterLights().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginWaterLights event with a handler function
publisher->getEventBeginWaterLights().connect(beginwaterlights_event_handler);
// remove subscription to the BeginWaterLights event later by the handler function
publisher->getEventBeginWaterLights().disconnect(beginwaterlights_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginwaterlights_handler_id;
// subscribe to the BeginWaterLights event with a lambda handler function and keeping connection ID
beginwaterlights_handler_id = publisher->getEventBeginWaterLights().connect([]() {
Log::message("\Handling BeginWaterLights event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginWaterLights().disconnect(beginwaterlights_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginWaterLights events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWaterLights().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginWaterLights().setEnabled(true);
Return value
Event reference.Event<> getEventEndWaterDecals() const#
Usage Example
// implement the EndWaterDecals event handler
void endwaterdecals_event_handler()
{
Log::message("\Handling EndWaterDecals event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endwaterdecals_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndWaterDecals().connect(endwaterdecals_event_connections, endwaterdecals_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndWaterDecals().connect(endwaterdecals_event_connections, []() {
Log::message("\Handling EndWaterDecals event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endwaterdecals_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endwaterdecals_event_connection;
// subscribe to the EndWaterDecals event with a handler function keeping the connection
publisher->getEventEndWaterDecals().connect(endwaterdecals_event_connection, endwaterdecals_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endwaterdecals_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endwaterdecals_event_connection.setEnabled(true);
// ...
// remove subscription to the EndWaterDecals event via the connection
endwaterdecals_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndWaterDecals event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndWaterDecals event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndWaterDecals().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndWaterDecals event with a handler function
publisher->getEventEndWaterDecals().connect(endwaterdecals_event_handler);
// remove subscription to the EndWaterDecals event later by the handler function
publisher->getEventEndWaterDecals().disconnect(endwaterdecals_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endwaterdecals_handler_id;
// subscribe to the EndWaterDecals event with a lambda handler function and keeping connection ID
endwaterdecals_handler_id = publisher->getEventEndWaterDecals().connect([]() {
Log::message("\Handling EndWaterDecals event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndWaterDecals().disconnect(endwaterdecals_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndWaterDecals events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndWaterDecals().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndWaterDecals().setEnabled(true);
Return value
Event reference.Event<> getEventBeginWaterDecals() const#
Usage Example
// implement the BeginWaterDecals event handler
void beginwaterdecals_event_handler()
{
Log::message("\Handling BeginWaterDecals event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginwaterdecals_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWaterDecals().connect(beginwaterdecals_event_connections, beginwaterdecals_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWaterDecals().connect(beginwaterdecals_event_connections, []() {
Log::message("\Handling BeginWaterDecals event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginwaterdecals_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginwaterdecals_event_connection;
// subscribe to the BeginWaterDecals event with a handler function keeping the connection
publisher->getEventBeginWaterDecals().connect(beginwaterdecals_event_connection, beginwaterdecals_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginwaterdecals_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginwaterdecals_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginWaterDecals event via the connection
beginwaterdecals_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginWaterDecals event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginWaterDecals event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWaterDecals().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginWaterDecals event with a handler function
publisher->getEventBeginWaterDecals().connect(beginwaterdecals_event_handler);
// remove subscription to the BeginWaterDecals event later by the handler function
publisher->getEventBeginWaterDecals().disconnect(beginwaterdecals_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginwaterdecals_handler_id;
// subscribe to the BeginWaterDecals event with a lambda handler function and keeping connection ID
beginwaterdecals_handler_id = publisher->getEventBeginWaterDecals().connect([]() {
Log::message("\Handling BeginWaterDecals event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginWaterDecals().disconnect(beginwaterdecals_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginWaterDecals events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWaterDecals().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginWaterDecals().setEnabled(true);
Return value
Event reference.Event<> getEventBeginWater() const#
Usage Example
// implement the BeginWater event handler
void beginwater_event_handler()
{
Log::message("\Handling BeginWater event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginwater_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginWater().connect(beginwater_event_connections, beginwater_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginWater().connect(beginwater_event_connections, []() {
Log::message("\Handling BeginWater event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginwater_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginwater_event_connection;
// subscribe to the BeginWater event with a handler function keeping the connection
publisher->getEventBeginWater().connect(beginwater_event_connection, beginwater_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginwater_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginwater_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginWater event via the connection
beginwater_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginWater event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginWater event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginWater().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginWater event with a handler function
publisher->getEventBeginWater().connect(beginwater_event_handler);
// remove subscription to the BeginWater event later by the handler function
publisher->getEventBeginWater().disconnect(beginwater_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginwater_handler_id;
// subscribe to the BeginWater event with a lambda handler function and keeping connection ID
beginwater_handler_id = publisher->getEventBeginWater().connect([]() {
Log::message("\Handling BeginWater event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginWater().disconnect(beginwater_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginWater events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginWater().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginWater().setEnabled(true);
Return value
Event reference.Event<> getEventEndClouds() const#
Usage Example
// implement the EndClouds event handler
void endclouds_event_handler()
{
Log::message("\Handling EndClouds event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endclouds_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndClouds().connect(endclouds_event_connections, endclouds_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndClouds().connect(endclouds_event_connections, []() {
Log::message("\Handling EndClouds event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endclouds_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endclouds_event_connection;
// subscribe to the EndClouds event with a handler function keeping the connection
publisher->getEventEndClouds().connect(endclouds_event_connection, endclouds_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endclouds_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endclouds_event_connection.setEnabled(true);
// ...
// remove subscription to the EndClouds event via the connection
endclouds_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndClouds event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndClouds event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndClouds().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndClouds event with a handler function
publisher->getEventEndClouds().connect(endclouds_event_handler);
// remove subscription to the EndClouds event later by the handler function
publisher->getEventEndClouds().disconnect(endclouds_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endclouds_handler_id;
// subscribe to the EndClouds event with a lambda handler function and keeping connection ID
endclouds_handler_id = publisher->getEventEndClouds().connect([]() {
Log::message("\Handling EndClouds event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndClouds().disconnect(endclouds_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndClouds events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndClouds().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndClouds().setEnabled(true);
Return value
Event reference.Event<> getEventBeginClouds() const#
Usage Example
// implement the BeginClouds event handler
void beginclouds_event_handler()
{
Log::message("\Handling BeginClouds event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginclouds_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginClouds().connect(beginclouds_event_connections, beginclouds_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginClouds().connect(beginclouds_event_connections, []() {
Log::message("\Handling BeginClouds event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginclouds_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginclouds_event_connection;
// subscribe to the BeginClouds event with a handler function keeping the connection
publisher->getEventBeginClouds().connect(beginclouds_event_connection, beginclouds_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginclouds_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginclouds_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginClouds event via the connection
beginclouds_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginClouds event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginClouds event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginClouds().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginClouds event with a handler function
publisher->getEventBeginClouds().connect(beginclouds_event_handler);
// remove subscription to the BeginClouds event later by the handler function
publisher->getEventBeginClouds().disconnect(beginclouds_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginclouds_handler_id;
// subscribe to the BeginClouds event with a lambda handler function and keeping connection ID
beginclouds_handler_id = publisher->getEventBeginClouds().connect([]() {
Log::message("\Handling BeginClouds event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginClouds().disconnect(beginclouds_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginClouds events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginClouds().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginClouds().setEnabled(true);
Return value
Event reference.Event<> getEventBeginTransparent() const#
Usage Example
// implement the BeginTransparent event handler
void begintransparent_event_handler()
{
Log::message("\Handling BeginTransparent event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections begintransparent_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginTransparent().connect(begintransparent_event_connections, begintransparent_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginTransparent().connect(begintransparent_event_connections, []() {
Log::message("\Handling BeginTransparent event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
begintransparent_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection begintransparent_event_connection;
// subscribe to the BeginTransparent event with a handler function keeping the connection
publisher->getEventBeginTransparent().connect(begintransparent_event_connection, begintransparent_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
begintransparent_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
begintransparent_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginTransparent event via the connection
begintransparent_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginTransparent event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginTransparent event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginTransparent().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginTransparent event with a handler function
publisher->getEventBeginTransparent().connect(begintransparent_event_handler);
// remove subscription to the BeginTransparent event later by the handler function
publisher->getEventBeginTransparent().disconnect(begintransparent_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId begintransparent_handler_id;
// subscribe to the BeginTransparent event with a lambda handler function and keeping connection ID
begintransparent_handler_id = publisher->getEventBeginTransparent().connect([]() {
Log::message("\Handling BeginTransparent event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginTransparent().disconnect(begintransparent_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginTransparent events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginTransparent().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginTransparent().setEnabled(true);
Return value
Event reference.Event<> getEventEndCompositeDeferred() const#
Usage Example
// implement the EndCompositeDeferred event handler
void endcompositedeferred_event_handler()
{
Log::message("\Handling EndCompositeDeferred event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endcompositedeferred_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndCompositeDeferred().connect(endcompositedeferred_event_connections, endcompositedeferred_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndCompositeDeferred().connect(endcompositedeferred_event_connections, []() {
Log::message("\Handling EndCompositeDeferred event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endcompositedeferred_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endcompositedeferred_event_connection;
// subscribe to the EndCompositeDeferred event with a handler function keeping the connection
publisher->getEventEndCompositeDeferred().connect(endcompositedeferred_event_connection, endcompositedeferred_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endcompositedeferred_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endcompositedeferred_event_connection.setEnabled(true);
// ...
// remove subscription to the EndCompositeDeferred event via the connection
endcompositedeferred_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndCompositeDeferred event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndCompositeDeferred event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndCompositeDeferred().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndCompositeDeferred event with a handler function
publisher->getEventEndCompositeDeferred().connect(endcompositedeferred_event_handler);
// remove subscription to the EndCompositeDeferred event later by the handler function
publisher->getEventEndCompositeDeferred().disconnect(endcompositedeferred_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endcompositedeferred_handler_id;
// subscribe to the EndCompositeDeferred event with a lambda handler function and keeping connection ID
endcompositedeferred_handler_id = publisher->getEventEndCompositeDeferred().connect([]() {
Log::message("\Handling EndCompositeDeferred event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndCompositeDeferred().disconnect(endcompositedeferred_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndCompositeDeferred events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndCompositeDeferred().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndCompositeDeferred().setEnabled(true);
Return value
Event reference.Event<> getEventBeginCompositeDeferred() const#
Usage Example
// implement the BeginCompositeDeferred event handler
void begincompositedeferred_event_handler()
{
Log::message("\Handling BeginCompositeDeferred event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections begincompositedeferred_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginCompositeDeferred().connect(begincompositedeferred_event_connections, begincompositedeferred_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginCompositeDeferred().connect(begincompositedeferred_event_connections, []() {
Log::message("\Handling BeginCompositeDeferred event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
begincompositedeferred_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection begincompositedeferred_event_connection;
// subscribe to the BeginCompositeDeferred event with a handler function keeping the connection
publisher->getEventBeginCompositeDeferred().connect(begincompositedeferred_event_connection, begincompositedeferred_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
begincompositedeferred_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
begincompositedeferred_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginCompositeDeferred event via the connection
begincompositedeferred_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginCompositeDeferred event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginCompositeDeferred event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginCompositeDeferred().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginCompositeDeferred event with a handler function
publisher->getEventBeginCompositeDeferred().connect(begincompositedeferred_event_handler);
// remove subscription to the BeginCompositeDeferred event later by the handler function
publisher->getEventBeginCompositeDeferred().disconnect(begincompositedeferred_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId begincompositedeferred_handler_id;
// subscribe to the BeginCompositeDeferred event with a lambda handler function and keeping connection ID
begincompositedeferred_handler_id = publisher->getEventBeginCompositeDeferred().connect([]() {
Log::message("\Handling BeginCompositeDeferred event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginCompositeDeferred().disconnect(begincompositedeferred_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginCompositeDeferred events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginCompositeDeferred().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginCompositeDeferred().setEnabled(true);
Return value
Event reference.Event<> getEventEndSky() const#
Usage Example
// implement the EndSky event handler
void endsky_event_handler()
{
Log::message("\Handling EndSky event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endsky_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSky().connect(endsky_event_connections, endsky_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSky().connect(endsky_event_connections, []() {
Log::message("\Handling EndSky event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endsky_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endsky_event_connection;
// subscribe to the EndSky event with a handler function keeping the connection
publisher->getEventEndSky().connect(endsky_event_connection, endsky_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endsky_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endsky_event_connection.setEnabled(true);
// ...
// remove subscription to the EndSky event via the connection
endsky_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndSky event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndSky event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSky().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndSky event with a handler function
publisher->getEventEndSky().connect(endsky_event_handler);
// remove subscription to the EndSky event later by the handler function
publisher->getEventEndSky().disconnect(endsky_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endsky_handler_id;
// subscribe to the EndSky event with a lambda handler function and keeping connection ID
endsky_handler_id = publisher->getEventEndSky().connect([]() {
Log::message("\Handling EndSky event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndSky().disconnect(endsky_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndSky events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSky().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndSky().setEnabled(true);
Return value
Event reference.Event<> getEventBeginSky() const#
Usage Example
// implement the BeginSky event handler
void beginsky_event_handler()
{
Log::message("\Handling BeginSky event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginsky_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSky().connect(beginsky_event_connections, beginsky_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSky().connect(beginsky_event_connections, []() {
Log::message("\Handling BeginSky event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginsky_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginsky_event_connection;
// subscribe to the BeginSky event with a handler function keeping the connection
publisher->getEventBeginSky().connect(beginsky_event_connection, beginsky_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginsky_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginsky_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginSky event via the connection
beginsky_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginSky event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginSky event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSky().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginSky event with a handler function
publisher->getEventBeginSky().connect(beginsky_event_handler);
// remove subscription to the BeginSky event later by the handler function
publisher->getEventBeginSky().disconnect(beginsky_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginsky_handler_id;
// subscribe to the BeginSky event with a lambda handler function and keeping connection ID
beginsky_handler_id = publisher->getEventBeginSky().connect([]() {
Log::message("\Handling BeginSky event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginSky().disconnect(beginsky_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginSky events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSky().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginSky().setEnabled(true);
Return value
Event reference.Event<> getEventEndSSGI() const#
Usage Example
// implement the EndSSGI event handler
void endssgi_event_handler()
{
Log::message("\Handling EndSSGI event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endssgi_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSSGI().connect(endssgi_event_connections, endssgi_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSSGI().connect(endssgi_event_connections, []() {
Log::message("\Handling EndSSGI event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endssgi_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endssgi_event_connection;
// subscribe to the EndSSGI event with a handler function keeping the connection
publisher->getEventEndSSGI().connect(endssgi_event_connection, endssgi_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endssgi_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endssgi_event_connection.setEnabled(true);
// ...
// remove subscription to the EndSSGI event via the connection
endssgi_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndSSGI event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndSSGI event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSSGI().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndSSGI event with a handler function
publisher->getEventEndSSGI().connect(endssgi_event_handler);
// remove subscription to the EndSSGI event later by the handler function
publisher->getEventEndSSGI().disconnect(endssgi_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endssgi_handler_id;
// subscribe to the EndSSGI event with a lambda handler function and keeping connection ID
endssgi_handler_id = publisher->getEventEndSSGI().connect([]() {
Log::message("\Handling EndSSGI event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndSSGI().disconnect(endssgi_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndSSGI events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSSGI().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndSSGI().setEnabled(true);
Return value
Event reference.Event<> getEventBeginSSGI() const#
Usage Example
// implement the BeginSSGI event handler
void beginssgi_event_handler()
{
Log::message("\Handling BeginSSGI event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginssgi_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSSGI().connect(beginssgi_event_connections, beginssgi_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSSGI().connect(beginssgi_event_connections, []() {
Log::message("\Handling BeginSSGI event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginssgi_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginssgi_event_connection;
// subscribe to the BeginSSGI event with a handler function keeping the connection
publisher->getEventBeginSSGI().connect(beginssgi_event_connection, beginssgi_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginssgi_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginssgi_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginSSGI event via the connection
beginssgi_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginSSGI event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginSSGI event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSSGI().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginSSGI event with a handler function
publisher->getEventBeginSSGI().connect(beginssgi_event_handler);
// remove subscription to the BeginSSGI event later by the handler function
publisher->getEventBeginSSGI().disconnect(beginssgi_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginssgi_handler_id;
// subscribe to the BeginSSGI event with a lambda handler function and keeping connection ID
beginssgi_handler_id = publisher->getEventBeginSSGI().connect([]() {
Log::message("\Handling BeginSSGI event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginSSGI().disconnect(beginssgi_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginSSGI events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSSGI().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginSSGI().setEnabled(true);
Return value
Event reference.Event<> getEventEndSSAO() const#
Usage Example
// implement the EndSSAO event handler
void endssao_event_handler()
{
Log::message("\Handling EndSSAO event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endssao_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSSAO().connect(endssao_event_connections, endssao_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSSAO().connect(endssao_event_connections, []() {
Log::message("\Handling EndSSAO event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endssao_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endssao_event_connection;
// subscribe to the EndSSAO event with a handler function keeping the connection
publisher->getEventEndSSAO().connect(endssao_event_connection, endssao_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endssao_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endssao_event_connection.setEnabled(true);
// ...
// remove subscription to the EndSSAO event via the connection
endssao_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndSSAO event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndSSAO event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSSAO().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndSSAO event with a handler function
publisher->getEventEndSSAO().connect(endssao_event_handler);
// remove subscription to the EndSSAO event later by the handler function
publisher->getEventEndSSAO().disconnect(endssao_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endssao_handler_id;
// subscribe to the EndSSAO event with a lambda handler function and keeping connection ID
endssao_handler_id = publisher->getEventEndSSAO().connect([]() {
Log::message("\Handling EndSSAO event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndSSAO().disconnect(endssao_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndSSAO events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSSAO().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndSSAO().setEnabled(true);
Return value
Event reference.Event<> getEventBeginSSAO() const#
Usage Example
// implement the BeginSSAO event handler
void beginssao_event_handler()
{
Log::message("\Handling BeginSSAO event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginssao_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSSAO().connect(beginssao_event_connections, beginssao_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSSAO().connect(beginssao_event_connections, []() {
Log::message("\Handling BeginSSAO event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginssao_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginssao_event_connection;
// subscribe to the BeginSSAO event with a handler function keeping the connection
publisher->getEventBeginSSAO().connect(beginssao_event_connection, beginssao_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginssao_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginssao_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginSSAO event via the connection
beginssao_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginSSAO event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginSSAO event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSSAO().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginSSAO event with a handler function
publisher->getEventBeginSSAO().connect(beginssao_event_handler);
// remove subscription to the BeginSSAO event later by the handler function
publisher->getEventBeginSSAO().disconnect(beginssao_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginssao_handler_id;
// subscribe to the BeginSSAO event with a lambda handler function and keeping connection ID
beginssao_handler_id = publisher->getEventBeginSSAO().connect([]() {
Log::message("\Handling BeginSSAO event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginSSAO().disconnect(beginssao_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginSSAO events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSSAO().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginSSAO().setEnabled(true);
Return value
Event reference.Event<> getEventEndSSR() const#
Usage Example
// implement the EndSSR event handler
void endssr_event_handler()
{
Log::message("\Handling EndSSR event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endssr_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSSR().connect(endssr_event_connections, endssr_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSSR().connect(endssr_event_connections, []() {
Log::message("\Handling EndSSR event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endssr_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endssr_event_connection;
// subscribe to the EndSSR event with a handler function keeping the connection
publisher->getEventEndSSR().connect(endssr_event_connection, endssr_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endssr_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endssr_event_connection.setEnabled(true);
// ...
// remove subscription to the EndSSR event via the connection
endssr_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndSSR event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndSSR event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSSR().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndSSR event with a handler function
publisher->getEventEndSSR().connect(endssr_event_handler);
// remove subscription to the EndSSR event later by the handler function
publisher->getEventEndSSR().disconnect(endssr_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endssr_handler_id;
// subscribe to the EndSSR event with a lambda handler function and keeping connection ID
endssr_handler_id = publisher->getEventEndSSR().connect([]() {
Log::message("\Handling EndSSR event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndSSR().disconnect(endssr_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndSSR events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSSR().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndSSR().setEnabled(true);
Return value
Event reference.Event<> getEventBeginSSR() const#
Usage Example
// implement the BeginSSR event handler
void beginssr_event_handler()
{
Log::message("\Handling BeginSSR event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginssr_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSSR().connect(beginssr_event_connections, beginssr_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSSR().connect(beginssr_event_connections, []() {
Log::message("\Handling BeginSSR event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginssr_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginssr_event_connection;
// subscribe to the BeginSSR event with a handler function keeping the connection
publisher->getEventBeginSSR().connect(beginssr_event_connection, beginssr_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginssr_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginssr_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginSSR event via the connection
beginssr_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginSSR event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginSSR event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSSR().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginSSR event with a handler function
publisher->getEventBeginSSR().connect(beginssr_event_handler);
// remove subscription to the BeginSSR event later by the handler function
publisher->getEventBeginSSR().disconnect(beginssr_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginssr_handler_id;
// subscribe to the BeginSSR event with a lambda handler function and keeping connection ID
beginssr_handler_id = publisher->getEventBeginSSR().connect([]() {
Log::message("\Handling BeginSSR event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginSSR().disconnect(beginssr_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginSSR events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSSR().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginSSR().setEnabled(true);
Return value
Event reference.Event<> getEventEndSSSS() const#
Usage Example
// implement the EndSSSS event handler
void endssss_event_handler()
{
Log::message("\Handling EndSSSS event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endssss_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSSSS().connect(endssss_event_connections, endssss_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSSSS().connect(endssss_event_connections, []() {
Log::message("\Handling EndSSSS event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endssss_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endssss_event_connection;
// subscribe to the EndSSSS event with a handler function keeping the connection
publisher->getEventEndSSSS().connect(endssss_event_connection, endssss_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endssss_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endssss_event_connection.setEnabled(true);
// ...
// remove subscription to the EndSSSS event via the connection
endssss_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndSSSS event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndSSSS event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSSSS().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndSSSS event with a handler function
publisher->getEventEndSSSS().connect(endssss_event_handler);
// remove subscription to the EndSSSS event later by the handler function
publisher->getEventEndSSSS().disconnect(endssss_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endssss_handler_id;
// subscribe to the EndSSSS event with a lambda handler function and keeping connection ID
endssss_handler_id = publisher->getEventEndSSSS().connect([]() {
Log::message("\Handling EndSSSS event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndSSSS().disconnect(endssss_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndSSSS events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSSSS().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndSSSS().setEnabled(true);
Return value
Event reference.Event<> getEventBeginSSSS() const#
Usage Example
// implement the BeginSSSS event handler
void beginssss_event_handler()
{
Log::message("\Handling BeginSSSS event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginssss_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSSSS().connect(beginssss_event_connections, beginssss_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSSSS().connect(beginssss_event_connections, []() {
Log::message("\Handling BeginSSSS event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginssss_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginssss_event_connection;
// subscribe to the BeginSSSS event with a handler function keeping the connection
publisher->getEventBeginSSSS().connect(beginssss_event_connection, beginssss_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginssss_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginssss_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginSSSS event via the connection
beginssss_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginSSSS event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginSSSS event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSSSS().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginSSSS event with a handler function
publisher->getEventBeginSSSS().connect(beginssss_event_handler);
// remove subscription to the BeginSSSS event later by the handler function
publisher->getEventBeginSSSS().disconnect(beginssss_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginssss_handler_id;
// subscribe to the BeginSSSS event with a lambda handler function and keeping connection ID
beginssss_handler_id = publisher->getEventBeginSSSS().connect([]() {
Log::message("\Handling BeginSSSS event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginSSSS().disconnect(beginssss_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginSSSS events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSSSS().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginSSSS().setEnabled(true);
Return value
Event reference.Event<> getEventEndTransparentBlurBuffer() const#
Usage Example
// implement the EndTransparentBlurBuffer event handler
void endtransparentblurbuffer_event_handler()
{
Log::message("\Handling EndTransparentBlurBuffer event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endtransparentblurbuffer_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndTransparentBlurBuffer().connect(endtransparentblurbuffer_event_connections, endtransparentblurbuffer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndTransparentBlurBuffer().connect(endtransparentblurbuffer_event_connections, []() {
Log::message("\Handling EndTransparentBlurBuffer event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endtransparentblurbuffer_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endtransparentblurbuffer_event_connection;
// subscribe to the EndTransparentBlurBuffer event with a handler function keeping the connection
publisher->getEventEndTransparentBlurBuffer().connect(endtransparentblurbuffer_event_connection, endtransparentblurbuffer_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endtransparentblurbuffer_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endtransparentblurbuffer_event_connection.setEnabled(true);
// ...
// remove subscription to the EndTransparentBlurBuffer event via the connection
endtransparentblurbuffer_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndTransparentBlurBuffer event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndTransparentBlurBuffer event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndTransparentBlurBuffer().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndTransparentBlurBuffer event with a handler function
publisher->getEventEndTransparentBlurBuffer().connect(endtransparentblurbuffer_event_handler);
// remove subscription to the EndTransparentBlurBuffer event later by the handler function
publisher->getEventEndTransparentBlurBuffer().disconnect(endtransparentblurbuffer_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endtransparentblurbuffer_handler_id;
// subscribe to the EndTransparentBlurBuffer event with a lambda handler function and keeping connection ID
endtransparentblurbuffer_handler_id = publisher->getEventEndTransparentBlurBuffer().connect([]() {
Log::message("\Handling EndTransparentBlurBuffer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndTransparentBlurBuffer().disconnect(endtransparentblurbuffer_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndTransparentBlurBuffer events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndTransparentBlurBuffer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndTransparentBlurBuffer().setEnabled(true);
Return value
Event reference.Event<> getEventBeginTransparentBlurBuffer() const#
Usage Example
// implement the BeginTransparentBlurBuffer event handler
void begintransparentblurbuffer_event_handler()
{
Log::message("\Handling BeginTransparentBlurBuffer event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections begintransparentblurbuffer_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginTransparentBlurBuffer().connect(begintransparentblurbuffer_event_connections, begintransparentblurbuffer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginTransparentBlurBuffer().connect(begintransparentblurbuffer_event_connections, []() {
Log::message("\Handling BeginTransparentBlurBuffer event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
begintransparentblurbuffer_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection begintransparentblurbuffer_event_connection;
// subscribe to the BeginTransparentBlurBuffer event with a handler function keeping the connection
publisher->getEventBeginTransparentBlurBuffer().connect(begintransparentblurbuffer_event_connection, begintransparentblurbuffer_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
begintransparentblurbuffer_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
begintransparentblurbuffer_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginTransparentBlurBuffer event via the connection
begintransparentblurbuffer_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginTransparentBlurBuffer event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginTransparentBlurBuffer event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginTransparentBlurBuffer().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginTransparentBlurBuffer event with a handler function
publisher->getEventBeginTransparentBlurBuffer().connect(begintransparentblurbuffer_event_handler);
// remove subscription to the BeginTransparentBlurBuffer event later by the handler function
publisher->getEventBeginTransparentBlurBuffer().disconnect(begintransparentblurbuffer_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId begintransparentblurbuffer_handler_id;
// subscribe to the BeginTransparentBlurBuffer event with a lambda handler function and keeping connection ID
begintransparentblurbuffer_handler_id = publisher->getEventBeginTransparentBlurBuffer().connect([]() {
Log::message("\Handling BeginTransparentBlurBuffer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginTransparentBlurBuffer().disconnect(begintransparentblurbuffer_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginTransparentBlurBuffer events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginTransparentBlurBuffer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginTransparentBlurBuffer().setEnabled(true);
Return value
Event reference.Event<> getEventEndRefractionBuffer() const#
Usage Example
// implement the EndRefractionBuffer event handler
void endrefractionbuffer_event_handler()
{
Log::message("\Handling EndRefractionBuffer event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endrefractionbuffer_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndRefractionBuffer().connect(endrefractionbuffer_event_connections, endrefractionbuffer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndRefractionBuffer().connect(endrefractionbuffer_event_connections, []() {
Log::message("\Handling EndRefractionBuffer event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endrefractionbuffer_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endrefractionbuffer_event_connection;
// subscribe to the EndRefractionBuffer event with a handler function keeping the connection
publisher->getEventEndRefractionBuffer().connect(endrefractionbuffer_event_connection, endrefractionbuffer_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endrefractionbuffer_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endrefractionbuffer_event_connection.setEnabled(true);
// ...
// remove subscription to the EndRefractionBuffer event via the connection
endrefractionbuffer_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndRefractionBuffer event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndRefractionBuffer event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndRefractionBuffer().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndRefractionBuffer event with a handler function
publisher->getEventEndRefractionBuffer().connect(endrefractionbuffer_event_handler);
// remove subscription to the EndRefractionBuffer event later by the handler function
publisher->getEventEndRefractionBuffer().disconnect(endrefractionbuffer_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endrefractionbuffer_handler_id;
// subscribe to the EndRefractionBuffer event with a lambda handler function and keeping connection ID
endrefractionbuffer_handler_id = publisher->getEventEndRefractionBuffer().connect([]() {
Log::message("\Handling EndRefractionBuffer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndRefractionBuffer().disconnect(endrefractionbuffer_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndRefractionBuffer events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndRefractionBuffer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndRefractionBuffer().setEnabled(true);
Return value
Event reference.Event<> getEventBeginRefractionBuffer() const#
Usage Example
// implement the BeginRefractionBuffer event handler
void beginrefractionbuffer_event_handler()
{
Log::message("\Handling BeginRefractionBuffer event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginrefractionbuffer_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginRefractionBuffer().connect(beginrefractionbuffer_event_connections, beginrefractionbuffer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginRefractionBuffer().connect(beginrefractionbuffer_event_connections, []() {
Log::message("\Handling BeginRefractionBuffer event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginrefractionbuffer_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginrefractionbuffer_event_connection;
// subscribe to the BeginRefractionBuffer event with a handler function keeping the connection
publisher->getEventBeginRefractionBuffer().connect(beginrefractionbuffer_event_connection, beginrefractionbuffer_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginrefractionbuffer_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginrefractionbuffer_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginRefractionBuffer event via the connection
beginrefractionbuffer_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginRefractionBuffer event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginRefractionBuffer event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginRefractionBuffer().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginRefractionBuffer event with a handler function
publisher->getEventBeginRefractionBuffer().connect(beginrefractionbuffer_event_handler);
// remove subscription to the BeginRefractionBuffer event later by the handler function
publisher->getEventBeginRefractionBuffer().disconnect(beginrefractionbuffer_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginrefractionbuffer_handler_id;
// subscribe to the BeginRefractionBuffer event with a lambda handler function and keeping connection ID
beginrefractionbuffer_handler_id = publisher->getEventBeginRefractionBuffer().connect([]() {
Log::message("\Handling BeginRefractionBuffer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginRefractionBuffer().disconnect(beginrefractionbuffer_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginRefractionBuffer events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginRefractionBuffer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginRefractionBuffer().setEnabled(true);
Return value
Event reference.Event<> getEventEndAuxiliaryBuffer() const#
Usage Example
// implement the EndAuxiliaryBuffer event handler
void endauxiliarybuffer_event_handler()
{
Log::message("\Handling EndAuxiliaryBuffer event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endauxiliarybuffer_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndAuxiliaryBuffer().connect(endauxiliarybuffer_event_connections, endauxiliarybuffer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndAuxiliaryBuffer().connect(endauxiliarybuffer_event_connections, []() {
Log::message("\Handling EndAuxiliaryBuffer event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endauxiliarybuffer_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endauxiliarybuffer_event_connection;
// subscribe to the EndAuxiliaryBuffer event with a handler function keeping the connection
publisher->getEventEndAuxiliaryBuffer().connect(endauxiliarybuffer_event_connection, endauxiliarybuffer_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endauxiliarybuffer_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endauxiliarybuffer_event_connection.setEnabled(true);
// ...
// remove subscription to the EndAuxiliaryBuffer event via the connection
endauxiliarybuffer_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndAuxiliaryBuffer event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndAuxiliaryBuffer event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndAuxiliaryBuffer().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndAuxiliaryBuffer event with a handler function
publisher->getEventEndAuxiliaryBuffer().connect(endauxiliarybuffer_event_handler);
// remove subscription to the EndAuxiliaryBuffer event later by the handler function
publisher->getEventEndAuxiliaryBuffer().disconnect(endauxiliarybuffer_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endauxiliarybuffer_handler_id;
// subscribe to the EndAuxiliaryBuffer event with a lambda handler function and keeping connection ID
endauxiliarybuffer_handler_id = publisher->getEventEndAuxiliaryBuffer().connect([]() {
Log::message("\Handling EndAuxiliaryBuffer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndAuxiliaryBuffer().disconnect(endauxiliarybuffer_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndAuxiliaryBuffer events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndAuxiliaryBuffer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndAuxiliaryBuffer().setEnabled(true);
Return value
Event reference.Event<> getEventBeginAuxiliaryBuffer() const#
Usage Example
// implement the BeginAuxiliaryBuffer event handler
void beginauxiliarybuffer_event_handler()
{
Log::message("\Handling BeginAuxiliaryBuffer event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginauxiliarybuffer_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginAuxiliaryBuffer().connect(beginauxiliarybuffer_event_connections, beginauxiliarybuffer_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginAuxiliaryBuffer().connect(beginauxiliarybuffer_event_connections, []() {
Log::message("\Handling BeginAuxiliaryBuffer event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginauxiliarybuffer_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginauxiliarybuffer_event_connection;
// subscribe to the BeginAuxiliaryBuffer event with a handler function keeping the connection
publisher->getEventBeginAuxiliaryBuffer().connect(beginauxiliarybuffer_event_connection, beginauxiliarybuffer_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginauxiliarybuffer_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginauxiliarybuffer_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginAuxiliaryBuffer event via the connection
beginauxiliarybuffer_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginAuxiliaryBuffer event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginAuxiliaryBuffer event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginAuxiliaryBuffer().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginAuxiliaryBuffer event with a handler function
publisher->getEventBeginAuxiliaryBuffer().connect(beginauxiliarybuffer_event_handler);
// remove subscription to the BeginAuxiliaryBuffer event later by the handler function
publisher->getEventBeginAuxiliaryBuffer().disconnect(beginauxiliarybuffer_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginauxiliarybuffer_handler_id;
// subscribe to the BeginAuxiliaryBuffer event with a lambda handler function and keeping connection ID
beginauxiliarybuffer_handler_id = publisher->getEventBeginAuxiliaryBuffer().connect([]() {
Log::message("\Handling BeginAuxiliaryBuffer event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginAuxiliaryBuffer().disconnect(beginauxiliarybuffer_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginAuxiliaryBuffer events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginAuxiliaryBuffer().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginAuxiliaryBuffer().setEnabled(true);
Return value
Event reference.Event<> getEventEndOpacityPlanarProbes() const#
Usage Example
// implement the EndOpacityPlanarProbes event handler
void endopacityplanarprobes_event_handler()
{
Log::message("\Handling EndOpacityPlanarProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endopacityplanarprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndOpacityPlanarProbes().connect(endopacityplanarprobes_event_connections, endopacityplanarprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndOpacityPlanarProbes().connect(endopacityplanarprobes_event_connections, []() {
Log::message("\Handling EndOpacityPlanarProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endopacityplanarprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endopacityplanarprobes_event_connection;
// subscribe to the EndOpacityPlanarProbes event with a handler function keeping the connection
publisher->getEventEndOpacityPlanarProbes().connect(endopacityplanarprobes_event_connection, endopacityplanarprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endopacityplanarprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endopacityplanarprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the EndOpacityPlanarProbes event via the connection
endopacityplanarprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndOpacityPlanarProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndOpacityPlanarProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndOpacityPlanarProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndOpacityPlanarProbes event with a handler function
publisher->getEventEndOpacityPlanarProbes().connect(endopacityplanarprobes_event_handler);
// remove subscription to the EndOpacityPlanarProbes event later by the handler function
publisher->getEventEndOpacityPlanarProbes().disconnect(endopacityplanarprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endopacityplanarprobes_handler_id;
// subscribe to the EndOpacityPlanarProbes event with a lambda handler function and keeping connection ID
endopacityplanarprobes_handler_id = publisher->getEventEndOpacityPlanarProbes().connect([]() {
Log::message("\Handling EndOpacityPlanarProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndOpacityPlanarProbes().disconnect(endopacityplanarprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndOpacityPlanarProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndOpacityPlanarProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndOpacityPlanarProbes().setEnabled(true);
Return value
Event reference.Event<> getEventBeginOpacityPlanarProbes() const#
Usage Example
// implement the BeginOpacityPlanarProbes event handler
void beginopacityplanarprobes_event_handler()
{
Log::message("\Handling BeginOpacityPlanarProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginopacityplanarprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginOpacityPlanarProbes().connect(beginopacityplanarprobes_event_connections, beginopacityplanarprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginOpacityPlanarProbes().connect(beginopacityplanarprobes_event_connections, []() {
Log::message("\Handling BeginOpacityPlanarProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginopacityplanarprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginopacityplanarprobes_event_connection;
// subscribe to the BeginOpacityPlanarProbes event with a handler function keeping the connection
publisher->getEventBeginOpacityPlanarProbes().connect(beginopacityplanarprobes_event_connection, beginopacityplanarprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginopacityplanarprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginopacityplanarprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginOpacityPlanarProbes event via the connection
beginopacityplanarprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginOpacityPlanarProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginOpacityPlanarProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginOpacityPlanarProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginOpacityPlanarProbes event with a handler function
publisher->getEventBeginOpacityPlanarProbes().connect(beginopacityplanarprobes_event_handler);
// remove subscription to the BeginOpacityPlanarProbes event later by the handler function
publisher->getEventBeginOpacityPlanarProbes().disconnect(beginopacityplanarprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginopacityplanarprobes_handler_id;
// subscribe to the BeginOpacityPlanarProbes event with a lambda handler function and keeping connection ID
beginopacityplanarprobes_handler_id = publisher->getEventBeginOpacityPlanarProbes().connect([]() {
Log::message("\Handling BeginOpacityPlanarProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginOpacityPlanarProbes().disconnect(beginopacityplanarprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginOpacityPlanarProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginOpacityPlanarProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginOpacityPlanarProbes().setEnabled(true);
Return value
Event reference.Event<> getEventEndOpacityEnvironmentProbes() const#
Usage Example
// implement the EndOpacityEnvironmentProbes event handler
void endopacityenvironmentprobes_event_handler()
{
Log::message("\Handling EndOpacityEnvironmentProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endopacityenvironmentprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndOpacityEnvironmentProbes().connect(endopacityenvironmentprobes_event_connections, endopacityenvironmentprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndOpacityEnvironmentProbes().connect(endopacityenvironmentprobes_event_connections, []() {
Log::message("\Handling EndOpacityEnvironmentProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endopacityenvironmentprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endopacityenvironmentprobes_event_connection;
// subscribe to the EndOpacityEnvironmentProbes event with a handler function keeping the connection
publisher->getEventEndOpacityEnvironmentProbes().connect(endopacityenvironmentprobes_event_connection, endopacityenvironmentprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endopacityenvironmentprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endopacityenvironmentprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the EndOpacityEnvironmentProbes event via the connection
endopacityenvironmentprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndOpacityEnvironmentProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndOpacityEnvironmentProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndOpacityEnvironmentProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndOpacityEnvironmentProbes event with a handler function
publisher->getEventEndOpacityEnvironmentProbes().connect(endopacityenvironmentprobes_event_handler);
// remove subscription to the EndOpacityEnvironmentProbes event later by the handler function
publisher->getEventEndOpacityEnvironmentProbes().disconnect(endopacityenvironmentprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endopacityenvironmentprobes_handler_id;
// subscribe to the EndOpacityEnvironmentProbes event with a lambda handler function and keeping connection ID
endopacityenvironmentprobes_handler_id = publisher->getEventEndOpacityEnvironmentProbes().connect([]() {
Log::message("\Handling EndOpacityEnvironmentProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndOpacityEnvironmentProbes().disconnect(endopacityenvironmentprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndOpacityEnvironmentProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndOpacityEnvironmentProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndOpacityEnvironmentProbes().setEnabled(true);
Return value
Event reference.Event<> getEventBeginOpacityEnvironmentProbes() const#
Usage Example
// implement the BeginOpacityEnvironmentProbes event handler
void beginopacityenvironmentprobes_event_handler()
{
Log::message("\Handling BeginOpacityEnvironmentProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginopacityenvironmentprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginOpacityEnvironmentProbes().connect(beginopacityenvironmentprobes_event_connections, beginopacityenvironmentprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginOpacityEnvironmentProbes().connect(beginopacityenvironmentprobes_event_connections, []() {
Log::message("\Handling BeginOpacityEnvironmentProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginopacityenvironmentprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginopacityenvironmentprobes_event_connection;
// subscribe to the BeginOpacityEnvironmentProbes event with a handler function keeping the connection
publisher->getEventBeginOpacityEnvironmentProbes().connect(beginopacityenvironmentprobes_event_connection, beginopacityenvironmentprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginopacityenvironmentprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginopacityenvironmentprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginOpacityEnvironmentProbes event via the connection
beginopacityenvironmentprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginOpacityEnvironmentProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginOpacityEnvironmentProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginOpacityEnvironmentProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginOpacityEnvironmentProbes event with a handler function
publisher->getEventBeginOpacityEnvironmentProbes().connect(beginopacityenvironmentprobes_event_handler);
// remove subscription to the BeginOpacityEnvironmentProbes event later by the handler function
publisher->getEventBeginOpacityEnvironmentProbes().disconnect(beginopacityenvironmentprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginopacityenvironmentprobes_handler_id;
// subscribe to the BeginOpacityEnvironmentProbes event with a lambda handler function and keeping connection ID
beginopacityenvironmentprobes_handler_id = publisher->getEventBeginOpacityEnvironmentProbes().connect([]() {
Log::message("\Handling BeginOpacityEnvironmentProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginOpacityEnvironmentProbes().disconnect(beginopacityenvironmentprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginOpacityEnvironmentProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginOpacityEnvironmentProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginOpacityEnvironmentProbes().setEnabled(true);
Return value
Event reference.Event<> getEventEndOpacityVoxelProbes() const#
Usage Example
// implement the EndOpacityVoxelProbes event handler
void endopacityvoxelprobes_event_handler()
{
Log::message("\Handling EndOpacityVoxelProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endopacityvoxelprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndOpacityVoxelProbes().connect(endopacityvoxelprobes_event_connections, endopacityvoxelprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndOpacityVoxelProbes().connect(endopacityvoxelprobes_event_connections, []() {
Log::message("\Handling EndOpacityVoxelProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endopacityvoxelprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endopacityvoxelprobes_event_connection;
// subscribe to the EndOpacityVoxelProbes event with a handler function keeping the connection
publisher->getEventEndOpacityVoxelProbes().connect(endopacityvoxelprobes_event_connection, endopacityvoxelprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endopacityvoxelprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endopacityvoxelprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the EndOpacityVoxelProbes event via the connection
endopacityvoxelprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndOpacityVoxelProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndOpacityVoxelProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndOpacityVoxelProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndOpacityVoxelProbes event with a handler function
publisher->getEventEndOpacityVoxelProbes().connect(endopacityvoxelprobes_event_handler);
// remove subscription to the EndOpacityVoxelProbes event later by the handler function
publisher->getEventEndOpacityVoxelProbes().disconnect(endopacityvoxelprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endopacityvoxelprobes_handler_id;
// subscribe to the EndOpacityVoxelProbes event with a lambda handler function and keeping connection ID
endopacityvoxelprobes_handler_id = publisher->getEventEndOpacityVoxelProbes().connect([]() {
Log::message("\Handling EndOpacityVoxelProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndOpacityVoxelProbes().disconnect(endopacityvoxelprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndOpacityVoxelProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndOpacityVoxelProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndOpacityVoxelProbes().setEnabled(true);
Return value
Event reference.Event<> getEventBeginOpacityVoxelProbes() const#
Usage Example
// implement the BeginOpacityVoxelProbes event handler
void beginopacityvoxelprobes_event_handler()
{
Log::message("\Handling BeginOpacityVoxelProbes event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginopacityvoxelprobes_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginOpacityVoxelProbes().connect(beginopacityvoxelprobes_event_connections, beginopacityvoxelprobes_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginOpacityVoxelProbes().connect(beginopacityvoxelprobes_event_connections, []() {
Log::message("\Handling BeginOpacityVoxelProbes event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginopacityvoxelprobes_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginopacityvoxelprobes_event_connection;
// subscribe to the BeginOpacityVoxelProbes event with a handler function keeping the connection
publisher->getEventBeginOpacityVoxelProbes().connect(beginopacityvoxelprobes_event_connection, beginopacityvoxelprobes_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginopacityvoxelprobes_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginopacityvoxelprobes_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginOpacityVoxelProbes event via the connection
beginopacityvoxelprobes_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginOpacityVoxelProbes event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginOpacityVoxelProbes event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginOpacityVoxelProbes().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginOpacityVoxelProbes event with a handler function
publisher->getEventBeginOpacityVoxelProbes().connect(beginopacityvoxelprobes_event_handler);
// remove subscription to the BeginOpacityVoxelProbes event later by the handler function
publisher->getEventBeginOpacityVoxelProbes().disconnect(beginopacityvoxelprobes_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginopacityvoxelprobes_handler_id;
// subscribe to the BeginOpacityVoxelProbes event with a lambda handler function and keeping connection ID
beginopacityvoxelprobes_handler_id = publisher->getEventBeginOpacityVoxelProbes().connect([]() {
Log::message("\Handling BeginOpacityVoxelProbes event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginOpacityVoxelProbes().disconnect(beginopacityvoxelprobes_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginOpacityVoxelProbes events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginOpacityVoxelProbes().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginOpacityVoxelProbes().setEnabled(true);
Return value
Event reference.Event<> getEventEndOpacityLights() const#
Usage Example
// implement the EndOpacityLights event handler
void endopacitylights_event_handler()
{
Log::message("\Handling EndOpacityLights event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endopacitylights_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndOpacityLights().connect(endopacitylights_event_connections, endopacitylights_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndOpacityLights().connect(endopacitylights_event_connections, []() {
Log::message("\Handling EndOpacityLights event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endopacitylights_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endopacitylights_event_connection;
// subscribe to the EndOpacityLights event with a handler function keeping the connection
publisher->getEventEndOpacityLights().connect(endopacitylights_event_connection, endopacitylights_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endopacitylights_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endopacitylights_event_connection.setEnabled(true);
// ...
// remove subscription to the EndOpacityLights event via the connection
endopacitylights_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndOpacityLights event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndOpacityLights event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndOpacityLights().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndOpacityLights event with a handler function
publisher->getEventEndOpacityLights().connect(endopacitylights_event_handler);
// remove subscription to the EndOpacityLights event later by the handler function
publisher->getEventEndOpacityLights().disconnect(endopacitylights_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endopacitylights_handler_id;
// subscribe to the EndOpacityLights event with a lambda handler function and keeping connection ID
endopacitylights_handler_id = publisher->getEventEndOpacityLights().connect([]() {
Log::message("\Handling EndOpacityLights event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndOpacityLights().disconnect(endopacitylights_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndOpacityLights events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndOpacityLights().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndOpacityLights().setEnabled(true);
Return value
Event reference.Event<> getEventBeginOpacityLights() const#
Usage Example
// implement the BeginOpacityLights event handler
void beginopacitylights_event_handler()
{
Log::message("\Handling BeginOpacityLights event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginopacitylights_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginOpacityLights().connect(beginopacitylights_event_connections, beginopacitylights_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginOpacityLights().connect(beginopacitylights_event_connections, []() {
Log::message("\Handling BeginOpacityLights event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginopacitylights_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginopacitylights_event_connection;
// subscribe to the BeginOpacityLights event with a handler function keeping the connection
publisher->getEventBeginOpacityLights().connect(beginopacitylights_event_connection, beginopacitylights_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginopacitylights_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginopacitylights_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginOpacityLights event via the connection
beginopacitylights_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginOpacityLights event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginOpacityLights event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginOpacityLights().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginOpacityLights event with a handler function
publisher->getEventBeginOpacityLights().connect(beginopacitylights_event_handler);
// remove subscription to the BeginOpacityLights event later by the handler function
publisher->getEventBeginOpacityLights().disconnect(beginopacitylights_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginopacitylights_handler_id;
// subscribe to the BeginOpacityLights event with a lambda handler function and keeping connection ID
beginopacitylights_handler_id = publisher->getEventBeginOpacityLights().connect([]() {
Log::message("\Handling BeginOpacityLights event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginOpacityLights().disconnect(beginopacitylights_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginOpacityLights events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginOpacityLights().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginOpacityLights().setEnabled(true);
Return value
Event reference.Event<> getEventEndSSRTGI() const#
Usage Example
// implement the EndSSRTGI event handler
void endssrtgi_event_handler()
{
Log::message("\Handling EndSSRTGI event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endssrtgi_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndSSRTGI().connect(endssrtgi_event_connections, endssrtgi_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndSSRTGI().connect(endssrtgi_event_connections, []() {
Log::message("\Handling EndSSRTGI event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endssrtgi_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endssrtgi_event_connection;
// subscribe to the EndSSRTGI event with a handler function keeping the connection
publisher->getEventEndSSRTGI().connect(endssrtgi_event_connection, endssrtgi_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endssrtgi_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endssrtgi_event_connection.setEnabled(true);
// ...
// remove subscription to the EndSSRTGI event via the connection
endssrtgi_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A EndSSRTGI event handler implemented as a class member
void event_handler()
{
Log::message("\Handling EndSSRTGI event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventEndSSRTGI().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the EndSSRTGI event with a handler function
publisher->getEventEndSSRTGI().connect(endssrtgi_event_handler);
// remove subscription to the EndSSRTGI event later by the handler function
publisher->getEventEndSSRTGI().disconnect(endssrtgi_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId endssrtgi_handler_id;
// subscribe to the EndSSRTGI event with a lambda handler function and keeping connection ID
endssrtgi_handler_id = publisher->getEventEndSSRTGI().connect([]() {
Log::message("\Handling EndSSRTGI event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventEndSSRTGI().disconnect(endssrtgi_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all EndSSRTGI events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventEndSSRTGI().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventEndSSRTGI().setEnabled(true);
Return value
Event reference.Event<> getEventBeginSSRTGI() const#
Usage Example
// implement the BeginSSRTGI event handler
void beginssrtgi_event_handler()
{
Log::message("\Handling BeginSSRTGI event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections beginssrtgi_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventBeginSSRTGI().connect(beginssrtgi_event_connections, beginssrtgi_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventBeginSSRTGI().connect(beginssrtgi_event_connections, []() {
Log::message("\Handling BeginSSRTGI event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
beginssrtgi_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection beginssrtgi_event_connection;
// subscribe to the BeginSSRTGI event with a handler function keeping the connection
publisher->getEventBeginSSRTGI().connect(beginssrtgi_event_connection, beginssrtgi_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
beginssrtgi_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
beginssrtgi_event_connection.setEnabled(true);
// ...
// remove subscription to the BeginSSRTGI event via the connection
beginssrtgi_event_connection.disconnect();
//////////////////////////////////////////////////////////////////////////////
// 3. You can add EventConnection/EventConnections instance as a member of the
// class that handles the event. In this case all linked subscriptions will be
// automatically removed when class destructor is called
//////////////////////////////////////////////////////////////////////////////
// Class handling the event
class SomeClass
{
public:
// instance of the EventConnections class as a class member
EventConnections e_connections;
// A BeginSSRTGI event handler implemented as a class member
void event_handler()
{
Log::message("\Handling BeginSSRTGI event\n");
// ...
}
};
SomeClass *sc = new SomeClass();
// ...
// specify a class instance in case a handler method belongs to some class
publisher->getEventBeginSSRTGI().connect(sc->e_connections, sc, &SomeClass::event_handler);
// ...
// handler class instance is deleted with all its subscriptions removed automatically
delete sc;
//////////////////////////////////////////////////////////////////////////////
// 4. You can subscribe and unsubscribe via the handler function directly
//////////////////////////////////////////////////////////////////////////////
// subscribe to the BeginSSRTGI event with a handler function
publisher->getEventBeginSSRTGI().connect(beginssrtgi_event_handler);
// remove subscription to the BeginSSRTGI event later by the handler function
publisher->getEventBeginSSRTGI().disconnect(beginssrtgi_event_handler);
//////////////////////////////////////////////////////////////////////////////
// 5. Subscribe to an event saving an ID and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// define a connection ID to be used to unsubscribe later
EventConnectionId beginssrtgi_handler_id;
// subscribe to the BeginSSRTGI event with a lambda handler function and keeping connection ID
beginssrtgi_handler_id = publisher->getEventBeginSSRTGI().connect([]() {
Log::message("\Handling BeginSSRTGI event (lambda).\n");
}
);
// remove the subscription later using the ID
publisher->getEventBeginSSRTGI().disconnect(beginssrtgi_handler_id);
//////////////////////////////////////////////////////////////////////////////
// 6. Ignoring all BeginSSRTGI events when necessary
//////////////////////////////////////////////////////////////////////////////
// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventBeginSSRTGI().setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
publisher->getEventBeginSSRTGI().setEnabled(true);
Return value
Event reference.Event<> getEventEndCurvatureComposite() const#
Usage Example
// implement the EndCurvatureComposite event handler
void endcurvaturecomposite_event_handler()
{
Log::message("\Handling EndCurvatureComposite event\n");
}
//////////////////////////////////////////////////////////////////////////////
// 1. Multiple subscriptions can be linked to an instance of the EventConnections
// class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnections class
EventConnections endcurvaturecomposite_event_connections;
// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventEndCurvatureComposite().connect(endcurvaturecomposite_event_connections, endcurvaturecomposite_event_handler);
// other subscriptions are also linked to this EventConnections instance
// (e.g. you can subscribe using lambdas)
publisher->getEventEndCurvatureComposite().connect(endcurvaturecomposite_event_connections, []() {
Log::message("\Handling EndCurvatureComposite event (lambda).\n");
}
);
// ...
// later all of these linked subscriptions can be removed with a single line
endcurvaturecomposite_event_connections.disconnectAll();
//////////////////////////////////////////////////////////////////////////////
// 2. You can subscribe and unsubscribe via an instance of the EventConnection
// class. And toggle this particular connection off and on, when necessary.
//////////////////////////////////////////////////////////////////////////////
// create an instance of the EventConnection class
EventConnection endcurvaturecomposite_event_connection;
// subscribe to the EndCurvatureComposite event with a handler function keeping the connection
publisher->getEventEndCurvatureComposite().connect(endcurvaturecomposite_event_connection, endcurvaturecomposite_event_handler);
// ...
// you can temporarily disable a particular event connection to perform certain actions
endcurvaturecomposite_event_connection.setEnabled(false);
// ... actions to be performed
// and enable it back when necessary
endcurvaturecomposite_event_connection.setEnabled(true);
// ...
// remove subscription to the EndCurvature