GUIOptionsSerializer Class Reference

#include <GUIOptionsSerializer.hh>

Inheritance diagram for GUIOptionsSerializer:

Collaboration diagram for GUIOptionsSerializer:

Public Member Functions
	GUIOptionsSerializer (std::string configurationName)
virtual	~GUIOptionsSerializer ()
void	writeState (const ObjectState *optionsState)
ObjectState *	readState ()
void	writeOptions (const GUIOptions &options)
GUIOptions *	readOptions ()
Public Member Functions inherited from XMLSerializer
	XMLSerializer ()
virtual	~XMLSerializer ()
void	setSourceFile (const std::string &fileName)
void	setSourceString (const std::string &source)
void	setDestinationFile (const std::string &fileName)
void	setDestinationString (std::string &destination)
void	setSchemaFile (const std::string &fileName)
void	setUseSchema (bool useSchema)
void	setXMLNamespace (std::string nsUri)
Public Member Functions inherited from TCETools::Serializer
virtual	~Serializer ()

Protected Member Functions
virtual ObjectState *	convertToConfigFileFormat (const ObjectState *options) const
virtual ObjectState *	convertToOptionsObjectFormat (const ObjectState *root) const
Protected Member Functions inherited from XMLSerializer
std::string	sourceFile () const

Private Member Functions
void	setWindowProperties (const ObjectState *windowElem, ObjectState *options) const
void	setToolbarProperties (const ObjectState *toolbarElem, ObjectState *options) const
void	addKeyboardShortcut (const ObjectState *ksElem, ObjectState *options) const
	GUIOptionsSerializer (const GUIOptionsSerializer &)
	Copying not allowed. More...
GUIOptionsSerializer &	operator= (const GUIOptionsSerializer &)
	Assignment not allowed. More...

Private Attributes
std::string	configurationName_
	Name of the configuration to read/write. More...

Detailed Description

Reads and writes options of a graphical user interface from an XML file.

This is a base class which provides storing of options common to all GUIs, such as window size and position, toolbar contents and list of keyboard shortcuts. If a GUI needs application specific options, a custom options serializer can be derived from this class. See design documentation for details.

Definition at line 52 of file GUIOptionsSerializer.hh.

Constructor & Destructor Documentation

GUIOptionsSerializer() [1/2]

GUIOptionsSerializer::GUIOptionsSerializer

(

std::string

name

)

Constructor.

Parameters

name	Name of the configuration.

Definition at line 113 of file GUIOptionsSerializer.cc.

                                                         :
    XMLSerializer(),
    configurationName_(name) {
}

~GUIOptionsSerializer()

GUIOptionsSerializer::~GUIOptionsSerializer ( )

virtual

Destructor.

Definition at line 122 of file GUIOptionsSerializer.cc.

                                            {
}

GUIOptionsSerializer() [2/2]

GUIOptionsSerializer::GUIOptionsSerializer ( const GUIOptionsSerializer &  )

private

Copying not allowed.

Member Function Documentation

addKeyboardShortcut()

void GUIOptionsSerializer::addKeyboardShortcut ( const ObjectState *  ksElem, ObjectState *  options  ) const

private

Adds a keyboard shortcut to the given options according to the given keyboard-shortcut element.

Parameters

ksElem	ObjectState representing a keyboard-shortcut element in options file.
options	Options ObjectState which is modified.

Definition at line 495 of file GUIOptionsSerializer.cc.

                                {
 
    ObjectState* shortcut =
        new ObjectState(KeyboardShortcut::OSNAME_KEYBOARD_SHORTCUT);
    options->addChild(shortcut);
 
    ObjectState* keyCombElem = ksElem->childByName(KS_KEY_COMBINATION);
    if (keyCombElem->hasChild(KEY_COMB_CTRL)) {
        shortcut->setAttribute(KeyboardShortcut::OSKEY_CTRL, true);
    } else {
        shortcut->setAttribute(KeyboardShortcut::OSKEY_CTRL, false);
    }
 
    if (keyCombElem->hasChild(KEY_COMB_ALT)) {
        shortcut->setAttribute(KeyboardShortcut::OSKEY_ALT, true);
    } else {
        shortcut->setAttribute(KeyboardShortcut::OSKEY_ALT, false);
    }
 
    if (keyCombElem->hasChild(KEY_COMB_KEY)) {
        ObjectState* keyElem = keyCombElem->childByName(KEY_COMB_KEY);
        string key = keyElem->stringAttribute(KEY_VALUE);
        char keyChar = 0;
 
        // delete key requires extra checking
        if (key == DELETE_KEY) {
            keyChar = 127; // ASCII 127 = DEL
        } else {
            keyChar = *(key.c_str());
        }
 
        shortcut->setAttribute(KeyboardShortcut::OSKEY_KEY, keyChar);
    }
 
    if (keyCombElem->hasChild(KEY_COMB_FKEY)) {
        ObjectState* fKeyElem = keyCombElem->childByName(KEY_COMB_FKEY);
        int number = fKeyElem->intAttribute(FKEY_NUMBER);
        shortcut->setAttribute(KeyboardShortcut::OSKEY_FKEY, number);
    }
 
    ObjectState* actionElem = ksElem->childByName(KS_ACTION);
    string action = actionElem->stringValue();
    shortcut->setAttribute(KeyboardShortcut::OSKEY_ACTION, action);
}

References ObjectState::childByName(), DELETE_KEY, FKEY_NUMBER, ObjectState::hasChild(), ObjectState::intAttribute(), KEY_COMB_ALT, KEY_COMB_CTRL, KEY_COMB_FKEY, KEY_COMB_KEY, KEY_VALUE, KS_ACTION, KS_KEY_COMBINATION, options, KeyboardShortcut::OSKEY_ACTION, KeyboardShortcut::OSKEY_ALT, KeyboardShortcut::OSKEY_CTRL, KeyboardShortcut::OSKEY_FKEY, KeyboardShortcut::OSKEY_KEY, KeyboardShortcut::OSNAME_KEYBOARD_SHORTCUT, ObjectState::setAttribute(), ObjectState::stringAttribute(), and ObjectState::stringValue().

Referenced by convertToOptionsObjectFormat().

Here is the call graph for this function:

convertToConfigFileFormat()

ObjectState * GUIOptionsSerializer::convertToConfigFileFormat ( const ObjectState *  options ) const

protectedvirtual

Converts the given ObjectState tree created by GUIOptions::saveState to the format of configuration file.

Parameters

options

ObjectState tree to be converted.

Returns

The newly created ObjectState tree which matches with configuration file format.

Reimplemented in ProDeOptionsSerializer.

Definition at line 194 of file GUIOptionsSerializer.cc.

                                      {
 
    ObjectState* root = new ObjectState(configurationName_);
 
    // add window element
    ObjectState* window = new ObjectState(WINDOW);
    root->addChild(window);
 
    ObjectState* fullScreen = new ObjectState(WI_FULLSCREEN);
    window->addChild(fullScreen);
    if (options->intAttribute(GUIOptions::OSKEY_FULL_SCREEN)) {
        fullScreen->setValue(TRUE);
    } else {
        fullScreen->setValue(FALSE);
    }
 
    ObjectState* width = new ObjectState(WI_WIDTH);
    window->addChild(width);
    width->setValue(options->stringAttribute(GUIOptions::OSKEY_WINDOW_WIDTH));
 
    ObjectState* height = new ObjectState(WI_HEIGHT);
    window->addChild(height);
    height->setValue(
        options->stringAttribute(GUIOptions::OSKEY_WINDOW_HEIGHT));
 
    ObjectState* xPos = new ObjectState(WI_X_POSITION);
    window->addChild(xPos);
    xPos->setValue(options->stringAttribute(GUIOptions::OSKEY_X_POS));
 
    ObjectState* yPos = new ObjectState(WI_Y_POSITION);
    window->addChild(yPos);
    yPos->setValue(options->stringAttribute(GUIOptions::OSKEY_Y_POS));
 
    // add toolbar element
    ObjectState* toolbar = new ObjectState(TOOLBAR);
    root->addChild(toolbar);
 
    ObjectState* layout = new ObjectState(TB_LAYOUT);
    toolbar->addChild(layout);
 
    string toolbarLayout = options->
        stringAttribute(GUIOptions::OSKEY_TOOLBAR_LAYOUT);
    if (toolbarLayout == GUIOptions::OSVALUE_TEXT) {
        layout->addChild(new ObjectState(TB_LA_TEXT));
    } else if (toolbarLayout == GUIOptions::OSVALUE_ICON) {
        layout->addChild(new ObjectState(TB_LA_ICON));
    } else {
        layout->addChild(new ObjectState(TB_LA_TEXT));
        layout->addChild(new ObjectState(TB_LA_ICON));
    }
 
    ObjectState* visible = new ObjectState(TB_VISIBLE);
    toolbar->addChild(visible);
    int vis =
        options->intAttribute(GUIOptions::OSKEY_TOOLBAR_VISIBILITY);
    if (vis) {
        visible->setValue(TRUE);
    } else {
        visible->setValue(FALSE);
    }
 
    // add toolbar buttons
    for (int i = 0; i < options->childCount(); i++) {
        ObjectState* child = options->child(i);
        if (child->name() == ToolbarButton::OSNAME_TOOLBAR_BUTTON) {
            ObjectState* slot = new ObjectState(TB_SLOT);
            toolbar->addChild(slot);
            slot->setAttribute(SLOT_POSITION,
                               child->stringAttribute(
                                   ToolbarButton::OSKEY_SLOT));
            ObjectState* action = new ObjectState(TB_SLOT_ACTION);
            slot->addChild(action);
            action->setValue(child->stringAttribute(
                                 ToolbarButton::OSKEY_ACTION));
        }
    }
 
    // add toolbar separators
    for (int i = 0; i < options->childCount(); i++) {
        ObjectState* child = options->child(i);
        if (child->name() == GUIOptions::OSNAME_SEPARATOR) {
            ObjectState* separator = new ObjectState(TB_SEPARATOR);
            toolbar->addChild(separator);
            separator->setAttribute(SEPARATOR_POSITION,
                                    child->stringAttribute(
                                        GUIOptions::OSKEY_POSITION));
        }
    }
 
    // add keyboard shortcuts
    for (int i = 0; i < options->childCount(); i++) {
        ObjectState* child = options->child(i);
        if (child->name() !=
            KeyboardShortcut::OSNAME_KEYBOARD_SHORTCUT) {
            continue;
        }
        ObjectState* sc = new ObjectState(KEYBOARD_SHORTCUT);
        root->addChild(sc);
        ObjectState* keyComb = new ObjectState(KS_KEY_COMBINATION);
        sc->addChild(keyComb);
 
        if (child->intAttribute(KeyboardShortcut::OSKEY_CTRL)) {
            keyComb->addChild(new ObjectState(KEY_COMB_CTRL));
        }
        if (child->intAttribute(KeyboardShortcut::OSKEY_ALT)) {
            keyComb->addChild(new ObjectState(KEY_COMB_ALT));
        }
        if (child->hasAttribute(KeyboardShortcut::OSKEY_FKEY)) {
            ObjectState* fKey = new ObjectState(KEY_COMB_FKEY);
            keyComb->addChild(fKey);
            fKey->setAttribute(FKEY_NUMBER,
                               child->stringAttribute(
                                   KeyboardShortcut::OSKEY_FKEY));
        }
        if (child->hasAttribute(KeyboardShortcut::OSKEY_KEY)) {
            ObjectState* key = new ObjectState(KEY_COMB_KEY);
            keyComb->addChild(key);
            char charKey = child->intAttribute(
                KeyboardShortcut::OSKEY_KEY);
            string stringKey;
 
            // check if key is 'del'
            if (charKey == 127) {
                stringKey = DELETE_KEY;
            } else {
                stringKey = Conversion::toString(charKey);
            }
 
            key->setAttribute(KEY_VALUE, stringKey);
        }
        ObjectState* action = new ObjectState(KS_ACTION);
        sc->addChild(action);
        action->setValue(child->stringAttribute(
                             KeyboardShortcut::OSKEY_ACTION));
    }
 
    return root;
}

References ObjectState::addChild(), configurationName_, DELETE_KEY, FALSE, FKEY_NUMBER, ObjectState::hasAttribute(), ObjectState::intAttribute(), KEY_COMB_ALT, KEY_COMB_CTRL, KEY_COMB_FKEY, KEY_COMB_KEY, KEY_VALUE, KEYBOARD_SHORTCUT, KS_ACTION, KS_KEY_COMBINATION, ObjectState::name(), options, ToolbarButton::OSKEY_ACTION, KeyboardShortcut::OSKEY_ACTION, KeyboardShortcut::OSKEY_ALT, KeyboardShortcut::OSKEY_CTRL, KeyboardShortcut::OSKEY_FKEY, GUIOptions::OSKEY_FULL_SCREEN, KeyboardShortcut::OSKEY_KEY, GUIOptions::OSKEY_POSITION, ToolbarButton::OSKEY_SLOT, GUIOptions::OSKEY_TOOLBAR_LAYOUT, GUIOptions::OSKEY_TOOLBAR_VISIBILITY, GUIOptions::OSKEY_WINDOW_HEIGHT, GUIOptions::OSKEY_WINDOW_WIDTH, GUIOptions::OSKEY_X_POS, GUIOptions::OSKEY_Y_POS, KeyboardShortcut::OSNAME_KEYBOARD_SHORTCUT, GUIOptions::OSNAME_SEPARATOR, ToolbarButton::OSNAME_TOOLBAR_BUTTON, GUIOptions::OSVALUE_ICON, GUIOptions::OSVALUE_TEXT, SEPARATOR_POSITION, ObjectState::setAttribute(), ObjectState::setValue(), SLOT_POSITION, ObjectState::stringAttribute(), TB_LA_ICON, TB_LA_TEXT, TB_LAYOUT, TB_SEPARATOR, TB_SLOT, TB_SLOT_ACTION, TB_VISIBLE, TOOLBAR, Conversion::toString(), TRUE, WI_FULLSCREEN, WI_HEIGHT, WI_WIDTH, WI_X_POSITION, WI_Y_POSITION, and WINDOW.

Referenced by ProDeOptionsSerializer::convertToConfigFileFormat(), and writeState().

Here is the call graph for this function:

convertToOptionsObjectFormat()

ObjectState * GUIOptionsSerializer::convertToOptionsObjectFormat ( const ObjectState *  root ) const

protectedvirtual

Creates a new ObjectState tree which can be given to GUIOptions constructor. The tree is created according to the given tree which matches with the syntax of the options file.

Parameters

root	Root node of the ObjectState tree to be converted.

Reimplemented in ProDeOptionsSerializer.

Definition at line 343 of file GUIOptionsSerializer.cc.

                                   {
 
    ObjectState* options = new ObjectState(GUIOptions::OSNAME_OPTIONS);
 
    // set window properties
    if (root->hasChild(WINDOW)) {
        ObjectState* window = root->childByName(WINDOW);
        setWindowProperties(window, options);
    } else {
        options->setAttribute(GUIOptions::OSKEY_FULL_SCREEN, true);
        options->setAttribute(GUIOptions::OSKEY_WINDOW_WIDTH, DEFAULT_WIDTH);
        options->setAttribute(GUIOptions::OSKEY_WINDOW_HEIGHT, DEFAULT_HEIGHT);
        options->setAttribute(GUIOptions::OSKEY_X_POS, DEFAULT_X_POS);
        options->setAttribute(GUIOptions::OSKEY_Y_POS, DEFAULT_Y_POS);
    }
 
    // set toolbar properties
    if (root->hasChild(TOOLBAR)) {
        ObjectState* toolbar = root->childByName(TOOLBAR);
        setToolbarProperties(toolbar, options);
    } else {
        options->setAttribute(GUIOptions::OSKEY_TOOLBAR_VISIBILITY, false);
        options->setAttribute(GUIOptions::OSKEY_TOOLBAR_LAYOUT,
                              GUIOptions::OSVALUE_BOTH);
    }
 
    // set keyboard shortcuts
    for (int i = 0; i < root->childCount(); i++) {
        ObjectState* child = root->child(i);
        if (child->name() == KEYBOARD_SHORTCUT) {
            addKeyboardShortcut(child, options);
        }
    }
 
    return options;
}

References addKeyboardShortcut(), ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), DEFAULT_HEIGHT, DEFAULT_WIDTH, DEFAULT_X_POS, DEFAULT_Y_POS, ObjectState::hasChild(), KEYBOARD_SHORTCUT, ObjectState::name(), options, GUIOptions::OSKEY_FULL_SCREEN, GUIOptions::OSKEY_TOOLBAR_LAYOUT, GUIOptions::OSKEY_TOOLBAR_VISIBILITY, GUIOptions::OSKEY_WINDOW_HEIGHT, GUIOptions::OSKEY_WINDOW_WIDTH, GUIOptions::OSKEY_X_POS, GUIOptions::OSKEY_Y_POS, GUIOptions::OSNAME_OPTIONS, GUIOptions::OSVALUE_BOTH, setToolbarProperties(), setWindowProperties(), TOOLBAR, and WINDOW.

Referenced by ProDeOptionsSerializer::convertToOptionsObjectFormat(), and readState().

Here is the call graph for this function:

operator=()

GUIOptionsSerializer& GUIOptionsSerializer::operator= ( const GUIOptionsSerializer &  )

private

Assignment not allowed.

readOptions()

GUIOptions * GUIOptionsSerializer::readOptions

(

)

Reads the current input file and creates GUIOptions according to it.

Returns

The newly created GUIOptions instance.

Exceptions

SerializerException	If an error occurs while reading the file.
ObjectStateLoadingException	If an error occurs while creating options.

Definition at line 178 of file GUIOptionsSerializer.cc.

                                  {
    ObjectState* optionsState = readState();
    GUIOptions* options = new GUIOptions(optionsState);
    delete optionsState;
    return options;
}

References options, and readState().

Here is the call graph for this function:

readState()

ObjectState * GUIOptionsSerializer::readState ( )

virtual

Reads the options from the current XML file set and creates an ObjectState tree which can be read by GUIOptions::loadState.

Returns

The newly created ObjectState tree.

Exceptions

SerializerException

If an error occurs while reading the file.

Reimplemented from XMLSerializer.

Definition at line 149 of file GUIOptionsSerializer.cc.

                                {
    ObjectState* state = XMLSerializer::readState();
    ObjectState* converted = convertToOptionsObjectFormat(state);
    delete state;
    return converted;
}

References convertToOptionsObjectFormat(), and XMLSerializer::readState().

Referenced by Proxim::loadOptions(), ProDe::OnInit(), and readOptions().

Here is the call graph for this function:

setToolbarProperties()

void GUIOptionsSerializer::setToolbarProperties ( const ObjectState *  toolbarElem, ObjectState *  options  ) const

private

Sets the toolbar properties for the given options according to the given toolbar element.

Parameters

toolbarElem	ObjectState representing toolbar element in options file.
options	Options ObjectState which is modified.

Definition at line 430 of file GUIOptionsSerializer.cc.

                                {
 
    // set layout
    ObjectState* layoutElem = toolbarElem->childByName(TB_LAYOUT);
    if (layoutElem->hasChild(TB_LA_TEXT) &&
        layoutElem->hasChild(TB_LA_ICON)) {
        options->setAttribute(GUIOptions::OSKEY_TOOLBAR_LAYOUT,
                              GUIOptions::OSVALUE_BOTH);
    } else if (layoutElem->hasChild(TB_LA_TEXT)) {
        options->setAttribute(GUIOptions::OSKEY_TOOLBAR_LAYOUT,
                              GUIOptions::OSVALUE_TEXT);
    } else if (layoutElem->hasChild(TB_LA_ICON)) {
        options->setAttribute(GUIOptions::OSKEY_TOOLBAR_LAYOUT,
                              GUIOptions::OSVALUE_ICON);
    } else {
        assert(false);
    }
 
    // set visibility
    ObjectState* visibleElem = toolbarElem->childByName(TB_VISIBLE);
    if (visibleElem->stringValue() == TRUE) {
        options->setAttribute(GUIOptions::OSKEY_TOOLBAR_VISIBILITY,
                              true);
    } else if (visibleElem->stringValue() == FALSE) {
        options->setAttribute(GUIOptions::OSKEY_TOOLBAR_VISIBILITY,
                              false);
    }
 
    // set buttons and separators
    for (int i = 0; i < toolbarElem->childCount(); i++) {
        ObjectState* child = toolbarElem->child(i);
        if (child->name() == TB_SLOT) {
            ObjectState* button = new ObjectState(
                ToolbarButton::OSNAME_TOOLBAR_BUTTON);
            options->addChild(button);
 
            string slot = child->stringAttribute(SLOT_POSITION);
            button->setAttribute(ToolbarButton::OSKEY_SLOT, slot);
 
            ObjectState* action = child->childByName(TB_SLOT_ACTION);
            string actionString = action->stringValue();
            button->setAttribute(ToolbarButton::OSKEY_ACTION, actionString);
 
        } else if (child->name() == TB_SEPARATOR) {
            ObjectState* separator =
                new ObjectState(GUIOptions::OSNAME_SEPARATOR);
            options->addChild(separator);
            string position = child->stringAttribute(SEPARATOR_POSITION);
            separator->setAttribute(GUIOptions::OSKEY_POSITION, position);
        }
    }
}

References assert, ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), FALSE, ObjectState::hasChild(), ObjectState::name(), options, ToolbarButton::OSKEY_ACTION, GUIOptions::OSKEY_POSITION, ToolbarButton::OSKEY_SLOT, GUIOptions::OSKEY_TOOLBAR_LAYOUT, GUIOptions::OSKEY_TOOLBAR_VISIBILITY, GUIOptions::OSNAME_SEPARATOR, ToolbarButton::OSNAME_TOOLBAR_BUTTON, GUIOptions::OSVALUE_BOTH, GUIOptions::OSVALUE_ICON, GUIOptions::OSVALUE_TEXT, SEPARATOR_POSITION, ObjectState::setAttribute(), SLOT_POSITION, ObjectState::stringAttribute(), ObjectState::stringValue(), TB_LA_ICON, TB_LA_TEXT, TB_LAYOUT, TB_SEPARATOR, TB_SLOT, TB_SLOT_ACTION, TB_VISIBLE, and TRUE.

Referenced by convertToOptionsObjectFormat().

Here is the call graph for this function:

setWindowProperties()

void GUIOptionsSerializer::setWindowProperties ( const ObjectState *  windowElem, ObjectState *  options  ) const

private

Sets the window properties for the given options according to the given window element.

Parameters

windowElem	ObjectState representing window element in options file.
options	Options ObjectState which is modified.

Definition at line 390 of file GUIOptionsSerializer.cc.

                                {
 
    ObjectState* fullscreenElem = windowElem->childByName(WI_FULLSCREEN);
    if (fullscreenElem->stringValue() == TRUE) {
        options->setAttribute(GUIOptions::OSKEY_FULL_SCREEN, true);
    } else if (fullscreenElem->stringValue() == FALSE) {
        options->setAttribute(GUIOptions::OSKEY_FULL_SCREEN, false);
    } else {
        assert(false);
    }
 
    ObjectState* widthElem = windowElem->childByName(WI_WIDTH);
    options->setAttribute(GUIOptions::OSKEY_WINDOW_WIDTH,
                          widthElem->stringValue());
 
    ObjectState* heightElem = windowElem->childByName(WI_HEIGHT);
    options->setAttribute(GUIOptions::OSKEY_WINDOW_HEIGHT,
                          heightElem->stringValue());
 
    ObjectState* xPosElem = windowElem->childByName(WI_X_POSITION);
    options->setAttribute(GUIOptions::OSKEY_X_POS,
                          xPosElem->stringValue());
 
    ObjectState* yPosElem = windowElem->childByName(WI_Y_POSITION);
    options->setAttribute(GUIOptions::OSKEY_Y_POS,
                          yPosElem->stringValue());
}

References assert, ObjectState::childByName(), FALSE, options, GUIOptions::OSKEY_FULL_SCREEN, GUIOptions::OSKEY_WINDOW_HEIGHT, GUIOptions::OSKEY_WINDOW_WIDTH, GUIOptions::OSKEY_X_POS, GUIOptions::OSKEY_Y_POS, ObjectState::stringValue(), TRUE, WI_FULLSCREEN, WI_HEIGHT, WI_WIDTH, WI_X_POSITION, and WI_Y_POSITION.

Referenced by convertToOptionsObjectFormat().

Here is the call graph for this function:

writeOptions()

void GUIOptionsSerializer::writeOptions

(

const GUIOptions &

options

)

Serializes the given options to the file set.

Parameters

options

The options to be serialized.

Exceptions

SerializerException

If an error occurs while serializing.

Definition at line 163 of file GUIOptionsSerializer.cc.

                                                            {
    ObjectState* optionsState = options.saveState();
    writeState(optionsState);
    delete optionsState;
}

References options, and writeState().

Referenced by SaveOptionsCmd::Do(), and ProximQuitCmd::Do().

Here is the call graph for this function:

writeState()

void GUIOptionsSerializer::writeState ( const ObjectState *  optionsState )

virtual

Serializes the given ObjectState tree created by GUIOptions::saveState to an XML file.

Parameters

optionsState

ObjectState tree created by GUIOptions::saveState.

Exceptions

SerializerException

If the current destination file cannot be written.

Reimplemented from XMLSerializer.

Definition at line 135 of file GUIOptionsSerializer.cc.

                                                                {
    ObjectState* converted = convertToConfigFileFormat(optionsState);
    XMLSerializer::writeState(converted);
    delete converted;
}

References convertToConfigFileFormat(), and XMLSerializer::writeState().

Referenced by writeOptions().

Here is the call graph for this function:

Member Data Documentation

configurationName_

std::string GUIOptionsSerializer::configurationName_

private

Name of the configuration to read/write.

Definition at line 84 of file GUIOptionsSerializer.hh.

Referenced by convertToConfigFileFormat().

---

The documentation for this class was generated from the following files:

• GUIOptionsSerializer.hh
• GUIOptionsSerializer.cc