Unigine::Plugins::SpiderVision::SpiderVisionConfig Class

功能列表:

Name	描述 View: Sort by:
getPath	Returns the current path to the displays configuration file.
getNumViewports	Returns the current total number of viewports in the configuration.
getNumGroups	Returns the current total number of projection groups in the configuration.
setShowHotkey	Setter and Getter for hotkey that opens the displays configuration window.
getShowHotkey
getEventViewportCreated	The event triggered when a viewport is created.
getEventViewportRemoved	The event triggered when a viewport is removed.
getEventLoad	The event triggered on loading a displays configuration from a file.
getEventClear	The event triggered on clearing displays configuration.
getEventCalibrationGridChanged	The event triggered on making changes to the calibration grid.
getViewportByIndex	Returns the data for the specified viewport.
getViewport	Returns the data for the specified viewport.
createViewport	Creates a viewport for the specified viewport group.
removeViewport	Removes the specified viewport.
getGroupByIndex	Returns the group with the specified index.
getGroup	Returns the group with the specified ID.
createGroup	Creates the group of the specified type.
removeGroup	Removes the group with the specified ID.
getCalibrationGrid	Returns the calibration grid for the configuration.
hasUnsavedChanges	Returns the value indicating if the displays configuration has any unsaved changes.
loadConfig	Loads the configuration from the specified source.
saveConfig	Saves the configuration the specified displays configuration file.
clear	Clears the displays configuration.
saveXml	Saves the displays configuration data to the given instance of the Xml class.
restoreXml	Loads the displays configuration data from the specified instance of the Xml class.
save	Saves the displays configuration data to the specified stream.
restore	Loads the displays configuration data from the specified stream.
loadConfig	Loads the configuration from the XML file.

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

GroupData::GROUP_TYPE type - Type of the group.

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

Help improve this article

Was this article helpful?

Report a problem related to this article

(or select a word/phrase and press Ctrl+Enter)

Unigine::Plugins::SpiderVision::SpiderVisionConfig Class

In This Article:

功能列表:

DisplaysConfig Class

Members

String getPath() const#

Return value

unsigned int getNumViewports() const#

Return value

unsigned int getNumGroups() const#

Return value

void setShowHotkey ( Input::KEY hotkey ) #

Arguments

Input::KEY getShowHotkey() const#

Return value

static Event<ViewportData*> getEventViewportCreated() const#

Return value

static Event<ViewportData*> getEventViewportRemoved() const#

Return value

static Event<> getEventLoad() const#

Return value

static Event<> getEventClear() const#

Return value

static Event<CalibrationGridData*> getEventCalibrationGridChanged() const#

Return value

ViewportData * getViewportByIndex ( int index ) const#

Arguments

Return value

ViewportData * getViewport ( int id ) const#

Arguments

Return value

ViewportData * createViewport ( int group_id = -1 ) #

Arguments

Return value

void removeViewport ( int id ) #

Arguments

GroupData * getGroupByIndex ( int index ) const#

Arguments

Return value

GroupData * getGroup ( int id ) const#

Arguments

Return value

GroupData * createGroup ( GroupData::GROUP_TYPE type ) #

Arguments

Return value

void removeGroup ( int id ) #

Arguments

CalibrationGridData * getCalibrationGrid ( ) #

Return value

bool hasUnsavedChanges ( ) const#

Return value

bool loadConfig ( const char * filepath ) #

Arguments

Return value

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

Arguments

bool saveConfig ( const char * filepath ) #

Arguments

Return value

void clear ( ) #

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

Arguments

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

Arguments

Return value

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

Arguments

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

Arguments

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

Arguments