This page has been translated automatically.
Video Tutorials
Interface
Essentials
Advanced
How To
Basics
Rendering
Professional (SIM)
UnigineEditor
Interface Overview
Assets Workflow
Version Control
Settings and Preferences
Working With Projects
Adjusting Node Parameters
Setting Up Materials
Setting Up Properties
Lighting
Sandworm
Using Editor Tools for Specific Tasks
Extending Editor Functionality
Built-in Node Types
Nodes
Objects
Effects
Decals
Light Sources
Geodetics
World Nodes
Sound Objects
Pathfinding Objects
Players
Programming
Fundamentals
Setting Up Development Environment
Usage Examples
C++
C#
UnigineScript
UUSL (Unified UNIGINE Shader Language)
Plugins
File Formats
Materials and Shaders
Rebuilding the Engine Tools
GUI
Double Precision Coordinates
API
Animations-Related Classes
Containers
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
VR-Related Classes
Content Creation
Content Optimization
Materials
Material Nodes Library
Miscellaneous
Input
Math
Matrix
Textures
Art Samples
Tutorials

Unigine::Plugins::SpiderVision::SpiderVisionConfig Class

Header: #include <plugins/Unigine/SpiderVision/UnigineSpiderVision.h>

The object of this class describes the current configuration, stores information about all viewports and groups of the current configuration and provides an interface to interact with them.

DisplaysConfig Class

Members

String getPath() const#

Returns the current path to the displays configuration file.

Return value

Current path to the displays configuration file.

unsigned int getNumViewports() const#

Returns the current total number of viewports in the configuration.

Return value

Current total number of viewports in the configuration.

unsigned int getNumGroups() const#

Returns the current total number of projection groups in the configuration.

Return value

Current total number of projection groups in the configuration.

void setShowHotkey ( Input::KEY hotkey ) #

Sets a new hotkey that opens the displays configuration window.

Arguments

  • Input::KEY hotkey - The hotkey that opens the displays configuration window.

Input::KEY getShowHotkey() const#

Returns the current hotkey that opens the displays configuration window.

Return value

Current hotkey that opens the displays configuration window.

static Event<ViewportData*> getEventViewportCreated() const#

event triggered when a viewport is created. You can subscribe to events via connect()   and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler(ViewportData *viewport_data)

Usage Example

Source code (C++)
// implement the ViewportCreated event handler
void viewportcreated_event_handler(ViewportData *viewport_data)
{
	Log::message("\Handling ViewportCreated 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 viewportcreated_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
DisplaysConfig::getEventViewportCreated().connect(viewportcreated_event_connections, viewportcreated_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
DisplaysConfig::getEventViewportCreated().connect(viewportcreated_event_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling ViewportCreated event (lambda).\n");
	}
);

// ...

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

// subscribe to the ViewportCreated event with a handler function keeping the connection
DisplaysConfig::getEventViewportCreated().connect(viewportcreated_event_connection, viewportcreated_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the ViewportCreated event via the connection
viewportcreated_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 ViewportCreated event handler implemented as a class member
	void event_handler(ViewportData *viewport_data)
	{
		Log::message("\Handling ViewportCreated event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

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

// subscribe to the ViewportCreated event with a lambda handler function and keeping connection ID
viewportcreated_handler_id = DisplaysConfig::getEventViewportCreated().connect(e_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling ViewportCreated event (lambda).\n");
	}
);

// remove the subscription later using the ID
DisplaysConfig::getEventViewportCreated().disconnect(viewportcreated_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
DisplaysConfig::getEventViewportCreated().setEnabled(true);

Return value

Event reference.

static Event<ViewportData*> getEventViewportRemoved() const#

event triggered when a viewport is removed. You can subscribe to events via connect()   and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler(ViewportData *viewport_data)

Usage Example

Source code (C++)
// implement the ViewportRemoved event handler
void viewportremoved_event_handler(ViewportData *viewport_data)
{
	Log::message("\Handling ViewportRemoved 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 viewportremoved_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
DisplaysConfig::getEventViewportRemoved().connect(viewportremoved_event_connections, viewportremoved_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
DisplaysConfig::getEventViewportRemoved().connect(viewportremoved_event_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling ViewportRemoved event (lambda).\n");
	}
);

// ...

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

// subscribe to the ViewportRemoved event with a handler function keeping the connection
DisplaysConfig::getEventViewportRemoved().connect(viewportremoved_event_connection, viewportremoved_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the ViewportRemoved event via the connection
viewportremoved_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 ViewportRemoved event handler implemented as a class member
	void event_handler(ViewportData *viewport_data)
	{
		Log::message("\Handling ViewportRemoved event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

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

// subscribe to the ViewportRemoved event with a lambda handler function and keeping connection ID
viewportremoved_handler_id = DisplaysConfig::getEventViewportRemoved().connect(e_connections, [](ViewportData *viewport_data) { 
		Log::message("\Handling ViewportRemoved event (lambda).\n");
	}
);

// remove the subscription later using the ID
DisplaysConfig::getEventViewportRemoved().disconnect(viewportremoved_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
DisplaysConfig::getEventViewportRemoved().setEnabled(true);

Return value

Event reference.

static Event<> getEventLoad() const#

event triggered on a displays configuration from a file. You can subscribe to events via connect()   and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the Load event handler
void load_event_handler()
{
	Log::message("\Handling Load 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 load_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
DisplaysConfig::getEventLoad().connect(load_event_connections, load_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
DisplaysConfig::getEventLoad().connect(load_event_connections, []() { 
		Log::message("\Handling Load event (lambda).\n");
	}
);

// ...

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

// subscribe to the Load event with a handler function keeping the connection
DisplaysConfig::getEventLoad().connect(load_event_connection, load_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

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

// subscribe to the Load event with a lambda handler function and keeping connection ID
load_handler_id = DisplaysConfig::getEventLoad().connect(e_connections, []() { 
		Log::message("\Handling Load event (lambda).\n");
	}
);

// remove the subscription later using the ID
DisplaysConfig::getEventLoad().disconnect(load_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
DisplaysConfig::getEventLoad().setEnabled(true);

Return value

Event reference.

static Event<> getEventClear() const#

event triggered on clearing displays configuration. You can subscribe to events via connect()   and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler()

Usage Example

Source code (C++)
// implement the Clear event handler
void clear_event_handler()
{
	Log::message("\Handling Clear 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 clear_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
DisplaysConfig::getEventClear().connect(clear_event_connections, clear_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
DisplaysConfig::getEventClear().connect(clear_event_connections, []() { 
		Log::message("\Handling Clear event (lambda).\n");
	}
);

// ...

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

// subscribe to the Clear event with a handler function keeping the connection
DisplaysConfig::getEventClear().connect(clear_event_connection, clear_event_handler);

// ...

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

// ... actions to be performed

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

// ...

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

SomeClass *sc = new SomeClass();

// ...

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

// subscribe to the Clear event with a lambda handler function and keeping connection ID
clear_handler_id = DisplaysConfig::getEventClear().connect(e_connections, []() { 
		Log::message("\Handling Clear event (lambda).\n");
	}
);

// remove the subscription later using the ID
DisplaysConfig::getEventClear().disconnect(clear_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
DisplaysConfig::getEventClear().setEnabled(true);

Return value

Event reference.

static Event<CalibrationGridData*> getEventCalibrationGridChanged() const#

event triggered on making changes to the calibration grid. You can subscribe to events via connect()   and unsubscribe via disconnect(). You can also use EventConnection and EventConnections classes for convenience (see examples below).
Notice
For more details see the Event Handling article.
The event handler signature is as follows: myhandler(CalibrationGridData *calibration_data)

Usage Example

Source code (C++)
// implement the CalibrationGridChanged event handler
void calibrationgridchanged_event_handler(CalibrationGridData *calibration_data)
{
	Log::message("\Handling CalibrationGridChanged 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 calibrationgridchanged_event_connections;

// link to this instance when subscribing to an event (subscription to various events can be linked)
DisplaysConfig::getEventCalibrationGridChanged().connect(calibrationgridchanged_event_connections, calibrationgridchanged_event_handler);

// other subscriptions are also linked to this EventConnections instance 
// (e.g. you can subscribe using lambdas)
DisplaysConfig::getEventCalibrationGridChanged().connect(calibrationgridchanged_event_connections, [](CalibrationGridData *calibration_data) { 
		Log::message("\Handling CalibrationGridChanged event (lambda).\n");
	}
);

// ...

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

// subscribe to the CalibrationGridChanged event with a handler function keeping the connection
DisplaysConfig::getEventCalibrationGridChanged().connect(calibrationgridchanged_event_connection, calibrationgridchanged_event_handler);

// ...

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

// ... actions to be performed

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

// ...

// remove subscription to the CalibrationGridChanged event via the connection
calibrationgridchanged_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 CalibrationGridChanged event handler implemented as a class member
	void event_handler(CalibrationGridData *calibration_data)
	{
		Log::message("\Handling CalibrationGridChanged event\n");
		// ...
	}
};

SomeClass *sc = new SomeClass();

// ...

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

// subscribe to the CalibrationGridChanged event with a lambda handler function and keeping connection ID
calibrationgridchanged_handler_id = DisplaysConfig::getEventCalibrationGridChanged().connect(e_connections, [](CalibrationGridData *calibration_data) { 
		Log::message("\Handling CalibrationGridChanged event (lambda).\n");
	}
);

// remove the subscription later using the ID
DisplaysConfig::getEventCalibrationGridChanged().disconnect(calibrationgridchanged_handler_id);


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

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

// ... actions to be performed

// and enable it back when necessary
DisplaysConfig::getEventCalibrationGridChanged().setEnabled(true);

Return value

Event reference.

ViewportData * getViewportByIndex ( int index ) const#

Returns the data for the specified viewport.

Arguments

  • int index - Index of the viewport.

Return value

ViewportData class instance that stores the viewport data.

ViewportData * getViewport ( int id ) const#

Returns the data for the specified viewport.

Arguments

  • int id - ID of the viewport.

Return value

ViewportData class instance that stores the viewport data.

ViewportData * createViewport ( int group_id = -1 ) #

Creates a viewport for the specified viewport group. If no group is set, an individual viewport is created.

Arguments

  • int group_id - ID of the group. The default value of -1 means that the viewport is not related to any group.

Return value

ViewportData class instance that stores the viewport data.

void removeViewport ( int id ) #

Removes the specified viewport.

Arguments

  • int id - ID of the viewport.

GroupData * getGroupByIndex ( int index ) const#

Returns the group with the specified index.

Arguments

  • int index - Index of the group.

Return value

GroupData class instance that stores the group data.

GroupData * getGroup ( int id ) const#

Returns the group with the specified ID.

Arguments

  • int id - ID of the group.

Return value

GroupData class instance that stores the group data.

GroupData * createGroup ( GroupData::GROUP_TYPE type ) #

Creates the group of the specified type.

Arguments

Return value

GroupData class instance that stores the group data.

void removeGroup ( int id ) #

Removes the group with the specified ID.

Arguments

  • int id - ID of the group.

CalibrationGridData * getCalibrationGrid ( ) #

Returns the calibration grid for the configuration.

Return value

CalibrationGridData class instance that stores the calibration grid data.

bool hasUnsavedChanges ( ) const#

Returns the value indicating if the displays configuration has any unsaved changes.

Return value

true if the displays configuration has any unsaved changes, otherwise false.

bool loadConfig ( const char * filepath ) #

Loads the configuration from the specified source.

Arguments

  • const char * filepath - Path to the displays configuration file.

Return value

true if the configuration file is loaded successfully, otherwise false.

void loadConfig ( const Ptr<Stream> & stream ) #

Loads the configuration data from the specified source.

Arguments

  • const Ptr<Stream> & stream - Source stream pointer.

bool saveConfig ( const char * filepath ) #

Saves the configuration the specified displays configuration file.

Arguments

  • const char * filepath - Path to the displays configuration file.

Return value

true if the configuration file is saved successfully, otherwise false.

void clear ( ) #

Clears the displays configuration.

void saveXml ( const Ptr<Xml> & xml ) #

Saves the displays configuration data to the given instance of the Xml class.

Arguments

  • const Ptr<Xml> & xml - Xml class instance into which the data will be saved.

bool restoreXml ( const Ptr<Xml> & xml ) #

Loads the displays configuration data from the specified instance of the Xml class.

Arguments

  • const Ptr<Xml> & xml - Xml class instance the data from which is to be loaded.

Return value

true if the data has been loaded successfully, otherwise false.

void save ( const Ptr<Stream> & stream ) #

Saves the displays configuration data to the specified stream.

Arguments

  • const Ptr<Stream> & stream - Stream to which the data is to be written.

void restore ( const Ptr<Stream> & stream ) #

Loads the displays configuration data from the specified stream.

Arguments

  • const Ptr<Stream> & stream - Stream the data from which is to be loaded.

void loadConfig ( const Ptr<Xml> & stream ) #

Loads the configuration from the XML file.

Arguments

  • const Ptr<Xml> & stream - Xml class instance the data from which is to be loaded.
Last update: 2024-07-12
Build: ()