Source Code for Module teamwork.widgets.PsychGUI.AgentWindow.MentalModelPane

  1  import string 
  2  import time 
  3  import threading 
  4  from Tkinter import * 
  5  import tkMessageBox 
  6  import Pmw 
  7  from teamwork.widgets.PsychGUI.RadioBox import Rbox 
  8  from teamwork.widgets.cookbook import MultiListbox 
  9   
 10 -class MentalModelFrame(Pmw.MegaWidget): 
 11       
 12 -    def __init__(self,parent,entity,balloon,**kw): 
 13          optiondefs = ( 
 14              ('balloon',None,Pmw.INITOPT), 
 15              ('expert', False,self.setExpert), 
 16              ) 
 17          self.defineoptions(kw, optiondefs) 
 18          self.entity = entity 
 19          fr = Pmw.MegaWidget.__init__(self,parent) 
 20          button = self.createcomponent('%s Lock Models' % \ 
 21                                        entity.ancestry(), 
 22                                        (),None,Button, 
 23                                        (self.interior(),)) 
 24          button.pack(side=TOP) 
 25          sf = self.createcomponent('Models %s' % (entity.ancestry()), 
 26                                    (),None, 
 27                                    Pmw.ScrolledFrame, 
 28                                    (self.interior(),), 
 29                                    horizflex='elastic') 
 30          boxList = [] 
 31          self.mentalwidgets = {} 
 32          for e2 in entity.getEntities(): 
 33              e2 = entity.getEntity(e2) 
 34              name = e2.ancestry().replace('_','') 
 35              g = self.createcomponent('%sGroup' % (name), 
 36                                       (),None, 
 37                                       Pmw.Group, 
 38                                       (sf.interior(),), 
 39                                       tag_text = e2.name) 
 40              g.pack(fill = X) 
 41              if len(e2.models) > 0: 
 42                  rb = self.createcomponent('%s Models' % (name), 
 43                                            (),None,Rbox, 
 44                                            (g.interior(),), 
 45                                            buttontype='radiobutton') 
 46                  rb.configure(command=lambda n,e2=e2:e2.setModel(n)) 
 47                  for key in e2.models.keys(): 
 48                      rb.add(key) 
 49                  rb.pack(fill='x') 
 50                  if e2.model: 
 51                      try: 
 52                          rb.setvalue(e2.model['name']) 
 53                      except KeyError: 
 54                          # This model is not defined for this entity 
 55                          # (can happen in generic society view) 
 56                          pass 
 57  ##                            raise KeyError,'%s has no model: %s' % \ 
 58  ##                                  (e2.ancestry(),e2.model['name']) 
 59                  key = entity.name + '_' + e2.name 
 60                  cmd = lambda e2=e2,rb=rb: \ 
 61                        rb.setvalue(e2.model['name']) 
 62                  self.mentalwidgets[key] = cmd 
 63                  boxList.append(rb) 
 64              cmd = lambda e=e2.name,s=self: s.generate(e) 
 65              rb = Button(g.interior(),text='Auto-Generate',command=cmd) 
 66              rb.pack() 
 67          sf.pack(expand = 1, fill = 'both') 
 68          button.configure(command=lambda e=entity,b=button,l=boxList:\ 
 69                           setModelChange(e,b,l)) 
 70          setModelChange(entity,button,boxList,0) 
 71          self.initialiseoptions() 
 72   
 73 -    def setExpert(self): 
 74          pass 
 75       
 76 -    def recreate_mental(self): 
 77          for key in self.mentalwidgets.keys(): 
 78              try: 
 79                  apply(self.mentalwidgets[key],()) 
 80              except TypeError: 
 81                  # No mental model set here...ignore 
 82                  pass 
 83   
 84 -    def generate(self,entity): 
 85          label = '%s Dialog' % (entity) 
 86          try: 
 87              dialog = self.component(label) 
 88          except KeyError: 
 89              dialog = self.createcomponent(label,(),None,ModelGenerator, 
 90                                            (self.interior(), 
 91                                             self.entity.getEntity(entity)), 
 92                                            title='Auto-Generate Mental Models', 
 93                                            buttons=('Done','Apply'), 
 94                                            defaultbutton='Done', 
 95                                            ) 
 96          box = dialog.component('buttonbox') 
 97          dialog.activate() 
 98           
 99 -def setModelChange(entity,button,radioList,toggle=1): 
100      if toggle: 
101          entity.modelChange = not entity.modelChange 
102      if entity.modelChange: 
103          button.configure(text='Lock') 
104      else: 
105          button.configure(text='Unlock') 
106      for rBox in radioList: 
107          if entity.modelChange: 
108              rBox.enable() 
109          else: 
110              rBox.disable() 
111   
112 -class ModelGenerator(Pmw.Dialog): 
113 -    def __init__(self,parent,entity,**kw): 
114          optiondefs = ( 
115              ('initialgranularity', 11,   Pmw.INITOPT), 
116              ('minimumgranularity', 2,    Pmw.INITOPT), 
117              ('maximumgranularity', 100,  Pmw.INITOPT), 
118              ('columnWidth',        12,   Pmw.INITOPT), 
119              ('command',            self.execute, Pmw.INITOPT), 
120              ('messageFont', ('Courier',10,'normal'), Pmw.INITOPT), 
121              ) 
122          self.defineoptions(kw, optiondefs) 
123          self.entity = entity 
124          Pmw.Dialog.__init__(self,parent) 
125  ##         widget = Label(self.interior(), 
126  ##                        text='Number of values to try for each goal:', 
127  ##                        borderwidth=3,relief='ridge', 
128  ##                        ) 
129  ##         widget.pack(side='top',fill='x') 
130          widget = self.createcomponent('Granularity', 
131                                        (),None,Scale, 
132                                        (self.interior(),), 
133                                        label='Number of values to try for each goal', 
134                                        from_=self['minimumgranularity'], 
135                                        to=self['maximumgranularity'], 
136                                        orient='horizontal', 
137                                        ) 
138          widget.set(self['initialgranularity']) 
139          widget.pack(side='top',fill='x') 
140          goals = self.entity.getGoals() 
141          goals.sort() 
142          columns = [('\nModel\n',5)] 
143          for goal in goals: 
144              if goal.type == 'state': 
145                  entity = string.join(goal.entity,', ') 
146              else: 
147                  entity = 'Anyone' 
148              columns.append(('%s\n%s\n%s' % \ 
149                              (goal.direction[:self['columnWidth']], 
150                               goal.key[:self['columnWidth']], 
151                               entity[:self['columnWidth']]), 
152                              self['columnWidth']+1)) 
153          columns.append(('\nStatus\n',12)) 
154          widget = self.createcomponent('Message',(),None,MultiListbox, 
155                                        (self.interior(),columns), 
156                                        ) 
157          widget.pack(side='top',fill='both',expand='yes') 
158          self.initialiseoptions() 
159          # Threading stuff 
160          self.thread = None 
161          self.lock = threading.Lock() 
162          self.event = threading.Event() 
163          self.results = {} 
164          self.root = self.winfo_toplevel() 
165   
166 -    def execute(self,cmd): 
167          if cmd in ['OK','Apply']: 
168              if self.thread: 
169                  self.event.set() 
170              else: 
171                  # Update the relevant widgets 
172                  box = self.component('buttonbox') 
173                  box.component('Done').configure(state='disabled') 
174                  box.component('Apply').configure(text='Stop') 
175                  self.component('Message').delete(0,'end') 
176                  # Extract the granularity across each goal dimension 
177                  granularity = self.component('Granularity').get() 
178                  goals = self.entity.getGoals() 
179                  goals.sort() 
180                  # Construct the set of possible points in goal space 
181                  weightList = self.entity.generateSpace(granularity) 
182                  if not self.entity.reachable(weightList,granularity): 
183                      raise UserWarning 
184                  for index in range(len(weightList)): 
185                      weighting = weightList[index] 
186                      element = [index] 
187                      for goal in goals: 
188                          element.append('%5.3f' % (weighting[goal])) 
189                      element.append('') 
190                      self.component('Message').insert('end',element) 
191                  # Set up threading 
192                  self.event.clear() 
193                  self.queue = [] 
194                  self.result = {} 
195                  self.thread = threading.Thread(target=self.entity.clusterSpace, 
196                                                 args=(granularity,weightList, 
197                                                       self.message,self.done, 
198                                                       self.event)) 
199                  self.root.after(100,self.log) 
200                  self.thread.start() 
201          elif cmd == 'Help': 
202              tkMessageBox.showinfo('Auto-Generate Help', 
203                                    'Sorry, you\'re on your own.') 
204          if cmd in ['OK','Cancel','Done']: 
205              self.deactivate() 
206   
207 -    def done(self,results): 
208          self.results = results 
209          self.event.set() 
210           
211 -    def message(self,msg): 
212          self.lock.acquire() 
213          if isinstance(msg,list): 
214              msg.reverse() 
215              self.queue += msg 
216          else: 
217              self.queue.insert(0,msg) 
218          self.lock.release() 
219   
220 -    def log(self): 
221          widget = self.component('Message') 
222          self.lock.acquire() 
223          while len(self.queue) > 0: 
224              line,msg = self.queue.pop() 
225              if line >= 0: 
226                  self.setMsg(line,msg) 
227                  widget.see(line) 
228          self.lock.release() 
229          if self.event.isSet(): 
230              self.root.after(20,self.enable) 
231          else: 
232              self.root.after(1,self.log) 
233   
234 -    def setMsg(self,line,msg): 
235          widget = self.component('Message') 
236          element = widget.get(line)[:-1]+[msg] 
237          widget.delete(line,line) 
238          widget.insert(line,element) 
239           
240 -    def enable(self): 
241          box = self.component('buttonbox') 
242          box.component('Done').configure(state='normal') 
243          box.component('Apply').configure(text='Apply') 
244          self.thread.join() 
245          self.thread = None 
246          if self.results: 
247              unique = self.results.keys() 
248              unique.sort() 
249              unique.reverse() 
250  ##             last = unique[0] 
251  ##             widget = self.component('Message') 
252  ##             widget.delete(last+1,'end') 
253  ##             for index in unique[1:]: 
254  ##                 print self.results[last].keys() 
255  ##                 myNeighbors = filter(lambda k:k != '_policy', 
256  ##                                      self.results[last].keys()) 
257  ##                 myNeighbors.sort() 
258  ##                 self.setMsg(last,str(myNeighbors)) 
259  ##                 self.component('Message').delete(index+1,last-1) 
260  ##                 last = index 
261  ##             myNeighbors = filter(lambda k:k != '_policy', 
262  ##                                  self.results[last].keys()) 
263  ##             myNeighbors.sort() 
264  ##             self.setMsg(0,str(myNeighbors)) 
265          else: 
266              self.component('Message').delete(0,'end') 
267