Unigine::Plugins::SpiderVision::ViewportData Class

// implement the BaseChanged event handler
void basechanged_event_handler(ViewportData *viewport_data)
{
	Log::message("\Handling BaseChanged 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 basechanged_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
ViewportData::getEventBaseChanged().connect(basechanged_event_connections, basechanged_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
ViewportData::getEventBaseChanged().connect(basechanged_event_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling BaseChanged event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
basechanged_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 basechanged_event_connection;

// subscribe to the BaseChanged event with a handler function keeping the connection
ViewportData::getEventBaseChanged().connect(basechanged_event_connection, basechanged_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
basechanged_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
basechanged_event_connection.setEnabled(true);

// ...

// remove subscription to the BaseChanged event via the connection
basechanged_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 BaseChanged event handler implemented as a class member
	void event_handler(ViewportData *viewport_data)
	{
		Log::message("\Handling BaseChanged event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
ViewportData::getEventBaseChanged().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;


//////////////////////////////////////////////////////////////////////////////
//   4. Subscribe to an event saving a particular connection ID
//   and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// instance of the EventConnections class to manage event connections
EventConnections e_connections;

// define a particular connection ID to be used to unsubscribe later
EventConnectionId basechanged_handler_id;

// subscribe to the BaseChanged event with a lambda handler function and keeping connection ID
basechanged_handler_id = ViewportData::getEventBaseChanged().connect(e_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling BaseChanged event (lambda).\n");
	}
);

// remove the subscription later using the ID
ViewportData::getEventBaseChanged().disconnect(basechanged_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   5. Ignoring all BaseChanged events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
ViewportData::getEventBaseChanged().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
ViewportData::getEventBaseChanged().setEnabled(true);

// implement the WarpChanged event handler
void warpchanged_event_handler(ViewportData *viewport_data)
{
	Log::message("\Handling WarpChanged 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 warpchanged_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
ViewportData::getEventWarpChanged().connect(warpchanged_event_connections, warpchanged_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
ViewportData::getEventWarpChanged().connect(warpchanged_event_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling WarpChanged event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
warpchanged_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 warpchanged_event_connection;

// subscribe to the WarpChanged event with a handler function keeping the connection
ViewportData::getEventWarpChanged().connect(warpchanged_event_connection, warpchanged_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
warpchanged_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
warpchanged_event_connection.setEnabled(true);

// ...

// remove subscription to the WarpChanged event via the connection
warpchanged_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 WarpChanged event handler implemented as a class member
	void event_handler(ViewportData *viewport_data)
	{
		Log::message("\Handling WarpChanged event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
ViewportData::getEventWarpChanged().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;


//////////////////////////////////////////////////////////////////////////////
//   4. Subscribe to an event saving a particular connection ID
//   and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// instance of the EventConnections class to manage event connections
EventConnections e_connections;

// define a particular connection ID to be used to unsubscribe later
EventConnectionId warpchanged_handler_id;

// subscribe to the WarpChanged event with a lambda handler function and keeping connection ID
warpchanged_handler_id = ViewportData::getEventWarpChanged().connect(e_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling WarpChanged event (lambda).\n");
	}
);

// remove the subscription later using the ID
ViewportData::getEventWarpChanged().disconnect(warpchanged_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   5. Ignoring all WarpChanged events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
ViewportData::getEventWarpChanged().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
ViewportData::getEventWarpChanged().setEnabled(true);

// implement the EasyblendChanged event handler
void easyblendchanged_event_handler(ViewportData *viewport_data)
{
	Log::message("\Handling EasyblendChanged 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 easyblendchanged_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
ViewportData::getEventEasyblendChanged().connect(easyblendchanged_event_connections, easyblendchanged_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
ViewportData::getEventEasyblendChanged().connect(easyblendchanged_event_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling EasyblendChanged event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
easyblendchanged_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 easyblendchanged_event_connection;

// subscribe to the EasyblendChanged event with a handler function keeping the connection
ViewportData::getEventEasyblendChanged().connect(easyblendchanged_event_connection, easyblendchanged_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
easyblendchanged_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
easyblendchanged_event_connection.setEnabled(true);

// ...

// remove subscription to the EasyblendChanged event via the connection
easyblendchanged_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 EasyblendChanged event handler implemented as a class member
	void event_handler(ViewportData *viewport_data)
	{
		Log::message("\Handling EasyblendChanged event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
ViewportData::getEventEasyblendChanged().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;


//////////////////////////////////////////////////////////////////////////////
//   4. Subscribe to an event saving a particular connection ID
//   and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// instance of the EventConnections class to manage event connections
EventConnections e_connections;

// define a particular connection ID to be used to unsubscribe later
EventConnectionId easyblendchanged_handler_id;

// subscribe to the EasyblendChanged event with a lambda handler function and keeping connection ID
easyblendchanged_handler_id = ViewportData::getEventEasyblendChanged().connect(e_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling EasyblendChanged event (lambda).\n");
	}
);

// remove the subscription later using the ID
ViewportData::getEventEasyblendChanged().disconnect(easyblendchanged_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   5. Ignoring all EasyblendChanged events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
ViewportData::getEventEasyblendChanged().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
ViewportData::getEventEasyblendChanged().setEnabled(true);

// implement the BlendChanged event handler
void blendchanged_event_handler(ViewportData *viewport_data)
{
	Log::message("\Handling BlendChanged 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 blendchanged_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
ViewportData::getEventBlendChanged().connect(blendchanged_event_connections, blendchanged_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
ViewportData::getEventBlendChanged().connect(blendchanged_event_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling BlendChanged event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
blendchanged_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 blendchanged_event_connection;

// subscribe to the BlendChanged event with a handler function keeping the connection
ViewportData::getEventBlendChanged().connect(blendchanged_event_connection, blendchanged_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
blendchanged_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
blendchanged_event_connection.setEnabled(true);

// ...

// remove subscription to the BlendChanged event via the connection
blendchanged_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 BlendChanged event handler implemented as a class member
	void event_handler(ViewportData *viewport_data)
	{
		Log::message("\Handling BlendChanged event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
ViewportData::getEventBlendChanged().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;


//////////////////////////////////////////////////////////////////////////////
//   4. Subscribe to an event saving a particular connection ID
//   and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// instance of the EventConnections class to manage event connections
EventConnections e_connections;

// define a particular connection ID to be used to unsubscribe later
EventConnectionId blendchanged_handler_id;

// subscribe to the BlendChanged event with a lambda handler function and keeping connection ID
blendchanged_handler_id = ViewportData::getEventBlendChanged().connect(e_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling BlendChanged event (lambda).\n");
	}
);

// remove the subscription later using the ID
ViewportData::getEventBlendChanged().disconnect(blendchanged_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   5. Ignoring all BlendChanged events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
ViewportData::getEventBlendChanged().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
ViewportData::getEventBlendChanged().setEnabled(true);

// implement the MaskChanged event handler
void maskchanged_event_handler(ViewportData *viewport_data)
{
	Log::message("\Handling MaskChanged 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 maskchanged_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
ViewportData::getEventMaskChanged().connect(maskchanged_event_connections, maskchanged_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
ViewportData::getEventMaskChanged().connect(maskchanged_event_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling MaskChanged event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
maskchanged_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 maskchanged_event_connection;

// subscribe to the MaskChanged event with a handler function keeping the connection
ViewportData::getEventMaskChanged().connect(maskchanged_event_connection, maskchanged_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
maskchanged_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
maskchanged_event_connection.setEnabled(true);

// ...

// remove subscription to the MaskChanged event via the connection
maskchanged_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 MaskChanged event handler implemented as a class member
	void event_handler(ViewportData *viewport_data)
	{
		Log::message("\Handling MaskChanged event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
ViewportData::getEventMaskChanged().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;


//////////////////////////////////////////////////////////////////////////////
//   4. Subscribe to an event saving a particular connection ID
//   and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// instance of the EventConnections class to manage event connections
EventConnections e_connections;

// define a particular connection ID to be used to unsubscribe later
EventConnectionId maskchanged_handler_id;

// subscribe to the MaskChanged event with a lambda handler function and keeping connection ID
maskchanged_handler_id = ViewportData::getEventMaskChanged().connect(e_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling MaskChanged event (lambda).\n");
	}
);

// remove the subscription later using the ID
ViewportData::getEventMaskChanged().disconnect(maskchanged_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   5. Ignoring all MaskChanged events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
ViewportData::getEventMaskChanged().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
ViewportData::getEventMaskChanged().setEnabled(true);

// implement the ColorChanged event handler
void colorchanged_event_handler(ViewportData *viewport_data)
{
	Log::message("\Handling ColorChanged 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 colorchanged_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
ViewportData::getEventColorChanged().connect(colorchanged_event_connections, colorchanged_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
ViewportData::getEventColorChanged().connect(colorchanged_event_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling ColorChanged event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
colorchanged_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 colorchanged_event_connection;

// subscribe to the ColorChanged event with a handler function keeping the connection
ViewportData::getEventColorChanged().connect(colorchanged_event_connection, colorchanged_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
colorchanged_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
colorchanged_event_connection.setEnabled(true);

// ...

// remove subscription to the ColorChanged event via the connection
colorchanged_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 ColorChanged event handler implemented as a class member
	void event_handler(ViewportData *viewport_data)
	{
		Log::message("\Handling ColorChanged event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
ViewportData::getEventColorChanged().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;


//////////////////////////////////////////////////////////////////////////////
//   4. Subscribe to an event saving a particular connection ID
//   and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// instance of the EventConnections class to manage event connections
EventConnections e_connections;

// define a particular connection ID to be used to unsubscribe later
EventConnectionId colorchanged_handler_id;

// subscribe to the ColorChanged event with a lambda handler function and keeping connection ID
colorchanged_handler_id = ViewportData::getEventColorChanged().connect(e_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling ColorChanged event (lambda).\n");
	}
);

// remove the subscription later using the ID
ViewportData::getEventColorChanged().disconnect(colorchanged_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   5. Ignoring all ColorChanged events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
ViewportData::getEventColorChanged().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
ViewportData::getEventColorChanged().setEnabled(true);

// implement the DebugChanged event handler
void debugchanged_event_handler(ViewportData *viewport_data)
{
	Log::message("\Handling DebugChanged 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 debugchanged_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
ViewportData::getEventDebugChanged().connect(debugchanged_event_connections, debugchanged_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
ViewportData::getEventDebugChanged().connect(debugchanged_event_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling DebugChanged event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
debugchanged_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 debugchanged_event_connection;

// subscribe to the DebugChanged event with a handler function keeping the connection
ViewportData::getEventDebugChanged().connect(debugchanged_event_connection, debugchanged_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
debugchanged_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
debugchanged_event_connection.setEnabled(true);

// ...

// remove subscription to the DebugChanged event via the connection
debugchanged_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 DebugChanged event handler implemented as a class member
	void event_handler(ViewportData *viewport_data)
	{
		Log::message("\Handling DebugChanged event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
ViewportData::getEventDebugChanged().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;


//////////////////////////////////////////////////////////////////////////////
//   4. Subscribe to an event saving a particular connection ID
//   and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// instance of the EventConnections class to manage event connections
EventConnections e_connections;

// define a particular connection ID to be used to unsubscribe later
EventConnectionId debugchanged_handler_id;

// subscribe to the DebugChanged event with a lambda handler function and keeping connection ID
debugchanged_handler_id = ViewportData::getEventDebugChanged().connect(e_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling DebugChanged event (lambda).\n");
	}
);

// remove the subscription later using the ID
ViewportData::getEventDebugChanged().disconnect(debugchanged_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   5. Ignoring all DebugChanged events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
ViewportData::getEventDebugChanged().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
ViewportData::getEventDebugChanged().setEnabled(true);

// implement the SomethingChanged event handler
void somethingchanged_event_handler(ViewportData *viewport_data)
{
	Log::message("\Handling SomethingChanged 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 somethingchanged_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
ViewportData::getEventSomethingChanged().connect(somethingchanged_event_connections, somethingchanged_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
ViewportData::getEventSomethingChanged().connect(somethingchanged_event_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling SomethingChanged event (lambda).\n");
	}
);

// ...

// later all of these linked subscriptions can be removed with a single line
somethingchanged_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 somethingchanged_event_connection;

// subscribe to the SomethingChanged event with a handler function keeping the connection
ViewportData::getEventSomethingChanged().connect(somethingchanged_event_connection, somethingchanged_event_handler);

// ...

// you can temporarily disable a particular event connection to perform certain actions
somethingchanged_event_connection.setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
somethingchanged_event_connection.setEnabled(true);

// ...

// remove subscription to the SomethingChanged event via the connection
somethingchanged_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 SomethingChanged event handler implemented as a class member
	void event_handler(ViewportData *viewport_data)
	{
		Log::message("\Handling SomethingChanged event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
ViewportData::getEventSomethingChanged().connect(sc->e_connections, sc, &SomeClass::event_handler);

// ...

// handler class instance is deleted with all its subscriptions removed automatically
delete sc;


//////////////////////////////////////////////////////////////////////////////
//   4. Subscribe to an event saving a particular connection ID
//   and unsubscribe later by this ID
//////////////////////////////////////////////////////////////////////////////
// instance of the EventConnections class to manage event connections
EventConnections e_connections;

// define a particular connection ID to be used to unsubscribe later
EventConnectionId somethingchanged_handler_id;

// subscribe to the SomethingChanged event with a lambda handler function and keeping connection ID
somethingchanged_handler_id = ViewportData::getEventSomethingChanged().connect(e_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling SomethingChanged event (lambda).\n");
	}
);

// remove the subscription later using the ID
ViewportData::getEventSomethingChanged().disconnect(somethingchanged_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   5. Ignoring all SomethingChanged events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
ViewportData::getEventSomethingChanged().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
ViewportData::getEventSomethingChanged().setEnabled(true);