void BreakpointDlg::Initialize() { std::vector<BreakpointInfo> bps; ManagerST::Get()->GetBreakpointsMgr()->GetBreakpoints(bps); // This does the display stuff m_listCtrlBreakpoints->Initialise(bps); // Store the internal and external ids m_ids.clear(); std::vector<BreakpointInfo>::iterator iter = bps.begin(); for(; iter != bps.end(); ++iter) { struct bpd_IDs IDs(*iter); m_ids.push_back(IDs); } int count = m_listCtrlBreakpoints->GetItemCount(); bool hasitems = count > 0; if (hasitems) { // Select the first item if there's not already a selection if (m_selectedItem == wxNOT_FOUND) { m_selectedItem = 0; } if (m_selectedItem >= count) { // e.g. if the selection was the last item, then one is deleted m_selectedItem = count-1; } // Even if an item was previously selected, refreshing the pane means we need to reselect m_listCtrlBreakpoints->SetItemState(m_selectedItem, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED); } // Since any change results in Initialize() being rerun, we can do updateUI here m_buttonEdit->Enable(hasitems); m_buttonDelete->Enable(hasitems); // The 'Apply Pending' button is more complicated: it should be hidden, // unless there are pending bps to apply,and the debugger is running bool pending = ManagerST::Get()->GetBreakpointsMgr()->PendingBreakpointsExist(); IDebugger *dbgr = DebuggerMgr::Get().GetActiveDebugger(); m_buttonApplyPending->Show( pending && dbgr && dbgr->IsRunning() ); Layout(); // Enable DeleteAll if there are either bps or pending bps m_buttonDeleteAll->Enable(hasitems || pending); }
void BreakptMgr::SetAllBreakpointsEnabledState(bool enabled) { unsigned int successes = 0; bool debuggerIsRunning = false; bool contIsNeeded = false; IDebugger *dbgr = DebuggerMgr::Get().GetActiveDebugger(); if (dbgr && dbgr->IsRunning()) { debuggerIsRunning = true; contIsNeeded = PauseDebuggerIfNeeded(); } for (size_t i=0; i<m_bps.size(); ++i) { BreakpointInfo &bp = m_bps.at(i); if (((bp.debugger_id != -1) || !debuggerIsRunning) // Sanity check for when the debugger's running && (bp.is_enabled != enabled)) { // No point setting it to the current status if (debuggerIsRunning) { if (dbgr->SetEnabledState(bp.debugger_id, enabled)) { bp.is_enabled = enabled; ++successes; } } else { bp.is_enabled = enabled; ++successes; } } } if (debuggerIsRunning && contIsNeeded) { dbgr->Continue(); } if (successes) { RefreshBreakpointMarkers(); clMainFrame::Get()->GetDebuggerPane()->GetBreakpointView()->Initialize(); wxString msg = wxString::Format(wxT("%u "), successes); msg << (enabled ? _("breakpoints enabled") : _("breakpoints disabled")); clMainFrame::Get()->SetStatusMessage(msg, 0); } }
void BreakptMgr::ApplyPendingBreakpoints() { if (!PendingBreakpointsExist()) { return; // Nothing to do } IDebugger *dbgr = DebuggerMgr::Get().GetActiveDebugger(); if (!(dbgr && dbgr->IsRunning())) { return; // If the debugger isn't running, there's no point (and we shouldn't have reached here anyway) } bool contIsNeeded = PauseDebuggerIfNeeded(); for (size_t i=m_pendingBreakpointsList.size(); i>0; --i) { BreakpointInfo bp = m_pendingBreakpointsList.at(i-1); // First check to see if the debugger already accepted this one // The answer should be no, as acceptance should have removed it from this list int index = FindBreakpointById(bp.internal_id, m_bps); if (index != wxNOT_FOUND) { // Hmm. See if there's a valid debugger_id. If so, the bp *was* accepted, and shouldn't be on the pending list if (m_bps.at(index).debugger_id != -1) { m_pendingBreakpointsList.erase(m_pendingBreakpointsList.begin()+i-1); } continue; // The bp hasn't been assessed yet; it's probably pointless to try to reapply it atm } // This bp didn't 'take' the first time; "..try, try again" :p dbgr->Break(bp); m_bps.push_back(bp); } if (contIsNeeded) { dbgr->Continue(); } RefreshBreakpointMarkers(); }
void BreakptMgr::EditBreakpoint(int index, bool &bpExist) { // sanity bpExist = true; if (index < 0 || index >= (int)m_bps.size()) { wxLogMessage(wxT("BreakptMgr::EditBreakpoint: Insane index")); bpExist = false; return; } BreakpointInfo bp = m_bps.at(index); BreakptPropertiesDlg dlg(NULL); wxString title; if (bp.bp_type == BP_type_watchpt) { title = _("Properties for watchpoint "); } else { title = _("Properties for breakpoint "); } int id = bp.debugger_id; if (id == -1) { id = bp.internal_id - FIRST_INTERNAL_ID; } title << id; dlg.SetTitle(title); dlg.EnterBPData(bp); if (dlg.ShowModal() != wxID_OK) { return ; } SetBestBPType(dlg.b); // The edited data's available. Use it to determine the best bp_type if (bp == dlg.b) { // Nothing was altered return ; } // We've got our altered dlg.b If the debugger's running, we can update it now // Otherwise, it'll be automatically inserted correctly when the debugger starts IDebugger *dbgr = DebuggerMgr::Get().GetActiveDebugger(); if (dbgr && dbgr->IsRunning()) { if (CanThisBreakpointBeUpdated(dlg.b, bp)) { if (dlg.b.ignore_number != bp.ignore_number) { if (! SetBPIgnoreCount(dlg.b.debugger_id, dlg.b.ignore_number)) { return; // Harsh, but what else can one do? } } if (dlg.b.is_enabled != bp.is_enabled) { if (! SetBPEnabledState(dlg.b.debugger_id, dlg.b.is_enabled)) { return ; } } if (dlg.b.conditions != bp.conditions) { if (! SetBPConditon(dlg.b)) { return ; } } if (dlg.b.commandlist != bp.commandlist) { if (! SetBPCommands(dlg.b)) { return ; } } } else { // If it can't be updated (because gdb wouldn't be able to cope with the change), replace bool contIsNeeded = PauseDebuggerIfNeeded(); dbgr->RemoveBreak(bp.debugger_id); dbgr->Break(dlg.b); // dbgr->Break(bp) doesn't set the ignore/disabled/etc states // but we can't do it now, as we don't yet know the debugger_id // However it will happen later, in SetBreakpointDebuggerID if (contIsNeeded) { dbgr->Continue(); } } } // Replace the old data with the new, in m_bps m_bps.at(index) = dlg.b; DeleteAllBreakpointMarkers(); RefreshBreakpointMarkers(); }