/[ascend]/trunk/pygtk/gtkbrowser.py
ViewVC logotype

Diff of /trunk/pygtk/gtkbrowser.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 532 by johnpye, Mon Apr 24 02:23:08 2006 UTC revision 533 by johnpye, Mon Apr 24 05:54:11 2006 UTC
# Line 81  from observer import *         # observe Line 81  from observer import *         # observe
81  from properties import *       # solver_var properties dialog  from properties import *       # solver_var properties dialog
82  from varentry import *         # for inputting of variables with units  from varentry import *         # for inputting of variables with units
83  from diagnose import *         # for diagnosing block non-convergence  from diagnose import *         # for diagnosing block non-convergence
84  from solverreporter import * # solver status reporting  from solverreporter import *   # solver status reporting
85    from modelview import *        # model browser
86  import config  import config
87    
88  print_loading_status("Starting GUI")  print_loading_status("Starting GUI")
# Line 100  ESCAPE_KEY = 65307 Line 101  ESCAPE_KEY = 65307
101    
102  HELP_ROOT = None  HELP_ROOT = None
103    
 BROWSER_FIXED_COLOR = "#008800"  
 BROWSER_FREE_COLOR = "#000088"  
104  #======================================  #======================================
105  # Browser is the main ASCEND library/model browser window  # Browser is the main ASCEND library/model browser window
106    
# Line 136  class Browser: Line 135  class Browser:
135              ,default=None              ,default=None
136          )          )
137    
138          (options, args) = parser.parse_args()          (self.options, args) = parser.parse_args()
139    
140          #print "OPTIONS_______________:",options          #print "OPTIONS_______________:",self.options
141    
142          self.assets_dir = options.assets_dir          self.assets_dir = self.options.assets_dir
143                    
144          self.observers = []          self.observers = []
145          self.clip = None          self.clip = None
# Line 158  class Browser: Line 157  class Browser:
157          #--------          #--------
158          # set up library path and the path to use for File->Open dialogs          # set up library path and the path to use for File->Open dialogs
159                    
160          if options.library_path != None:          if self.options.library_path != None:
161              _path = os.path.abspath(options.library_path)              _path = os.path.abspath(self.options.library_path)
162              _pathsrc = "commandline"              _pathsrc = "commandline"
163              # when a special path is specified, use that as the file-open location              # when a special path is specified, use that as the file-open location
164              self.fileopenpath = _path              self.fileopenpath = _path
# Line 194  class Browser: Line 193  class Browser:
193              _iconpath = self.assets_dir+'ascend'+config.ICON_EXTENSION              _iconpath = self.assets_dir+'ascend'+config.ICON_EXTENSION
194              _icon.set_from_file(_iconpath)              _icon.set_from_file(_iconpath)
195              self.icon = _icon.get_pixbuf()                    self.icon = _icon.get_pixbuf()      
196            
197          #-------------------          #-------------------
198          # Set up the window and main widget actions          # Set up the window and main widget actions
199    
# Line 261  class Browser: Line 260  class Browser:
260          self.close_on_converged.set_active(self.prefs.getBoolPref("SolverReporter","close_on_converged",True))          self.close_on_converged.set_active(self.prefs.getBoolPref("SolverReporter","close_on_converged",True))
261          self.close_on_nonconverged=glade.get_widget("close_on_nonconverged")          self.close_on_nonconverged=glade.get_widget("close_on_nonconverged")
262          self.close_on_nonconverged.set_active(self.prefs.getBoolPref("SolverReporter","close_on_nonconverged",True))          self.close_on_nonconverged.set_active(self.prefs.getBoolPref("SolverReporter","close_on_nonconverged",True))
         #-------------------  
         # waitwin  
   
         self.waitwin = gtk.gdk.Window(self.window.window,  
             gtk.gdk.screen_width(),  
             gtk.gdk.screen_height(),  
             gtk.gdk.WINDOW_CHILD,  
             0,  
             gtk.gdk.INPUT_ONLY)  
   
         _cursor = gtk.gdk.Cursor(gtk.gdk.WATCH)  
         self.waitwin.set_cursor(_cursor)  
263    
264          #-------------------          #-------
265          # pixbufs to be used in the error listing          # Status icons
   
         self.iconok = self.window.render_icon(gtk.STOCK_YES,gtk.ICON_SIZE_MENU)  
         self.iconinfo = self.window.render_icon(gtk.STOCK_DIALOG_INFO,gtk.ICON_SIZE_MENU)  
         self.iconwarning = self.window.render_icon(gtk.STOCK_DIALOG_WARNING,gtk.ICON_SIZE_MENU)  
         self.iconerror = self.window.render_icon(gtk.STOCK_DIALOG_ERROR,gtk.ICON_SIZE_MENU)  
   
         #--------------------  
         # pixbufs for solver_var status  
266    
267          self.fixedimg = gtk.Image()          self.fixedimg = gtk.Image()
268          self.fixedimg.set_from_file(options.assets_dir+'locked.png')          self.fixedimg.set_from_file(self.options.assets_dir+'locked.png')
269    
270          self.iconstatusunknown = None          self.iconstatusunknown = None
271          self.iconfixed = self.fixedimg.get_pixbuf()          self.iconfixed = self.fixedimg.get_pixbuf()
# Line 301  class Browser: Line 280  class Browser:
280              ,ascpy.ASCXX_VAR_ACTIVE: self.iconactive              ,ascpy.ASCXX_VAR_ACTIVE: self.iconactive
281              ,ascpy.ASCXX_VAR_UNSOLVED: self.iconunsolved              ,ascpy.ASCXX_VAR_UNSOLVED: self.iconunsolved
282          }          }
283    
284    
285          self.statusmessages={          self.statusmessages={
286              ascpy.ASCXX_VAR_STATUS_UNKNOWN: "Status unknown"              ascpy.ASCXX_VAR_STATUS_UNKNOWN: "Status unknown"
287              ,ascpy.ASCXX_VAR_FIXED: "Fixed"              ,ascpy.ASCXX_VAR_FIXED: "Fixed"
288              ,ascpy.ASCXX_VAR_SOLVED: "Converged"              ,ascpy.ASCXX_VAR_SOLVED: "Converged"
289              ,ascpy.ASCXX_VAR_ACTIVE: "Active (unconverged)"              ,ascpy.ASCXX_VAR_ACTIVE: "Active (unconverged)"
290              ,ascpy.ASCXX_VAR_UNSOLVED: "Not yet visited"              ,ascpy.ASCXX_VAR_UNSOLVED: "Not yet visited"
291          }                }
292    
293          #--------------------          #-------------------
294          # set up the context menu for fixing/freeing vars          # waitwin
295    
296          # TODO import this menu from Glade (this code is a PITA)          self.waitwin = gtk.gdk.Window(self.window.window,
297                gtk.gdk.screen_width(),
298                gtk.gdk.screen_height(),
299                gtk.gdk.WINDOW_CHILD,
300                0,
301                gtk.gdk.INPUT_ONLY)
302    
303            _cursor = gtk.gdk.Cursor(gtk.gdk.WATCH)
304            self.waitwin.set_cursor(_cursor)
305    
306            #-------------------
307            # pixbufs to be used in the error listing
308    
309            self.iconok = self.window.render_icon(gtk.STOCK_YES,gtk.ICON_SIZE_MENU)
310            self.iconinfo = self.window.render_icon(gtk.STOCK_DIALOG_INFO,gtk.ICON_SIZE_MENU)
311            self.iconwarning = self.window.render_icon(gtk.STOCK_DIALOG_WARNING,gtk.ICON_SIZE_MENU)
312            self.iconerror = self.window.render_icon(gtk.STOCK_DIALOG_ERROR,gtk.ICON_SIZE_MENU)
313    
314          self.treecontext = gtk.Menu();          #--------------------
315          self.fixmenuitem = gtk.ImageMenuItem("_Fix",True);          # pixbufs for solver_var status
         self.fixmenuitem.set_image(self.fixedimg)  
   
         self.freemenuitem = gtk.ImageMenuItem("F_ree",True);  
         _img = gtk.Image()  
         _img.set_from_file(options.assets_dir+'unlocked.png')  
         self.freemenuitem.set_image(_img)  
   
         self.plotmenuitem = gtk.ImageMenuItem("P_lot",True);  
         _img = gtk.Image()  
         _img.set_from_file(options.assets_dir+'plot.png')  
         self.plotmenuitem.set_image(_img)  
   
         self.propsmenuitem = gtk.ImageMenuItem("_Properties",True);  
         _img = gtk.Image()  
         _img.set_from_file(options.assets_dir+'properties.png')  
         self.propsmenuitem.set_image(_img)  
   
         self.observemenuitem = gtk.ImageMenuItem("_Observe",True);  
         _img = gtk.Image()  
         _img.set_from_file(options.assets_dir+'observe.png')  
         self.observemenuitem.set_image(_img)  
   
         self.fixmenuitem.show(); self.fixmenuitem.set_sensitive(False)  
         self.freemenuitem.show(); self.freemenuitem.set_sensitive(False)  
         self.plotmenuitem.show(); self.plotmenuitem.set_sensitive(False)  
         self.observemenuitem.show(); self.observemenuitem.set_sensitive(False)  
         self.propsmenuitem.show()  
         self.treecontext.append(self.fixmenuitem)  
         self.treecontext.append(self.freemenuitem)  
         _sep = gtk.SeparatorMenuItem(); _sep.show()  
         self.treecontext.append(_sep);  
         self.treecontext.append(self.plotmenuitem)  
         self.treecontext.append(self.observemenuitem)  
         _sep = gtk.SeparatorMenuItem(); _sep.show()  
         self.treecontext.append(_sep)  
         self.treecontext.append(self.propsmenuitem)  
         self.fixmenuitem.connect("activate",self.fix_activate)  
         self.freemenuitem.connect("activate",self.free_activate)  
         self.plotmenuitem.connect("activate",self.plot_activate)  
         self.propsmenuitem.connect("activate",self.props_activate)  
         self.observemenuitem.connect("activate",self.observe_activate)  
316    
         if not self.treecontext:  
             raise RuntimeError("Couldn't create browsercontext")  
317          #--------------------          #--------------------
318          # set up the error view          # set up the error view
319    
# Line 428  class Browser: Line 382  class Browser:
382          #--------          #--------
383          # set up the instance browser view          # set up the instance browser view
384    
385          self.otank = {}          self.modelview = ModelView(self, glade)
         self.treeview = glade.get_widget("browserview")  
   
         # name, type, value, foreground, weight, editable, status-icon  
         columns = [str,str,str,str,int,bool,gtk.gdk.Pixbuf]  
         self.treestore = gtk.TreeStore(*columns)  
         titles = ["Name","Type","Value"];  
         self.treeview.set_model(self.treestore)  
         self.tvcolumns = [ gtk.TreeViewColumn() for _type in columns[:len(titles)] ]  
           
         self.treeview.connect("row-expanded", self.row_expanded )  
         self.treeview.connect("button-press-event", self.on_treeview_event )  
         self.treeview.connect("key-press-event",self.on_treeview_event )  
   
         # data columns are: name type value colour weight editable  
           
         i = 0  
         for tvcolumn in self.tvcolumns[:len(titles)]:  
             tvcolumn.set_title(titles[i])  
             self.treeview.append_column(tvcolumn)            
   
             if(i==2):  
                 # add status icon  
                 renderer1 = gtk.CellRendererPixbuf()  
                 tvcolumn.pack_start(renderer1, False)  
                 tvcolumn.add_attribute(renderer1, 'pixbuf', 6)  
   
             renderer = gtk.CellRendererText()  
             tvcolumn.pack_start(renderer, True)  
             tvcolumn.add_attribute(renderer, 'text', i)  
             tvcolumn.add_attribute(renderer, 'foreground', 3)  
             tvcolumn.add_attribute(renderer, 'weight', 4)  
             if(i==2):  
                 tvcolumn.add_attribute(renderer, 'editable', 5)  
                 renderer.connect('edited',self.cell_edited_callback)  
             i = i + 1  
386    
387            #--------
388            # options
389    
390          if(len(args)==1):          if(len(args)==1):
391              self.do_open(args[0])              self.do_open(args[0])
392    
393              print "Options: ",options              print "Options: ",self.options
394    
395              if options.model:              if self.options.model:
396                  try:                  try:
397                      _t =self.library.findType(options.model);                      _t =self.library.findType(self.options.model);
398                      self.do_sim(_t);                      self.do_sim(_t);
399                  except RuntimeError, e:                  except RuntimeError, e:
400                      self.reporter.reportError("Failed to create instance of '%s': %s" %(options.model, str(e)));                      self.reporter.reportError("Failed to create instance of '%s': %s" %(self.options.model, str(e)));
401                    
402    
403      def run(self):      def run(self):
# Line 487  class Browser: Line 408  class Browser:
408  #   --------------------------------------------  #   --------------------------------------------
409  #   MAJOR GUI COMMANDS  #   MAJOR GUI COMMANDS
410    
411        def on_fix_variable_activate(self,*args):
412            self.modelview.on_fix_variable_activate(*args)
413    
414        def on_free_variable_activate(self,*args):
415            self.modelview.on_free_variable_activate(*args)
416    
417      def do_open(self,filename):      def do_open(self,filename):
418          # TODO does the user want to lose their work?          # TODO does the user want to lose their work?
# Line 496  class Browser: Line 422  class Browser:
422    
423          self.errorstore.clear()          self.errorstore.clear()
424    
425          self.treestore.clear()          self.modelview.clear()
         self.otank = {}  
426            
427          # self.library.clear()          # self.library.clear()
428    
# Line 594  class Browser: Line 519  class Browser:
519    
520          self.sim.setSolver(ascpy.Solver("QRSlv"))          self.sim.setSolver(ascpy.Solver("QRSlv"))
521    
         # empty things out first  
         self.methodstore.clear()  
         self.treestore.clear()  
   
522          # methods          # methods
523            self.methodstore.clear()
524          _methods = self.sim.getType().getMethods()          _methods = self.sim.getType().getMethods()
525          _activemethod = None;          _activemethod = None;
526          for _m in _methods:          for _m in _methods:
# Line 606  class Browser: Line 528  class Browser:
528              if _m.getName()=="default_self":              if _m.getName()=="default_self":
529                  self.methodsel.set_active_iter(_i)                  self.methodsel.set_active_iter(_i)
530    
531          # instance hierarchy          self.modelview.setSimulation(self.sim)
         self.otank = {} # map path -> (name,value)  
         self.make( self.sim.getName(),self.sim.getModel() )  
         self.maintabs.set_current_page(1);  
532            
533      def do_solve_if_auto(self):      def do_solve_if_auto(self):
534          if self.is_auto:          if self.is_auto:
# Line 617  class Browser: Line 536  class Browser:
536              self.do_solve()              self.do_solve()
537          else:          else:
538              self.sim.processVarStatus()              self.sim.processVarStatus()
539              self.refreshtree()              self.modelview.refreshtree()
540    
541          self.sync_observers()          self.sync_observers()
542                    
# Line 638  class Browser: Line 557  class Browser:
557          self.stop_waiting()          self.stop_waiting()
558                    
559          self.sim.processVarStatus()          self.sim.processVarStatus()
560          self.refreshtree()          self.modelview.refreshtree()
561    
562      def do_check(self):      def do_check(self):
563          if not self.sim:          if not self.sim:
# Line 657  class Browser: Line 576  class Browser:
576    
577          self.stop_waiting()          self.stop_waiting()
578    
579          self.refreshtree()          self.modelview.refreshtree()
580    
581      def do_method(self,method):      def do_method(self,method):
582          if not self.sim:          if not self.sim:
583              self.reporter.reportError("No model selected yet")              self.reporter.reportError("No model selected yet")
584    
585          self.sim.run(method)          self.sim.run(method)
586          self.refreshtree()          self.modelview.refreshtree()
587    
588      def do_quit(self):      def do_quit(self):
589          print_loading_status("Saving window location")                print_loading_status("Saving window location")      
# Line 740  class Browser: Line 659  class Browser:
659              return              return
660          self.observers[0].copy_to_clipboard(self.clip)          self.observers[0].copy_to_clipboard(self.clip)
661    
     def on_fix_variable_activate(self,*args):  
         _path,_col = self.treeview.get_cursor()  
         _instance = self.otank[_path][1]  
         self.set_fixed(_instance,True)  
   
     def on_free_variable_activate(self,*args):  
         _path,_col = self.treeview.get_cursor()  
         _instance = self.otank[_path][1]  
         self.set_fixed(_instance,False)  
   
     def set_fixed(self,instance,val):  
         if instance.getType().isRefinedSolverVar():  
             f = instance.isFixed();  
             if (f and not val) or (not f and val):  
                 instance.setFixed(val)  
                 self.do_solve_if_auto()  
   
662      def on_show_solving_popup_toggle(self,checkmenuitem,*args):      def on_show_solving_popup_toggle(self,checkmenuitem,*args):
663          _v = checkmenuitem.get_active()          _v = checkmenuitem.get_active()
664          self.prefs.setBoolPref("SolverReporter","show_popup",_v)          self.prefs.setBoolPref("SolverReporter","show_popup",_v)
# Line 792  class Browser: Line 694  class Browser:
694                  self.do_sim(_type)                  self.do_sim(_type)
695              else:              else:
696                  self.reporter.reportError("Didn't find type corresponding to row")                  self.reporter.reportError("Didn't find type corresponding to row")
               
 #   --------------------------------------------  
 #   INSTANCE TREE  
   
     def get_tree_row_data(self,instance): # for instance browser  
         _value = str(instance.getValue())  
         _type = str(instance.getType())  
         _name = str(instance.getName())  
         _fgcolor = "black"  
         _fontweight = pango.WEIGHT_NORMAL  
         _editable = False  
         _statusicon = None  
         if instance.getType().isRefinedSolverVar():  
             _editable = True  
             _fontweight = pango.WEIGHT_BOLD  
             if instance.isFixed():  
                 _fgcolor = BROWSER_FIXED_COLOR  
             else:  
                 _fgcolor = BROWSER_FREE_COLOR  
                 _fontweight = pango.WEIGHT_BOLD  
             _status = instance.getVarStatus();  
             _statusicon = self.statusicons[_status]  
       
         elif instance.isBool() or instance.isReal() or instance.isInt():  
             # TODO can't edit constants that have already been refined  
             _editable = True  
   
         #if(len(_value) > 80):  
         #   _value = _value[:80] + "..."  
           
         return [_name, _type, _value, _fgcolor, _fontweight, _editable, _statusicon]  
   
     def make_row( self, piter, name, value ): # for instance browser  
   
         _piter = self.treestore.append( piter, self.get_tree_row_data(value) )  
         return _piter  
   
     def refreshtree(self):  
         # @TODO FIXME use a better system than colour literals!  
         for _path in self.otank: # { path : (name,value) }  
             _iter = self.treestore.get_iter(_path)  
             _name, _instance = self.otank[_path]  
             self.treestore.set_value(_iter, 2, _instance.getValue())  
             if _instance.getType().isRefinedSolverVar():  
                 if _instance.isFixed() and self.treestore.get_value(_iter,3)==BROWSER_FREE_COLOR:  
                     self.treestore.set_value(_iter,3,BROWSER_FIXED_COLOR)  
                 elif not _instance.isFixed() and self.treestore.get_value(_iter,3)==BROWSER_FIXED_COLOR:  
                     self.treestore.set_value(_iter,3,BROWSER_FREE_COLOR)  
                 self.treestore.set_value(_iter, 6, self.statusicons[_instance.getVarStatus()])  
   
     def cell_edited_callback(self, renderer, path, newtext, **kwargs):  
         # get back the Instance object we just edited (having to use this seems like a bug)  
         path = tuple( map(int,path.split(":")) )  
   
         if not self.otank.has_key(path):  
             raise RuntimeError("cell_edited_callback: invalid path '%s'" % path)  
             return  
   
         _name, _instance = self.otank[path]  
   
         if _instance.isReal():  
             # only real-valued things can have units  
               
             _e = RealAtomEntry(_instance,newtext);  
             try:  
                 _e.checkEntry()  
                 _e.setValue()  
                 _e.exportPreferredUnits(self.prefs)  
             except InputError, e:  
                 self.reporter.reportError(str(e))  
                 return;  
   
         else:  
             if _instance.isBool():  
                 _lower = newtext.lower();  
                 if _lower.startswith("t") or _lower.startswith("y") or _lower.strip()=="1":  
                     newtext = 1  
                 elif _lower.startswith("f") or _lower.startswith("n") or _lower.strip()=="0":  
                     newtext = 0  
                 else:  
                     self.reporter.reportError("Invalid entry for a boolean variable: '%s'" % newtext)  
                     return  
                 _val = bool(newtext);  
                 if _val == _instance.getValue():  
                     self.reporter.reportNote("Boolean atom '%s' was not altered" % _instance.getName())  
                     return  
                 _instance.setBoolValue(_val)  
   
             elif _instance.isInt():  
                 _val = int(newtext)  
                 if _val == _instance.getValue():  
                     self.reporter.reportNote("Integer atom '%s' was not altered" % _instance.getName())  
                     return  
                 _instance.setIntValue(_val)  
             else:  
                 self.reporter.reportError("Attempt to set a non-real, non-boolean, non-integer value!")  
                 return  
   
         # now that the variable is set, update the GUI and re-solve if desired  
         _iter = self.treestore.get_iter(path)  
         self.treestore.set_value(_iter,2,_instance.getValue())  
   
         if _instance.getType().isRefinedSolverVar():  
             self.treestore.set_value(_iter,3,BROWSER_FIXED_COLOR) # set the row green as fixed  
           
         self.do_solve_if_auto()  
   
     def make_children(self, value, piter ):  
         if value.isCompound():  
             children=value.getChildren();  
             for child in children:  
                 _name = child.getName();  
                 _piter = self.make_row(piter,_name,child)  
                 _path = self.treestore.get_path(_piter)  
                 self.otank[_path]=(_name,child)  
                 #self.reporter.reportError("2 Added %s at path %s" % (_name,repr(_path)))  
   
     def make(self, name=None, value=None, path=None, depth=1):  
         if path is None:  
             # make root node  
             piter = self.make_row( None, name, value )  
             path = self.treestore.get_path( piter )  
             self.otank[ path ] = (name, value)  
             #self.reporter.reportError("4 Added %s at path %s" % (name, path))  
         else:  
             name, value = self.otank[ path ]  
   
         piter = self.treestore.get_iter( path )  
         if not self.treestore.iter_has_child( piter ):  
             self.make_children(value,piter)  
   
         if depth:  
             for i in range( self.treestore.iter_n_children( piter ) ):  
                 self.make( path = path+(i,), depth = depth - 1 )  
         else:  
             self.treeview.expand_row("0",False)  
   
     def row_expanded( self, treeview, piter, path ):  
         self.make( path = path )  
697    
698  #   ----------------------------------  #   ----------------------------------
699  #   ERROR PANEL  #   ERROR PANEL
# Line 1032  class Browser: Line 795  class Browser:
795              _t = self.library.findType(_type)              _t = self.library.findType(_type)
796              self.do_sim(_t)              self.do_sim(_t)
797    
798        def props_activate(self,widget,*args):
799            return self.modelview.props_activate(self,widget,*args)
800    
801        def observe_activate(self,widget,*args):
802            return self.modelview.observe_activate(self,widget,*args)
803    
804      def solve_click(self,*args):      def solve_click(self,*args):
805          #self.reporter.reportError("Solving simulation '" + self.sim.getName().toString() +"'...")          #self.reporter.reportError("Solving simulation '" + self.sim.getName().toString() +"'...")
806          self.do_solve()          self.do_solve()
# Line 1109  class Browser: Line 878  class Browser:
878      def sync_observers(self):      def sync_observers(self):
879          for _o in self.observers:          for _o in self.observers:
880              _o.sync()              _o.sync()
881        
882        def delete_event(self, widget, event):
883            self.do_quit()  
884            return False
885    
886  #   ------------------------------      def observe(self,instance):
 #   CONTEXT MENU  
   
     def on_treeview_event(self,widget,event):  
         _contextmenu = False;  
         if event.type==gtk.gdk.KEY_PRESS and gtk.gdk.keyval_name(event.keyval)=='Menu':  
             _contextmenu = True  
             _path, _col = self.treeview.get_cursor()  
             _button = 3;  
         elif event.type==gtk.gdk.BUTTON_PRESS:  
             if event.button == 3:  
                 _contextmenu = True  
                 _x = int(event.x)  
                 _y = int(event.y)  
                 _button = event.button  
                 _pthinfo = self.treeview.get_path_at_pos(_x, _y)  
                 if _pthinfo == None:  
                     return  
                 _path, _col, _cellx, _celly = _pthinfo  
           
         # which button was clicked?  
         if not _contextmenu:  
             return  
   
         _canpop = False;  
         # self.reporter.reportError("Right click on %s" % self.otank[_path][0])  
         _instance = self.otank[_path][1]  
         if _instance.getType().isRefinedSolverVar():  
             _canpop = True;  
             self.observemenuitem.set_sensitive(True)  
             if _instance.isFixed():  
                 self.fixmenuitem.set_sensitive(False)  
                 self.freemenuitem.set_sensitive(True)  
             else:  
                 self.fixmenuitem.set_sensitive(True)  
                 self.freemenuitem.set_sensitive(False)  
         elif _instance.isRelation():  
             _canpop = True;  
             self.propsmenuitem.set_sensitive(True)                    
   
         if _instance.isPlottable():  
             self.plotmenuitem.set_sensitive(True)  
             _canpop = True;  
         else:  
             self.plotmenuitem.set_sensitive(False)  
   
         if not _canpop:  
             return  
   
         self.treeview.grab_focus()  
         self.treeview.set_cursor( _path, _col, 0)  
         self.treecontext.popup( None, None, None, _button, event.time)  
         return 1  
   
     def fix_activate(self,widget):  
         _path,_col = self.treeview.get_cursor()  
         _name, _instance = self.otank[_path]  
         self.set_fixed(_instance,True);  
         _instance.setFixed(True)  
         return 1  
   
     def free_activate(self,widget):  
         _path,_col = self.treeview.get_cursor()  
         _instance = self.otank[_path][1]  
         self.set_fixed(_instance,False)  
         return 1  
   
     def plot_activate(self,widget):  
         self.reporter.reportNote("plot_activate...");  
         _path,_col = self.treeview.get_cursor()  
         _instance = self.otank[_path][1]  
         if not _instance.isPlottable():  
             self.reporter.reportError("Can't plot instance %s" % _instance.getName().toString())  
             return  
         else:  
             self.reporter.reportNote("Instance %s about to be plotted..." % _instance.getName().toString())  
   
         print("Plotting instance '%s'..." % _instance.getName().toString())  
   
         _plot = _instance.getPlot()  
   
         print "Title: ", _plot.getTitle()  
         _plot.show(True)  
   
         return 1  
   
     def props_activate(self,widget):  
         _path,_col = self.treeview.get_cursor()  
         _instance = self.otank[_path][1]  
         if _instance.isRelation():  
             print "Relation '"+_instance.getName().toString()+"':", \  
                 _instance.getRelationAsString(self.sim.getModel())  
             _dia = RelPropsWin(self,_instance);  
             _dia.run();  
         elif _instance.getType().isRefinedSolverVar():  
             _dia = VarPropsWin(self,_instance);  
             _dia.run();  
         else:  
             self.reporter.reportWarning("Select a variable first...")  
   
     def observe_activate(self,widget):  
         _path,_col = self.treeview.get_cursor()  
         _instance = self.otank[_path][1]  
         if _instance.getType().isRefinedSolverVar():  
             print "OBSERVING",_instance.getName().toString()          
887              if len(self.observers) > 1:              if len(self.observers) > 1:
888                  self.reporter.reportError("Not implemented: multiple observers (currently %d observers)" %                  self.reporter.reportError("Not implemented: multiple observers (currently %d observers)" %
889                      len(self.observers) )                      len(self.observers) )
# Line 1222  class Browser: Line 891  class Browser:
891              if len(self.observers) ==0:              if len(self.observers) ==0:
892                  self.create_observer()                  self.create_observer()
893              _observer = self.observers[0]              _observer = self.observers[0]
894              _observer.add_instance(_instance)              _observer.add_instance(instance)
       
     def delete_event(self, widget, event):  
         self.do_quit()    
         return False  
895    
896  if __name__ == "__main__":  if __name__ == "__main__":
897      b = Browser();      b = Browser();

Legend:
Removed from v.532  
changed lines
  Added in v.533

john.pye@anu.edu.au
ViewVC Help
Powered by ViewVC 1.1.22