MainFrame Class Reference

#include <MainFrame.hh>

Inheritance diagram for MainFrame:

Collaboration diagram for MainFrame:

Public Member Functions
	MainFrame (wxDocManager *manager, wxFrame *parent, const wxString &title, const wxPoint &position, const wxSize &size, long style)
void	onKeyEvent (wxKeyEvent &event)
void	createToolbar ()
void	createMenubar ()
void	onToggleToolbar ()
void	onToggleStatusbar ()
void	updateUI ()
void	OnExit (wxCommandEvent &WXUNUSED(event))

Private Types
enum	{   ID_ADD_SUBMENU = 12000 , ID_ADD_FROM_HDB_SUBMENU , ID_ZOOM_SUBMENU , ID_VIEW_TOOLBAR ,   ID_VIEW_STATUSBAR }
	GUI element IDs. More...

Private Member Functions
wxMenu *	createOptionsMenu ()
wxMenu *	createHelpMenu ()
void	onCommandEvent (wxCommandEvent &event)
void	onUpdateUI (wxUpdateUIEvent &event)
wxString	menuAccelerator (int id)

Private Attributes
CommandRegistry *	commandRegistry_
	Command registry.
wxToolBar *	toolbar_
	Toolbar.

Detailed Description

Main window of the editor.

Contains a default menubar, toolbar, statusbar and the child frames for all open documents. Derived from the wxDocMDIParentFrame class, which handles the child frames automatically. Handles the Options and the Help menu events and the events for toggling visibility of the menubar and the toolbar.

Definition at line 50 of file MainFrame.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

GUI element IDs.

Enumerator
ID_ADD_SUBMENU
ID_ADD_FROM_HDB_SUBMENU
ID_ZOOM_SUBMENU
ID_VIEW_TOOLBAR
ID_VIEW_STATUSBAR

Definition at line 78 of file MainFrame.hh.

         {
        ID_ADD_SUBMENU = 12000,
        ID_ADD_FROM_HDB_SUBMENU,
        ID_ZOOM_SUBMENU,
        ID_VIEW_TOOLBAR,
        ID_VIEW_STATUSBAR
    };

Constructor & Destructor Documentation

MainFrame()

MainFrame::MainFrame	(	wxDocManager *	manager,
		wxFrame *	parent,
		const wxString &	title,
		const wxPoint &	position,
		const wxSize &	size,
		long	style
	)

The Constructor.

Parameters

manager	Pointer to the editor's document manager.
parent	Parent frame of the MainFrame.
title	Title of the MainFrame.
position	Position of the MainFrame on the screen.
size	Size of the MainFrame on the screen.
style	Style of the MainFrame.

Definition at line 118 of file MainFrame.cc.

               :
    wxDocMDIParentFrame(manager, parent, -1, title,
            position, size, style, _T("MainFrame")) {
 
    commandRegistry_ = wxGetApp().commandRegistry();
    assert(commandRegistry_ != NULL);
    commandRegistry_->addCommand(new NewDocumentCmd());
    commandRegistry_->addCommand(new OpenDocumentCmd());
    commandRegistry_->addCommand(new CloseDocumentCmd());
    commandRegistry_->addCommand(new SaveDocumentCmd());
    commandRegistry_->addCommand(new SaveDocumentAsCmd());
    commandRegistry_->addCommand(new PrintCmd());
    commandRegistry_->addCommand(new PrintPreviewCmd());
    commandRegistry_->addCommand(new ProDeExportCmd());
    commandRegistry_->addCommand(new QuitCmd());
    commandRegistry_->addCommand(new UndoCmd());
    commandRegistry_->addCommand(new RedoCmd());
    commandRegistry_->addCommand(new AddFUCmd());
    commandRegistry_->addCommand(new AddRFCmd());
    commandRegistry_->addCommand(new AddBusCmd());
    commandRegistry_->addCommand(new AddSocketCmd());
    commandRegistry_->addCommand(new AddBridgeCmd());
    commandRegistry_->addCommand(new AddIUCmd());
    commandRegistry_->addCommand(new AddGCUCmd());
    commandRegistry_->addCommand(new AddASCmd());
    commandRegistry_->addCommand(new AddRFFromHDBCmd());
    commandRegistry_->addCommand(new AddIUFromHDBCmd());
    commandRegistry_->addCommand(new AddFUFromHDBCmd());
    commandRegistry_->addCommand(new CopyComponentCmd());
    commandRegistry_->addCommand(new CutComponentCmd());
    commandRegistry_->addCommand(new PasteComponentCmd());
    commandRegistry_->addCommand(new DeleteComponentCmd());
    commandRegistry_->addCommand(new ModifyComponentCmd());
    commandRegistry_->addCommand(new EditConnectionsCmd());
    commandRegistry_->addCommand(new EditAddressSpacesCmd());
    commandRegistry_->addCommand(new EditBusOrderCmd());
    commandRegistry_->addCommand(new EditTemplatesCmd());
    commandRegistry_->addCommand(new EditOTAFormatsCmd());
    commandRegistry_->addCommand(new EditMachineCmd());
    commandRegistry_->addCommand(new EditImmediateSlotsCmd());
    commandRegistry_->addCommand(new SelectCmd());
    commandRegistry_->addCommand(new FullyConnectBussesCmd());
    commandRegistry_->addCommand(new ZoomInCmd());
    commandRegistry_->addCommand(new ZoomOutCmd());
    commandRegistry_->addCommand(new FitWindowCmd());
    commandRegistry_->addCommand(new FitHeightCmd());
    commandRegistry_->addCommand(new FitWidthCmd());
    commandRegistry_->addCommand(new ToggleUnitDetailsCmd());
    commandRegistry_->addCommand(new VerifyMachineCmd());
    commandRegistry_->addCommand(new ImplementMachineCmd());
    commandRegistry_->addCommand(new CallExplorerPluginCmd());
    commandRegistry_->addCommand(new EditOptionsCmd());
    commandRegistry_->addCommand(new SaveOptionsCmd());
    commandRegistry_->addCommand(new UserManualCmd());
    commandRegistry_->addCommand(new AboutCmd());
    commandRegistry_->addCommand(new VLIWConnectICCmd());
    commandRegistry_->addCommand(new BlocksConnectICCmd());
 
    toolbar_ = NULL;
    CreateStatusBar(2);
    int widths[2] = {-2, -1};
    SetStatusWidths(2, widths);
 
    createMenubar();
    createToolbar();
}

References assert.

Member Function Documentation

createHelpMenu()

wxMenu * MainFrame::createHelpMenu ( )

private

Creates and returns a new help menu.

Returns

Help menu.

Definition at line 260 of file MainFrame.cc.

                          {
    wxMenu* helpMenu = new wxMenu;
    helpMenu->Append(
        UserManualCmd::COMMAND_ID,
        menuAccelerator(UserManualCmd::COMMAND_ID).Prepend(
            _T("&User Manual...")));
 
    helpMenu->Append(
        ProDeConstants::COMMAND_ABOUT,
        menuAccelerator(ProDeConstants::COMMAND_ABOUT).Prepend(
            _T("&About...")));
 
    return helpMenu;
}

References ProDeConstants::COMMAND_ABOUT, UserManualCmd::COMMAND_ID, and menuAccelerator().

Referenced by createMenubar().

Here is the call graph for this function:

createMenubar()

void MainFrame::createMenubar

(

)

Creates the default menubar.

Definition at line 414 of file MainFrame.cc.

                         {
    // File menu
    wxMenu* fileMenu = new wxMenu;
 
    fileMenu->Append(
        ProDeConstants::COMMAND_NEW_DOC,
        menuAccelerator(ProDeConstants::COMMAND_NEW_DOC).Prepend(_T("New")));
 
    fileMenu->Append(
        ProDeConstants::COMMAND_OPEN_DOC,
        menuAccelerator(
            ProDeConstants::COMMAND_OPEN_DOC).Prepend(_T("Open...")));
 
    fileMenu->Append(
        ProDeConstants::COMMAND_SAVE_DOC,
        menuAccelerator(
            ProDeConstants::COMMAND_SAVE_DOC).Prepend(_T("&Save")));
 
    fileMenu->Append(
        ProDeConstants::COMMAND_SAVEAS_DOC,
        menuAccelerator(
            ProDeConstants::COMMAND_SAVEAS_DOC).Prepend(_T("Save &As...")));
 
    fileMenu->Append(
        ProDeConstants::COMMAND_CLOSE_DOC,
        menuAccelerator(
            ProDeConstants::COMMAND_CLOSE_DOC).Prepend(_T("&Close")));
 
    fileMenu->AppendSeparator();
 
    fileMenu->Append(
        ProDeConstants::COMMAND_PRINT,
        menuAccelerator(
            ProDeConstants::COMMAND_PRINT).Prepend(_T("&Print...")));
 
    fileMenu->Append(
        ProDeConstants::COMMAND_PRINT_PREVIEW,
        menuAccelerator(ProDeConstants::COMMAND_PRINT_PREVIEW).Prepend(
            _T("Print Pre&view...")));
 
    fileMenu->Append(
        ProDeConstants::COMMAND_EXPORT,
        menuAccelerator(ProDeConstants::COMMAND_EXPORT).Prepend(
            _T("Export...")));
 
    fileMenu->AppendSeparator();
 
    fileMenu->Append(
        ProDeConstants::COMMAND_QUIT,
        menuAccelerator(ProDeConstants::COMMAND_QUIT).Prepend(_T("&Quit")));
 
    // Edit menu
    wxMenu* editMenu = new wxMenu;
    wxMenu* addSubMenu = new wxMenu;
    wxMenu* addFromHDBSubMenu = new wxMenu;
        
    editMenu->Append(
        ProDeConstants::COMMAND_UNDO,
        menuAccelerator(ProDeConstants::COMMAND_UNDO).Prepend(
            _T("&Undo")));
 
    editMenu->Append(
        ProDeConstants::COMMAND_REDO,
        menuAccelerator(ProDeConstants::COMMAND_REDO).Prepend(
            _T("&Redo")));
 
    editMenu->AppendSeparator();
        editMenu->Append(
        ProDeConstants::COMMAND_CUT,
        menuAccelerator(ProDeConstants::COMMAND_CUT).Prepend(
            _T("Cu&t")));
 
    editMenu->Append(
        ProDeConstants::COMMAND_COPY,
        menuAccelerator(ProDeConstants::COMMAND_COPY).Prepend(
            _T("&Copy")));
        
    editMenu->Append(
        ProDeConstants::COMMAND_PASTE,
        menuAccelerator(ProDeConstants::COMMAND_PASTE).Prepend(
            _T("&Paste")));
 
    editMenu->AppendSeparator();
 
    addSubMenu->Append(
        ProDeConstants::COMMAND_ADD_FU,
        menuAccelerator(ProDeConstants::COMMAND_ADD_FU).Prepend(
            _T("&Function Unit...")));
 
    addSubMenu->Append(
        ProDeConstants::COMMAND_ADD_RF,
        menuAccelerator(ProDeConstants::COMMAND_ADD_RF).Prepend(
            _T("&Register File...")));
 
    addSubMenu->Append(
        ProDeConstants::COMMAND_ADD_BUS,
        menuAccelerator(ProDeConstants::COMMAND_ADD_BUS).Prepend(
            _T("&Transport Bus...")));
 
    addSubMenu->Append(
        ProDeConstants::COMMAND_ADD_SOCKET,
        menuAccelerator(ProDeConstants::COMMAND_ADD_SOCKET).Prepend(
            _T("&Socket...")));
 
    addSubMenu->Append(
        ProDeConstants::COMMAND_ADD_BRIDGE,
        menuAccelerator(ProDeConstants::COMMAND_ADD_BRIDGE).Prepend(
            _T("&Bridge...")));
 
    addSubMenu->Append(
        ProDeConstants::COMMAND_ADD_IU,
        menuAccelerator(ProDeConstants::COMMAND_ADD_IU).Prepend(
            _T("&Immediate Unit...")));
 
    addSubMenu->Append(
        ProDeConstants::COMMAND_ADD_GCU,
        menuAccelerator(ProDeConstants::COMMAND_ADD_GCU).Prepend(
            _T("&Global Control Unit...")));
 
    addSubMenu->Append(
        ProDeConstants::COMMAND_ADD_AS,
        menuAccelerator(ProDeConstants::COMMAND_ADD_AS).Prepend(
            _T("&Address Space...")));
 
    editMenu->Append(ID_ADD_SUBMENU, _T("&Add"), addSubMenu);
 
    addFromHDBSubMenu->Append(
        ProDeConstants::COMMAND_ADD_FU_FROM_HDB,
        menuAccelerator(ProDeConstants::COMMAND_ADD_FU_FROM_HDB).Prepend(
            _T("&Function Unit...")));
 
    addFromHDBSubMenu->Append(
        ProDeConstants::COMMAND_ADD_IU_FROM_HDB,
        menuAccelerator(ProDeConstants::COMMAND_ADD_IU_FROM_HDB).Prepend(
            _T("&Immediate Unit...")));
 
    addFromHDBSubMenu->Append(
        ProDeConstants::COMMAND_ADD_RF_FROM_HDB,
        menuAccelerator(ProDeConstants::COMMAND_ADD_RF_FROM_HDB).Prepend(
            _T("&Register File...")));
 
    editMenu->Append(
        ID_ADD_FROM_HDB_SUBMENU,
        _T("Add From &HDB"), addFromHDBSubMenu);
 
    editMenu->Append(
        ProDeConstants::COMMAND_DELETE_COMP,
        menuAccelerator(ProDeConstants::COMMAND_DELETE_COMP).Prepend(
            _T("&Delete")));
 
    editMenu->Append(
        ProDeConstants::COMMAND_MODIFY_COMP,
        menuAccelerator(ProDeConstants::COMMAND_MODIFY_COMP).Prepend(
            _T("&Modify...")));
 
    editMenu->AppendSeparator();
    editMenu->Append(
        ProDeConstants::COMMAND_EDIT_ADDRESS_SPACES,
        menuAccelerator(ProDeConstants::COMMAND_EDIT_ADDRESS_SPACES).Prepend(
            _T("Address &Spaces...")));
 
    editMenu->Append(
        ProDeConstants::COMMAND_EDIT_TEMPLATES,
        menuAccelerator(ProDeConstants::COMMAND_EDIT_TEMPLATES).Prepend(
            _T("Instruction &Templates...")));
 
    editMenu->Append(
        ProDeConstants::COMMAND_EDIT_OTA_FORMATS,
        menuAccelerator(ProDeConstants::COMMAND_EDIT_OTA_FORMATS)
            .Prepend(_T("OTA Formats...")));
 
    editMenu->Append(
        ProDeConstants::COMMAND_EDIT_IMMEDIATE_SLOTS,
        menuAccelerator(ProDeConstants::COMMAND_EDIT_IMMEDIATE_SLOTS).Prepend(
            _T("&Immediate Slots...")));
 
    editMenu->Append(
        ProDeConstants::COMMAND_EDIT_BUS_ORDER,
        menuAccelerator(ProDeConstants::COMMAND_EDIT_BUS_ORDER).Prepend(
            _T("Transport Bus &Order...")));
 
    editMenu->Append(
        ProDeConstants::COMMAND_EDIT_MACHINE,
        menuAccelerator(ProDeConstants::COMMAND_EDIT_MACHINE).Prepend(
            _T("Architecture Features...")));
 
    // View menu
    wxMenu* viewMenu = new wxMenu;
    wxMenu* zoomSubMenu = new wxMenu;
    zoomSubMenu->Append(
        ProDeConstants::COMMAND_ZOOM_IN,
        menuAccelerator(ProDeConstants::COMMAND_ZOOM_IN).Prepend(
            _T("Zoom &In")));
 
    zoomSubMenu->Append(
        ProDeConstants::COMMAND_ZOOM_OUT,
        menuAccelerator(ProDeConstants::COMMAND_ZOOM_OUT).Prepend(
            _T("Zoom &Out")));
 
    zoomSubMenu->AppendSeparator();
    zoomSubMenu->Append(
        ProDeConstants::COMMAND_ZOOM_FIT_WIN,
        menuAccelerator(ProDeConstants::COMMAND_ZOOM_FIT_WIN).Prepend(
            _T("&Fit Window")));
 
    zoomSubMenu->Append(
        ProDeConstants::COMMAND_ZOOM_FIT_HEI,
        menuAccelerator(ProDeConstants::COMMAND_ZOOM_FIT_HEI).Prepend(
            _T("Fit &Height")));
 
    zoomSubMenu->Append(
        ProDeConstants::COMMAND_ZOOM_FIT_WID,
        menuAccelerator(ProDeConstants::COMMAND_ZOOM_FIT_WID).Prepend(
            _T("Fit &Width")));
 
    viewMenu->Append(ID_ZOOM_SUBMENU, _T("&Zoom"), zoomSubMenu);
    viewMenu->AppendSeparator();
    viewMenu->AppendCheckItem(
        ProDeConstants::COMMAND_TOGGLE_UNIT_DETAILS,
        menuAccelerator(ProDeConstants::COMMAND_TOGGLE_UNIT_DETAILS).Prepend(
            _T("Unit &Details")));
 
    viewMenu->AppendSeparator();
    viewMenu->AppendCheckItem(ID_VIEW_TOOLBAR, _T("&Toolbar"));
    viewMenu->AppendCheckItem(ID_VIEW_STATUSBAR, _T("&Statusbar"));
    viewMenu->Check(ID_VIEW_STATUSBAR, true);
    viewMenu->Check(ID_VIEW_TOOLBAR, true);
 
    // Tool menu
    wxMenu* toolMenu = new wxMenu;
    toolMenu->Append(
        ProDeConstants::COMMAND_SELECT,
        menuAccelerator(ProDeConstants::COMMAND_SELECT).Prepend(
            _T("&Select")));
 
    toolMenu->Append(
        ProDeConstants::COMMAND_EDIT_CONNECTIONS,
        menuAccelerator(ProDeConstants::COMMAND_EDIT_CONNECTIONS).Prepend(
            _T("&Edit Connections")));
 
    toolMenu->AppendSeparator();
    toolMenu->Append(
        ProDeConstants::COMMAND_FULLY_CONNECT_BUSSES,
        menuAccelerator(ProDeConstants::COMMAND_FULLY_CONNECT_BUSSES).Prepend(
            _T("&Fully Connect IC")));
 
    toolMenu->Append(
        ProDeConstants::COMMAND_VLIW_CONNECT_IC,
        menuAccelerator(ProDeConstants::COMMAND_VLIW_CONNECT_IC).Prepend(
            _T("&VLIW Connect IC")));
 
    toolMenu->Append(
        ProDeConstants::COMMAND_BLOCKS_CONNECT_IC,
        menuAccelerator(ProDeConstants::COMMAND_BLOCKS_CONNECT_IC)
            .Prepend(_T("&Blocks Connect IC")));
 
    toolMenu->Append(
        ProDeConstants::COMMAND_VERIFY_MACHINE,
        menuAccelerator(ProDeConstants::COMMAND_VERIFY_MACHINE).Prepend(
            _T("&Verify...")));
 
    toolMenu->Append(
        ProDeConstants::COMMAND_IMPLEMENTATION,
        menuAccelerator(ProDeConstants::COMMAND_IMPLEMENTATION).Prepend(
            _T("&Processor Implementation...")));
    
    toolMenu->Append(
        ProDeConstants::COMMAND_CALL_EXPLORER_PLUGIN,
        menuAccelerator(ProDeConstants::COMMAND_CALL_EXPLORER_PLUGIN).Prepend(
            _T("&Call Explorer Plugin...")));
 
    // Options menu
    wxMenu* optionsMenu = createOptionsMenu();
 
    // Help menu
    wxMenu* helpMenu = createHelpMenu();
 
    // add menus to the menubar
    wxMenuBar* menuBar = new wxMenuBar;
    menuBar->Append(fileMenu, _T("&File"));
    menuBar->Append(editMenu, _T("&Edit"));
    menuBar->Append(viewMenu, _T("&View"));
    menuBar->Append(toolMenu, _T("&Tools"));
    menuBar->Append(optionsMenu, _T("&Options"));
    menuBar->Append(helpMenu, _T("&Help"));
 
    SetMenuBar(menuBar);
}

References ProDeConstants::COMMAND_ADD_AS, ProDeConstants::COMMAND_ADD_BRIDGE, ProDeConstants::COMMAND_ADD_BUS, ProDeConstants::COMMAND_ADD_FU, ProDeConstants::COMMAND_ADD_FU_FROM_HDB, ProDeConstants::COMMAND_ADD_GCU, ProDeConstants::COMMAND_ADD_IU, ProDeConstants::COMMAND_ADD_IU_FROM_HDB, ProDeConstants::COMMAND_ADD_RF, ProDeConstants::COMMAND_ADD_RF_FROM_HDB, ProDeConstants::COMMAND_ADD_SOCKET, ProDeConstants::COMMAND_BLOCKS_CONNECT_IC, ProDeConstants::COMMAND_CALL_EXPLORER_PLUGIN, ProDeConstants::COMMAND_CLOSE_DOC, ProDeConstants::COMMAND_COPY, ProDeConstants::COMMAND_CUT, ProDeConstants::COMMAND_DELETE_COMP, ProDeConstants::COMMAND_EDIT_ADDRESS_SPACES, ProDeConstants::COMMAND_EDIT_BUS_ORDER, ProDeConstants::COMMAND_EDIT_CONNECTIONS, ProDeConstants::COMMAND_EDIT_IMMEDIATE_SLOTS, ProDeConstants::COMMAND_EDIT_MACHINE, ProDeConstants::COMMAND_EDIT_OTA_FORMATS, ProDeConstants::COMMAND_EDIT_TEMPLATES, ProDeConstants::COMMAND_EXPORT, ProDeConstants::COMMAND_FULLY_CONNECT_BUSSES, ProDeConstants::COMMAND_IMPLEMENTATION, ProDeConstants::COMMAND_MODIFY_COMP, ProDeConstants::COMMAND_NEW_DOC, ProDeConstants::COMMAND_OPEN_DOC, ProDeConstants::COMMAND_PASTE, ProDeConstants::COMMAND_PRINT, ProDeConstants::COMMAND_PRINT_PREVIEW, ProDeConstants::COMMAND_QUIT, ProDeConstants::COMMAND_REDO, ProDeConstants::COMMAND_SAVE_DOC, ProDeConstants::COMMAND_SAVEAS_DOC, ProDeConstants::COMMAND_SELECT, ProDeConstants::COMMAND_TOGGLE_UNIT_DETAILS, ProDeConstants::COMMAND_UNDO, ProDeConstants::COMMAND_VERIFY_MACHINE, ProDeConstants::COMMAND_VLIW_CONNECT_IC, ProDeConstants::COMMAND_ZOOM_FIT_HEI, ProDeConstants::COMMAND_ZOOM_FIT_WID, ProDeConstants::COMMAND_ZOOM_FIT_WIN, ProDeConstants::COMMAND_ZOOM_IN, ProDeConstants::COMMAND_ZOOM_OUT, createHelpMenu(), createOptionsMenu(), ID_ADD_FROM_HDB_SUBMENU, ID_ADD_SUBMENU, ID_VIEW_STATUSBAR, ID_VIEW_TOOLBAR, ID_ZOOM_SUBMENU, and menuAccelerator().

Here is the call graph for this function:

createOptionsMenu()

wxMenu * MainFrame::createOptionsMenu ( )

private

Creates and returns a new options menu.

Returns

Options menu.

Definition at line 237 of file MainFrame.cc.

                             {
    wxMenu* optionsMenu = new wxMenu;
    optionsMenu->Append(
        ProDeConstants::COMMAND_EDIT_OPTIONS,
        menuAccelerator(ProDeConstants::COMMAND_EDIT_OPTIONS).Prepend(
            _T("&Edit...")));
 
    optionsMenu->AppendSeparator();
    optionsMenu->Append(
        ProDeConstants::COMMAND_SAVE_OPTIONS,
        menuAccelerator(ProDeConstants::COMMAND_SAVE_OPTIONS).Prepend(
            _T("&Save")));
 
    return optionsMenu;
}

References ProDeConstants::COMMAND_EDIT_OPTIONS, ProDeConstants::COMMAND_SAVE_OPTIONS, and menuAccelerator().

Referenced by createMenubar().

Here is the call graph for this function:

createToolbar()

void MainFrame::createToolbar

(

)

Creates the toolbar.

Definition at line 746 of file MainFrame.cc.

                         {
 
    // delete old toolbar
    if (toolbar_ != NULL) {
        delete toolbar_;
        toolbar_ = NULL;
    }
 
    CommandRegistry* registry = wxGetApp().commandRegistry();
    ProDeOptions* options = wxGetApp().options();
    wxString iconPath = WxConversion::toWxString(Environment::iconDirPath());
 
    toolbar_ = options->createToolbar(this, *registry, iconPath);
 
    // set new toolbar as the MainFrame toolbar
    SetToolBar(toolbar_);
    toolbar_->Show(true);
}

References Environment::iconDirPath(), options, toolbar_, and WxConversion::toWxString().

Referenced by onToggleToolbar(), and ProDe::setOptions().

Here is the call graph for this function:

menuAccelerator()

wxString MainFrame::menuAccelerator ( int  id )

private

Returns a menu accelerator string for a command.

The returned string can be appended to the menu item text to set the keyboard shortcut defined in the options for the command.

Parameters

id	Command ID.

Returns

Accelerator string.

Definition at line 713 of file MainFrame.cc.

                                 {
 
    const CommandRegistry* reg = wxGetApp().commandRegistry();
    const GUIOptions* options = wxGetApp().options();
    std::string cmdName = reg->commandName(id);
    const KeyboardShortcut* sc = options->keyboardShortcut(cmdName);
 
    if (sc != NULL) {
        wxString accel = _T("\t");
        if (sc->ctrl()) {
            accel.Append(_T("Ctrl-"));
            accel.Append(WxConversion::toWxString(sc->key()));
            return accel;
        } else if (sc->alt()) {
            accel.Append(_T("Alt-"));
            accel.Append(WxConversion::toWxString(sc->key()));
            return accel;
        } else if (sc->fKey() > 0) {
            accel.Append(_T("F"));
            accel.Append(WxConversion::toWxString(sc->fKey()));
            return accel;
        } else {
            // Invalid shortcut.
            return _T("");
        }
    }
    return _T("");
}

References KeyboardShortcut::alt(), CommandRegistry::commandName(), KeyboardShortcut::ctrl(), KeyboardShortcut::fKey(), KeyboardShortcut::key(), options, and WxConversion::toWxString().

Referenced by createHelpMenu(), createMenubar(), and createOptionsMenu().

Here is the call graph for this function:

onCommandEvent()

void MainFrame::onCommandEvent ( wxCommandEvent &  event )

private

Handles menu and toolbar events.

Parameters

event

Event to handle.

Definition at line 283 of file MainFrame.cc.

                                               {
 
    if (event.GetId() == ID_VIEW_TOOLBAR) {
        onToggleToolbar();
        return;
    }
 
    if (event.GetId() == ID_VIEW_STATUSBAR) {
        onToggleStatusbar();
        return;
    }
 
    GUICommand* command = wxGetApp().commandRegistry()
    ->createCommand(event.GetId());
 
    if (command == NULL) {
    ErrorDialog dialog(this,
               _T("No handler found for the command event!"));
    dialog.ShowModal();
    return;
    }
 
    if (!command->isEnabled()) {
        delete command;
        return;
    }
 
    wxView* view = wxGetApp().docManager()->GetCurrentView();
    if (view != NULL) {
        command->setParentWindow(this);
        EditorCommand* editorCmd = dynamic_cast<EditorCommand*>(command);
        if (editorCmd != NULL) {
            editorCmd->setView(view);
        }
        command->Do();
        updateUI();
        delete command;
        return;
    }
 
    // set command parent window and view
    command->setParentWindow(this);
    // execute the command
    command->Do();
    updateUI();
    delete command;
}

References GUICommand::Do(), ID_VIEW_STATUSBAR, ID_VIEW_TOOLBAR, GUICommand::isEnabled(), onToggleStatusbar(), onToggleToolbar(), GUICommand::setParentWindow(), EditorCommand::setView(), and updateUI().

Here is the call graph for this function:

OnExit()

void MainFrame::OnExit

(

wxCommandEvent &

WXUNUSEDevent

)

Performs routines before exiting a program

Parameters

event

Command event to handle.

Definition at line 771 of file MainFrame.cc.

                                                 {
    Close();
}

Referenced by QuitCmd::Do().

onKeyEvent()

void MainFrame::onKeyEvent

(

wxKeyEvent &

event

)

Handles key events on the canvas.

Parameters

event

Key event to handle.

Definition at line 406 of file MainFrame.cc.

                                 {
}

onToggleStatusbar()

void MainFrame::onToggleStatusbar

(

)

Toggles visibility of the statusbar.

Definition at line 215 of file MainFrame.cc.

                             {
    wxStatusBar* statusbar = GetStatusBar();
    if (statusbar != NULL) {
        SetStatusBar(NULL);
        delete statusbar;
        statusbar = NULL;
    } else {
        CreateStatusBar(2);
        int widths[2] = {-4, -1};
        SetStatusWidths(2, widths);
    }
    Layout();
    Fit();
}

Referenced by onCommandEvent().

onToggleToolbar()

void MainFrame::onToggleToolbar

(

)

Toggles visibility of the toolbar.

Definition at line 196 of file MainFrame.cc.

                           {
    ProDeOptions* options = wxGetApp().options();
    if (toolbar_ != NULL) {
        options->setToolbarVisibility(false);
        SetToolBar(NULL);
        delete toolbar_;
        toolbar_ = NULL;
    } else {
        options->setToolbarVisibility(true);
        createToolbar();
    }
    Layout();
}

References createToolbar(), options, and toolbar_.

Referenced by onCommandEvent().

Here is the call graph for this function:

onUpdateUI()

void MainFrame::onUpdateUI ( wxUpdateUIEvent &  event )

private

Updates toolbar and menubar item enabled/disabled states.

Parameters

event

Update event for the menu or toolbar item to be updated.

Definition at line 338 of file MainFrame.cc.

                                            {
    
    CommandRegistry* registry = wxGetApp().commandRegistry();
    GUICommand* command = registry->createCommand(event.GetId());
 
    if (command == NULL) {
        event.Skip();
        return;
    }
 
    wxView* view = wxGetApp().docManager()->GetCurrentView();
    if (view != NULL) {        
    EditorCommand* editorCmd = dynamic_cast<EditorCommand*>(command);
        if (editorCmd != NULL) {
            editorCmd->setView(view);
        }
    }
 
    if (command->isEnabled()) {
    event.Enable(true);
    } else {
    event.Enable(false);
    }
 
    if (command->isChecked()) {
        event.Check(command->isChecked());
    }
 
    delete command;
}

References CommandRegistry::createCommand(), GUICommand::isChecked(), GUICommand::isEnabled(), and EditorCommand::setView().

Here is the call graph for this function:

updateUI()

void MainFrame::updateUI

(

)

Updates enabled/disabled states of toolbar buttons and menu items.

Definition at line 373 of file MainFrame.cc.

                    {
 
    wxMenuBar* menubar = GetMenuBar();
    for (unsigned i = 0; i < menubar->GetMenuCount(); i++) {
        menubar->GetMenu(i)->UpdateUI();
    }
 
    if (toolbar_ == NULL) {
        return;
    }
 
    CommandRegistry* registry = wxGetApp().commandRegistry();
    ProDeOptions* options = wxGetApp().options();
    ToolbarButton* tool = options->firstToolbarButton();
 
    while (tool != NULL) {
        int id = registry->commandId(tool->action());
        if (!registry->isEnabled(tool->action())) {
            toolbar_->EnableTool(id, false);
        } else {
            toolbar_->EnableTool(id, true);
        }
        tool = options->nextToolbarButton();
    }
 
}

References ToolbarButton::action(), CommandRegistry::commandId(), CommandRegistry::isEnabled(), options, and toolbar_.

Referenced by onCommandEvent().

Here is the call graph for this function:

Member Data Documentation

commandRegistry_

CommandRegistry* MainFrame::commandRegistry_

private

Command registry.

Definition at line 72 of file MainFrame.hh.

toolbar_

wxToolBar* MainFrame::toolbar_

private

Toolbar.

Definition at line 75 of file MainFrame.hh.

Referenced by createToolbar(), onToggleToolbar(), and updateUI().

---

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

• MainFrame.hh
• MainFrame.cc