iceprod.client.GtkParameterList

1 #!/bin/env python 2 # 3 """ 4 IceTray connections frame for GtkIcetraConfig application 5 6 copyright (c) 2005 the icecube collaboration 7 8 @version: $Revision: $ 9 @date: $Date: $ 10 @author: Juan Carlos Diaz Velez <juancarlos@icecube.wisc.edu> 11 """ 12 13 import pygtk 14 pygtk.require("2.0") 15 import gtk, gobject 16 from iceprod.core.dataclasses import * 17 from GtkVector import GtkVector 18 import logging 19 20 logger = logging.getLogger('GtkParameterList') 21

22 -class GtkParameterList:

23 """ The GUI class is the controller for our application """

24 - def __init__(self,cobj):

25 26 self.cobj = cobj 27 self.store = InfoModel(self.cobj) 28 self.display = DisplayModel(self) 29 30 # setup the main window 31 self.root = gtk.Window(type=gtk.WINDOW_TOPLEVEL) 32 self.root.set_title("Parameter Table") 33 self.root.set_size_request(800, 700) 34 35 # Add scrolled window 36 self.sw = gtk.ScrolledWindow() 37 38 # Get the model and attach it to the view 39 self.mdl = self.store.get_model() 40 self.view = self.display.make_view( self.mdl ) 41 self.vbox = gtk.VBox() 42 self.sw.add(self.view) 43 self.vbox.pack_start(self.sw) 44 45 self.hbbox = gtk.HButtonBox() 46 self.b0 = gtk.Button('Add Parameter') 47 self.b1 = gtk.Button('Delete Parameter') 48 self.b0.connect('clicked', self.display.add_parameter,self.store) 49 self.b1.connect('clicked', self.display.delete_parameter,self.mdl) 50 self.hbbox.pack_start(self.b0, False, False, 1) 51 self.hbbox.pack_start(self.b1, False, False, 1) 52 53 self.vbox.pack_start(self.hbbox, False) 54 # Add our view into the main window 55 self.root.add(self.vbox) 56 self.root.show_all() 57 return

58

59 - def redraw(self, widget, event=None):

60 self.store.redraw()

61

62 -class InfoModel:

63 """ The model class holds the information we want to display """ 64

65 - def __init__(self,cobj):

66 """ Sets up and populates our gtk.TreeStore """ 67 self.tree_store = gtk.ListStore( str, str, str , str) 68 self.cobj = cobj 69 self.redraw()

70

71 - def redraw(self):

72 self.tree_store.clear() 73 params = self.cobj.GetParameters() 74 for p in params: 75 if p.GetType() == 'OMKey': 76 value = "OMKey(%s,%s)" % (p.GetValue().stringid,p.GetValue().omid) 77 row = [p.GetType(),p.GetName(), value, '' ] 78 elif p.GetType() == 'OMKeyv': 79 getvalue = lambda x: "OMKey(%s,%s)" % (x.stringid,x.omid) 80 if len(p.GetValue()) > 0: 81 value = "[%s]" % (','.join(map(getvalue,p.GetValue()))) 82 else: 83 value = "[]" % (','.join(map(getvalue,p.GetValue()))) 84 row = [p.GetType(),p.GetName(), value, '' ] 85 elif p.GetType() in VectorTypes: 86 getvalue = lambda x: x.unit and "%s*I3Units::%s" % (x.value,x.unit) \ 87 or x.value 88 if len(p.GetValue()) > 0: 89 value = "[%s]" % (','.join(map(getvalue,p.GetValue()))) 90 else: 91 value = "[]" 92 row = [p.GetType(),p.GetName(), value, '' ] 93 else: 94 row = [p.GetType(),p.GetName(), p.GetValue().value, p.GetValue().unit or '' ] 95 self.tree_store.append( row ) 96 logger.debug('|'.join(row))

97 98

99 - def add_parameter(self, param):

100 row = [param.GetType(),param.GetName(),param.GetValue().value,param.GetValue().unit or '' ] 101 self.tree_store.append( row ) 102 logger.debug('|'.join(row))

103

104 - def get_model(self):

105 """ Returns the model """ 106 if self.tree_store: 107 return self.tree_store 108 else: 109 return None

110

111 -class DisplayModel:

112 """ Displays the Info_Model model in a view """

113 - def __init__(self,parent):

114 self.parent = parent 115 self.cobj = self.parent.cobj 116 self.tips = gtk.Tooltips() 117 self.tips.enable()

118

119 - def edit_vector(self, tv, path, viewcol):

120 sel = self.view.get_selection() 121 sel.select_path(path) 122 model, iter = sel.get_selected() 123 row = model[path] 124 pname = row[1] 125 param = self.cobj.GetParameter(pname) 126 if param: 127 if param.GetType() in VectorTypes: 128 self.mlist = GtkVector(param,self.parent)

129

130 - def on_selection_changed(self,selection):

131 pname = None 132 133 model, iter = selection.get_selected() 134 if iter: 135 try: 136 ptype = model.get_value(iter, 0) 137 pname = model.get_value(iter, 1) 138 param = self.cobj.GetParameter(pname) 139 logger.debug("selected: %s %s" % (ptype,pname)) 140 141 self.tips.disable() 142 self.tips.set_tip(self.view, param.GetDescription()) 143 self.tips.enable() 144 if ptype in VectorTypes: 145 self.renderer2.set_property( 'editable', False) 146 else: 147 self.renderer2.set_property( 'editable', True) 148 except: pass

149 150

151 - def make_view( self, model ):

152 """ Form a view for the Tree Model """ 153 self.view = gtk.TreeView( model ) 154 self.selection = self.view.get_selection() 155 self.selection.connect('changed', self.on_selection_changed) 156 self.view.connect( 'row-activated', self.edit_vector ) 157 158 # setup the text cell renderer and allows these 159 # cells to be edited. 160 self.renderer0 = gtk.CellRendererText() 161 self.renderer0.set_property( 'editable', True) 162 self.renderer0.connect( 'edited', self.col0_edited_cb, model ) 163 164 self.renderer1 = gtk.CellRendererText() 165 self.renderer1.set_property( 'editable', True) 166 self.renderer1.connect( 'edited', self.col1_edited_cb, model ) 167 168 self.renderer2 = gtk.CellRendererText() 169 self.renderer2.set_property( 'editable', True ) 170 self.renderer2.connect( 'edited', self.col2_edited_cb, model ) 171 172 self.renderer3 = gtk.CellRendererText() 173 self.renderer3.set_property( 'editable', True ) 174 self.renderer3.connect( 'edited', self.col3_edited_cb, model ) 175 176 self.column0 = gtk.TreeViewColumn("Type",self.renderer0, text=0) 177 self.column1 = gtk.TreeViewColumn("Name",self.renderer1, text=1) 178 self.column2 = gtk.TreeViewColumn("Value",self.renderer2,text=2 ) 179 self.column3 = gtk.TreeViewColumn("Unit",self.renderer3,text=3 ) 180 181 self.view.append_column( self.column0 ) 182 self.view.append_column( self.column1 ) 183 self.view.append_column( self.column2 ) 184 self.view.append_column( self.column3 ) 185 return self.view

186

187 - def col0_edited_cb( self, cell, path, new_text, model ):

188 """ 189 Canges the type of the parameter (for manually added params) 190 @todo: add type checking for input values 191 """ 192 logger.debug("Change '%s' to '%s'" % (model[path][0], new_text)) 193 row = model[path] 194 pname = row[1] 195 param = self.cobj.GetParameter(pname) 196 if param: 197 # Some kind of type checking should happen here 198 param.SetType(u'%s' % new_text) 199 if new_text in VectorTypes and not isinstance(param.GetValue(),list): 200 param.SetValue([param.GetValue()]) 201 202 row[0] = u'%s' % new_text 203 204 self.parent.redraw(None,None)

205

206 - def col1_edited_cb( self, cell, path, new_text, model ):

207 """ 208 Canges the name of the parameter (for manually added params) 209 @todo: add type checking for input values 210 """ 211 logger.debug("Change '%s' to '%s'" % (model[path][2], new_text)) 212 row = model[path] 213 pname = row[1] 214 param = self.cobj.GetParameter(pname) 215 if param: 216 self.cobj.RemoveParameter(pname) 217 param.SetName(u'%s' % new_text) 218 self.cobj.AddParameter(param) 219 row[1] = u'%s' % new_text

220

221 - def parse_val(self,ptype,value):

222 if ptype in VectorTypes: 223 if ptype.startswith("OMKey"): 224 valvect = re.findall(r'OMKey$\s*[0-9]+\s*,\s*[0-9]+\s*$',value) 225 valvect = map(lambda x: self.parse_val("OMKey",x),valvect) 226 return valvect 227 else: 228 val = value.strip("[").strip("]").strip().split(",") 229 val = map(lambda x: x.strip("\""),val) 230 231 if ptype.startswith("string") or ptype.startswith("bool"): 232 return map(Value,val) 233 else: 234 vals = map(lambda x: x.split("*I3Units::")[0],val) 235 units = map(lambda x: (len(x.split("*I3Units::")) > 1 and \ 236 x.split("*I3Units::") or [None,None])[1] ,val) 237 return map(lambda x,y: Value(x,y),vals,units) 238 elif ptype == 'OMKey' and value.startswith("OMKey"): 239 val = value.replace("OMKey",'').replace("(",'').replace(")",'').split(",") 240 return pyOMKey(val[0],val[1]) 241 else: return Value(value)

242

243 - def col2_edited_cb( self, cell, path, new_text, model ):

244 """ 245 Canges the value of the parameter 246 @todo: add type checking for input values 247 @todo: add descriptions 248 """ 249 logger.debug("Change '%s' to '%s'" % (model[path][2], new_text)) 250 row = model[path] 251 pname = row[1] 252 param = self.cobj.GetParameter(pname) 253 if param: 254 if param.GetType() in VectorTypes: 255 return 256 else: 257 try: 258 unit = model[path][3] 259 param.SetValue(self.parse_val(param.GetType(),new_text)) 260 if unit: 261 param.GetValue().SetUnit(unit) 262 row[2] = u'%s' % new_text 263 except Exception,e: 264 logger.error(str(e)+": unable to parse value '%s'"% new_text)

265

266 - def col3_edited_cb( self, cell, path, new_text, model ):

267 """ 268 Canges the value of the parameter 269 @todo: add type checking for input values 270 @todo: add descriptions 271 """ 272 logger.debug("Change '%s' to '%s'" % (model[path][3], new_text)) 273 row = model[path] 274 pname = row[1] 275 param = self.cobj.GetParameter(pname) 276 if param and new_text: 277 if param.GetType().startswith('OMKey'): 278 logger.error("type '%s' - does not accept I3Units"%param.GetType()) 279 return 280 elif param.GetType() in VectorTypes: 281 map(lambda x:x.SetUnit(u'%s' % new_text),param.GetValue()) 282 else: 283 param.GetValue().SetUnit(u'%s' % new_text) 284 row[3] = u'%s' % new_text

285

286 - def add_parameter(self, b, model):

287 """ 288 Manually add a parameter 289 """ 290 param = Parameter() 291 param.SetName('new_parameter') 292 param.SetType('string') 293 param.SetValue(Value('NULL')) 294 self.cobj.AddParameter(param) 295 model.add_parameter(param)

296 297

298 - def delete_parameter(self, b, mymodel):

299 sel = self.view.get_selection() 300 model, iter = sel.get_selected() 301 pname = mymodel.get_value(iter,1) 302 logger.debug("deleting %s" % pname) 303 self.cobj.RemoveParameter(pname) 304 model.remove(iter)

305

Source Code for Module iceprod.client.GtkParameterList