← Back to branch summary

~ubuntu-branches/ubuntu/trusty/monodevelop/trusty-proposed

« back to all changes in this revision

Viewing changes to src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/BreakpointPad.cs

  • Committer: Package Import Robot
  • Author(s): Jo Shields
  • Date: 2013-05-12 09:46:03 UTC
  • mto: This revision was merged to the branch mainline in revision 29.
  • Revision ID: package-import@ubuntu.com-20130512094603-mad323bzcxvmcam0
Tags: upstream-4.0.5+dfsg
Import upstream version 4.0.5+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/addins/MonoDevelop.Debugger/MonoDevelop.Debugger/BreakpointPad.cs
23
23
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24
24
// THE SOFTWARE.
25
25
 
26
 
using GLib;
27
26
using Gtk;
28
27
using System;
29
28
 
88
87
                        menuSet.AddItem (DebugCommands.EnableDisableBreakpoint);
89
88
                        menuSet.AddItem (DebugCommands.ClearAllBreakpoints);
90
89
                        menuSet.AddItem (DebugCommands.DisableAllBreakpoints);
91
 
                        menuSet.AddItem (EditCommands.Delete);
 
90
                        menuSet.AddItem (EditCommands.DeleteKey);
92
91
                        menuSet.AddSeparator ();
93
92
                        menuSet.Add (propertiesCmd);
94
93
                        
109
108
                        tree.RulesHint = true;
110
109
                        tree.HeadersVisible = true;
111
110
                        tree.DoPopupMenu = ShowPopup;
 
111
                        tree.KeyPressEvent += OnKeyPressEvent;
 
112
                        tree.Selection.Mode = SelectionMode.Multiple;
112
113
                        
113
114
                        treeState = new TreeViewState (tree, (int) Columns.Breakpoint);
114
115
                                                        
199
200
                [CommandHandler (LocalCommands.Properties)]
200
201
                protected void OnProperties ()
201
202
                {
 
203
                        var selected = tree.Selection.GetSelectedRows ();
202
204
                        TreeIter iter;
203
 
                        if (tree.Selection.GetSelected (out iter)) {
 
205
 
 
206
                        if (selected.Length == 1 && store.GetIter (out iter, selected[0])) {
204
207
                                Breakpoint bp = (Breakpoint) store.GetValue (iter, (int) Columns.Breakpoint);
205
208
                                if (DebuggingService.ShowBreakpointProperties (bp, false))
206
209
                                        UpdateDisplay ();
210
213
                [CommandHandler (DebugCommands.EnableDisableBreakpoint)]
211
214
                protected void OnEnableDisable ()
212
215
                {
213
 
                        TreeIter iter;
214
 
                        if (tree.Selection.GetSelected (out iter)) {
215
 
                                Breakpoint bp = (Breakpoint) store.GetValue (iter, (int) Columns.Breakpoint);
216
 
                                bp.Enabled = !bp.Enabled;
 
216
                        DebuggingService.Breakpoints.Changed -= breakpointChangedHandler;
 
217
 
 
218
                        try {
 
219
                                bool enable = false;
 
220
 
 
221
                                // If any breakpoints are disabled, we'll enable them all. Otherwise, disable them all.
 
222
                                foreach (var path in tree.Selection.GetSelectedRows ()) {
 
223
                                        TreeIter iter;
 
224
 
 
225
                                        if (!store.GetIter (out iter, path))
 
226
                                                continue;
 
227
 
 
228
                                        Breakpoint bp = (Breakpoint) store.GetValue (iter, (int) Columns.Breakpoint);
 
229
                                        if (!bp.Enabled) {
 
230
                                                enable = true;
 
231
                                                break;
 
232
                                        }
 
233
                                }
 
234
 
 
235
                                foreach (var path in tree.Selection.GetSelectedRows ()) {
 
236
                                        TreeIter iter;
 
237
 
 
238
                                        if (!store.GetIter (out iter, path))
 
239
                                                continue;
 
240
 
 
241
                                        Breakpoint bp = (Breakpoint) store.GetValue (iter, (int) Columns.Breakpoint);
 
242
                                        bp.Enabled = enable;
 
243
 
 
244
                                        store.SetValue (iter, (int) Columns.Icon, enable ? "md-breakpoint" : "md-breakpoint-disabled");
 
245
                                        store.SetValue (iter, (int) Columns.Selected, enable);
 
246
                                }
 
247
                        } finally {
 
248
                                DebuggingService.Breakpoints.Changed += breakpointChangedHandler;
217
249
                        }
218
250
                }
219
251
                
220
252
                [CommandHandler (LocalCommands.GoToFile)]
221
253
                protected void OnBpJumpTo ()
222
254
                {
 
255
                        var selected = tree.Selection.GetSelectedRows ();
223
256
                        TreeIter iter;
224
 
                        if (tree.Selection.GetSelected (out iter)) {
 
257
 
 
258
                        if (selected.Length == 1 && store.GetIter (out iter, selected[0])) {
225
259
                                Breakpoint bp = (Breakpoint) store.GetValue (iter, (int) Columns.Breakpoint);
226
260
                                if (!string.IsNullOrEmpty (bp.FileName))
227
261
                                        IdeApp.Workbench.OpenDocument (bp.FileName, bp.Line, 1);
228
262
                        }
229
263
                }
230
 
                
 
264
 
 
265
                bool DeleteSelectedBreakpoints ()
 
266
                {
 
267
                        bool deleted = false;
 
268
 
 
269
                        DebuggingService.Breakpoints.BreakpointRemoved -= breakpointRemovedHandler;
 
270
 
 
271
                        try {
 
272
                                // Note: since we'll be modifying the list of breakpoints, we need to sort
 
273
                                // the paths in reverse order.
 
274
                                var selected = tree.Selection.GetSelectedRows ();
 
275
                                Array.Sort (selected, new TreePathComparer (true));
 
276
 
 
277
                                foreach (var path in selected) {
 
278
                                        TreeIter iter;
 
279
 
 
280
                                        if (!store.GetIter (out iter, path))
 
281
                                                continue;
 
282
 
 
283
                                        var bp = (Breakpoint) store.GetValue (iter, (int) Columns.Breakpoint);
 
284
                                        bps.Remove (bp);
 
285
                                        deleted = true;
 
286
                                }
 
287
                        } finally {
 
288
                                DebuggingService.Breakpoints.BreakpointRemoved += breakpointRemovedHandler;
 
289
                        }
 
290
 
 
291
                        return deleted;
 
292
                }
 
293
 
 
294
                [CommandUpdateHandler (EditCommands.SelectAll)]
 
295
                protected void UpdateSelectAll (CommandInfo cmd)
 
296
                {
 
297
                        TreeIter iter;
 
298
 
 
299
                        cmd.Enabled = store.GetIterFirst (out iter);
 
300
                }
 
301
 
 
302
                [CommandHandler (EditCommands.SelectAll)]
 
303
                protected void OnSelectAll ()
 
304
                {
 
305
                        tree.Selection.SelectAll ();
 
306
                }
 
307
 
231
308
                [CommandHandler (EditCommands.Delete)]
232
309
                [CommandHandler (EditCommands.DeleteKey)]
233
310
                protected void OnDeleted ()
234
311
                {
235
 
                        TreeIter iter;
236
 
                        if (tree.Selection.GetSelected (out iter)) {
237
 
                                Breakpoint bp = (Breakpoint) store.GetValue (iter, (int) Columns.Breakpoint);   
238
 
                                bps.Remove (bp);
239
 
                        }       
 
312
                        if (DeleteSelectedBreakpoints ())
 
313
                                UpdateDisplay ();
 
314
                }
 
315
 
 
316
                [CommandUpdateHandler (LocalCommands.GoToFile)]
 
317
                [CommandUpdateHandler (LocalCommands.Properties)]
 
318
                protected void UpdateBpCommand (CommandInfo cmd)
 
319
                {
 
320
                        cmd.Enabled = tree.Selection.CountSelectedRows () == 1;
240
321
                }
241
322
                
242
323
                [CommandUpdateHandler (EditCommands.Delete)]
243
324
                [CommandUpdateHandler (EditCommands.DeleteKey)]
244
 
                [CommandUpdateHandler (LocalCommands.GoToFile)]
245
 
                [CommandUpdateHandler (LocalCommands.Properties)]
246
325
                [CommandUpdateHandler (DebugCommands.EnableDisableBreakpoint)]
247
 
                protected void UpdateBpCommand (CommandInfo cmd)
248
 
                {
249
 
                        TreeIter iter;
250
 
                        cmd.Enabled = tree.Selection.GetSelected (out iter);
 
326
                protected void UpdateMultiBpCommand (CommandInfo cmd)
 
327
                {
 
328
                        cmd.Enabled = tree.Selection.CountSelectedRows () > 0;
 
329
                }
 
330
 
 
331
                [GLib.ConnectBefore]
 
332
                void OnKeyPressEvent (object sender, KeyPressEventArgs args)
 
333
                {
 
334
                        // Delete the currently selected breakpoint(s) with any delete key
 
335
                        switch (args.Event.Key) {
 
336
                        case Gdk.Key.Delete:
 
337
                        case Gdk.Key.KP_Delete:
 
338
                        case Gdk.Key.BackSpace:
 
339
                                if (DeleteSelectedBreakpoints ()) {
 
340
                                        args.RetVal = true;
 
341
                                        UpdateDisplay ();
 
342
                                }
 
343
                                break;
 
344
                        case Gdk.Key.space:
 
345
                                if (tree.Selection.CountSelectedRows () > 0) {
 
346
                                        OnEnableDisable ();
 
347
                                        args.RetVal = true;
 
348
                                }
 
349
                                break;
 
350
                        }
251
351
                }
252
352
                
253
 
                private void ItemToggled (object o, ToggledArgs args)
 
353
                void ItemToggled (object o, ToggledArgs args)
254
354
                {
255
 
                        Gtk.TreeIter iter;
256
 
                        if (store.GetIterFromString(out iter, args.Path)) {
257
 
                                bool val = (bool) store.GetValue(iter, (int)Columns.Selected);
258
 
                                Breakpoint bp = (Breakpoint) store.GetValue (iter, (int) Columns.Breakpoint);
259
 
                                store.SetValue (iter, (int)Columns.Selected, !val);
260
 
                                bp.Enabled = !bp.Enabled;
 
355
                        DebuggingService.Breakpoints.Changed -= breakpointChangedHandler;
 
356
                        
 
357
                        try {
 
358
                                TreeIter iter;
 
359
 
 
360
                                if (store.GetIterFromString (out iter, args.Path)) {
 
361
                                        Breakpoint bp = (Breakpoint) store.GetValue (iter, (int) Columns.Breakpoint);
 
362
                                        bp.Enabled = !bp.Enabled;
 
363
 
 
364
                                        store.SetValue (iter, (int) Columns.Icon, bp.Enabled ? "md-breakpoint" : "md-breakpoint-disabled");
 
365
                                        store.SetValue (iter, (int) Columns.Selected, bp.Enabled);
 
366
                                }
 
367
                        } finally {
 
368
                                DebuggingService.Breakpoints.Changed += breakpointChangedHandler;
261
369
                        }
262
370
                }
263
371
                
264
372
                public void UpdateDisplay ()
265
373
                {
 
374
                        if (tree.IsRealized)
 
375
                                tree.ScrollToPoint (0, 0);
 
376
 
266
377
                        treeState.Save ();
267
378
                        
268
379
                        store.Clear ();
269
380
                        if (bps != null) {              
270
381
                                foreach (Breakpoint bp in bps.GetBreakpoints ()) {
 
382
                                        string hitCount = bp.HitCountMode != HitCountMode.None ? bp.CurrentHitCount.ToString () : "";
271
383
                                        string traceExp = bp.HitAction == HitAction.PrintExpression ? bp.TraceExpression : "";
272
384
                                        string traceVal = bp.HitAction == HitAction.PrintExpression ? bp.LastTraceValue : "";
273
 
                                        string hitCount = bp.HitCount > 0 ? bp.HitCount.ToString () : "";
274
385
                                        string name;
275
386
                                        
276
387
                                        if (bp is FunctionBreakpoint) {
281
392
                                                else
282
393
                                                        name = fb.FunctionName;
283
394
                                        } else {
284
 
                                                name = ((Breakpoint) bp).FileName + ":" + bp.Line.ToString ();
 
395
                                                name = string.Format ("{0}:{1},{2}", ((Breakpoint) bp).FileName, bp.Line, bp.Column);
285
396
                                        }
286
397
                                        
287
398
                                        if (bp.Enabled)
296
407
                void OnBreakpointUpdated (object s, BreakpointEventArgs args)
297
408
                {
298
409
                        TreeIter it;
 
410
 
299
411
                        if (!store.GetIterFirst (out it))
300
412
                                return;
 
413
 
301
414
                        do {
302
415
                                Breakpoint bp = (Breakpoint) store.GetValue (it, (int) Columns.Breakpoint);
303
416
                                if (bp == args.Breakpoint) {
 
417
                                        string hitCount = bp.HitCountMode != HitCountMode.None ? bp.CurrentHitCount.ToString () : "";
304
418
                                        string traceVal = bp.HitAction == HitAction.PrintExpression ? bp.LastTraceValue : "";
305
 
                                        string hitCount = bp.HitCount > 0 ? bp.HitCount.ToString () : "";
306
419
                                        store.SetValue (it, (int) Columns.HitCount, hitCount);
307
420
                                        store.SetValue (it, (int) Columns.LastTrace, traceVal);
308
421
                                        break;
330
443
                        if (control != null)
331
444
                                control.Sensitive = !DebuggingService.Breakpoints.IsReadOnly;
332
445
                }
333
 
                
334
 
                
 
446
 
335
447
                void OnRowActivated (object o, Gtk.RowActivatedArgs args)
336
448
                {
337
449
                        OnBpJumpTo ();