This page has been translated automatically.
Video Tutorials
How To
Professional (SIM)
Interface Overview
Assets Workflow
Settings and Preferences
Working With Projects
Adjusting Node Parameters
Setting Up Materials
Setting Up Properties
Using Editor Tools for Specific Tasks
Extending Editor Functionality
Built-in Node Types
Light Sources
World Nodes
Sound Objects
Pathfinding Objects
Setting Up Development Environment
Usage Examples
UUSL (Unified UNIGINE Shader Language)
File Formats
Materials and Shaders
Rebuilding the Engine Tools
Double Precision Coordinates
Common Functionality
Controls-Related Classes
Engine-Related Classes
Filesystem Functionality
GUI-Related Classes
Math Functionality
Node-Related Classes
Objects-Related Classes
Networking Functionality
Pathfinding-Related Classes
Physics-Related Classes
Plugins-Related Classes
IG Plugin
CIGIConnector Plugin
Rendering-Related Classes
Content Creation
Content Optimization
Material Nodes Library
Art Samples
Warning! This version of documentation is OUTDATED, as it describes an older SDK version! Please switch to the documentation for the latest SDK version.
Warning! This version of documentation describes an old SDK version which is no longer supported! Please upgrade to the latest SDK version.

Window Management

UNIGINE provides an advanced toolkit simplifying development of various visual tools, with a large number of widgets and capabilities.

For windows creation, the EngineWindow class is used. It allows managing engine windows components, relations with other windows, size, position, and other features.

All window management operations are performed via the WindowManager class enabling you to access any window of the application, group or stack windows, create various dialogs, and so on.

Usually the engine windows stay available during the whole UNIGINE Engine runtime, so their creation and management must be implemented as a part of the System Logic.

See Also#

Creating Windows#

To create the engine window, one of the EngineWindow class constructors is used.

Source code (C++)
// create an engine window of the specified size with the specified name
EngineWindowPtr window_0 = EngineWindow::create("Window", 580, 300);
// create the main engine window of the specified size
EngineWindowPtr window_1 = EngineWindow::create(580, 300, EngineWindow::FLAGS_MAIN);

When the window is created, you can change its appearance and properties, specify the engine tools available for the window and add widgets to its client area. All these operations can be done by means of the EngineWindow class as well.

Source code (C++)
// set an icon and a title for the window 
window_1->setTitle("Main Window");

// allow using the window as a nested one

// enable the console, profiler and visualizer for the window

// add widgets to the client area of the window
window_1->addChild(WidgetLabel::create(window->getSelfGui(), String::format("This is %s window.", window->getTitle())));
window_1->addChild(WidgetButton::create(window->getSelfGui(), window->getTitle()), Gui::ALIGN_CENTER);

To render the engine window, use the show() function:

Source code (C++)
// render the window

Accessing Windows#

An application window can be accessed via the getWindow() function of the WindowManager class.

Source code (C++)
// get the number of windows
int num = WindowManager::getNumWindows();
// check each window
for (int i = 0; i < num; i++)
	// get the window with the current index
	EngineWindowPtr window = WindowManager::getWindow(i);
	// change its position and size if it is main
	if (window->isMain())
		window->setPosition(Math::ivec2(1020, 60));
		window->setSize(Math::ivec2(305, 670));

There are also some functions (like getMainWindow()) that allow accessing the specific windows (the main, focused, fullscreen window and so on). For example:

Source code (C++)
// get the main window
EngineWindowPtr main_window = WindowManager::getMainWindow();
// change its position and size
if (main_window)
	main_window->setPosition(Math::ivec2(1020, 60));
	main_window->setSize(Math::ivec2(305, 670));

Grouping Windows#

The engine windows created via the EngineWindow class can be grouped. When two windows are grouped, a new window containing these windows is created. The new window is called a group. The number of windows in the group is unlimited.

There are three types of the window groups:

  • Vertical
  • Horizontal
  • Group of tabs

Within the group, all windows are stacked according to one of these types.

Grouping of the created windows can be done via the code or by using the mouse while the application is running.

The WindowManager class provides two main functions for grouping windows:

Source code (C++)
// create separate windows
EngineWindowPtr horizontal_1 = EngineWindow::create("Horizontal 1", 512, 256);
EngineWindowPtr horizontal_2 = EngineWindow::create("Horizontal 2", 512, 256);
EngineWindowPtr horizontal_3 = EngineWindow::create("Horizontal 3", 512, 256);
EngineWindowPtr horizontal_4 = EngineWindow::create("Horizontal 4", 512, 256);

// create 2 horizontal window groups 
EngineWindowPtr horizontal_group_1 = WindowManager::stack(horizontal_1, horizontal_2, 1, EngineWindow::GROUP_TYPE_HORIZONTAL);
EngineWindowPtr horizontal_group_2 = WindowManager::stack(horizontal_3, horizontal_4, 1, EngineWindow::GROUP_TYPE_HORIZONTAL);
// create a vertical group of 2 horizontal groups
EngineWindowPtr vertical_group = WindowManager::stackGroups(horizontal_group_1, horizontal_group_2, EngineWindow::GROUP_TYPE_VERTICAL);
// specify position, size, title of the verical window group
vertical_group->setPosition(Math::ivec2(50, 60));
vertical_group->setSize(Math::ivec2(565, 310));
vertical_group->setTitle("Vertical Group");
// render the window group

Each window or window group has a state, so it changes after stacking.

There are also functions based on the stack() function that should be used in specific cases to avoid additional checking of arguments:

  • stackToParentGroup() stacks the second window to the parent group of the first window. In the result, both windows passed as arguments will be on the same level in the group hierarchy.

    Source code (C++)
    // stack 2 separate windows
    EngineWindowPtr group_0 = WindowManager::stackWindows(window_1, window_2, EngineWindow::GROUP_TYPE_HORIZONTAL);
    // stack a separate window to the parent group of "window_1"

  • stackToWindow() stacks the window to the other window. If the first argument is the separate window, a new window group is returned. If the first argument is the nested window, the window is added to its group.

    Source code (C++)
    // create a group of 2 windows
    EngineWindowPtr group_1 = WindowManager::stack(window_1, window_2, 1, EngineWindow::GROUP_TYPE_HORIZONTAL);
    // stack a separate window to the window from the window group
    WindowManager::stackToWindow(window_1, window_3, EngineWindow::GROUP_TYPE_VERTICAL);

  • stackWindows() creates a group of the separate/nested windows. The windows are stacked in the default order.
  • stackToGroup() stacks the window or window group to another window group.

For ungrouping, the unstack() function is used: it removes the window or the window group from the parent group. If only one window remains in the group, it is automatically removed from the group and the group is deleted.

Grouping Using the Mouse#

While the application is running, you can group and ungroup the existing windows by using the mouse.

To group two separate windows, do the following:

  1. Hold the mouse button while moving the window to the destination one. The destination window will be divided into 9 sectors.
  2. Choose the required sector and release the mouse button: the windows will be grouped.

To add the window to the existing group, you should hold the mouse button while moving the window and release it in one of the following areas:

  • For the horizontal group:

  • For the vertical group:

  • For the group of tabs:

To ungroup the window, move it outside the group.

Working with Dialogs#

To create a dialog window, use the corresponding functions of the class. For example:

Source code (C++)
// event handler function
int AppSystemLogic::onButtonClicked()
	// show the message dialog
	WindowManager::dialogMessage("Message", "The button has been pressed.");
	return 1; 


int AppSystemLogic::init()
	// create a window with widgets in the client area
	auto create_window = [](const char *name)
		EngineWindowPtr window = EngineWindow::create(name, 512, 256);

		window->addChild(WidgetLabel::create(window->getSelfGui(), String::format("This is a {0}.", name)), Gui::ALIGN_TOP);
		window->addChild(WidgetButton::create(window->getSelfGui(), name), Gui::ALIGN_CENTER);

		return window;


		// create a window
		EngineWindowPtr window = create_window("Window");
		// get the child widget of the window
		WidgetPtr button = window->getChild(1);
		// add a callback for this widget
		button->addCallback(Gui::CLICKED, MakeCallback(this, &AppSystemLogic::onButtonClicked));
		// show the window
		window->setPosition(Math::ivec2(50, 60));

	return 1;


If you press the button in the client area of the created window, the following dialog will be shown:

Last update: 2022-12-14
Build: ()