Unigine::Animations Class

// implement the TrackRemoved event handler
void trackremoved_event_handler(const Ptr<AnimationTrack> & anim_track)
{
	Log::message("\Handling TrackRemoved 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 trackremoved_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
Animations::getEventTrackRemoved().connect(trackremoved_event_connections, trackremoved_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
Animations::getEventTrackRemoved().connect(trackremoved_event_connections, [](const Ptr<AnimationTrack> & anim_track) { 
		Log::message("\Handling TrackRemoved event (lambda).\n");
	}
);

// ...

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

// subscribe to the TrackRemoved event with a handler function keeping the connection
Animations::getEventTrackRemoved().connect(trackremoved_event_connection, trackremoved_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the TrackRemoved event via the connection
trackremoved_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 TrackRemoved event handler implemented as a class member
	void event_handler(const Ptr<AnimationTrack> & anim_track)
	{
		Log::message("\Handling TrackRemoved event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
Animations::getEventTrackRemoved().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 trackremoved_handler_id;

// subscribe to the TrackRemoved event with a lambda handler function and keeping connection ID
trackremoved_handler_id = Animations::getEventTrackRemoved().connect(e_connections, [](const Ptr<AnimationTrack> & anim_track) { 
		Log::message("\Handling TrackRemoved event (lambda).\n");
	}
);

// remove the subscription later using the ID
Animations::getEventTrackRemoved().disconnect(trackremoved_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
Animations::getEventTrackRemoved().setEnabled(true);

// implement the TrackAdded event handler
void trackadded_event_handler(const Ptr<AnimationTrack> & anim_track)
{
	Log::message("\Handling TrackAdded 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 trackadded_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
Animations::getEventTrackAdded().connect(trackadded_event_connections, trackadded_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
Animations::getEventTrackAdded().connect(trackadded_event_connections, [](const Ptr<AnimationTrack> & anim_track) { 
		Log::message("\Handling TrackAdded event (lambda).\n");
	}
);

// ...

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

// subscribe to the TrackAdded event with a handler function keeping the connection
Animations::getEventTrackAdded().connect(trackadded_event_connection, trackadded_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the TrackAdded event via the connection
trackadded_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 TrackAdded event handler implemented as a class member
	void event_handler(const Ptr<AnimationTrack> & anim_track)
	{
		Log::message("\Handling TrackAdded event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
Animations::getEventTrackAdded().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 trackadded_handler_id;

// subscribe to the TrackAdded event with a lambda handler function and keeping connection ID
trackadded_handler_id = Animations::getEventTrackAdded().connect(e_connections, [](const Ptr<AnimationTrack> & anim_track) { 
		Log::message("\Handling TrackAdded event (lambda).\n");
	}
);

// remove the subscription later using the ID
Animations::getEventTrackAdded().disconnect(trackadded_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
Animations::getEventTrackAdded().setEnabled(true);

// implement the ObjectRemoved event handler
void objectremoved_event_handler(const Ptr<AnimationObject> & anim_object)
{
	Log::message("\Handling ObjectRemoved 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 objectremoved_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
Animations::getEventObjectRemoved().connect(objectremoved_event_connections, objectremoved_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
Animations::getEventObjectRemoved().connect(objectremoved_event_connections, [](const Ptr<AnimationObject> & anim_object) { 
		Log::message("\Handling ObjectRemoved event (lambda).\n");
	}
);

// ...

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

// subscribe to the ObjectRemoved event with a handler function keeping the connection
Animations::getEventObjectRemoved().connect(objectremoved_event_connection, objectremoved_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the ObjectRemoved event via the connection
objectremoved_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 ObjectRemoved event handler implemented as a class member
	void event_handler(const Ptr<AnimationObject> & anim_object)
	{
		Log::message("\Handling ObjectRemoved event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
Animations::getEventObjectRemoved().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 objectremoved_handler_id;

// subscribe to the ObjectRemoved event with a lambda handler function and keeping connection ID
objectremoved_handler_id = Animations::getEventObjectRemoved().connect(e_connections, [](const Ptr<AnimationObject> & anim_object) { 
		Log::message("\Handling ObjectRemoved event (lambda).\n");
	}
);

// remove the subscription later using the ID
Animations::getEventObjectRemoved().disconnect(objectremoved_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
Animations::getEventObjectRemoved().setEnabled(true);

// implement the ObjectAdded event handler
void objectadded_event_handler(const Ptr<AnimationObject> & anim_object)
{
	Log::message("\Handling ObjectAdded 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 objectadded_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
Animations::getEventObjectAdded().connect(objectadded_event_connections, objectadded_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
Animations::getEventObjectAdded().connect(objectadded_event_connections, [](const Ptr<AnimationObject> & anim_object) { 
		Log::message("\Handling ObjectAdded event (lambda).\n");
	}
);

// ...

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

// subscribe to the ObjectAdded event with a handler function keeping the connection
Animations::getEventObjectAdded().connect(objectadded_event_connection, objectadded_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the ObjectAdded event via the connection
objectadded_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 ObjectAdded event handler implemented as a class member
	void event_handler(const Ptr<AnimationObject> & anim_object)
	{
		Log::message("\Handling ObjectAdded event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
Animations::getEventObjectAdded().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 objectadded_handler_id;

// subscribe to the ObjectAdded event with a lambda handler function and keeping connection ID
objectadded_handler_id = Animations::getEventObjectAdded().connect(e_connections, [](const Ptr<AnimationObject> & anim_object) { 
		Log::message("\Handling ObjectAdded event (lambda).\n");
	}
);

// remove the subscription later using the ID
Animations::getEventObjectAdded().disconnect(objectadded_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
Animations::getEventObjectAdded().setEnabled(true);