[Bio] / ModelEditor / RecoElempanel.py Repository:
ViewVC logotype

Annotation of /ModelEditor/RecoElempanel.py

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.9 - (view) (download) (as text)

1 : efrank 1.4 from ModelEditor.DoubleTextEntryDialog import DoubleTextEntryDialog
2 : efrank 1.1 import copy
3 :     from wxPython.wx import *
4 :     from KahApp.KahConfigMgr import KahConfigMgr
5 :     from FaST.BssFactory import BssFactory
6 :     from KahOM.RecoElem import RecoElem
7 :     import os
8 :     from tempfile import mktemp
9 :     from tempfile import TemporaryFile
10 :    
11 : efrank 1.4 from MeSharedEditServer import putOnClipboard
12 :     from MeSharedEditServer import getCbDescriptor
13 : efrank 1.5 from KahDataServices.ModelFromText import modelFromText
14 : efrank 1.1
15 :     #------------------------------------------------------------------------
16 :     class TreeData:
17 :     #------------------------------------------------------------------------
18 :     """
19 :     TreeData instances are associated with wxTree nodes via
20 :     SetPyData(). TreeData is just a struct to keep us sane
21 :     when fetching things back. It holds a RecoElem and the
22 :     CatalogEntry that owns it.
23 :     """
24 :    
25 :     def __init__(self, itemId, aRecoElem, aCatalogEntry):
26 :     self.re = aRecoElem
27 :     self.ce = aCatalogEntry
28 :     self.itemId = itemId
29 :     return
30 :    
31 :    
32 :    
33 :    
34 :     #------------------------------------------------------------------------
35 :     class RecoElempanel:
36 :     #------------------------------------------------------------------------
37 :     # def __init__(self, parent):
38 :     # def initEvents(self):
39 :     # def ID_NUM(self,event):
40 :     # def AddRecoElemTree( self, treeItemId, aRecoElem, aCatalogEntry ):
41 :     # def onSelectReaction(self,event):
42 :     # def onSelect(self, treeEvent):
43 :     # def redrawRecoElemRxList(self, re):
44 :     # def onRightListClick( self, event):
45 :     # def setupRecoElemRxListEditMenu(self):
46 :     # def rightTreeClick( self, event):
47 :     # def setupRecoElemEditMenu(self):
48 :     # def updateTreeBranchText(self, sourceRXNum):
49 :     # def recoElemPasteRx(self, event):
50 :     # def recoElemPasteFromSelectedRxGrid(self, event):
51 :     # def recoElemAddKid(self, event):
52 :     # def recoElemAddRoot(self, event):
53 :     # def recoElemRxListCut(self, event):
54 :     # def recoElemRxListCopy(self, event):
55 :     # def recoElemRxListPaste(self, event):
56 :    
57 :     #------------------------------------------------------------------
58 :     def __init__(self, parent):
59 :     #------------------------------------------------------------------
60 :     self.selectedItem = None # last thing selected. Instance of TreeItem
61 :     self.cutOrCopiedRx = None
62 :     self.cutOrCopiedRE = None
63 :     self._pluginDict = {} # used to dispatch calls to plugins.
64 :     self.parent = parent
65 :    
66 :     self.parent.rootId = self.parent.tree_ctr.AddRoot("top item")
67 :    
68 :    
69 :     #set up menu for editing recoelem
70 :     self.recoElemEditMenu = wxMenu()
71 :     self.recoElemNewKidId = wxNewId()
72 :     self.recoElemCopyREBranchId = wxNewId()
73 :     self.recoElemCutREBranchId = wxNewId()
74 :     self.recoElemPasteREBranchId = wxNewId()
75 : efrank 1.6 self.recoElemMergeREBranchId = wxNewId()
76 : efrank 1.1
77 :     self.recoElemPasteRxId = wxNewId()
78 :     self.recoElemPasteFromSelectedRxGridId = wxNewId()
79 : efrank 1.5 self.recoElemAppendFromTextFileId = wxNewId()
80 : efrank 1.1 self.recoElemVizWithCytoScapeId = wxNewId()
81 :     self.recoElemWriteToBssId = wxNewId()
82 : efrank 1.2
83 :     self.recoElemWriteToCbId= wxNewId()
84 : efrank 1.1 self.setupRecoElemEditMenu()
85 :    
86 :     #set up menu for list
87 :     self.recoElemRxListEditMenu = wxMenu()
88 :     self.recoElemRxListCutId = wxNewId()
89 :     self.recoElemRxListCopyId = wxNewId()
90 :     self.recoElemRxListPasteId = wxNewId()
91 :     self.setupRecoElemRxListEditMenu()
92 :    
93 :     self.initEvents()
94 :     return
95 :    
96 :     #------------------------------------------------------------------
97 :     def initEvents(self):
98 :     #------------------------------------------------------------------
99 :    
100 :     #button1= self.parent.OK_button
101 :     # select in list of reactions
102 :     EVT_LISTBOX(self.parent, self.parent.list_box.GetId(),
103 :     self.onSelectReaction)
104 :    
105 :     # hit the button that loads a RecoElem id
106 :     #EVT_BUTTON(self.parent, button1.GetId(), self.ID_NUM)
107 :    
108 :     # select in tree
109 :     EVT_TREE_SEL_CHANGED(self.parent.tree_ctr,
110 :     self.parent.tree_ctr.GetId(), self.onSelect)
111 :    
112 :     # Right click on tree (presumably after selection)
113 :     EVT_RIGHT_DOWN(self.parent.tree_ctr, self.rightTreeClick)
114 :    
115 :     # Right click on List (presumably after selection)
116 :     EVT_RIGHT_DOWN(self.parent.list_box, self.onRightListClick)
117 :    
118 :     # this does not work for some reason.
119 :     #EVT_LISTBOX(self.parent.list_box, self.parent.list_box.GetId(),
120 :     # self.onRightListClick)
121 :    
122 :    
123 :     return
124 :    
125 :    
126 :     #------------------------------------------------------------------
127 :     def addRecoElemTree( self, treeItemId, aRecoElem, aCatalogEntry ):
128 :     #------------------------------------------------------------------
129 : efrank 1.4 """
130 :     @type treeItemId: wx tree item id
131 :     @type aRecoElem: KahOM.RecoElem
132 :     @type aCatalogEntry: CatalogServices.CatalogEntry
133 :    
134 :     Attach aRecoElem at node treeItemId, recording the catalogEntry.
135 :     Also, recursively attach all childern AND force all children to
136 :     have the same catalogEntry.
137 :     """
138 :    
139 : efrank 1.1
140 : efrank 1.9 numrx= aRecoElem.nReactions()
141 : efrank 1.1 if numrx > 0:
142 : efrank 1.9 rxitem = "(" + str(numrx) + "rx"+ ") " + aRecoElem.getName()
143 : efrank 1.1 else:
144 : efrank 1.9 rxitem = aRecoElem.getName()
145 : efrank 1.1
146 :     itemId=self.parent.tree_ctr.AppendItem(treeItemId, rxitem )
147 :     self.parent.tree_ctr.SetPyData(itemId,
148 :     TreeData( itemId, aRecoElem, aCatalogEntry))
149 :    
150 : efrank 1.9 for kid in aRecoElem.getRawSubElems():
151 : efrank 1.1 self.addRecoElemTree( itemId, kid, aCatalogEntry )
152 :    
153 :     return
154 :    
155 :     #------------------------------------------------------------------
156 :     def onSelectReaction(self,event):
157 :     #------------------------------------------------------------------
158 :     return
159 :    
160 :     pt=self.parent.list_box.GetPosition()
161 :     item =self.parent.list_box.HitTest(pt)
162 :    
163 :     selectedlist=self.parent.list_box.GetSelections()
164 :    
165 :     for count in selectedlist:
166 :     rx = self.parent.list_boxData[count]
167 :    
168 :     return
169 :    
170 :     #------------------------------------------------------------------
171 :     def onSelect(self, treeEvent):
172 :     #------------------------------------------------------------------
173 :     item = treeEvent.GetItem()
174 :     re = self.parent.tree_ctr.GetPyData(item).re
175 :     self.selectedItem=item
176 :    
177 :     self.redrawRecoElemRxList( re )
178 :     return
179 :    
180 :     #------------------------------------------------------------------
181 :     def redrawRecoElemRxList(self, re):
182 :     #------------------------------------------------------------------
183 :     """
184 :     @type re: KahOM.RecoElem
185 :     @rtype: none
186 :     """
187 :     wxBeginBusyCursor()
188 :     self.parent.list_box.Clear()
189 :     offset = 0
190 :     self.parent.list_boxData.clear()
191 : efrank 1.9 for rx in re.getRawReactions():
192 : efrank 1.1 item = rx.asString()
193 :     listnum = self.parent.list_box.Append(item)
194 :     itemNo = self.parent.list_box.GetCount()-1
195 :     # we store the recoElem ptr too in case we have to rm the rx
196 :     self.parent.list_boxData[itemNo] = (rx, offset, re)
197 :     offset += 1
198 :    
199 :     wxEndBusyCursor()
200 :    
201 :     return
202 :    
203 :     #------------------------------------------------------------------
204 :     def onRightListClick( self, event):
205 :     #------------------------------------------------------------------
206 :    
207 :     listBoxObject = event.GetEventObject()
208 :     listBoxObject.PopupMenu(self.recoElemRxListEditMenu, event.GetPosition())
209 :    
210 :     return
211 :    
212 :     #------------------------------------------------------------------
213 :     def setupRecoElemRxListEditMenu(self):
214 :     #------------------------------------------------------------------
215 :     self.recoElemRxListEditMenu.Append( self.recoElemRxListCutId,
216 :     "Cut", "Cut" )
217 :     EVT_MENU(self.parent, self.recoElemRxListCutId, self.recoElemRxListCut)
218 :    
219 :    
220 :     self.recoElemRxListEditMenu.Append( self.recoElemRxListCopyId,
221 :     "Copy","Copy")
222 :     EVT_MENU(self.parent, self.recoElemRxListCopyId,self.recoElemRxListCopy)
223 :     self.recoElemRxListEditMenu.Append( self.recoElemRxListPasteId,
224 :     "Paste", "Paste")
225 :     EVT_MENU(self.parent, self.recoElemRxListPasteId,
226 :     self.recoElemRxListPaste)
227 :    
228 :     self.recoElemRxListEditMenu.Append( self.recoElemPasteFromSelectedRxGridId,
229 :     "Paste From Selected Rx Table",
230 :     "Paste From Selected Rx Table")
231 :     EVT_MENU(self.parent, self.recoElemPasteFromSelectedRxGridId,
232 :     self.recoElemPasteFromSelectedRxGrid)
233 :    
234 :    
235 :     return
236 :    
237 :     #------------------------------------------------------------------
238 :     def rightTreeClick( self, event):
239 :     #------------------------------------------------------------------
240 :     #pt=event.GetPosition()
241 :     #if self.selectedItem != None:
242 :     if 1:
243 :     treeObject = event.GetEventObject()
244 :     treeObject.PopupMenu(self.recoElemEditMenu, event.GetPosition() )
245 :    
246 :     return
247 :    
248 :     #------------------------------------------------------------------
249 :     def setupRecoElemEditMenu(self):
250 :     #------------------------------------------------------------------
251 :     self.recoElemEditMenu.Append( self.recoElemNewKidId,
252 :     "New Sub Element", "New kid arg3" )
253 :     EVT_MENU(self.parent, self.recoElemNewKidId, self.recoElemNewKid)
254 :     #
255 :     self.recoElemEditMenu.Append( self.recoElemCopyREBranchId,
256 :     "Copy Tree Branch", "Copy Tree Branch" )
257 :     EVT_MENU(self.parent, self.recoElemCopyREBranchId, self.recoElemCopyREBranch)
258 :     #
259 :     self.recoElemEditMenu.Append( self.recoElemCutREBranchId,
260 :     "Cut Tree Branch", "Cut Tree Branch" )
261 :     EVT_MENU(self.parent, self.recoElemCutREBranchId, self.recoElemCutREBranch)
262 :     #
263 :     self.recoElemEditMenu.Append( self.recoElemPasteREBranchId,
264 :     "Paste Tree Branch", "Paste Tree Branch" )
265 :     EVT_MENU(self.parent, self.recoElemPasteREBranchId, self.recoElemPasteREBranch)
266 : efrank 1.6
267 :     self.recoElemEditMenu.Append( self.recoElemMergeREBranchId,
268 :     "Merge into Tree Branch",
269 :     "Merge into Tree Branch" )
270 :     EVT_MENU(self.parent, self.recoElemMergeREBranchId, self.recoElemMergeREBranch)
271 : efrank 1.1 #
272 :     # Rx related
273 :     #
274 :    
275 :     #
276 :     self.recoElemEditMenu.AppendSeparator()
277 :     #
278 :    
279 :     self.recoElemEditMenu.Append( self.recoElemPasteRxId,
280 :     "Paste Rx", "Add kid arg3" )
281 :     EVT_MENU(self.parent, self.recoElemPasteRxId, self.recoElemPasteRx)
282 :     #
283 :     self.recoElemEditMenu.Append( self.recoElemPasteFromSelectedRxGridId,
284 :     "Paste From Selected Rx Table",
285 :     "Paste From Selected Rx Table")
286 :     EVT_MENU(self.parent, self.recoElemPasteFromSelectedRxGridId,
287 :     self.recoElemPasteFromSelectedRxGrid)
288 :     #
289 :     self.recoElemEditMenu.AppendSeparator()
290 :     #
291 : efrank 1.5
292 :     self.recoElemEditMenu.Append( self.recoElemAppendFromTextFileId,
293 :     "Append from text file",
294 :     "Append from text file")
295 :     EVT_MENU(self.parent, self.recoElemAppendFromTextFileId,
296 :     self.recoElemAppendFromTextFile)
297 :    
298 : efrank 1.1 self.recoElemEditMenu.Append( self.recoElemWriteToBssId,
299 : efrank 1.5 "Write new version",
300 :     "Write new version")
301 : efrank 1.1 EVT_MENU(self.parent, self.recoElemWriteToBssId,
302 :     self.recoElemWriteToBss)
303 :    
304 :    
305 :     #
306 : efrank 1.2 # Shared editing
307 :    
308 :     self.recoElemEditMenu.AppendSeparator()
309 :     self.recoElemEditMenu.Append( self.recoElemWriteToCbId,
310 :     "Copy to shared clipboard",
311 :     "Copy to shared clipboard")
312 :     EVT_MENU(self.parent, self.recoElemWriteToCbId, self.recoElemWriteToCb)
313 :    
314 :    
315 :    
316 :     #
317 : efrank 1.1 # plug-ins will be added beyond here via extendRecoElemEditMenu.
318 :     #
319 :    
320 :     self.recoElemEditMenu.AppendSeparator()
321 :    
322 :     self.recoElemEditMenu.Append( self.recoElemVizWithCytoScapeId,
323 :     "Visualize in CytoScape",
324 :     "Visualize in CytoScape")
325 :     EVT_MENU(self.parent, self.recoElemVizWithCytoScapeId,
326 :     self.recoElemVizWithCytoScape)
327 :    
328 :     return
329 :    
330 :     #------------------------------------------------------------------
331 : efrank 1.9 def extendRecoElemEditMenu(self, menuText, helpText, theModule):
332 : efrank 1.1 #------------------------------------------------------------------
333 :     """
334 :     Used for plugins. Adds them to the RecoElemEditMenu
335 :    
336 :     @type menuText: string The text to be shown in the menu.
337 :     @type helpText: string The help text for the item.
338 : efrank 1.9 @type theModule: Instance of KahModule
339 : efrank 1.1 """
340 :    
341 : efrank 1.9 # is there already a module with this name? Name must be unique.
342 :     #
343 :    
344 :     mgr = self.parent.getConfigMgr()
345 :    
346 :     try:
347 :     cfg = mgr.getSection( theModule.name() )
348 :     self.parent.error("extendRecoelemEditMenu: Already have a module with name %s. Abort loading new plugin." % theModule.name())
349 :     return
350 :     except KeyError:
351 :     pass
352 :    
353 :     # Make new menu item
354 :     #
355 :    
356 : efrank 1.1 theNewId = wxNewId()
357 : efrank 1.9 self._pluginDict[theNewId] = theModule
358 :    
359 :     # Configure the new module. Don't reread config script...just
360 :     # allows its values to be used.
361 :    
362 : efrank 1.1 try:
363 : efrank 1.9 cfg = mgr.newSection( theModule.name() )
364 :     except ValueError:
365 :     # should never get here....
366 :     self.parent.error( "extendRecoelemEditMenu: program error.")
367 : efrank 1.1 return
368 :    
369 : efrank 1.9 theModule.config( cfg )
370 :     mgr.redoOverrides()
371 :    
372 :     #
373 : efrank 1.1 self.recoElemEditMenu.Append( theNewId, menuText, helpText )
374 :     EVT_MENU(self.parent, theNewId, self.pluginHandler)
375 :    
376 :     return
377 :    
378 :     #------------------------------------------------------------------
379 :     def pluginHandler(self, event):
380 :     #------------------------------------------------------------------
381 :     """
382 :     Dispatches a wxCommandEvent that arose from an EVT_MENU
383 :     registration to the actual plugin.
384 :     """
385 :    
386 :     if (self.selectedItem == None):
387 :     self.parent.error( "Select a RecoElem first" )
388 :     return
389 :    
390 :     # form the arg list to the plugin
391 :    
392 :     treeData = self.parent.tree_ctr.GetPyData( self.selectedItem)
393 :     re = treeData.re
394 :    
395 :     ##
396 :     # find and call the plugin
397 :     #
398 :     # this is a little wonky right now. we'r exposing the execution
399 :     # rules and have the config file hardwired. its a start. don't
400 :     # copy this code.
401 :     ##
402 :    
403 :     theModule = self._pluginDict[ event.GetId() ]
404 : efrank 1.9 mgr = self.parent.getConfigMgr()
405 :     cfg = mgr.getSection( theModule.name() )
406 : efrank 1.1 theModule.process( re, cfg )
407 :     theModule.finish( cfg )
408 :    
409 :     # the plugin may have changed the recoelem, so we have to
410 :     # bring the display up to date. this is really inefficient,
411 :     # but we're going to destroy everything for the recoelem
412 :     # and rebuilt from scratch to make sure we get it right.
413 :    
414 :     id=treeData.itemId
415 :     self.parent.tree_ctr.DeleteChildren( id )
416 :     self.parent.tree_ctr.Delete( id )
417 :     parentId = self.parent.tree_ctr.GetItemParent( id )
418 :    
419 :     self.addRecoElemTree( parentId, re, treeData.ce )
420 :    
421 :     return
422 :    
423 :     #------------------------------------------------------------------
424 :     def updateTreeBranchText(self, sourceRXNum, recoElemName):
425 :     #------------------------------------------------------------------
426 :    
427 :     rxPrevName = self.parent.tree_ctr.GetItemText(self.selectedItem)
428 :     newLabel = "(" + str(sourceRXNum) + "rx" ") " + recoElemName
429 :    
430 :     #sylistic purposes get rid of (0 rx) if it exist
431 :     if newLabel[1] == '0':
432 :     newLabel = newLabel[6:]
433 :    
434 :    
435 :     self.parent.tree_ctr.SetItemText(self.selectedItem, newLabel)
436 :     return
437 :    
438 :     #------------------------------------------------------------------
439 :     def recoElemNewKid(self, event):
440 :     #------------------------------------------------------------------
441 :     if (self.selectedItem == None): return
442 :     treeData = self.parent.tree_ctr.GetPyData( self.selectedItem)
443 :     re = treeData.re
444 :    
445 : efrank 1.9 prompt = "Name of new child for " + re.getName()
446 : efrank 1.1 dlg = wxTextEntryDialog(self.parent, message=prompt, style=wxOK)
447 :    
448 :     if ( dlg.ShowModal() == wxID_OK):
449 :     kidName = dlg.GetValue()
450 :     if ( kidName=="" ): return
451 :     dlg.Destroy()
452 :     else:
453 :     #didn't get a kid name
454 :     dlg.Destroy()
455 :     return
456 :    
457 :     newKid = RecoElem( kidName )
458 : efrank 1.9 re.appendSubElems( newKid )
459 : efrank 1.1 self.addRecoElemTree( self.selectedItem, newKid, treeData.ce)
460 :    
461 :     return
462 :    
463 :     #------------------------------------------------------------------
464 :     def recoElemCopyREBranch(self, event):
465 :     #------------------------------------------------------------------
466 :     if (self.selectedItem == None): return
467 :     self.cutOrCopiedRE = self.selectedItem
468 :     return
469 :    
470 :     #------------------------------------------------------------------
471 :     def recoElemCutREBranch(self, event):
472 :     #------------------------------------------------------------------
473 :     if (self.selectedItem == None): return
474 :    
475 :     # first, modify the actual recoElem tree.
476 :     parentItem = self.parent.tree_ctr.GetItemParent(self.selectedItem)
477 :     parentRe = self.parent.tree_ctr.GetPyData( parentItem ).re
478 :     selectedRe = self.parent.tree_ctr.GetPyData(self.selectedItem ).re
479 :    
480 :     # if we have a parent, i.e., if we are not the top of the tree,
481 :     # then remove ourself from our parents kid-list
482 :    
483 :     if (parentRe != None):
484 : efrank 1.9 parentRe.getRawSubElems().remove( selectedRe )
485 :     parentRe.setDirty()
486 : efrank 1.1
487 :     # this no longer points anyplace valid
488 :     self.cutOrCopiedRE = None
489 :     self.selectedItem == None
490 :    
491 :     # now modify the display
492 :     self.parent.tree_ctr.Delete(self.selectedItem)
493 :     return
494 :    
495 :     #------------------------------------------------------------------
496 :     def recoElemPasteREBranch(self, event):
497 :     #------------------------------------------------------------------
498 :     if (self.selectedItem == None):
499 :     self.parent.error( "Select a tree branch first as target.")
500 :     return
501 :    
502 :     if (self.cutOrCopiedRE == None):
503 :     self.parent.error( "Select and copy a tree branch first.")
504 :     return
505 :    
506 :     reSource = self.parent.tree_ctr.GetPyData( self.cutOrCopiedRE ).re
507 :     reTarget = self.parent.tree_ctr.GetPyData( self.selectedItem).re
508 :     ceTarget = self.parent.tree_ctr.GetPyData( self.selectedItem).ce
509 :    
510 :     reSourceCopy = copy.deepcopy( reSource )
511 : efrank 1.9 reTarget.appendSubElems( reSourceCopy )
512 : efrank 1.1
513 :     self.addRecoElemTree( self.selectedItem, reSourceCopy, ceTarget )
514 :    
515 :     return
516 :    
517 :     #------------------------------------------------------------------
518 : efrank 1.6 def recoElemMergeREBranch(self, event):
519 :     #------------------------------------------------------------------
520 :     if (self.selectedItem == None):
521 :     self.parent.error( "Select a tree branch first as target.")
522 :     return
523 :    
524 :     if (self.cutOrCopiedRE == None):
525 :     self.parent.error( "Select and copy a tree branch first.")
526 :     return
527 :    
528 :     reSource = self.parent.tree_ctr.GetPyData( self.cutOrCopiedRE ).re
529 :     reTarget = self.parent.tree_ctr.GetPyData( self.selectedItem).re
530 :     ceTarget = self.parent.tree_ctr.GetPyData( self.selectedItem).ce
531 :    
532 : efrank 1.9 for k in reSource.getRawSubElems():
533 : efrank 1.6 kCopy = copy.deepcopy( k )
534 : efrank 1.9 reTarget.appendSubElems( kCopy )
535 : efrank 1.6 self.addRecoElemTree( self.selectedItem, kCopy, ceTarget )
536 :    
537 :    
538 :     # unlike pasting the whole branch in, we must drain any
539 :     # reactions out of the cut/copied branch
540 :    
541 : efrank 1.9 for rx in reSource.getRawReactions():
542 :     reTarget.appendReactions( copy.deepcopy(rx ) )
543 : efrank 1.6
544 : efrank 1.9 rxListNum = reTarget.nReactions()
545 :     self.updateTreeBranchText(rxListNum, reTarget.getName())
546 : efrank 1.6 self.redrawRecoElemRxList(reTarget)
547 :    
548 :     return
549 :    
550 :     #------------------------------------------------------------------
551 : efrank 1.1 def recoElemPasteRx(self, event):
552 :     #------------------------------------------------------------------
553 :    
554 :     if ( None == self.selectedItem ): return
555 :     if ( None == self.cutOrCopiedRx ): return
556 :    
557 :    
558 :     re = self.parent.tree_ctr.GetPyData( self.selectedItem).re
559 :    
560 : efrank 1.9 re.appendReactions( self.cutOrCopiedRx )
561 : efrank 1.1
562 : efrank 1.9 rxListNum = re.nReactions()
563 : efrank 1.1
564 : efrank 1.9 self.updateTreeBranchText(rxListNum, re.getName())
565 : efrank 1.1 self.redrawRecoElemRxList(re)
566 :    
567 :     return
568 :    
569 :    
570 :     #------------------------------------------------------------------
571 :     def recoElemPasteFromSelectedRxGrid(self, event):
572 :     #------------------------------------------------------------------
573 :     if (self.selectedItem == None): return
574 :    
575 :     re = self.parent.tree_ctr.GetPyData( self.selectedItem).re
576 :    
577 :     rxList = self.parent.rx.getSelectedRx()
578 : efrank 1.9 rxListNum = re.nReactions()
579 : efrank 1.1
580 :     for rx in rxList:
581 : efrank 1.9 re.appendReactions(rx)
582 : efrank 1.1
583 : efrank 1.9 self.updateTreeBranchText(rxListNum, re.getName())
584 : efrank 1.1 self.redrawRecoElemRxList(re)
585 :    
586 :     return
587 :    
588 :     #------------------------------------------------------------------
589 :     def recoElemVizWithCytoScape(self, event):
590 :     #------------------------------------------------------------------
591 :     if (self.selectedItem == None): return
592 :     re = self.parent.tree_ctr.GetPyData( self.selectedItem).re
593 :    
594 :     # "not connectable" is for things like ATP that happen so much
595 :     # that you can't just draw one node or you get a mess. But cytoscape
596 :     # SIF files uses "same name, same node." So we're going to bump up
597 :     # a counter every time we hit a not-connectible and tack it on the
598 :     # end of the name.
599 :     #
600 :     nNotConnect = 0
601 :    
602 :     #
603 :     # KEGG provides isConnected as an attribute of a reactant. We're
604 :     # going to try something here and ignore the isConnected int he
605 :     # Reactant object and make our decions based upon the number of
606 :     # edges coming into a reactant node in the full graph of the
607 :     # system
608 :    
609 :     rxGraph = re.getGraph()
610 :     thresh = 5
611 :    
612 :     allRxList = []
613 :     re.gatherReactions( allRxList )
614 :    
615 :     output = mktemp(suffix=".sif")
616 :     nodeAttribs = mktemp(suffix=".node")
617 :     out_file = open(output, "w") # Create temporary
618 :     nodeAttrib_file = open(nodeAttribs, "w") # Create temporary
619 :     print output, nodeAttribs
620 :    
621 :     nodeAttrib_file.write("NodeType\n")
622 :    
623 :     nRx = 0
624 :     for r in allRxList:
625 :     nRx += 1
626 :     rxKind="enzymatic"
627 : efrank 1.9 if (r.nEnzymeNames() > 0):
628 :     enzName= r.getEnzymeNames(0)
629 : efrank 1.1 if (enzName == "spontaneous"): rxKind = "spontaneous"
630 :     enzName.replace(' ', '_')
631 :     else:
632 :     enzName= ""
633 :     rxKind="spontaneous"
634 :     rxName = "Rx%d-%s" % ( nRx, enzName)
635 :     nodeAttrib_file.write("%s = %s\n" % ( rxName, rxKind) )
636 : efrank 1.9 if (r.getDirection() == "forward"):
637 : efrank 1.7 #edgeName = "ci" # compound to irreversible rx
638 :     edgeName = "cr" # turn offf for now
639 : efrank 1.1 else:
640 :     edgeName = "cr" # compound to reversible rx
641 : efrank 1.9 for i in r.getRawInputs():
642 :     if (not i.getIsConnected() or (rxGraph.all_degree( i.getName()) > thresh) ):
643 :     theName=i.getName().replace(' ','_')+ ":%d" % (nNotConnect)
644 : efrank 1.1 nNotConnect += 1
645 :     else:
646 : efrank 1.9 theName=i.getName().replace(' ','_')
647 : efrank 1.1 out_file.write( "%s %s %s\n" % (theName, edgeName, rxName) )
648 :     nodeAttrib_file.write("%s = reactant\n" % (theName) )
649 :    
650 : efrank 1.9 for o in r.getRawOutputs():
651 :     if (not o.getIsConnected() or (rxGraph.all_degree( o.getName())>thresh) ):
652 :     theName=o.getName().replace(' ','_')+ ":%d" % (nNotConnect)
653 : efrank 1.1 nNotConnect += 1
654 :     else:
655 : efrank 1.9 theName=o.getName().replace(' ','_')
656 : efrank 1.1 out_file.write( "%s rc %s\n" % (rxName, theName))
657 :     nodeAttrib_file.write("%s = reactant\n" % (theName) )
658 :    
659 :     out_file.close()
660 :     cytoInstallDir = os.getenv( 'CYTOSCAPE_HOME' )
661 :     cytoCmd = os.getenv( 'CYTOSCAPE_COMMAND' )
662 :    
663 :     #cmd = "(cd $CYTOSCAPE_HOME; java -jar cytoscape.jar -i %s -n %s&)" % (output, nodeAttribs)
664 :     cmd = "(cd %s; %s -i %s -n %s&)" % (cytoInstallDir, cytoCmd, output, nodeAttribs)
665 :     print cytoInstallDir
666 :     print cytoCmd
667 :     print cmd
668 :    
669 :     os.system( cmd )
670 :    
671 :     #os.unlink( output )
672 :    
673 :     return
674 :    
675 :     #------------------------------------------------------------------
676 : efrank 1.5 def recoElemAppendFromTextFile(self, event):
677 :     #------------------------------------------------------------------
678 :     """
679 :     Read contents of a text file, convert to recoElem and append
680 :     as child to the selected item.
681 :     """
682 :    
683 :     if (self.selectedItem == None):
684 :     self.parent.error( "Select an item first.")
685 :     return
686 :    
687 :     prompt = "Choose a file"
688 :     dlg = wxFileDialog(self.parent, message=prompt, style=wxOPEN)
689 :     if ( dlg.ShowModal() == wxID_OK):
690 :     path = dlg.GetPath()
691 :     print "using path ", path
692 :     dlg.Destroy()
693 :     else:
694 :     #didn't get a kid name
695 :     dlg.Destroy()
696 :     return
697 :    
698 :     reTemp = RecoElem("temp")
699 :     try:
700 :     modelFromText(path, reTemp, verbose=1)
701 :     except Exception, e:
702 :     print e
703 :    
704 :     print "snarfed:"
705 :     reTemp.dump()
706 :    
707 :     treeData = self.parent.tree_ctr.GetPyData( self.selectedItem)
708 :     re = treeData.re
709 : efrank 1.9 for k in reTemp.getRawSubElems():
710 : efrank 1.5 # we don't deepcopy here because we've taken ownership
711 : efrank 1.9 re.appendSubElems( k )
712 : efrank 1.5 self.addRecoElemTree( self.selectedItem, k, treeData.ce)
713 :    
714 : efrank 1.9 for rx in reTemp.getReactions():
715 :     re.appendReactions( rx )
716 : efrank 1.5
717 : efrank 1.9 rxListNum = re.nReactions()
718 :     self.updateTreeBranchText(rxListNum, re.getName())
719 : efrank 1.5 self.redrawRecoElemRxList(re)
720 :    
721 :     return
722 :    
723 :     #------------------------------------------------------------------
724 : efrank 1.1 def recoElemWriteToBss(self, event):
725 :     #------------------------------------------------------------------
726 :     # there are so many problems here it's not funny. We _will_
727 :     # corrupt the DB with this but have to start somewhere. Example:
728 :     # How do we know we've not been passed a REcoElem that is
729 :     # owned by a higher entity? The system needs to be extended to
730 :     # understand the ownership model and catalog arch.
731 :    
732 :     if (self.selectedItem == None): return
733 : efrank 1.4
734 : efrank 1.1 re = self.parent.tree_ctr.GetPyData( self.selectedItem).re
735 :     catalogEntry = self.parent.tree_ctr.GetPyData( self.selectedItem).ce
736 :    
737 : efrank 1.4 if (None == catalogEntry):
738 :     # clipboard item. can't write that.
739 :     self.parent.error( "No catalog entry. Copy this item into a loaded model before writing")
740 :     return
741 :    
742 :     wxBeginBusyCursor()
743 : efrank 1.1 foundryItemKey = catalogEntry.write( re )
744 :    
745 :     if (foundryItemKey == None ):
746 :     self.parent.error( "Write failed.")
747 :     else:
748 :     self.parent.error( "Write succeeded" )
749 : efrank 1.4
750 :     wxEndBusyCursor()
751 : efrank 1.1 return
752 :    
753 : efrank 1.2 #------------------------------------------------------------------
754 :     def recoElemWriteToCb(self, event):
755 :     #------------------------------------------------------------------
756 :     """ Copy the current recoElem to the clipboard """
757 :    
758 : efrank 1.4 if not self.parent.cat.cbStarted:
759 : efrank 1.2 self.parent.error( "Shared editing not started.")
760 :     return
761 :    
762 :     if (self.selectedItem == None):
763 :     self.parent.error( "Make a selection first.")
764 :     return
765 :    
766 :     re0 = self.parent.tree_ctr.GetPyData( self.selectedItem).re
767 : efrank 1.4 re = copy.deepcopy(re0) #$$.deepCopy()
768 :    
769 : efrank 1.9 print "copying to clipboard ", re0.getName(), re.getName()
770 : efrank 1.4 intId = putOnClipboard( re )
771 : efrank 1.2 print "deep copied to clipboard:"
772 : efrank 1.4
773 : efrank 1.2
774 :     # tell everyone about it
775 :    
776 : efrank 1.4 descriptor = getCbDescriptor()
777 :     print "descriptor is ", descriptor
778 :    
779 :     self.parent.meAGMgr.cbChanged(descriptor)
780 : efrank 1.2
781 :     return
782 :    
783 : efrank 1.4 #------------------------------------------------------------------
784 :     def addCbItem(self, re):
785 :     #------------------------------------------------------------------
786 :     """
787 :     Add the passed clipboard item to the Navigator.
788 :    
789 :     @type re: FaST.RecoElem
790 :     @rtype: None
791 :    
792 :     Note- clipboard items haven't a catalogEntry associated with
793 :     them. They did not come from a factory or, better, they are
794 :     disowned?
795 :     """
796 :    
797 :     # add it to the tree. Set CatalogEntry to None...a magic value
798 :     # sniffed out elsewhere. Ick.
799 :    
800 :     self.addRecoElemTree( self.parent.rootId, re, None)
801 :    
802 :     return
803 : efrank 1.2
804 : efrank 1.1 #------------------------------------------------------------------
805 :     def recoElemRxListCut(self, event):
806 :     #------------------------------------------------------------------
807 :     # this has gotta be wrong...what were we thinking? It's ok for a
808 :     # single selection.
809 :    
810 :     re = None
811 :     for count in self.parent.list_box.GetSelections():
812 :     (rx,offset, re) = self.parent.list_boxData[count]
813 : efrank 1.9 del( re.getRawReactions()[offset:offset+1] )
814 :     re.setDirty()
815 : efrank 1.1 self.redrawRecoElemRxList(re)
816 :     self.cutOrCopiedRx = rx
817 :    
818 :     if (re == None):
819 :     return
820 :     else:
821 : efrank 1.9 rxListNum = re.nReactions()
822 :     self.updateTreeBranchText(rxListNum, re.getName())
823 : efrank 1.1
824 :     return
825 :    
826 :     #------------------------------------------------------------------
827 :     def recoElemRxListCopy(self, event):
828 :     #------------------------------------------------------------------
829 :     for count in self.parent.list_box.GetSelections():
830 :     (rx,offset,re) = self.parent.list_boxData[count]
831 :     self.cutOrCopiedRx = rx
832 :    
833 :     return
834 :    
835 :     #------------------------------------------------------------------
836 :     def recoElemRxListPaste(self, event):
837 :     #------------------------------------------------------------------
838 :     # we're pasting into a list_box. This list box is being
839 :     # shown *because* a recoElem has been selected. that means
840 :     # _it_ is the recoElem to modify.
841 :    
842 :     #since the listbox is only allowing single select.
843 :     #we won't count how big the selection is
844 :    
845 :     if (self.selectedItem == None): return
846 :     re = self.parent.tree_ctr.GetPyData( self.selectedItem).re
847 : efrank 1.9 re.appendReactions( self.cutOrCopiedRx )
848 : efrank 1.1
849 : efrank 1.9 rxListNum = re.nReactions()
850 :     self.updateTreeBranchText(rxListNum, re.getName())
851 : efrank 1.1 self.redrawRecoElemRxList(re)
852 :    
853 :     return
854 : efrank 1.2
855 :     #------------------------------------------------------------------
856 :     def startAGClipboard(self):
857 :     #------------------------------------------------------------------
858 : efrank 1.4 raise NotImplementedError
859 :    
860 :    
861 :     if (self.cbStarted): return
862 :    
863 :    
864 :     (host, portnum) = ("porta-video.mcs.anl.gov", 303030)
865 :    
866 : efrank 1.2 self.cbStarted = 1
867 :     self.clipboard = {}
868 :     self.nCb = 0 #used to make unique id for items on cb
869 : efrank 1.4
870 : efrank 1.2 return
871 :    
872 :     #------------------------------------------------------------------
873 :     def stopAGClipboard(self):
874 :     #------------------------------------------------------------------
875 : efrank 1.4 raise NotImplementedError
876 : efrank 1.2

MCS Webmaster
ViewVC Help
Powered by ViewVC 1.0.3