ProDe Class Reference

#include <ProDe.hh>

Inheritance diagram for ProDe:

Collaboration diagram for ProDe:

Public Member Functions
	ProDe ()
bool	OnInit ()
int	OnExit ()
MainFrame *	mainFrame () const
ProDeOptions *	options () const
void	setOptions (ProDeOptions *options)
CommandRegistry *	commandRegistry () const
wxDocManager *	docManager () const

Static Public Member Functions
static std::string	bitmapsDirPath ()

Private Member Functions
void	createDefaultOptions ()

Private Attributes
wxDocManager *	docManager_
	Manages multiple documents. More...
MainFrame *	mainFrame_
	Main frame of the application. More...
ProDeOptions *	options_
	editor options More...
CommandRegistry *	commandRegistry_
	editor command registry More...

Detailed Description

Represents the ProDe application.

This class is responsible for parsing the command line and initializing the editor accordingly. If the editor is executed in interactive mode, a graphical user interface will be initialized. The class is derived from wxApp class, which does the low level initialization of wxWindows automatically.

Definition at line 54 of file ProDe.hh.

Constructor & Destructor Documentation

ProDe()

ProDe::ProDe

(

)

The constructor.

Definition at line 72 of file ProDe.cc.

            : docManager_((wxDocManager*)NULL), options_(NULL) {
}

Member Function Documentation

bitmapsDirPath()

string ProDe::bitmapsDirPath ( )

static

Returns path of toolbar icon files.

Returns

ProDe icon files path.

Definition at line 427 of file ProDe.cc.

                      {
    string path = Environment::bitmapsDirPath("ProDe") +
        FileSystem::DIRECTORY_SEPARATOR;
    return path;
}

References Environment::bitmapsDirPath(), and FileSystem::DIRECTORY_SEPARATOR.

Referenced by AboutDialog::createContents().

Here is the call graph for this function:

commandRegistry()

CommandRegistry * ProDe::commandRegistry

(

)

const

Returns command registry of the editor.

Definition at line 406 of file ProDe.cc.

                             {
    return commandRegistry_;
}

References commandRegistry_.

createDefaultOptions()

void ProDe::createDefaultOptions ( )

private

Creates default options.

Definition at line 277 of file ProDe.cc.

                            {
 
    // kb shortcut: ctrl-N = New Document
    KeyboardShortcut* scNew = new KeyboardShortcut(
        ProDeConstants::CMD_NAME_NEW_DOC, 0, true, false, int('N'));
 
    // kb shortcut: ctrl-O = Open Document
    KeyboardShortcut* scOpen = new KeyboardShortcut(
        ProDeConstants::CMD_NAME_OPEN_DOC, 0, true, false, int('O'));
 
    // kb shortcut: ctrl-S = Save Document
    KeyboardShortcut* scSave = new KeyboardShortcut(
        ProDeConstants::CMD_NAME_SAVE_DOC, 0, true, false, int('S'));
 
    // kb shortcut: ctrl-W = close document
    KeyboardShortcut* scClose = new KeyboardShortcut(
        ProDeConstants::CMD_NAME_CLOSE_DOC, 0, true, false, int('W'));
 
    // kb shortcut: ctrl-P = print document
    KeyboardShortcut* scPrint = new KeyboardShortcut(
        ProDeConstants::CMD_NAME_PRINT, 0, true, false, int('P'));
 
    // kb shortcut: ctrl-Q = quit
    KeyboardShortcut* scQuit = new KeyboardShortcut(
        ProDeConstants::CMD_NAME_QUIT, 0, true, false, int('Q'));
 
 
    // kb shortcut: ctrl-C = copy
    KeyboardShortcut* scCopy = new KeyboardShortcut(
        ProDeConstants::CMD_NAME_COPY, 0, true, false, int('C'));
 
    // kb shortcut: ctrl-X = cut
    KeyboardShortcut* scCut = new KeyboardShortcut(
        ProDeConstants::CMD_NAME_CUT, 0, true, false, int('X'));
 
    // kb shortcut: ctrl-V = paste
    KeyboardShortcut* scPaste = new KeyboardShortcut(
        ProDeConstants::CMD_NAME_PASTE, 0, true, false, int('V'));
 
    // kb shortcut: ctrl-Z = undo
    KeyboardShortcut* scUndo = new KeyboardShortcut(
        ProDeConstants::CMD_NAME_UNDO, 0, true, false, int('Z'));
 
    // kb shortcut: ctrl-Y = redo
    KeyboardShortcut* scRedo = new KeyboardShortcut(
        ProDeConstants::CMD_NAME_REDO, 0, true, false, int('Y'));
 
    // kb shortcut: F1 = Help
    KeyboardShortcut* scUserManual = new KeyboardShortcut(
        UserManualCmd::COMMAND_NAME, 1, false, false, 0);
 
    // toolbar buttons
    ToolbarButton* buttonNew = new ToolbarButton(
        0, ProDeConstants::CMD_NAME_NEW_DOC);
 
    ToolbarButton* buttonOpen = new ToolbarButton(
        1, ProDeConstants::CMD_NAME_OPEN_DOC);
 
    ToolbarButton* buttonSave = new ToolbarButton(
        2, ProDeConstants::CMD_NAME_SAVE_DOC);
 
    ToolbarButton* buttonDelete = new ToolbarButton(
        4, ProDeConstants::CMD_NAME_DELETE_COMP);
 
    ToolbarButton* buttonModify = new ToolbarButton(
        5, ProDeConstants::CMD_NAME_MODIFY_COMP);
 
    ToolbarButton* buttonZoomIn = new ToolbarButton(
        7, ProDeConstants::CMD_NAME_ZOOM_IN);
 
    ToolbarButton* buttonZoomOut = new ToolbarButton(
        8, ProDeConstants::CMD_NAME_ZOOM_OUT);
 
    ToolbarButton* buttonZoomFit = new ToolbarButton(
        9, ProDeConstants::CMD_NAME_ZOOM_FIT_WIN);
 
    ToolbarButton* buttonOptions = new ToolbarButton(
        11, ProDeConstants::CMD_NAME_EDIT_OPTIONS);
 
    ToolbarButton* buttonHelp = new ToolbarButton(
        12, UserManualCmd::COMMAND_NAME);
 
    options_ = new ProDeOptions();
 
    options_->addKeyboardShortcut(scNew);
    options_->addKeyboardShortcut(scOpen);
    options_->addKeyboardShortcut(scSave);
    options_->addKeyboardShortcut(scClose);
    options_->addKeyboardShortcut(scQuit);
    options_->addKeyboardShortcut(scPrint);
    options_->addKeyboardShortcut(scCopy);
    options_->addKeyboardShortcut(scCut);
    options_->addKeyboardShortcut(scPaste);
    options_->addKeyboardShortcut(scUndo);
    options_->addKeyboardShortcut(scRedo);
    options_->addKeyboardShortcut(scUserManual);
 
    options_->addToolbarButton(buttonNew);
    options_->addToolbarButton(buttonOpen);
    options_->addToolbarButton(buttonSave);
    options_->addToolbarButton(buttonDelete);
    options_->addToolbarButton(buttonModify);
    options_->addToolbarButton(buttonZoomIn);
    options_->addToolbarButton(buttonZoomOut);
    options_->addToolbarButton(buttonZoomFit);
    options_->addToolbarButton(buttonOptions);
    options_->addToolbarButton(buttonHelp);
    options_->addSeparator(3);
    options_->addSeparator(6);
    options_->addSeparator(10);
 
    // default toolbar layout and visibility
    options_->setToolbarLayout(ProDeOptions::BOTH);
    options_->setToolbarVisibility(true);
 
    // default undo levels
    options_->setUndoStackSize(5);
 
    // set MainFrame size and position
    options_->setFullScreen(false);
    options_->setWindowSize(600, 500);
    options_->setWindowPosition(100, 50);
}

References GUIOptions::addKeyboardShortcut(), GUIOptions::addSeparator(), GUIOptions::addToolbarButton(), GUIOptions::BOTH, ProDeConstants::CMD_NAME_CLOSE_DOC, ProDeConstants::CMD_NAME_COPY, ProDeConstants::CMD_NAME_CUT, ProDeConstants::CMD_NAME_DELETE_COMP, ProDeConstants::CMD_NAME_EDIT_OPTIONS, ProDeConstants::CMD_NAME_MODIFY_COMP, ProDeConstants::CMD_NAME_NEW_DOC, ProDeConstants::CMD_NAME_OPEN_DOC, ProDeConstants::CMD_NAME_PASTE, ProDeConstants::CMD_NAME_PRINT, ProDeConstants::CMD_NAME_QUIT, ProDeConstants::CMD_NAME_REDO, ProDeConstants::CMD_NAME_SAVE_DOC, ProDeConstants::CMD_NAME_UNDO, ProDeConstants::CMD_NAME_ZOOM_FIT_WIN, ProDeConstants::CMD_NAME_ZOOM_IN, ProDeConstants::CMD_NAME_ZOOM_OUT, UserManualCmd::COMMAND_NAME, options_, GUIOptions::setFullScreen(), GUIOptions::setToolbarLayout(), GUIOptions::setToolbarVisibility(), ProDeOptions::setUndoStackSize(), GUIOptions::setWindowPosition(), and GUIOptions::setWindowSize().

Referenced by OnInit().

Here is the call graph for this function:

docManager()

wxDocManager * ProDe::docManager

(

)

const

Returns document manager of the editor.

Definition at line 416 of file ProDe.cc.

                        {
    return docManager_;
}

References docManager_.

mainFrame()

MainFrame * ProDe::mainFrame

(

)

const

Returns pointer to the main frame of the editor.

Returns

Pointer to the main frame of the editor.

Definition at line 242 of file ProDe.cc.

                       {
    return mainFrame_;
}

References mainFrame_.

OnExit()

int ProDe::OnExit

(

)

Deletes the application level dynamic objects not handled by wxWindows.

Called when the editor is about to exit, and all application windows are already destroyed.

Definition at line 227 of file ProDe.cc.

              {
    ProDeClipboard::destroy();
    ProDeTextGenerator::destroy();
    delete docManager_;
    delete options_;
    return 0;
}

References ProDeClipboard::destroy(), ProDeTextGenerator::destroy(), docManager_, and options_.

Here is the call graph for this function:

OnInit()

bool ProDe::OnInit

(

)

Parses the command line and initializes the editor accordingly.

Called only once by wxWindows when the program is executed. Command line is parsed using wxCmdLineParser class. If no script is provided with a "-s" option, main frame is created and set as the main window. An instance of the wxDocManager will be created to handle document templates, if the editor is ran in interactive mode.

Returns

true if application was succesfully initialized, false otherwise.

Definition at line 89 of file ProDe.cc.

              {
 
    Application::initialize(argc, WxConversion::toCStringArray(argc, argv));
 
    // parse command line
    static const wxCmdLineEntryDesc cmdLineDesc[] = {
 
#if wxCHECK_VERSION(3, 0, 0)
        { wxCMD_LINE_PARAM, "", "", "file", wxCMD_LINE_VAL_STRING,
          wxCMD_LINE_PARAM_OPTIONAL | wxCMD_LINE_PARAM_MULTIPLE },
 
        { wxCMD_LINE_NONE, "", "", "", wxCMD_LINE_VAL_STRING, 0}
#else
        { wxCMD_LINE_PARAM, _T(""), _T(""), _T("file"), wxCMD_LINE_VAL_STRING,
          wxCMD_LINE_PARAM_OPTIONAL | wxCMD_LINE_PARAM_MULTIPLE },
 
        { wxCMD_LINE_NONE, _T(""), _T(""), _T(""), wxCMD_LINE_VAL_STRING, 0}
#endif
 
    };
 
    wxCmdLineParser parser(cmdLineDesc, argc, argv);
    int parserStatus = parser.Parse();
    if (parserStatus != 0) {
        return false;
    }
 
    // create a document template for ADF files.
    docManager_ = new wxDocManager;
    (void) new wxDocTemplate((wxDocManager*) docManager_,
                 _T("Architecture Definition"),
                             _T("*.adf;*.xml;*.cfg"), _T(""),
                 _T("adf"), _T("Architecture Definition File"),
                 _T("ADF View"), CLASSINFO(MDFDocument),
                 CLASSINFO(MDFView));
 
    // Dummy doc template for cfgs.
    // Older versions of wxWidgets don't handle the *.adf;*.cfg file filter
    // correctly and .cfgs don't get associated to the correct document class
    // without this invisble template.
    (void) new wxDocTemplate((wxDocManager*) docManager_,
                 _T("Processor Configuration"),
                             _T("*.cfg"), _T(""),
                 _T("cfg"), _T("Architecture Definition File"),
                 _T("ADF View"), CLASSINFO(MDFDocument),
                 CLASSINFO(MDFView), wxTEMPLATE_INVISIBLE);
 
    // Dummy doc template for xmls.
    (void) new wxDocTemplate((wxDocManager*) docManager_,
                 _T("Architecture Definition File"),
                             _T("*.xml"), _T(""),
                 _T("xml"), _T("Architecture Definition File"),
                 _T("ADF View"), CLASSINFO(MDFDocument),
                 CLASSINFO(MDFView), wxTEMPLATE_INVISIBLE);
    
    // create a registry of commands
    commandRegistry_ = new CommandRegistry();
 
    // load image handler for pngs
    wxImage::AddHandler(new wxPNGHandler);
 
    // set configurations
    string configFile = Environment::confPath("ProDe.conf");
 
    // Name of the XML Schema for options file.
    string schemaFile =
        Environment::dataDirPath("ProDe")+
        FileSystem::DIRECTORY_SEPARATOR + "confschema.xsd";
 
    ProDeOptionsSerializer reader;
    reader.setSourceFile(configFile);
    reader.setSchemaFile(schemaFile);
    reader.setUseSchema(true);
    bool erroneousOptions = false;
    try {
        ObjectState* optionsState = reader.readState();
        options_ = new ProDeOptions(optionsState);
        delete optionsState;
        options_->validate();
        options_->setFileName(configFile);
    } catch (Exception& e) {
        cerr << e.errorMessage() << endl
             << "Default options will be used." << endl;
        erroneousOptions = true;
    }
 
    if (erroneousOptions) {
        createDefaultOptions();
    } else {
        options_->clearModified();
    }
 
    // create the main frame window
    mainFrame_ =
    new MainFrame((wxDocManager*) docManager_, (wxFrame*) NULL,
              ProDeConstants::EDITOR_NAME,
              wxPoint(options_->xPosition(), options_->yPosition()),
              wxSize(options_->windowWidth(),
                 options_->windowHeight()),
              wxDEFAULT_FRAME_STYLE | wxNO_FULL_REPAINT_ON_RESIZE);
 
    mainFrame_->Show(TRUE);
    SetTopWindow(mainFrame_);
 
    // open documents given in command line
    for (unsigned int i = 0; i < parser.GetParamCount(); i++) {
        wxString file = parser.GetParam(i);
        wxDocument* doc = docManager_->CreateDocument(file,  wxDOC_SILENT);
        if (doc == NULL) {
            string fileName = WxConversion::toString(file);
            if (FileSystem::fileExists(fileName)) {
                std::cerr << "Improper file '"
                          << fileName
                          << "' couldn't be opened."
                          << std::endl;
            } else {
                std::cerr << "Cannot open file '"
                          << fileName
                          << "'."
                          << std::endl;
            }
        }
    }
 
    //mainFrame_->updateMenubar();
    //mainFrame_->updateToolbar();
 
    return true;
}

References GUIOptions::clearModified(), commandRegistry_, Environment::confPath(), createDefaultOptions(), Environment::dataDirPath(), FileSystem::DIRECTORY_SEPARATOR, docManager_, ProDeConstants::EDITOR_NAME, Exception::errorMessage(), FileSystem::fileExists(), Application::initialize(), mainFrame_, options_, GUIOptionsSerializer::readState(), GUIOptions::setFileName(), XMLSerializer::setSchemaFile(), XMLSerializer::setSourceFile(), XMLSerializer::setUseSchema(), WxConversion::toCStringArray(), WxConversion::toString(), TRUE, GUIOptions::validate(), GUIOptions::windowHeight(), GUIOptions::windowWidth(), GUIOptions::xPosition(), and GUIOptions::yPosition().

Here is the call graph for this function:

options()

ProDeOptions * ProDe::options

(

)

const

Returns editor options.

Returns

Current editor options.

Definition at line 253 of file ProDe.cc.

                     {
    return options_;
}

References options_.

Referenced by setOptions().

setOptions()

void ProDe::setOptions

(

ProDeOptions *

options

)

Sets the editor options, and deletes old options.

Parameters

options

ProDeOptions to set as new options.

Definition at line 264 of file ProDe.cc.

                                       {
    if (options_ != NULL) {
    delete options_;
    }
    options_ = options;
    mainFrame_->createToolbar();
}

References MainFrame::createToolbar(), mainFrame_, options(), and options_.

Here is the call graph for this function:

Member Data Documentation

commandRegistry_

CommandRegistry* ProDe::commandRegistry_

private

editor command registry

Definition at line 76 of file ProDe.hh.

Referenced by commandRegistry(), and OnInit().

docManager_

wxDocManager* ProDe::docManager_

private

Manages multiple documents.

Definition at line 70 of file ProDe.hh.

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

mainFrame_

MainFrame* ProDe::mainFrame_

private

Main frame of the application.

Definition at line 72 of file ProDe.hh.

Referenced by mainFrame(), OnInit(), and setOptions().

options_

ProDeOptions* ProDe::options_

private

editor options

Definition at line 74 of file ProDe.hh.

Referenced by createDefaultOptions(), OnExit(), OnInit(), options(), and setOptions().

---

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

• ProDe.hh
• ProDe.cc