Unigine::WindowManager Class

// implement the ImmediateWindowEvent event handler
void immediatewindowevent_event_handler(const Ptr<WindowEvent> & event)
{
	Log::message("\Handling ImmediateWindowEvent 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 immediatewindowevent_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
WindowManager::getEventImmediateWindowEvent().connect(immediatewindowevent_event_connections, immediatewindowevent_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
WindowManager::getEventImmediateWindowEvent().connect(immediatewindowevent_event_connections, [](const Ptr<WindowEvent> & event) { 
		Log::message("\Handling ImmediateWindowEvent event (lambda).\n");
	}
);

// ...

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

// subscribe to the ImmediateWindowEvent event with a handler function keeping the connection
WindowManager::getEventImmediateWindowEvent().connect(immediatewindowevent_event_connection, immediatewindowevent_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
WindowManager::getEventImmediateWindowEvent().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 ImmediateWindowEvent event with a handler function
WindowManager::getEventImmediateWindowEvent().connect(immediatewindowevent_event_handler);


// remove subscription to the ImmediateWindowEvent event later by the handler function
WindowManager::getEventImmediateWindowEvent().disconnect(immediatewindowevent_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 immediatewindowevent_handler_id;

// subscribe to the ImmediateWindowEvent event with a lambda handler function and keeping connection ID
immediatewindowevent_handler_id = WindowManager::getEventImmediateWindowEvent().connect([](const Ptr<WindowEvent> & event) { 
		Log::message("\Handling ImmediateWindowEvent event (lambda).\n");
	}
);

// remove the subscription later using the ID
WindowManager::getEventImmediateWindowEvent().disconnect(immediatewindowevent_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
WindowManager::getEventImmediateWindowEvent().setEnabled(true);

// implement the WindowUnstacked event handler
void windowunstacked_event_handler(const Ptr<EngineWindow> & window)
{
	Log::message("\Handling WindowUnstacked 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 windowunstacked_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
WindowManager::getEventWindowUnstacked().connect(windowunstacked_event_connections, windowunstacked_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
WindowManager::getEventWindowUnstacked().connect(windowunstacked_event_connections, [](const Ptr<EngineWindow> & window) { 
		Log::message("\Handling WindowUnstacked event (lambda).\n");
	}
);

// ...

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

// subscribe to the WindowUnstacked event with a handler function keeping the connection
WindowManager::getEventWindowUnstacked().connect(windowunstacked_event_connection, windowunstacked_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
WindowManager::getEventWindowUnstacked().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 WindowUnstacked event with a handler function
WindowManager::getEventWindowUnstacked().connect(windowunstacked_event_handler);


// remove subscription to the WindowUnstacked event later by the handler function
WindowManager::getEventWindowUnstacked().disconnect(windowunstacked_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 windowunstacked_handler_id;

// subscribe to the WindowUnstacked event with a lambda handler function and keeping connection ID
windowunstacked_handler_id = WindowManager::getEventWindowUnstacked().connect([](const Ptr<EngineWindow> & window) { 
		Log::message("\Handling WindowUnstacked event (lambda).\n");
	}
);

// remove the subscription later using the ID
WindowManager::getEventWindowUnstacked().disconnect(windowunstacked_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
WindowManager::getEventWindowUnstacked().setEnabled(true);

// implement the WindowStacked event handler
void windowstacked_event_handler(const Ptr<EngineWindow> & window)
{
	Log::message("\Handling WindowStacked 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 windowstacked_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
WindowManager::getEventWindowStacked().connect(windowstacked_event_connections, windowstacked_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
WindowManager::getEventWindowStacked().connect(windowstacked_event_connections, [](const Ptr<EngineWindow> & window) { 
		Log::message("\Handling WindowStacked event (lambda).\n");
	}
);

// ...

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

// subscribe to the WindowStacked event with a handler function keeping the connection
WindowManager::getEventWindowStacked().connect(windowstacked_event_connection, windowstacked_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
WindowManager::getEventWindowStacked().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 WindowStacked event with a handler function
WindowManager::getEventWindowStacked().connect(windowstacked_event_handler);


// remove subscription to the WindowStacked event later by the handler function
WindowManager::getEventWindowStacked().disconnect(windowstacked_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 windowstacked_handler_id;

// subscribe to the WindowStacked event with a lambda handler function and keeping connection ID
windowstacked_handler_id = WindowManager::getEventWindowStacked().connect([](const Ptr<EngineWindow> & window) { 
		Log::message("\Handling WindowStacked event (lambda).\n");
	}
);

// remove the subscription later using the ID
WindowManager::getEventWindowStacked().disconnect(windowstacked_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
WindowManager::getEventWindowStacked().setEnabled(true);

// implement the WindowRemoved event handler
void windowremoved_event_handler(const Ptr<EngineWindow> & window)
{
	Log::message("\Handling WindowRemoved 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 windowremoved_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
WindowManager::getEventWindowRemoved().connect(windowremoved_event_connections, windowremoved_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
WindowManager::getEventWindowRemoved().connect(windowremoved_event_connections, [](const Ptr<EngineWindow> & window) { 
		Log::message("\Handling WindowRemoved event (lambda).\n");
	}
);

// ...

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

// subscribe to the WindowRemoved event with a handler function keeping the connection
WindowManager::getEventWindowRemoved().connect(windowremoved_event_connection, windowremoved_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
WindowManager::getEventWindowRemoved().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 WindowRemoved event with a handler function
WindowManager::getEventWindowRemoved().connect(windowremoved_event_handler);


// remove subscription to the WindowRemoved event later by the handler function
WindowManager::getEventWindowRemoved().disconnect(windowremoved_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 windowremoved_handler_id;

// subscribe to the WindowRemoved event with a lambda handler function and keeping connection ID
windowremoved_handler_id = WindowManager::getEventWindowRemoved().connect([](const Ptr<EngineWindow> & window) { 
		Log::message("\Handling WindowRemoved event (lambda).\n");
	}
);

// remove the subscription later using the ID
WindowManager::getEventWindowRemoved().disconnect(windowremoved_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
WindowManager::getEventWindowRemoved().setEnabled(true);

// implement the WindowCreated event handler
void windowcreated_event_handler(const Ptr<EngineWindow> & window)
{
	Log::message("\Handling WindowCreated 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 windowcreated_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
WindowManager::getEventWindowCreated().connect(windowcreated_event_connections, windowcreated_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
WindowManager::getEventWindowCreated().connect(windowcreated_event_connections, [](const Ptr<EngineWindow> & window) { 
		Log::message("\Handling WindowCreated event (lambda).\n");
	}
);

// ...

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

// subscribe to the WindowCreated event with a handler function keeping the connection
WindowManager::getEventWindowCreated().connect(windowcreated_event_connection, windowcreated_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

// specify a class instance in case a handler method belongs to some class
WindowManager::getEventWindowCreated().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 WindowCreated event with a handler function
WindowManager::getEventWindowCreated().connect(windowcreated_event_handler);


// remove subscription to the WindowCreated event later by the handler function
WindowManager::getEventWindowCreated().disconnect(windowcreated_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 windowcreated_handler_id;

// subscribe to the WindowCreated event with a lambda handler function and keeping connection ID
windowcreated_handler_id = WindowManager::getEventWindowCreated().connect([](const Ptr<EngineWindow> & window) { 
		Log::message("\Handling WindowCreated event (lambda).\n");
	}
);

// remove the subscription later using the ID
WindowManager::getEventWindowCreated().disconnect(windowcreated_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
WindowManager::getEventWindowCreated().setEnabled(true);