Unigine.Property Class

// implement the Destroy event handler
void destroy_event_handler(Property property)
{
	Log.Message("\Handling Destroy event\n");
}

//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an EventConnections instance
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections destroy_event_connections = new EventConnections();


// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher.EventDestroy.Connect(destroy_event_connections, destroy_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher.EventDestroy.Connect(destroy_event_connections, (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 the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the Destroy event with a handler function
publisher.EventDestroy.Connect(destroy_event_handler);


// remove subscription to the Destroy event later by the handler function
publisher.EventDestroy.Disconnect(destroy_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   3. Subscribe to an event and unsubscribe later via an EventConnection instance
//////////////////////////////////////////////////////////////////////////////

// define a connection to be used to unsubscribe later
EventConnection destroy_event_connection;

// subscribe to the Destroy event with a lambda handler function and keeping the connection
destroy_event_connection = publisher.EventDestroy.Connect((Property property) => { 
		Log.Message("Handling Destroy event lambda\n");
	}
);

// ...

// you can temporarily disable a particular event connection 
destroy_event_connection.Enabled = false;

// ... perform certain actions

// and enable it back when necessary
destroy_event_connection.Enabled = true;

// ...

// remove the subscription later using the saved connection
destroy_event_connection.Disconnect();

//////////////////////////////////////////////////////////////////////////////
//   4. Ignoring Destroy events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher.EventDestroy.Enabled = false;

// ... actions to be performed

// and enable it back when necessary
publisher.EventDestroy.Enabled = true;

// implement the ParameterChanged event handler
void parameterchanged_event_handler(Property property,  int param_index)
{
	Log.Message("\Handling ParameterChanged event\n");
}

//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an EventConnections instance
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections parameterchanged_event_connections = new EventConnections();


// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher.EventParameterChanged.Connect(parameterchanged_event_connections, parameterchanged_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher.EventParameterChanged.Connect(parameterchanged_event_connections, (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 the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the ParameterChanged event with a handler function
publisher.EventParameterChanged.Connect(parameterchanged_event_handler);


// remove subscription to the ParameterChanged event later by the handler function
publisher.EventParameterChanged.Disconnect(parameterchanged_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   3. Subscribe to an event and unsubscribe later via an EventConnection instance
//////////////////////////////////////////////////////////////////////////////

// define a connection to be used to unsubscribe later
EventConnection parameterchanged_event_connection;

// subscribe to the ParameterChanged event with a lambda handler function and keeping the connection
parameterchanged_event_connection = publisher.EventParameterChanged.Connect((Property property,  int param_index) => { 
		Log.Message("Handling ParameterChanged event lambda\n");
	}
);

// ...

// you can temporarily disable a particular event connection 
parameterchanged_event_connection.Enabled = false;

// ... perform certain actions

// and enable it back when necessary
parameterchanged_event_connection.Enabled = true;

// ...

// remove the subscription later using the saved connection
parameterchanged_event_connection.Disconnect();

//////////////////////////////////////////////////////////////////////////////
//   4. Ignoring ParameterChanged events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher.EventParameterChanged.Enabled = false;

// ... actions to be performed

// and enable it back when necessary
publisher.EventParameterChanged.Enabled = true;

// implement the Reparented event handler
void reparented_event_handler(Property property)
{
	Log.Message("\Handling Reparented event\n");
}

//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an EventConnections instance
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections reparented_event_connections = new EventConnections();


// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher.EventReparented.Connect(reparented_event_connections, reparented_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher.EventReparented.Connect(reparented_event_connections, (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 the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the Reparented event with a handler function
publisher.EventReparented.Connect(reparented_event_handler);


// remove subscription to the Reparented event later by the handler function
publisher.EventReparented.Disconnect(reparented_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   3. Subscribe to an event and unsubscribe later via an EventConnection instance
//////////////////////////////////////////////////////////////////////////////

// define a connection to be used to unsubscribe later
EventConnection reparented_event_connection;

// subscribe to the Reparented event with a lambda handler function and keeping the connection
reparented_event_connection = publisher.EventReparented.Connect((Property property) => { 
		Log.Message("Handling Reparented event lambda\n");
	}
);

// ...

// you can temporarily disable a particular event connection 
reparented_event_connection.Enabled = false;

// ... perform certain actions

// and enable it back when necessary
reparented_event_connection.Enabled = true;

// ...

// remove the subscription later using the saved connection
reparented_event_connection.Disconnect();

//////////////////////////////////////////////////////////////////////////////
//   4. Ignoring Reparented events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher.EventReparented.Enabled = false;

// ... actions to be performed

// and enable it back when necessary
publisher.EventReparented.Enabled = true;

// implement the Renamed event handler
void renamed_event_handler(Property property)
{
	Log.Message("\Handling Renamed event\n");
}

//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an EventConnections instance
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections renamed_event_connections = new EventConnections();


// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher.EventRenamed.Connect(renamed_event_connections, renamed_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher.EventRenamed.Connect(renamed_event_connections, (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 the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the Renamed event with a handler function
publisher.EventRenamed.Connect(renamed_event_handler);


// remove subscription to the Renamed event later by the handler function
publisher.EventRenamed.Disconnect(renamed_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   3. Subscribe to an event and unsubscribe later via an EventConnection instance
//////////////////////////////////////////////////////////////////////////////

// define a connection to be used to unsubscribe later
EventConnection renamed_event_connection;

// subscribe to the Renamed event with a lambda handler function and keeping the connection
renamed_event_connection = publisher.EventRenamed.Connect((Property property) => { 
		Log.Message("Handling Renamed event lambda\n");
	}
);

// ...

// you can temporarily disable a particular event connection 
renamed_event_connection.Enabled = false;

// ... perform certain actions

// and enable it back when necessary
renamed_event_connection.Enabled = true;

// ...

// remove the subscription later using the saved connection
renamed_event_connection.Disconnect();

//////////////////////////////////////////////////////////////////////////////
//   4. Ignoring Renamed events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher.EventRenamed.Enabled = false;

// ... actions to be performed

// and enable it back when necessary
publisher.EventRenamed.Enabled = true;

// implement the Moved event handler
void moved_event_handler(Property property)
{
	Log.Message("\Handling Moved event\n");
}

//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an EventConnections instance
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections moved_event_connections = new EventConnections();


// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher.EventMoved.Connect(moved_event_connections, moved_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher.EventMoved.Connect(moved_event_connections, (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 the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the Moved event with a handler function
publisher.EventMoved.Connect(moved_event_handler);


// remove subscription to the Moved event later by the handler function
publisher.EventMoved.Disconnect(moved_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   3. Subscribe to an event and unsubscribe later via an EventConnection instance
//////////////////////////////////////////////////////////////////////////////

// define a connection to be used to unsubscribe later
EventConnection moved_event_connection;

// subscribe to the Moved event with a lambda handler function and keeping the connection
moved_event_connection = publisher.EventMoved.Connect((Property property) => { 
		Log.Message("Handling Moved event lambda\n");
	}
);

// ...

// you can temporarily disable a particular event connection 
moved_event_connection.Enabled = false;

// ... perform certain actions

// and enable it back when necessary
moved_event_connection.Enabled = true;

// ...

// remove the subscription later using the saved connection
moved_event_connection.Disconnect();

//////////////////////////////////////////////////////////////////////////////
//   4. Ignoring Moved events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher.EventMoved.Enabled = false;

// ... actions to be performed

// and enable it back when necessary
publisher.EventMoved.Enabled = true;

// implement the Reloaded event handler
void reloaded_event_handler(Property property)
{
	Log.Message("\Handling Reloaded event\n");
}

//////////////////////////////////////////////////////////////////////////////
//  1. Multiple subscriptions can be linked to an EventConnections instance
//  class that you can use later to remove all these subscriptions at once
//////////////////////////////////////////////////////////////////////////////

// create an instance of the EventConnections class
EventConnections reloaded_event_connections = new EventConnections();


// link to this instance when subscribing to an event (subscription to various events can be linked)
publisher.EventReloaded.Connect(reloaded_event_connections, reloaded_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
publisher.EventReloaded.Connect(reloaded_event_connections, (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 the handler function directly
//////////////////////////////////////////////////////////////////////////////

// subscribe to the Reloaded event with a handler function
publisher.EventReloaded.Connect(reloaded_event_handler);


// remove subscription to the Reloaded event later by the handler function
publisher.EventReloaded.Disconnect(reloaded_event_handler);


//////////////////////////////////////////////////////////////////////////////
//   3. Subscribe to an event and unsubscribe later via an EventConnection instance
//////////////////////////////////////////////////////////////////////////////

// define a connection to be used to unsubscribe later
EventConnection reloaded_event_connection;

// subscribe to the Reloaded event with a lambda handler function and keeping the connection
reloaded_event_connection = publisher.EventReloaded.Connect((Property property) => { 
		Log.Message("Handling Reloaded event lambda\n");
	}
);

// ...

// you can temporarily disable a particular event connection 
reloaded_event_connection.Enabled = false;

// ... perform certain actions

// and enable it back when necessary
reloaded_event_connection.Enabled = true;

// ...

// remove the subscription later using the saved connection
reloaded_event_connection.Disconnect();

//////////////////////////////////////////////////////////////////////////////
//   4. Ignoring Reloaded events when necessary
//////////////////////////////////////////////////////////////////////////////

// you can temporarily disable the event to perform certain actions without triggering it
publisher.EventReloaded.Enabled = false;

// ... actions to be performed

// and enable it back when necessary
publisher.EventReloaded.Enabled = true;