Unigine::Property Class

// implement the Destroy event handler
void destroy_event_handler(const Ptr<Property> & property)
{
	Log::message("\Handling Destroy 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 destroy_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventDestroy().connect(destroy_event_connections, destroy_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventDestroy().connect(destroy_event_connections, [](const Ptr<Property> & property) { 
		Log::message("\Handling Destroy event (lambda).\n");
	}
);

// ...

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

// subscribe to the Destroy event with a handler function keeping the connection
publisher->getEventDestroy().connect(destroy_event_connection, destroy_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventDestroy().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 Destroy event with a handler function
publisher->getEventDestroy().connect(destroy_event_handler);


// remove subscription to the Destroy event later by the handler function
publisher->getEventDestroy().disconnect(destroy_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 destroy_handler_id;

// subscribe to the Destroy event with a lambda handler function and keeping connection ID
destroy_handler_id = publisher->getEventDestroy().connect([](const Ptr<Property> & property) { 
		Log::message("\Handling Destroy event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventDestroy().disconnect(destroy_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all Destroy events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventDestroy().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventDestroy().setEnabled(true);

// implement the ParameterChanged event handler
void parameterchanged_event_handler(const Ptr<Property> & property,  int param_index)
{
	Log::message("\Handling ParameterChanged 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 parameterchanged_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventParameterChanged().connect(parameterchanged_event_connections, parameterchanged_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventParameterChanged().connect(parameterchanged_event_connections, [](const Ptr<Property> & property,  int param_index) { 
		Log::message("\Handling ParameterChanged event (lambda).\n");
	}
);

// ...

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

// subscribe to the ParameterChanged event with a handler function keeping the connection
publisher->getEventParameterChanged().connect(parameterchanged_event_connection, parameterchanged_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the ParameterChanged event via the connection
parameterchanged_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 ParameterChanged event handler implemented as a class member
	void event_handler(const Ptr<Property> & property,  int param_index)
	{
		Log::message("\Handling ParameterChanged event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventParameterChanged().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 ParameterChanged event with a handler function
publisher->getEventParameterChanged().connect(parameterchanged_event_handler);


// remove subscription to the ParameterChanged event later by the handler function
publisher->getEventParameterChanged().disconnect(parameterchanged_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 parameterchanged_handler_id;

// subscribe to the ParameterChanged event with a lambda handler function and keeping connection ID
parameterchanged_handler_id = publisher->getEventParameterChanged().connect([](const Ptr<Property> & property,  int param_index) { 
		Log::message("\Handling ParameterChanged event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventParameterChanged().disconnect(parameterchanged_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all ParameterChanged events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventParameterChanged().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventParameterChanged().setEnabled(true);

// implement the Reparented event handler
void reparented_event_handler(const Ptr<Property> & property)
{
	Log::message("\Handling Reparented 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 reparented_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventReparented().connect(reparented_event_connections, reparented_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventReparented().connect(reparented_event_connections, [](const Ptr<Property> & property) { 
		Log::message("\Handling Reparented event (lambda).\n");
	}
);

// ...

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

// subscribe to the Reparented event with a handler function keeping the connection
publisher->getEventReparented().connect(reparented_event_connection, reparented_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventReparented().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 Reparented event with a handler function
publisher->getEventReparented().connect(reparented_event_handler);


// remove subscription to the Reparented event later by the handler function
publisher->getEventReparented().disconnect(reparented_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 reparented_handler_id;

// subscribe to the Reparented event with a lambda handler function and keeping connection ID
reparented_handler_id = publisher->getEventReparented().connect([](const Ptr<Property> & property) { 
		Log::message("\Handling Reparented event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventReparented().disconnect(reparented_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all Reparented events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventReparented().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventReparented().setEnabled(true);

// implement the Renamed event handler
void renamed_event_handler(const Ptr<Property> & property)
{
	Log::message("\Handling Renamed 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 renamed_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventRenamed().connect(renamed_event_connections, renamed_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventRenamed().connect(renamed_event_connections, [](const Ptr<Property> & property) { 
		Log::message("\Handling Renamed event (lambda).\n");
	}
);

// ...

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

// subscribe to the Renamed event with a handler function keeping the connection
publisher->getEventRenamed().connect(renamed_event_connection, renamed_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventRenamed().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 Renamed event with a handler function
publisher->getEventRenamed().connect(renamed_event_handler);


// remove subscription to the Renamed event later by the handler function
publisher->getEventRenamed().disconnect(renamed_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 renamed_handler_id;

// subscribe to the Renamed event with a lambda handler function and keeping connection ID
renamed_handler_id = publisher->getEventRenamed().connect([](const Ptr<Property> & property) { 
		Log::message("\Handling Renamed event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventRenamed().disconnect(renamed_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all Renamed events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventRenamed().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventRenamed().setEnabled(true);

// implement the Moved event handler
void moved_event_handler(const Ptr<Property> & property)
{
	Log::message("\Handling Moved 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 moved_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventMoved().connect(moved_event_connections, moved_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventMoved().connect(moved_event_connections, [](const Ptr<Property> & property) { 
		Log::message("\Handling Moved event (lambda).\n");
	}
);

// ...

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

// subscribe to the Moved event with a handler function keeping the connection
publisher->getEventMoved().connect(moved_event_connection, moved_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventMoved().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 Moved event with a handler function
publisher->getEventMoved().connect(moved_event_handler);


// remove subscription to the Moved event later by the handler function
publisher->getEventMoved().disconnect(moved_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 moved_handler_id;

// subscribe to the Moved event with a lambda handler function and keeping connection ID
moved_handler_id = publisher->getEventMoved().connect([](const Ptr<Property> & property) { 
		Log::message("\Handling Moved event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventMoved().disconnect(moved_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all Moved events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventMoved().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventMoved().setEnabled(true);

// implement the Reloaded event handler
void reloaded_event_handler(const Ptr<Property> & property)
{
	Log::message("\Handling Reloaded 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 reloaded_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher->getEventReloaded().connect(reloaded_event_connections, reloaded_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher->getEventReloaded().connect(reloaded_event_connections, [](const Ptr<Property> & property) { 
		Log::message("\Handling Reloaded event (lambda).\n");
	}
);

// ...

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

// subscribe to the Reloaded event with a handler function keeping the connection
publisher->getEventReloaded().connect(reloaded_event_connection, reloaded_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
publisher->getEventReloaded().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 Reloaded event with a handler function
publisher->getEventReloaded().connect(reloaded_event_handler);


// remove subscription to the Reloaded event later by the handler function
publisher->getEventReloaded().disconnect(reloaded_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 reloaded_handler_id;

// subscribe to the Reloaded event with a lambda handler function and keeping connection ID
reloaded_handler_id = publisher->getEventReloaded().connect([](const Ptr<Property> & property) { 
		Log::message("\Handling Reloaded event (lambda).\n");
	}
);

// remove the subscription later using the ID
publisher->getEventReloaded().disconnect(reloaded_handler_id);


//////////////////////////////////////////////////////////////////////////////
//   6. Ignoring all Reloaded events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher->getEventReloaded().setEnabled(false);

// ... actions to be performed

// and enable it back when necessary
publisher->getEventReloaded().setEnabled(true);