Proxim Class Reference

#include <Proxim.hh>

Inheritance diagram for Proxim:

Collaboration diagram for Proxim:

Public Member Functions
	Proxim ()
virtual	~Proxim ()
virtual bool	OnInit ()
virtual int	OnExit ()
ProximSimulationThread *	simulation ()
CommandRegistry &	commandRegistry ()
GUIOptions &	options ()

Private Member Functions
void	loadOptions ()
void	createDefaultOptions ()

Private Attributes
ProximMainFrame *	mainFrame_
	The application main frame.
CommandRegistry *	commandRegistry_
	The application command registry.
ProximSimulationThread *	simulation_
	The simulation thread running the simulator backend.
GUIOptions *	options_
	Options defining toolbar, keyboard shortcuts etc.

Static Private Attributes
static const std::string	CONFIG_FILE_NAME = "Proxim.conf"
	Name of the config file.
static const std::string	SCHEMA_FILE_NAME = "confschema.xsd"
	Name of the xml-schema file.

Detailed Description

Represents the Proxim application.

This is the top level class of the application. Derived from the wxApp class, which does the low level initialization of wxWidgets. This class is responsible for the application initialization and termination.

Definition at line 53 of file Proxim.hh.

Constructor & Destructor Documentation

Proxim()

Proxim::Proxim

(

)

The constructor.

Definition at line 67 of file Proxim.cc.

              :
    wxApp(), mainFrame_(NULL), commandRegistry_(NULL), simulation_(NULL),
    options_(NULL) {
}

~Proxim()

Proxim::~Proxim ( )

virtual

The Destructor.

Definition at line 76 of file Proxim.cc.

                {
    delete commandRegistry_;
}

References commandRegistry_.

Member Function Documentation

commandRegistry()

CommandRegistry & Proxim::commandRegistry

(

)

Returns reference to the application command registry.

The command registry stores all commands available for execution in the main fram menubar and toolbar.

Returns

Reference to the application command registry.

Definition at line 216 of file Proxim.cc.

                        {
    return *commandRegistry_;
}

References commandRegistry_.

createDefaultOptions()

void Proxim::createDefaultOptions ( )

private

Creates a default set of options if the configuration file is erroneous or not found.

Definition at line 270 of file Proxim.cc.

                             {
 
    ToolbarButton* buttonMachine = new ToolbarButton(
        0, ProximConstants::COMMAND_NAME_OPEN_MACHINE);
 
    ToolbarButton* buttonProgram = new ToolbarButton(
        1, ProximConstants::COMMAND_NAME_OPEN_PROGRAM);
 
    ToolbarButton* buttonRun = new ToolbarButton(
        3, ProximConstants::COMMAND_NAME_RUN);
 
    ToolbarButton* buttonResume = new ToolbarButton(
        4, ProximConstants::COMMAND_NAME_RESUME);
 
    ToolbarButton* buttonKill = new ToolbarButton(
        5, ProximConstants::COMMAND_NAME_KILL);
 
    ToolbarButton* buttonStepi = new ToolbarButton(
        6, ProximConstants::COMMAND_NAME_STEPI);
 
    ToolbarButton* buttonNexti = new ToolbarButton(
        7, ProximConstants::COMMAND_NAME_NEXTI);
 
    // F2 -> run
    KeyboardShortcut* scRun = new KeyboardShortcut(
        ProximConstants::COMMAND_NAME_RUN, 2, false, false, 0);
 
    // F4 -> kill
    KeyboardShortcut* scKill = new KeyboardShortcut(
        ProximConstants::COMMAND_NAME_KILL, 4, false, false, 0);
 
    // F5 -> stepi
    KeyboardShortcut* scStepi = new KeyboardShortcut(
        ProximConstants::COMMAND_NAME_STEPI, 5, false, false, 0);
 
    // F6 -> nexti
    KeyboardShortcut* scNexti = new KeyboardShortcut(
        ProximConstants::COMMAND_NAME_NEXTI, 6, false, false, 0);
 
    // F9 -> resume
    KeyboardShortcut* scResume = new KeyboardShortcut(
        ProximConstants::COMMAND_NAME_RESUME, 9, false, false, 0);
 
    // Ctrl + F -> find operation in assembly code window
    KeyboardShortcut* scFind = new KeyboardShortcut(
        ProximConstants::COMMAND_NAME_FIND, 0, true, false, int('F'));
 
    options_ = new GUIOptions(ProximConstants::CONFIGURATION_NAME);
    string fileName = Environment::userConfPath(CONFIG_FILE_NAME);
 
    options_->setFileName(fileName);
 
    options_->addToolbarButton(buttonMachine);
    options_->addToolbarButton(buttonProgram);
    options_->addToolbarButton(buttonRun);
    options_->addToolbarButton(buttonResume);
    options_->addToolbarButton(buttonKill);
    options_->addToolbarButton(buttonStepi);
    options_->addToolbarButton(buttonNexti);
    options_->addSeparator(2);
    options_->setToolbarLayout(GUIOptions::TEXT);
    options_->setToolbarVisibility(true);
 
    options_->addKeyboardShortcut(scRun);
    options_->addKeyboardShortcut(scStepi);
    options_->addKeyboardShortcut(scNexti);
    options_->addKeyboardShortcut(scResume);
    options_->addKeyboardShortcut(scKill);
    options_->addKeyboardShortcut(scFind);
}

References GUIOptions::addKeyboardShortcut(), GUIOptions::addSeparator(), GUIOptions::addToolbarButton(), ProximConstants::COMMAND_NAME_FIND, ProximConstants::COMMAND_NAME_KILL, ProximConstants::COMMAND_NAME_NEXTI, ProximConstants::COMMAND_NAME_OPEN_MACHINE, ProximConstants::COMMAND_NAME_OPEN_PROGRAM, ProximConstants::COMMAND_NAME_RESUME, ProximConstants::COMMAND_NAME_RUN, ProximConstants::COMMAND_NAME_STEPI, CONFIG_FILE_NAME, ProximConstants::CONFIGURATION_NAME, options_, GUIOptions::setFileName(), GUIOptions::setToolbarLayout(), GUIOptions::setToolbarVisibility(), GUIOptions::TEXT, and Environment::userConfPath().

Referenced by loadOptions().

Here is the call graph for this function:

loadOptions()

void Proxim::loadOptions ( )

private

Loads GUIOptions for Proxim from the configuration file.

If the configuration file is erroneous or not found, default options will be used.

Definition at line 227 of file Proxim.cc.

                    {
 
    if (options_ != NULL) {
        delete options_;
    }
 
    bool optionsOK = false;
 
    string configFile = Environment::confPath(CONFIG_FILE_NAME);
 
    string schemaFile = Environment::dataDirPath("Proxim") +
        FileSystem::DIRECTORY_SEPARATOR + SCHEMA_FILE_NAME;
 
    GUIOptionsSerializer reader(ProximConstants::CONFIGURATION_NAME);
    reader.setSourceFile(configFile);
    reader.setSchemaFile(schemaFile);
    reader.setUseSchema(true);
 
    try {
        ObjectState* optionsState = reader.readState();
        options_ = new GUIOptions(optionsState);
        delete optionsState;
        options_->validate();
        options_->setFileName(configFile);
        optionsOK = true;
    } catch (Exception& e) {
        cerr << "Error loading config file " << configFile << ":" << endl
             << e.errorMessage() << endl
             << "Default options will be used." << endl;
    }
 
    if (!optionsOK) {
        createDefaultOptions();
    } else {
        options_->clearModified();
    }
}

References GUIOptions::clearModified(), CONFIG_FILE_NAME, ProximConstants::CONFIGURATION_NAME, Environment::confPath(), createDefaultOptions(), Environment::dataDirPath(), FileSystem::DIRECTORY_SEPARATOR, Exception::errorMessage(), options_, GUIOptionsSerializer::readState(), SCHEMA_FILE_NAME, GUIOptions::setFileName(), XMLSerializer::setSchemaFile(), XMLSerializer::setSourceFile(), XMLSerializer::setUseSchema(), and GUIOptions::validate().

Referenced by OnInit().

Here is the call graph for this function:

OnExit()

int Proxim::OnExit ( )

virtual

Deletes the simulation thread when the application exits.

Returns

Exit code.

Definition at line 188 of file Proxim.cc.

               {
    simulation_->Delete();
    simulation_->Wait();
    delete simulation_;
    return EXIT_SUCCESS;
}

References simulation_.

OnInit()

bool Proxim::OnInit ( )

virtual

Initializes the application.

Creates command registry, application main frame and a simulation thread. The main frame console linereader is set as the linereader for the simulator thread.

Returns

True, if the application was succesfully initialized.

Definition at line 92 of file Proxim.cc.

               {
 
    Application::initialize(argc, WxConversion::toCStringArray(argc, argv));
 
    const wxCmdLineEntryDesc cmdLineDesc[] = {
 
#if wxCHECK_VERSION(3,0,0)
        { wxCMD_LINE_PARAM,  NULL, NULL, "input file",
#else
        { wxCMD_LINE_PARAM,  NULL, NULL, _T("input file"),
#endif
 
          wxCMD_LINE_VAL_STRING,
          (wxCMD_LINE_PARAM_MULTIPLE | wxCMD_LINE_PARAM_OPTIONAL) },
        { wxCMD_LINE_NONE, NULL, NULL, NULL, wxCMD_LINE_VAL_NONE, 0 }
    };
 
    wxCmdLineParser parser(cmdLineDesc);
    parser.SetCmdLine(argc, argv);
    parser.Parse();
 
    std::string machineToLoad = "";
    std::string programToLoad = "";
 
    if (parser.GetParamCount() == 1) {
        programToLoad = WxConversion::toString(parser.GetParam(0));
    } else if (parser.GetParamCount() == 2) {
        machineToLoad = WxConversion::toString(parser.GetParam(0));
        programToLoad = WxConversion::toString(parser.GetParam(1));
    } else if (parser.GetParamCount() > 2) {
        std::cout << ProximConstants::PROXIM_TITLE << " " 
                  << Application::TCEVersionString() << std::endl;
        std::cout << "Usage: proxim [program file]" << endl;
        std::cout << "       proxim [machine file] [program file]" << endl;
        
        return false;
    }
 
 
    // load image handler for pngs
    wxImage::AddHandler(new wxPNGHandler);
 
    commandRegistry_ = new CommandRegistry();
    simulation_ = new ProximSimulationThread();
    options_ = new GUIOptions("proxim-configuration");
 
    loadOptions();
 
    mainFrame_ = new ProximMainFrame(
    _T("TTA Processor Simulator"), wxDefaultPosition, wxSize(800, 600));
 
    simulation_->Create();
    simulation_->initialize(mainFrame_);
    simulation_->Run();
 
    mainFrame_->Show(true);
    SetTopWindow(mainFrame_);
 
    SimulatorInterpreter* interpreter = simulation_->interpreter();
 
    if (machineToLoad != "") {
        interpreter->interpret(
            ProximConstants::SCL_LOAD_MACHINE + " " + machineToLoad);
        if (interpreter->result().size() > 0) {
            wxString message = _T("Error loading machine file '");
            message.Append(WxConversion::toWxString(machineToLoad));
            message.Append(_T("'.\n"));
            message.Append(WxConversion::toWxString(interpreter->result()));
            ErrorDialog dialog(mainFrame_, message);
            dialog.ShowModal();
            return true;
        }
    }
 
    if (programToLoad != "") {
        interpreter->interpret(
            ProximConstants::SCL_LOAD_PROGRAM + " " + programToLoad);
        if (interpreter->result().size() > 0) {
            wxString message = _T("Error loading program file '");
            message.Append(WxConversion::toWxString(programToLoad));
            message.Append(_T("'.\n"));
            message.Append(WxConversion::toWxString(interpreter->result()));
            ErrorDialog dialog(mainFrame_, message);
            dialog.ShowModal();
        }
    }
    return true;
}

References commandRegistry_, Application::initialize(), ProximSimulationThread::initialize(), TclInterpreter::interpret(), ProximSimulationThread::interpreter(), loadOptions(), mainFrame_, options_, ProximConstants::PROXIM_TITLE, ScriptInterpreter::result(), ProximConstants::SCL_LOAD_MACHINE, ProximConstants::SCL_LOAD_PROGRAM, simulation_, Application::TCEVersionString(), WxConversion::toCStringArray(), WxConversion::toString(), and WxConversion::toWxString().

Here is the call graph for this function:

options()

GUIOptions & Proxim::options

(

)

Returns references to the application options.

Returns

GUIOptions of the application.

Definition at line 347 of file Proxim.cc.

                {
    return *options_;
}

References options_.

simulation()

ProximSimulationThread * Proxim::simulation

(

)

Returns pointer to the simulation thread.

Returns

Pointer to the simulation thread.

Definition at line 202 of file Proxim.cc.

                   {
    return simulation_;
}

References simulation_.

Member Data Documentation

commandRegistry_

CommandRegistry* Proxim::commandRegistry_

private

The application command registry.

Definition at line 70 of file Proxim.hh.

Referenced by commandRegistry(), OnInit(), and ~Proxim().

CONFIG_FILE_NAME

const std::string Proxim::CONFIG_FILE_NAME = "Proxim.conf"

staticprivate

Name of the config file.

Definition at line 77 of file Proxim.hh.

Referenced by createDefaultOptions(), and loadOptions().

mainFrame_

ProximMainFrame* Proxim::mainFrame_

private

The application main frame.

Definition at line 68 of file Proxim.hh.

Referenced by OnInit().

options_

GUIOptions* Proxim::options_

private

Options defining toolbar, keyboard shortcuts etc.

Definition at line 74 of file Proxim.hh.

Referenced by createDefaultOptions(), loadOptions(), OnInit(), and options().

SCHEMA_FILE_NAME

const std::string Proxim::SCHEMA_FILE_NAME = "confschema.xsd"

staticprivate

Name of the xml-schema file.

Definition at line 79 of file Proxim.hh.

Referenced by loadOptions().

simulation_

ProximSimulationThread* Proxim::simulation_

private

The simulation thread running the simulator backend.

Definition at line 72 of file Proxim.hh.

Referenced by OnExit(), OnInit(), and simulation().

---

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

• Proxim.hh
• Proxim.cc