BreakpointsFrame.py

   1 #!/usr/bin/python
   2 #shuber, 2008-06-04
   3
   4 __author__ = "shuber"
   5
   6
   7 import gobject
   8 import gtk
   9 import re
  10 import string
  11 import vte
  12
  13 import DbgTerminal
  14 import StatusFrame
  15
  16
  17 class BreakpointsFrame (StatusFrame.StatusFrame):
  18
  19
  20         def __init__(self, debugger):
  21
  22                 StatusFrame.StatusFrame.__init__(self, debugger)
  23                 self.set_label("Breakpoints")
  24
  25                 vbox = gtk.VBox(False, 5)
  26                 self.add(vbox)
  27
  28                 hbox = gtk.HBox()
  29                 vbox.pack_start(hbox, False, False)
  30                 self.bpEntry = gtk.Entry()
  31                 hbox.add(self.bpEntry)
  32
  33
  34                 hbox = gtk.HBox()
  35                 vbox.pack_start(hbox, False, False)
  36                 self.addBtn = gtk.Button(stock=gtk.STOCK_ADD)
  37                 self.delBtn = gtk.Button(stock=gtk.STOCK_REMOVE)
  38                 self.updBtn = gtk.Button("Update")
  39                 hbox.add(self.addBtn)
  40                 hbox.add(self.delBtn)
  41                 hbox.add(self.updBtn)
  42
  43                 sw = gtk.ScrolledWindow()
  44                 sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
  45                 sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
  46                 vbox.add(sw)
  47
  48                 self.model = self.__createModel()
  49                 self.tv = gtk.TreeView(self.model)
  50                 self.tv.set_rules_hint(True)
  51                 self.tv.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
  52
  53                 self.__addColumns(self.tv)
  54                 sw.add(self.tv)
  55
  56                 self.addBtn.connect("clicked", self.addBtnClicked)
  57                 self.delBtn.connect("clicked", self.delBtnClicked)
  58                 self.updBtn.connect("clicked", self.updBtnClicked)
  59
  60
  61
  62         def __createModel(self):
  63                 #Breakpoint number, position and a boolean flag indicating whether BP has been set
  64                 #at debugger yet
  65                 model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
  66
  67                 return model
  68
  69
  70         def __addColumns(self, tv):
  71
  72                 model = tv.get_model()
  73
  74                 renderer = gtk.CellRendererText()
  75                 renderer.set_data("column", 0)
  76                 col = gtk.TreeViewColumn("No", renderer, text=0)
  77                 col.set_resizable(True)
  78                 tv.append_column(col)
  79
  80
  81                 renderer = gtk.CellRendererText()
  82                 renderer.set_data("column", 1)
  83                 col = gtk.TreeViewColumn("Specification", renderer, text=1)
  84                 col.set_resizable(True)
  85                 tv.append_column(col)
  86
  87
  88
  89         def addBtnClicked(self, btn):
  90
  91                 if not self.debugger.isActive():
  92                         return
  93
  94
  95                 bpspec = self.bpEntry.get_text()
  96                 bpspec = bpspec.strip()
  97                 rx = re.compile("^[\w\._\-]+:\d+(\s+if\s+\S+.*)?$")
  98
  99                 #Check if format is correct
 100                 if not rx.search(bpspec):
 101                         dialog = gtk.MessageDialog(None, \
 102                                 gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, \
 103                                 gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, \
 104                                 "Invalid format!")
 105                         dialog.run()
 106                         dialog.destroy()
 107                         return
 108
 109
 110                 ifsplit = string.split(bpspec, "if")
 111
 112                 if len(ifsplit)>1:
 113                         cond = ifsplit[1].strip()
 114                 else:
 115                         cond = None
 116
 117                 pos = ifsplit[0].strip()
 118                 [file,lineno] = string.split(pos, ":")
 119
 120                 self.addBreakpoint(file, lineno, cond)
 121
 122
 123
 124         def addBreakpoint(self, file, lineno, cond=None):
 125
 126                 no = self.debugger.setBreakpoint(file, lineno, cond)
 127
 128                 if no!=None:
 129                         self.addBreakpointToList(no, file, lineno, cond)
 130                 else:
 131                         dialog = gtk.MessageDialog(None, \
 132                                 gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, \
 133                                 gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, \
 134                                 "Invalid specification!")
 135                         dialog.run()
 136                         dialog.destroy()
 137
 138
 139         def applyConfiguration(self, conf):
 140                 for b in conf.breakpoints:
 141                         self.addBreakpoint(b["file"], b["lineno"], b["cond"])
 142
 143         def fillConfiguration(self, conf):
 144                 iter = self.model.get_iter_first()
 145                 while iter != None:
 146                         spec, = self.model.get(iter, 1)
 147                         conf.parseBreak(spec)
 148                         iter = self.model.iter_next(iter)
 149
 150
 151
 152         def addBreakpointToList(self, no, file, lineno, cond=None):
 153                 iter = self.model.append()
 154                 self.model.set(iter, 0, no)
 155
 156                 if cond==None:
 157                         self.model.set(iter, 1, "%s:%s" % (str(file), str(lineno)))
 158                 else:
 159                         self.model.set(iter, 1, "%s:%s if %s" % (str(file), str(lineno), str(cond)))
 160
 161
 162
 163         def delBtnClicked(self, btn):
 164
 165                 if not self.debugger.isActive():
 166                         return
 167
 168                 selection = self.tv.get_selection()
 169                 model, paths = selection.get_selected_rows()
 170
 171                 for path in paths:
 172                         iter = model.get_iter(path)
 173                         bpno, = self.model.get(iter, 0)
 174                         self.debugger.delBreakpoint(bpno)
 175                         model.remove(iter)
 176
 177
 178         def updBtnClicked(self, btn):
 179
 180                 if not self.debugger.isActive():
 181                         return
 182
 183                 self.updateValues(None)
 184
 185
 186         def updateValues(self, pos):
 187
 188                 bpnts = self.debugger.getBreakpoints()
 189
 190                 #Remove them all
 191                 iter = self.model.get_iter_first()
 192                 while iter != None:
 193                         newiter = self.model.iter_next(iter)
 194                         self.model.remove(iter)
 195                         iter = newiter
 196
 197                 for bp in bpnts:
 198                         [no, file, lineno, cond] = bp
 199                         self.addBreakpointToList(no, file, lineno, cond)
 200
 201
 202