Source Code for Module iceprod.client.GtkModuleList

  1  #!/bin/env python 
  2  #   copyright  (c) 2005 
  3  #   the icecube collaboration 
  4  #   $Id: $ 
  5  # 
  6  #   @version $Revision: $ 
  7  #   @date $Date: $ 
  8  #   @author Juan Carlos Diaz Velez <juancarlos@icecube.wisc.edu> 
  9  #       @brief Project display frame for GtkIcetraConfig application 
 10  ######################################################################### 
 11  import pygtk 
 12  pygtk.require("2.0") 
 13  import gtk, gobject 
 14  from iceprod.core.dataclasses import * 
 15  import logging 
 16   
 17  logger = logging.getLogger('GtkModuleList') 
 18   
 19 -class GtkModuleList: 
 20      """ The GUI class is the controller for our application """ 
 21   
 22      fooname = 'foo' 
 23      fooclass = 'BarModule' 
 24      fooproject = 'pippo-project' 
 25   
 26 -    def __init__(self,iconfig,pdb,gtkmod,title="Available Modules"): 
 27   
 28          self.iconfig = iconfig 
 29          self.pdb = pdb 
 30          self.gtkmod = gtkmod 
 31          self.printer = None 
 32          self.display() 
 33   
 34          # setup the main window 
 35          self.root = gtk.Window(type=gtk.WINDOW_TOPLEVEL) 
 36          self.sw = gtk.ScrolledWindow() 
 37          self.root.set_title(title) 
 38          self.root.set_size_request(600, 475) 
 39   
 40          # Get the model and attach it to the view 
 41          self.view = self.make_view( self.store ) 
 42   
 43          b = gtk.Button(stock=gtk.STOCK_APPLY) 
 44          b.connect('clicked', self.commit_changes) 
 45          self.hbbox = gtk.HButtonBox() 
 46          self.hbbox.pack_start(b, False, False, 1) 
 47   
 48          # Add our view into the main window 
 49          self.sw.add(self.view) 
 50   
 51          self.vbox = gtk.VBox(False,0) 
 52          self.vbox.pack_start(self.sw,True,True,2) 
 53          self.vbox.pack_end(self.hbbox,False,False,2) 
 54          self.root.add(self.vbox) 
 55          self.root.show_all() 
 56          return 
 57   
 58 -    def SetPrinter(self,printer): 
 59          self.printer = printer 
 60   
 61 -    def SetParent(self,parent): 
 62          self.parent = parent 
 63   
 64 -    def Print(self,txt): 
 65          if self.printer: 
 66                          self.printer(txt) 
 67          else: 
 68                          print txt 
 69   
 70   
 71 -    def display(self): 
 72          """ Sets up and populates gtk.TreeStore """ 
 73          self.store = gtk.TreeStore( int, str, str, str, gobject.TYPE_BOOLEAN ) 
 74          row = [0,self.fooname,self.fooclass, self.fooproject,False]   
 75          self.store.append(None, row ) 
 76   
 77          if not self.pdb.cached and not self.pdb.connect(): return 
 78          for mp in self.iconfig.GetMetaProjectList(): 
 79              for p in self.pdb.GetProjects(mp.GetId()): 
 80                  pname = p.GetName() 
 81                  pver  = p.GetVersion()  
 82   
 83                  modules = self.pdb.GetModulesP(pname,pver) 
 84                  for m in modules: 
 85                          if not self.iconfig.GetModule(m.GetName()): 
 86                                  row = [m.GetId(),m.GetName(), m.GetClass(),pname,False]   
 87                                  logger.debug('|'.join(map(str,row))) 
 88                                  self.store.append(None, row ) 
 89   
 90          for p in self.iconfig.GetProjectList(): 
 91              pname = p.GetName() 
 92              pver  = p.GetVersion() 
 93   
 94              modules = self.pdb.GetModulesP(pname,pver) 
 95              for m in modules: 
 96                  if not self.iconfig.GetModule(m.GetName()): 
 97                          row = [m.GetId(),m.GetName(), m.GetClass(),pname,False]   
 98                          logger.debug('|'.join(map(str,row))) 
 99                          self.store.append(None, row ) 
100   
101 -    def add_module(self, tv, path, viewcol): 
102                  """  
103                   Add Module 
104                  """ 
105                  sel = tv.get_selection() 
106                  sel.select_path(path) 
107                  model, iter = sel.get_selected()  
108                  id     = model.get_value(iter, 0) 
109                  name   = model.get_value(iter, 1) 
110                  cname  = model.get_value(iter, 2) 
111                  proj_name   = model.get_value(iter, 3) 
112   
113                  newmod = Module() 
114                  newmod.SetName(name) 
115                  newmod.SetClass(cname) 
116   
117                  if not self.pdb.cached and not self.pdb.connect(): return 
118                  proj = self.iconfig.GetProject(proj_name) 
119                  if not proj:  
120                          for mp in self.iconfig.GetMetaProjectList(): 
121                                  for p in self.pdb.GetProjectsMM(newmod,mp): 
122                                          mp.AddProject(p.GetName(),p) 
123                                          if p.GetName() == proj_name: proj = p 
124                  if not proj:  
125                          raise Exception, "Could not find project for '%s'"% newmod.GetName() 
126                  newmod.AddProject(proj_name,proj) 
127   
128                  parameters = self.pdb.GetParameters(int(id)) 
129                  for p in parameters: 
130                          param = Parameter() 
131                          param.SetName(p.GetName()) 
132                          param.SetType(p.GetType()) 
133                          param.SetDescription(p.GetDescription()) 
134                          param.SetValue(p.GetValue()) 
135                          newmod.AddParameter(param) 
136   
137                  self.iconfig.AddModule(newmod) 
138                  self.gtkmod.showmodules() 
139                  self.root.destroy() 
140   
141 -    def commit_changes(self, widget, data=None): 
142          model = self.store 
143          self.mdict = {} 
144          if not self.pdb.cached and not self.pdb.connect(): return 
145          model.foreach(self.do_change) 
146          return 
147   
148 -    def do_change(self, model, path, iter,connect=True): 
149                  """  
150                   Add Module 
151                  """ 
152                  if model[path][4]: 
153                          id     = model[path][0] 
154                          name   = model[path][1] 
155                          cname  = model[path][2] 
156   
157                          proj_name  = model[path][3] 
158                          proj = self.iconfig.GetProject(proj_name) 
159   
160                          newmod = Module() 
161                          newmod.SetName(name) 
162                          newmod.SetClass(cname) 
163   
164                          proj = self.iconfig.GetProject(proj_name) 
165                          if not proj:  
166                                  for mp in self.iconfig.GetMetaProjectList(): 
167                                          for p in self.pdb.GetProjectsMM(newmod,mp): 
168                                                  mp.AddProject(p.GetName(),p) 
169                                                  if p.GetName() == proj_name: proj = p 
170   
171                                          if not proj: # search all projects in mp to match name 
172                                                  for p in self.pdb.GetProjects(mp.GetId()): 
173                                                          if p.GetName() == proj_name:  
174                                                                  mp.AddProject(p.GetName(),p) 
175                                                                  proj = p 
176                                                                  break 
177                          if not proj:  
178                                  raise Exception, "Could not find project for '%s'"% newmod.GetName() 
179                          newmod.AddProject(proj_name,proj) 
180   
181                          parameters = self.pdb.GetParameters(int(id)) 
182                          for p in parameters: 
183                                  param = Parameter() 
184                                  param.SetName(p.GetName()) 
185                                  param.SetType(p.GetType()) 
186                                  param.SetDescription(p.GetDescription()) 
187                                  param.SetValue(p.GetValue()) 
188                                  newmod.AddParameter(param) 
189   
190                          self.iconfig.AddModule(newmod) 
191                          self.gtkmod.showmodules() 
192                          self.root.destroy() 
193   
194 -    def col_edited( self, cell, path, new_text, model , column): 
195          """ 
196          Canges the name of the module 
197                  @todo: add type checking for input values 
198                  @todo: add descriptions 
199          """ 
200          row = model[path] 
201          row[column] = u'%s' % new_text 
202   
203   
204 -    def row_toggled( self,cell, path): 
205          """ 
206          Sets the toggled state on the toggle button to true or false. 
207          """ 
208          model = self.store 
209          model[path][4] =  not model[path][4]  
210   
211          if not model[path][4]: 
212                  self.renderer[1].set_property('editable', False) 
213                  self.renderer[2].set_property('editable', False) 
214                  self.renderer[3].set_property('editable', False) 
215                  return 
216   
217          if model[path][3] == self.fooproject: 
218                  self.renderer[3].set_property('editable', True) 
219                  self.renderer[3].connect( 'edited', self.col_edited,self.store,3) 
220          if model[path][2] == self.fooclass: 
221                  self.renderer[2].set_property('editable', True) 
222                  self.renderer[2].connect( 'edited', self.col_edited,self.store,2) 
223          if model[path][1] == self.fooname: 
224                  self.renderer[1].set_property('editable', True) 
225                  self.renderer[1].connect( 'edited', self.col_edited,self.store,1) 
226   
227   
228 -    def make_view( self, model ): 
229          """ Form a view for the Tree Model """ 
230          self.view = gtk.TreeView( model ) 
231          self.view.connect('row-activated', self.add_module) 
232   
233          # setup the text cell renderer and allows these 
234          # cells to be edited. 
235          self.renderer = [None]*5 
236          for i in range(4): 
237                  self.renderer[i] = gtk.CellRendererText() 
238          self.renderer[4]  = gtk.CellRendererToggle() 
239          self.renderer[4].set_property('activatable', True) 
240          self.renderer[4].connect( 'toggled', self.row_toggled) 
241                   
242          self.column =  [None]*5 
243          self.column[0] = gtk.TreeViewColumn("DbID",self.renderer[0], text=0) 
244          self.column[0].set_sort_column_id(0) 
245          self.column[1] = gtk.TreeViewColumn("Default Name",self.renderer[1], text=1) 
246          self.column[1].set_sort_column_id(1) 
247          self.column[2] = gtk.TreeViewColumn("Class",self.renderer[2], text=2) 
248          self.column[2].set_sort_column_id(2) 
249          self.column[3] = gtk.TreeViewColumn("Project",self.renderer[3],text=3 ) 
250          self.column[4] = gtk.TreeViewColumn('Selected') 
251          self.column[4].pack_start(self.renderer[4], True) 
252          self.column[4].add_attribute( self.renderer[4], "active", 4) 
253   
254          for i in range(5): 
255                  self.view.append_column( self.column[i] ) 
256          return self.view 
257