#include <ProximMainFrame.hh>

Inheritance diagram for ProximMainFrame:

Collaboration diagram for ProximMainFrame:

Public Member Functions
	ProximMainFrame (const wxString &title, const wxPoint &pos, const wxSize &size)

virtual	~ProximMainFrame ()

void	addSubWindow (ProximSimulatorWindow *window)

void	removeSubWindow (ProximSimulatorWindow *window)

void	createToolbar ()

void	createMenubar ()

void	reset ()

Private Member Functions
void	initialize ()

void	dockWindow (wxWindow *window)

void	onCommandEvent (wxCommandEvent &event)

void	onToggleWindow (wxCommandEvent &event)

void	onSimulatorTerminated (SimulatorEvent &event)

void	onSimulatorEvent (SimulatorEvent &event)

void	onKeyEvent (wxKeyEvent &event)

void	onClose (wxCloseEvent &event)

void	onStatusTimer (wxTimerEvent &event)

void	onReset (const SimulatorEvent &event)

void	updateCommand (wxUpdateUIEvent &event)

void	updateToggleItem (wxUpdateUIEvent &event)

void	updateSimulationStatus ()

void	updateMemoryWindowMenuItem ()

wxString	menuAccelerator (int id)

Private Attributes
wxBoxSizer *	sizer_
	Toplevel sizer of the window managing the basic layout.

wxWindow *	topSplitter_
	Top level splitter window of the splitted subwindow hierarchy.

std::vector< ProximSimulatorWindow * >	subwindows
	List of subwindows where to send the simulator events.

wxToolBar *	toolbar_
	Mainframe toolbar.

bool	stopDialogInstantiated_
	True, if an instance of the stop dialog is currently visible.

wxMutex *	resetMutex_
	Mutex for the resetCondition_.

wxCondition *	resetCondition_
	Condition which is signalled when the subwindow reset is complete.

bool	isReset_
	True if the subwindow reset is complete.

Detailed Description

Main window of the Proxim application.

ProximMainFrame is the top level window of the Proxim window hierarchy. This class is responsible for managing the simulation windows. All simulator backend events are passed to all subwindows. This class is also responsible for the menubar and executing command registry commands corresponding to the menu bar item ids. All subwindows are handled as wxPanels, and the simulator events are passed as custom wxEvents (see SimulatorEvent class).

Definition at line 58 of file ProximMainFrame.hh.

Constructor & Destructor Documentation

◆ ProximMainFrame()

ProximMainFrame::ProximMainFrame	(	const wxString &	title,
		const wxPoint &	pos,
		const wxSize &	size
	)

◆ ~ProximMainFrame()

ProximMainFrame::~ProximMainFrame ( )

virtual

The destructor.

Definition at line 176 of file ProximMainFrame.cc.

                                  {
    delete resetCondition_;
}

References resetCondition_.

Member Function Documentation

◆ addSubWindow()

void ProximMainFrame::addSubWindow ( ProximSimulatorWindow * window )

Adds a window to the list of subwindows to send the simulator events to.

Parameters

window Window to be added.

Definition at line 666 of file ProximMainFrame.cc.

                                                           {
    if (!ContainerTools::containsValue(subwindows, window)) {
        subwindows.push_back(window);
    }
}

References ContainerTools::containsValue(), and subwindows.

Here is the call graph for this function:

◆ createMenubar()

void ProximMainFrame::createMenubar ( )

Creates the proxim main frame menubar.

Definition at line 223 of file ProximMainFrame.cc.

                               {
 
    wxMenu* fileMenu = new wxMenu();
    wxMenu* viewMenu = new wxMenu();
    wxMenu* editMenu = new wxMenu();
    wxMenu* commandMenu = new wxMenu();
    wxMenu* sourceMenu = new wxMenu();
    wxMenu* programMenu = new wxMenu();
    wxMenu* dataMenu = new wxMenu();
    wxMenu* helpMenu = new wxMenu();
    wxMenu* highlightMenu = new wxMenu();
 
    // File menu
    fileMenu->Append(
        ProximConstants::COMMAND_OPEN_MACHINE,
        menuAccelerator(ProximConstants::COMMAND_OPEN_MACHINE).Prepend(
            _T("Open &Machine...")));
 
    fileMenu->Append(
        ProximConstants::COMMAND_OPEN_PROGRAM,
        menuAccelerator(ProximConstants::COMMAND_OPEN_PROGRAM).Prepend(
            _T("Open &Program...")));
 
    fileMenu->Append(
        ProximConstants::COMMAND_CD,
        menuAccelerator(ProximConstants::COMMAND_CD).Prepend(
            _T("&Change Directory...")));
 
    fileMenu->AppendSeparator();
 
    fileMenu->Append(
        ProximConstants::COMMAND_QUIT,
        menuAccelerator(ProximConstants::COMMAND_QUIT).Prepend(
            _T("&Quit")));
 
    wxMenuBar* menuBar = new wxMenuBar;
    menuBar->Append(fileMenu, _T("&File"));
 
    // View menu  
    viewMenu->AppendCheckItem(
        ProximConstants::COMMAND_TOGGLE_CONSOLE_WIN,
        _T("&Simulator Console"));
 
    viewMenu->AppendCheckItem(
        ProximConstants::COMMAND_TOGGLE_DISASM_WIN,
        _T("Program &Disassembly"));
    
    viewMenu->AppendCheckItem(
        ProximConstants::COMMAND_TOGGLE_MEMORY_WIN,
        _T("&Memory Window"));
    
    viewMenu->AppendCheckItem(
        ProximConstants::COMMAND_TOGGLE_CONTROL_WIN,
        _T("Simulator &Control"));
 
    viewMenu->AppendCheckItem(
        ProximConstants::COMMAND_TOGGLE_MACHINE_WIN,
        _T("&Machine Window"));
 
    viewMenu->AppendCheckItem(
        ProximConstants::COMMAND_TOGGLE_BREAKPOINT_WIN,
        _T("&Breakpoint Window"));
 
    viewMenu->AppendCheckItem(
        ProximConstants::COMMAND_TOGGLE_DEBUGGER_WIN,
        _T("&Debugger Window"));
 
    viewMenu->AppendSeparator();
    viewMenu->Append(
        ProximConstants::COMMAND_NEW_REGISTER_WINDOW,
        menuAccelerator(ProximConstants::COMMAND_NEW_REGISTER_WINDOW).Prepend(
            _T("New &Register Window")));
 
    viewMenu->Append(
        ProximConstants::COMMAND_NEW_PORT_WINDOW,
        menuAccelerator(ProximConstants::COMMAND_NEW_PORT_WINDOW).Prepend(
            _T("New &Port Window")));
 
    viewMenu->Check(ProximConstants::COMMAND_TOGGLE_CONSOLE_WIN, true);
    viewMenu->Check(ProximConstants::COMMAND_TOGGLE_DISASM_WIN, true);
    viewMenu->Enable(ProximConstants::COMMAND_TOGGLE_CONSOLE_WIN, false);
    viewMenu->Enable(ProximConstants::COMMAND_TOGGLE_DISASM_WIN, false);
 
    menuBar->Append(viewMenu, _T("&View"));
 
    editMenu->Append(
        ProximConstants::COMMAND_SIMULATOR_SETTINGS,
        menuAccelerator(ProximConstants::COMMAND_SIMULATOR_SETTINGS).Prepend(
            _T("Simulator Settings...")));
 
    editMenu->Append(
        ProximConstants::COMMAND_EDIT_OPTIONS,
        menuAccelerator(ProximConstants::COMMAND_EDIT_OPTIONS).Prepend(
            _T("Options...")));
 
    // Edit menu
    menuBar->Append(editMenu, _T("&Edit"));
 
    // Command menu
    commandMenu->Append(
    ProximConstants::COMMAND_CLEAR_CONSOLE,
        menuAccelerator(ProximConstants::COMMAND_CLEAR_CONSOLE).Prepend(
            _T("&Clear Console")));
 
    commandMenu->Append(
        ProximConstants::COMMAND_EXECUTE_FILE,
        menuAccelerator(ProximConstants::COMMAND_EXECUTE_FILE).Prepend(
            _T("&Execute File...")));
 
    commandMenu->Append(
        ProximConstants::COMMAND_FIND,
        menuAccelerator(ProximConstants::COMMAND_FIND).Prepend(
            _T("&Find in disassembly...")));
 
    commandMenu->AppendSeparator();
    commandMenu->AppendCheckItem(
        ProximConstants::COMMAND_TOGGLE_CMD_HISTORY_WIN,
        _T("Command &History Window"));
 
    menuBar->Append(commandMenu, _T("&Command"));
 
    // Source menu
    menuBar->Append(sourceMenu, _T("&Source"));
    sourceMenu->Append(17000, _T("&Profile Data"), highlightMenu);
 
    highlightMenu->Append(
        ProximConstants::COMMAND_CLEAR_DISASSEMBLY_HIGHLIGHT,
        menuAccelerator(
            ProximConstants::COMMAND_CLEAR_DISASSEMBLY_HIGHLIGHT).Prepend(
                _T("None")));
 
    highlightMenu->Append(
        ProximConstants::COMMAND_HIGHLIGHT_TOP_EXEC_COUNTS,
        menuAccelerator(
            ProximConstants::COMMAND_HIGHLIGHT_TOP_EXEC_COUNTS).Prepend(
                _T("Highlight Top Execution Counts")));
 
    highlightMenu->Append(
        ProximConstants::COMMAND_HIGHLIGHT_EXEC_PERCENTAGE,
        menuAccelerator(
            ProximConstants::COMMAND_HIGHLIGHT_EXEC_PERCENTAGE).Prepend(
                _T("Highlight Move Executions")));
 
    // Program menu
    programMenu->Append(
        ProximConstants::COMMAND_RUN,
        menuAccelerator(ProximConstants::COMMAND_RUN).Prepend(_T("&Run")));
 
    programMenu->AppendSeparator();
 
    programMenu->Append(
        ProximConstants::COMMAND_STEPI,
        menuAccelerator(ProximConstants::COMMAND_STEPI).Prepend(
            _T("&Step Instruction")));
 
    programMenu->Append(
        ProximConstants::COMMAND_NEXTI,
        menuAccelerator(ProximConstants::COMMAND_NEXTI).Prepend(
            _T("&Next Instruction")));
 
    programMenu->Append(
        ProximConstants::COMMAND_RESUME,
        menuAccelerator(ProximConstants::COMMAND_RESUME).Prepend(
            _T("R&esume")));
 
    programMenu->AppendSeparator();
    programMenu->Append(
        ProximConstants::COMMAND_KILL,
        menuAccelerator(ProximConstants::COMMAND_KILL).Prepend(_T("&Kill")));
 
    menuBar->Append(programMenu, _T("&Program"));
 
    // Data menu
    menuBar->Append(dataMenu, _T("&Data"));
 
    // Help menu
    helpMenu->Append(
        UserManualCmd::COMMAND_ID,
        menuAccelerator(UserManualCmd::COMMAND_ID).Prepend(
            _T("&User Manual...")));
 
    helpMenu->Append(
        ProximConstants::COMMAND_ABOUT,
        menuAccelerator(ProximConstants::COMMAND_ABOUT).Prepend(
            _T("&About...")));
 
    menuBar->Append(helpMenu, _T("&Help"));
 
    SetMenuBar(menuBar);
    
    updateMemoryWindowMenuItem();
}

Referenced by ProximOptionsCmd::Do(), and initialize().

Here is the call graph for this function:

◆ createToolbar()

void ProximMainFrame::createToolbar ( )

Creates the main frame toolbar.

Definition at line 420 of file ProximMainFrame.cc.

                               {
 
    if (toolbar_ != NULL) {
        delete toolbar_;
        toolbar_ = NULL;
    }
 
    CommandRegistry& registry = wxGetApp().commandRegistry();
    GUIOptions& options = wxGetApp().options();
    wxString iconPath = WxConversion::toWxString(Environment::iconDirPath());
 
    toolbar_ = options.createToolbar(this, registry, iconPath);
 
    SetToolBar(toolbar_);
    toolbar_->Show(options.toolbarVisibility());
}

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

Referenced by ProximOptionsCmd::Do(), and initialize().

Here is the call graph for this function:

◆ dockWindow()

void ProximMainFrame::dockWindow ( wxWindow * window )

private

Docks a simulation subwindow to the mainframe.

Parameters

window Sub window to add.

Definition at line 514 of file ProximMainFrame.cc.

                                            {
 
    // If the frame is empty, the window is added directly to the sizer
    // w/o a splitterwindow.
    if (topSplitter_ == NULL) {
        topSplitter_ = window;
        sizer_->Add(window);
        return;
    }
 
    // The frame already contained window(s). A new splitter window is created,
    // and the old contents of the frame is set as the top half of the
    // splitter window, and the new window as the bottom half of the
    // splitter. Finally, the old contents of the frame is replaced with the
    // new splitter window.
    sizer_->Detach(topSplitter_);
    wxSplitterWindow* newSplitter = new wxSplitterWindow(this, wxHORIZONTAL);
    newSplitter->SetMinimumPaneSize(25);
    window->Reparent(newSplitter);
    topSplitter_->Reparent(newSplitter);
    newSplitter->SplitHorizontally(topSplitter_, window);
    topSplitter_ = newSplitter;
    sizer_->Add(newSplitter, 1, wxGROW);
    sizer_->Layout();
    newSplitter->SetSashPosition(topSplitter_->GetSize().GetHeight() / 2);
}

References sizer_, and topSplitter_.

Referenced by initialize().

◆ initialize()

void ProximMainFrame::initialize ( )

private

Initializes the frame instance.

Creates the sizer managing the window layout, and creates an instance of the default windows.

Definition at line 188 of file ProximMainFrame.cc.

                            {
 
    createMenubar();
 
    wxStatusBar* statusbar = CreateStatusBar();
    int widths[3] = {-1, 200, 200};
    statusbar->SetFieldsCount(3, widths);
 
    sizer_ = new wxBoxSizer(wxVERTICAL);
 
    ProximDisassemblyWindow* disasmWindow = new ProximDisassemblyWindow(
        this, ProximConstants::ID_DISASSEMBLY_WINDOW);
    
    dockWindow(disasmWindow);
    dockWindow(new ConsoleWindow(this, ProximConstants::ID_CONSOLE_WINDOW));
    SetSizer(sizer_);
 
    createToolbar();
 
    SetSizeHints(400, 300);
}

References createMenubar(), createToolbar(), dockWindow(), ProximConstants::ID_CONSOLE_WINDOW, ProximConstants::ID_DISASSEMBLY_WINDOW, and sizer_.

Here is the call graph for this function:

◆ menuAccelerator()

wxString ProximMainFrame::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 448 of file ProximMainFrame.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 createMenubar().

Here is the call graph for this function:

◆ onClose()

void ProximMainFrame::onClose ( wxCloseEvent & event )

private

Handles system close events.

This event handler is called for example when the window is being closed using the frame close button X.

Parameters

event Close event to handle;

Definition at line 924 of file ProximMainFrame.cc.

                                            {
    if (event.CanVeto()) {
        // Execute quit-command.
        GUICommand* quitCommand = wxGetApp().commandRegistry().createCommand(
            ProximConstants::COMMAND_NAME_QUIT);
        if (quitCommand->isEnabled()) {
            quitCommand->setParentWindow(this);
            if (!quitCommand->Do()) {
                event.Veto();
            }
        }
        event.Veto();
        delete quitCommand;
        return;
    }
}

References ProximConstants::COMMAND_NAME_QUIT, GUICommand::Do(), GUICommand::isEnabled(), and GUICommand::setParentWindow().

Here is the call graph for this function:

◆ onCommandEvent()

void ProximMainFrame::onCommandEvent ( wxCommandEvent & event )

private

Handles command events from the menubar.

Commands are handled using Proxim command registry. A command is requested from the registry with the command event ID. If a command is found in the registry, the command will be executed. Otherwise an errordialog is displayed.

Parameters

event Command event to handle.

Definition at line 490 of file ProximMainFrame.cc.

                                                     {
 
    GUICommand* command =
        wxGetApp().commandRegistry().createCommand(event.GetId());
 
    if (command == NULL) {
        ErrorDialog dialog(
            this, _T("No handler found for the command event"));
        dialog.ShowModal();
        return;
    }
 
    command->setParentWindow(this);
    command->Do();
    delete command;
}

References GUICommand::Do(), and GUICommand::setParentWindow().

Here is the call graph for this function:

◆ onKeyEvent()

void ProximMainFrame::onKeyEvent ( wxKeyEvent & event )

private

Handles key events.

Parameters

event Key event to handle.

Definition at line 910 of file ProximMainFrame.cc.

                                             {
    event.Skip();
}   

◆ onReset()

void ProximMainFrame::onReset ( const SimulatorEvent & event )

private

Event handler for the simulator reset event.

Definition at line 1002 of file ProximMainFrame.cc.

                                              {
    reset();
}

References reset().

Here is the call graph for this function:

◆ onSimulatorEvent()

void ProximMainFrame::onSimulatorEvent ( SimulatorEvent & event )

private

Handles simulator events.

The events are passed to all subwindows registered as simulator listeners.

Parameters

event Simulator event to handle.

Definition at line 551 of file ProximMainFrame.cc.

                                                       {
 
    updateSimulationStatus();
 
    WXTYPE eventType = event.GetEventType();
 
    if (eventType == SimulatorEvent::EVT_SIMULATOR_COMMAND) {
        wxSetCursor(*wxHOURGLASS_CURSOR);
        wxString status = _T("Executing command '");
        status.Append(WxConversion::toWxString(event.data()));
        status.Append(_T("'."));
        GetStatusBar()->SetStatusText(status);
        GetMenuBar()->Disable();
 
        // If a toolbar button is disabled and re-enabled when a mouse cursor
        // is over the button, the button can't be clicked until the cursor
        // is moved away from the button and back over it. This prevents
        // stepi button to work when clicked repeatedly. Stepi
        // commands do not disable toolbar buttons when executed to avoid
        // this problem.
        std::string command = event.data();
        if (command != ProximConstants::SCL_STEP_INSTRUCTION) {
            GetToolBar()->Disable();
        }
    }
    
    if (eventType == SimulatorEvent::EVT_SIMULATOR_COMMAND_DONE) {
        wxSetCursor(*wxSTANDARD_CURSOR);
        GetStatusBar()->SetStatusText(_T(""));
        GetMenuBar()->Enable();
 
        std::string command = event.data();
        // Kludge to make stepi button to work better. See comment
        // in the previous if-clause.
        if (command != ProximConstants::SCL_STEP_INSTRUCTION) {
            GetToolBar()->Enable();
        }
    }
 
    if (eventType == SimulatorEvent::EVT_SIMULATOR_RUNTIME_ERROR) {
        wxString message = WxConversion::toWxString(event.data());
        ErrorDialog dialog(this, message);
        dialog.ShowModal();
    }
 
    if (eventType == SimulatorEvent::EVT_SIMULATOR_RUNTIME_WARNING) {
        wxString message = WxConversion::toWxString(event.data());
        WarningDialog dialog(this, message);
        dialog.ShowModal();
    }
 
    // Loading program.
    if (eventType == SimulatorEvent::EVT_SIMULATOR_LOADING_PROGRAM) {
        wxString message = _T("Loading program... ");
        message.Append(WxConversion::toWxString(event.data()));
        GetStatusBar()->SetStatusText(message);
    }
 
    // Program loaded
    if (eventType == SimulatorEvent::EVT_SIMULATOR_PROGRAM_LOADED) {
        wxString message = _T("Program loaded.");
        GetStatusBar()->SetStatusText(message);
        updateMemoryWindowMenuItem();
    }
 
    // Loading machine.
    if (eventType == SimulatorEvent::EVT_SIMULATOR_LOADING_MACHINE) {
        wxString message = _T("Loading machine... ");
        message.Append(WxConversion::toWxString(event.data()));
        GetStatusBar()->SetStatusText(message);
    }
 
    // Machine loaded
    if (eventType == SimulatorEvent::EVT_SIMULATOR_MACHINE_LOADED) {
        wxString message = _T("Machine loaded.");
        GetStatusBar()->SetStatusText(message);
    }
 
    //  Program is being simulated.
    if (eventType == SimulatorEvent::EVT_SIMULATOR_RUN) {
        // If an instance of stop dialog is already visible, do not create
        // a new one.
        if (!stopDialogInstantiated_) {
            stopDialogInstantiated_ = true;
            wxString message = _T("Running simulation... ");
            message.Append(WxConversion::toWxString(event.data()));
            GetStatusBar()->SetStatusText(message);
            ProximStopDialog dialog(this, -1, *ProximToolbox::frontend());
            dialog.ShowModal();
            stopDialogInstantiated_ = false;
            
            // Another workaround for a gtk-bug where button goes out of focus.
            GetToolBar()->Show(false);
            GetToolBar()->Show(true);
        }
    }
 
    for (unsigned i = 0; i < subwindows.size(); i++) {
        wxWindow * window = subwindows[i];
        wxPostEvent(window, event);
    }
 
    // Update menus.
    wxMenuBar* menubar = GetMenuBar();
    for (unsigned i = 0; i < menubar->GetMenuCount(); i++) {
        menubar->GetMenu(i)->UpdateUI();
    }
}

Here is the call graph for this function:

◆ onSimulatorTerminated()

void ProximMainFrame::onSimulatorTerminated ( SimulatorEvent & event )

private

Closes the GUI when the simulator engine is terminated.

Definition at line 214 of file ProximMainFrame.cc.

                                                      {
    Destroy();
}

◆ onStatusTimer()

void ProximMainFrame::onStatusTimer ( wxTimerEvent & event )

private

◆ onToggleWindow()

void ProximMainFrame::onToggleWindow ( wxCommandEvent & event )

private

Event handler for View menu check items.

Parameters

event View menu event to handle.

Definition at line 691 of file ProximMainFrame.cc.

                                                     {
 
    int id = event.GetId();
 
    switch (id) {
 
    case ProximConstants::COMMAND_TOGGLE_MEMORY_WIN: {
    // Toggle memory window.
    wxWindow* memoryWindow = FindWindowById(ProximConstants::ID_MEMORY_WINDOW);
    if (memoryWindow == NULL) {
        memoryWindow = new ProximMemoryWindow(
            this, ProximConstants::ID_MEMORY_WINDOW);
        ProximToolbox::addFramedWindow(
            memoryWindow, _T("Memory"), false, wxSize(620, 400));
    } else {
        memoryWindow->GetParent()->Destroy();
        memoryWindow = NULL;
    }
    return;
 
    }
 
    case ProximConstants::COMMAND_TOGGLE_CONTROL_WIN: {
    // Toggle control window.
    wxWindow* controlWindow =
        FindWindowById(ProximConstants::ID_CONTROL_WINDOW);
    if (controlWindow == NULL) {
        controlWindow = new ProximControlWindow(
            this, ProximConstants::ID_CONTROL_WINDOW);
        ProximToolbox::addFramedWindow(
            controlWindow, _T("Simulator control"), false);
    } else {
        controlWindow->GetParent()->Destroy();
        controlWindow = NULL;
    }
    return;
 
    }
 
    case ProximConstants::COMMAND_TOGGLE_MACHINE_WIN: {
    // Toggle machine window.
    wxWindow* machineWindow = FindWindowById(
        ProximConstants::ID_MACHINE_STATE_WINDOW);
    if (machineWindow == NULL) {
        machineWindow = new ProximMachineStateWindow(
            this, ProximConstants::ID_MACHINE_STATE_WINDOW);
        ProximToolbox::addFramedWindow(
            machineWindow, _T("Simulated Machine"), false, wxSize(600,400));
    } else {
        machineWindow->GetParent()->Destroy();
        machineWindow = NULL;
    }
    return;
 
    }
 
    case ProximConstants::COMMAND_TOGGLE_BREAKPOINT_WIN: {
    // Toggle breakpoitn window.
    wxWindow* breakpointWindow = FindWindowById(
        ProximConstants::ID_BREAKPOINT_WINDOW);
    if (breakpointWindow == NULL) {
        breakpointWindow = new ProximBreakpointWindow(
            this, ProximConstants::ID_BREAKPOINT_WINDOW);
        ProximToolbox::addFramedWindow(
            breakpointWindow, _T("Breakpoints"), false);
    } else {
        breakpointWindow->GetParent()->Close();
        breakpointWindow = NULL;
    }
    return;
 
    }
 
    case ProximConstants::COMMAND_TOGGLE_CMD_HISTORY_WIN: {
    // Toggle command history window.
    wxWindow* historyWindow = FindWindowById(
        ProximConstants::ID_CMD_HISTORY_WINDOW);
    if (historyWindow == NULL) {
        historyWindow = new ProximCmdHistoryWindow(
            this, ProximConstants::ID_CMD_HISTORY_WINDOW,
            ProximToolbox::lineReader());
        ProximToolbox::addFramedWindow(
            historyWindow, _T("Command History"), false);
    } else {
        historyWindow->GetParent()->Close();
        historyWindow = NULL;
    }
    return;
 
    }
 
    case ProximConstants::COMMAND_TOGGLE_DEBUGGER_WIN: {
    // Toggle command history window.
    wxWindow* debuggerWindow = FindWindowById(
        ProximConstants::ID_DEBUGGER_WINDOW);
    if (debuggerWindow == NULL) {
        debuggerWindow = new ProximDebuggerWindow(
            this, ProximConstants::ID_DEBUGGER_WINDOW);
        ProximToolbox::addFramedWindow(
            debuggerWindow, _T("Source code debugger"), false);
    } else {
        debuggerWindow->GetParent()->Close();
        debuggerWindow = NULL;
    }
    return;
 
    }
    }
    event.Skip();
}

References ProximToolbox::addFramedWindow(), ProximConstants::COMMAND_TOGGLE_BREAKPOINT_WIN, ProximConstants::COMMAND_TOGGLE_CMD_HISTORY_WIN, ProximConstants::COMMAND_TOGGLE_CONTROL_WIN, ProximConstants::COMMAND_TOGGLE_DEBUGGER_WIN, ProximConstants::COMMAND_TOGGLE_MACHINE_WIN, ProximConstants::COMMAND_TOGGLE_MEMORY_WIN, ProximConstants::ID_BREAKPOINT_WINDOW, ProximConstants::ID_CMD_HISTORY_WINDOW, ProximConstants::ID_CONTROL_WINDOW, ProximConstants::ID_DEBUGGER_WINDOW, ProximConstants::ID_MACHINE_STATE_WINDOW, ProximConstants::ID_MEMORY_WINDOW, and ProximToolbox::lineReader().

Here is the call graph for this function:

◆ removeSubWindow()

void ProximMainFrame::removeSubWindow ( ProximSimulatorWindow * window )

Removes window from the list of subwindows to send the simulator events to.

Parameters

window Window to be removed.

Definition at line 678 of file ProximMainFrame.cc.

                                                              {
    if (!ContainerTools::removeValueIfExists(subwindows, window)) {
        std::string procName = "ProximMainFrame::removeSubWindow";
        throw InstanceNotFound(__FILE__, __LINE__, procName);
    }
}

References ContainerTools::removeValueIfExists(), and subwindows.

Referenced by ProximSimulatorWindow::~ProximSimulatorWindow().

Here is the call graph for this function:

◆ reset()

void ProximMainFrame::reset ( )

Resets all subwidnows, which acess simulator data directly.

If this fucntion is from another thread than the GUI thread, a reset event is passed to the GUI thread, which will reset the windows in the GUI thread. The caller thread is blocked and wont return from this function until the reset is complete.

Definition at line 1016 of file ProximMainFrame.cc.

                       {
    if (wxThread::IsMain()) {
        for (int i = subwindows.size() - 1; i >= 0; i--) {
            subwindows[i]->reset();
        }
        isReset_ = true;
        resetCondition_->Signal();
    } else {
        SimulatorEvent event(SimulatorEvent::EVT_SIMULATOR_RESET);
        wxPostEvent(this, event);
        while (!isReset_) {
            resetCondition_->WaitTimeout(100);
        }
        isReset_ = false;
    }
}

References SimulatorEvent::EVT_SIMULATOR_RESET, isReset_, resetCondition_, and subwindows.

Referenced by ProximSimulationThread::handleEvent(), and onReset().

◆ updateCommand()

void ProximMainFrame::updateCommand ( wxUpdateUIEvent & event )

private

Event handler for wxUpdateUIEvents.

Proxim updates buttons and menu items for command registry commands using wxUpdateUIEvents. When a wxUpdateUIEvent is received, command registry is searched for corresponding command ID. If a command is found, the UI element enabled or disabled according to the command's isEnabled() return value.

Parameters

event Upadate event to handle.

Definition at line 815 of file ProximMainFrame.cc.

                                                     {
 
    if (wxGetApp().simulation() == NULL) {
        return;
    }
 
    GUICommand* command =
        wxGetApp().commandRegistry().createCommand(event.GetId());
 
    if (command != NULL) {
        event.Enable(command->isEnabled());
        delete command;
    } else {
        event.Enable(false);
    }
}

References GUICommand::isEnabled().

Here is the call graph for this function:

◆ updateMemoryWindowMenuItem()

void ProximMainFrame::updateMemoryWindowMenuItem ( )

private

Updates "Memory Window" menu item depending on if memory is available

Definition at line 980 of file ProximMainFrame.cc.

                                            {
    if (!wxGetApp().simulation() ||
        !wxGetApp().simulation()->frontend() ||        
        !wxGetApp().simulation()->frontend()->isSimulationInitialized() ||
        wxGetApp().simulation()->frontend()->memorySystem().
        memoryCount() == 0) {
        GetMenuBar()->Enable(ProximConstants::COMMAND_TOGGLE_MEMORY_WIN, false);
        wxWindow* memoryWindow = FindWindowById(ProximConstants::ID_MEMORY_WINDOW);
        if (memoryWindow != NULL) {
            memoryWindow->Destroy();
            memoryWindow = NULL;
        }
    } else {
        GetMenuBar()->Enable(ProximConstants::COMMAND_TOGGLE_MEMORY_WIN, true);
    }
}

References ProximConstants::COMMAND_TOGGLE_MEMORY_WIN, and ProximConstants::ID_MEMORY_WINDOW.

Referenced by createMenubar(), and onSimulatorEvent().

◆ updateSimulationStatus()

void ProximMainFrame::updateSimulationStatus ( )

private

Updates simulation status and cycle count in the statusbar.

Definition at line 946 of file ProximMainFrame.cc.

                                        {
    const SimulatorFrontend* simulation = ProximToolbox::frontend();
    wxString status;
    ClockCycleCount cycles = 0;
    if (simulation == NULL) {
        status = _T("Not initialzed");
    } else if (simulation->isSimulationInitialized()) {
        cycles = simulation->cycleCount();
        status = _T("Initialized");
    } else if (simulation->isSimulationRunning()) {
        cycles = simulation->cycleCount();
        status = _T("Running");
    } else if (simulation->isSimulationStopped()) {
        cycles = simulation->cycleCount();
        status = _T("Stopped");
    } else if (simulation->hasSimulationEnded()) {
        cycles = simulation->cycleCount();
        status = _T("Finished");
    }
 
    wxStatusBar* statusBar = GetStatusBar();
    statusBar->SetStatusText(status, 1);
 
    wxString cyclesStr = WxConversion::toWxString((boost::format("%.0f") %
                                                   cycles).str());
    cyclesStr.Prepend(_T("Cycles: "));
    statusBar->SetStatusText(cyclesStr, 2);
}

References SimulatorFrontend::cycleCount(), ProximToolbox::frontend(), SimulatorFrontend::hasSimulationEnded(), SimulatorFrontend::isSimulationInitialized(), SimulatorFrontend::isSimulationRunning(), SimulatorFrontend::isSimulationStopped(), and WxConversion::toWxString().

Referenced by onSimulatorEvent().

Here is the call graph for this function:

◆ updateToggleItem()

void ProximMainFrame::updateToggleItem ( wxUpdateUIEvent & event )

private

Event handler which updates view-menu check item check-marks.

When a wxUpdateUIEvent is received for view-menu check item, the main frame checks if corresponding subwindow exists and updates the menu item.

Definition at line 841 of file ProximMainFrame.cc.

                                                        {
 
    // memory window check-item
    if (event.GetId() == ProximConstants::COMMAND_TOGGLE_MEMORY_WIN) {
        bool exists = FindWindowById(ProximConstants::ID_MEMORY_WINDOW);
        if (exists) {
            event.Check(true);
        } else {
            event.Check(false);
        }
    }
 
    // simulator control window check-item
    if (event.GetId() == ProximConstants::COMMAND_TOGGLE_CONTROL_WIN) {
        bool exists = FindWindowById(ProximConstants::ID_CONTROL_WINDOW);
        if (exists) {
            event.Check(true);
        } else {
            event.Check(false);
        }
    }
 
    // machine window check-item
    if (event.GetId() == ProximConstants::COMMAND_TOGGLE_MACHINE_WIN) {
        bool exists = FindWindowById(ProximConstants::ID_MACHINE_STATE_WINDOW);
        if (exists) {
            event.Check(true);
        } else {
            event.Check(false);
        }
    }
 
    // breakpoint window check-item
    if (event.GetId() == ProximConstants::COMMAND_TOGGLE_BREAKPOINT_WIN) {
        bool exists = FindWindowById(ProximConstants::ID_BREAKPOINT_WINDOW);
        if (exists) {
            event.Check(true);
        } else {
            event.Check(false);
        }
    }
 
    // command history window check-item
    if (event.GetId() == ProximConstants::COMMAND_TOGGLE_CMD_HISTORY_WIN) {
        bool exists = FindWindowById(ProximConstants::ID_CMD_HISTORY_WINDOW);
        if (exists) {
            event.Check(true);
        } else {
            event.Check(false);
        }
    }
 
    // debugger window check-item
    if (event.GetId() == ProximConstants::COMMAND_TOGGLE_DEBUGGER_WIN) {
        bool exists = FindWindowById(ProximConstants::ID_DEBUGGER_WINDOW);
        if (exists) {
            event.Check(true);
        } else {
            event.Check(false);
        }
    }
}

References ProximConstants::COMMAND_TOGGLE_BREAKPOINT_WIN, ProximConstants::COMMAND_TOGGLE_CMD_HISTORY_WIN, ProximConstants::COMMAND_TOGGLE_CONTROL_WIN, ProximConstants::COMMAND_TOGGLE_DEBUGGER_WIN, ProximConstants::COMMAND_TOGGLE_MACHINE_WIN, ProximConstants::COMMAND_TOGGLE_MEMORY_WIN, ProximConstants::ID_BREAKPOINT_WINDOW, ProximConstants::ID_CMD_HISTORY_WINDOW, ProximConstants::ID_CONTROL_WINDOW, ProximConstants::ID_DEBUGGER_WINDOW, ProximConstants::ID_MACHINE_STATE_WINDOW, and ProximConstants::ID_MEMORY_WINDOW.

Member Data Documentation

◆ isReset_

bool ProximMainFrame::isReset_

private

True if the subwindow reset is complete.

Definition at line 106 of file ProximMainFrame.hh.

Referenced by reset().

◆ resetCondition_

wxCondition* ProximMainFrame::resetCondition_

private

Condition which is signalled when the subwindow reset is complete.

Definition at line 103 of file ProximMainFrame.hh.

Referenced by reset(), and ~ProximMainFrame().

◆ resetMutex_

wxMutex* ProximMainFrame::resetMutex_

private

Mutex for the resetCondition_.

Definition at line 101 of file ProximMainFrame.hh.

◆ sizer_

wxBoxSizer* ProximMainFrame::sizer_

private

Toplevel sizer of the window managing the basic layout.

Definition at line 89 of file ProximMainFrame.hh.

Referenced by dockWindow(), and initialize().

◆ stopDialogInstantiated_

bool ProximMainFrame::stopDialogInstantiated_

private

True, if an instance of the stop dialog is currently visible.

Definition at line 98 of file ProximMainFrame.hh.

Referenced by onSimulatorEvent().

◆ subwindows

std::vector<ProximSimulatorWindow*> ProximMainFrame::subwindows

private

List of subwindows where to send the simulator events.

Definition at line 93 of file ProximMainFrame.hh.

Referenced by addSubWindow(), onSimulatorEvent(), removeSubWindow(), and reset().

◆ toolbar_

wxToolBar* ProximMainFrame::toolbar_

private

Mainframe toolbar.

Definition at line 96 of file ProximMainFrame.hh.

Referenced by createToolbar().

◆ topSplitter_

wxWindow* ProximMainFrame::topSplitter_

private

Top level splitter window of the splitted subwindow hierarchy.

Definition at line 91 of file ProximMainFrame.hh.

Referenced by dockWindow().

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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ ProximMainFrame()

◆ ~ProximMainFrame()

Member Function Documentation

◆ addSubWindow()

◆ createMenubar()

◆ createToolbar()

◆ dockWindow()

◆ initialize()

◆ menuAccelerator()

◆ onClose()

◆ onCommandEvent()

◆ onKeyEvent()

◆ onReset()

◆ onSimulatorEvent()

◆ onSimulatorTerminated()

◆ onStatusTimer()

◆ onToggleWindow()

◆ removeSubWindow()

◆ reset()

◆ updateCommand()

◆ updateMemoryWindowMenuItem()

◆ updateSimulationStatus()

◆ updateToggleItem()

Member Data Documentation

◆ isReset_

◆ resetCondition_

◆ resetMutex_

◆ sizer_

◆ stopDialogInstantiated_

◆ subwindows

◆ toolbar_

◆ topSplitter_