WatchesFrame.py

   1 #!/usr/bin/python
   2 #shuber, 2008-06-04
   3
   4 __author__ = "shuber"
   5
   6
   7 import gobject
   8 import gtk
   9
  10 import StatusFrame
  11
  12
  13 class WatchesFrame (StatusFrame.StatusFrame):
  14
  15
  16         def __init__(self, debugger):
  17
  18                 StatusFrame.StatusFrame.__init__(self, debugger)
  19                 self.set_label("Watches")
  20
  21                 debugger.gotActiveCallback += [self.updateValues]
  22
  23                 vbox = gtk.VBox(False, 5)
  24                 self.add(vbox)
  25
  26                 hbox = gtk.HBox()
  27                 vbox.pack_start(hbox, False, False)
  28
  29                 self.addBtn = gtk.Button(stock=gtk.STOCK_ADD)
  30                 self.delBtn = gtk.Button(stock=gtk.STOCK_REMOVE)
  31                 hbox.add(self.addBtn)
  32                 hbox.add(self.delBtn)
  33
  34                 sw = gtk.ScrolledWindow()
  35                 sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
  36                 sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
  37                 vbox.add(sw)
  38
  39                 self.model = self.__createModel()
  40                 self.tv = gtk.TreeView(self.model)
  41                 self.tv.set_rules_hint(True)
  42                 self.tv.get_selection().set_mode(gtk.SELECTION_MULTIPLE)
  43
  44                 self.__addColumns(self.tv)
  45                 sw.add(self.tv)
  46
  47                 self.addBtn.connect("clicked", self.addBtnClicked)
  48                 self.delBtn.connect("clicked", self.delBtnClicked)
  49
  50
  51
  52         def __createModel(self):
  53
  54                 model = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_STRING, \
  55                                 gobject.TYPE_BOOLEAN)
  56
  57                 return model
  58
  59
  60         def __addColumns(self, tv):
  61
  62                 model = tv.get_model()
  63
  64                 renderer = gtk.CellRendererText()
  65                 renderer.connect("edited", self.onExprEdited, model)
  66                 renderer.set_data("column", 0)
  67                 col = gtk.TreeViewColumn("Expr", renderer, text=0, editable=2)
  68                 col.set_resizable(True)
  69                 tv.append_column(col)
  70
  71
  72                 renderer = gtk.CellRendererText()
  73                 renderer.set_data("column", 1)
  74                 col = gtk.TreeViewColumn("Result", renderer, text=1)
  75                 col.set_resizable(True)
  76                 tv.append_column(col)
  77
  78
  79         def onExprEdited(self, cell, pathStr, expr, model):
  80                 iter = model.get_iter_from_string(pathStr)
  81                 path = model.get_path(iter)[0]
  82                 col = cell.get_data("column")
  83
  84                 model.set(iter, 0, expr)
  85
  86                 if self.debugger.isActive():
  87                         res = self.debugger.getExpression(expr)
  88                         model.set(iter, 1, res)
  89
  90
  91         def applyConfiguration(self, conf):
  92                 for w in conf.watches:
  93                         iter = self.model.append()
  94                         self.model.set(iter, 0, w["expr"], 1, "<unkown>", 2, True)
  95                 self.updateValues(None, None)
  96
  97
  98         def fillConfiguration(self, conf):
  99
 100                 iter = self.model.get_iter_first()
 101                 while iter != None:
 102                         expr, = self.model.get(iter, 0)
 103                         conf.parseWatch(expr)
 104                         iter = self.model.iter_next(iter)
 105
 106
 107         def addWatch(self, expr):
 108                 if self.debugger.isActive():
 109                         res = self.debugger.getExpression(expr)
 110                 else:
 111                         res = expr
 112
 113                 iter = self.model.append()
 114                 self.model.set(iter, 0, expr, 1, res, 2, True)
 115
 116
 117         def delWatches(self, expr):
 118
 119                 def addIters(model, path, iter, iters):
 120                         if model.get_value(iter, 0)==expr:
 121                                 iters += [iter]
 122
 123                 iters = []
 124                 self.model.foreach(addIters, iters)
 125
 126                 #Need reversed here since rows are moved
 127                 #when removing rows
 128                 for i in reversed(iters):
 129                         self.model.remove(i)
 130
 131
 132         def addBtnClicked(self, btn):
 133                 self.addWatch("0")
 134
 135
 136         def delBtnClicked(self, btn):
 137
 138                 selection = self.tv.get_selection()
 139                 model, paths = selection.get_selected_rows()
 140
 141                 for path in reversed(paths):
 142                         iter = model.get_iter(path)
 143                         model.remove(iter)
 144
 145         def updateValues(self, status, param):
 146                 iter = self.model.get_iter_first()
 147                 while iter != None:
 148                         expr, = self.model.get(iter, 0)
 149                         res = self.debugger.getExpression(expr)
 150                         self.model.set(iter, 1, res)
 151
 152                         iter = self.model.iter_next(iter)
 153