apply( self.doitWrapper,(pack, page,),{})
CmdName1 =()
if len(CmdName2) != 0:
if CmdName2[0] == 'Login Page':
page = "Login Page"
pack = "Vision"
apply( self.doitWrapper,(pack, page,),{})
if CmdName2[0] == 'Archive Page':
page = "Archive Page"
pack = "Vision"
apply( self.doitWrapper,(pack, page,),{})
CmdName2 =()
mailingListsCommandGUI = CommandGUI()
mailingListsCommandGUI.addMenuCommand('menuRoot', 'Help',
'Mailing List')
class orderModelsCommand(Command):
"""Opens 'http://models.scripps.edu/?source=Pmv' with webbrowser
\nPackage : Pmv
\nModule : helpCommands
\nClass : orderModelsCommand
\nCommand : orderModelsCommand
\nSynopsis:\n
None <--- orderModelsCommand()
"""
def guiCallback(self, evt=None):
webbrowser.open_new('http://models.scripps.edu/?source=Pmv')
from AutoDockTools.autoanalyzeCommands import menuText,\
checkHasInitializedDockings, hideShowHide, toggleShowHide,\
checkNameStr, ADChooseMacro, ADReadMacro, ADEPDBMol,\
ADSeeSpots, ADShowBindingSite, ADMakeAllGrids, ADGetOutput,\
ADGetAGrid, ADSelectDLG, ADDeleteDLG, ADGetDirDLGs, ADGetDLG,\
ClusterDockingChooser, ModelDockingChooser, ADDrawHistogram,\
ADMacroLigandChart, ADDockingChooser, ReadAutoDockStates,\
StatesPlayerWidget, ShowAutoDockStatesBaseCmd, ShowAutoDockStates,\
ShowAutoDockStatesByEnergy, ShowAutoDockPopulation,\
ShowAutoDockStatesHISTOGRAM, ShowAutoDockClusteringStates,\
ReadAutoDockClusteringStates, WriteAutoDockStates,\
WriteAutoDockClustering, MakeAutoDockCLUSTERING,\
MakeAutoDockSubsetCLUSTERING
ADChooseMacroGUI=CommandGUI()
ADChooseMacroGUI.addMenuCommand('AutoTools3Bar', menuText['AnalyzeMB'],
menuText['chooseMacro'], cascadeName = menuText['MoleculesMB'])
ADReadMacroGUI=CommandGUI()
ADReadMacroGUI.addMenuCommand('AutoTools3Bar', menuText['AnalyzeMB'],
menuText['readMacro'], cascadeName = menuText['MoleculesMB'])
ADEPDBMolGUI=CommandGUI()
ADEPDBMolGUI.addMenuCommand('AutoTools3Bar', menuText['AnalyzeMB'],
menuText['epdbMol'], cascadeName = menuText['GridsMB'])
ADSeeSpotsGUI=CommandGUI()
except IndexError:
warnings.warn("IndexError for %s" %textcolor)
molecules, nodeSets = self.vf.getNodesByMolecule(nodes)
for mol, nodes in map(None, molecules, nodeSets):
nodes.sort()
drawLabels(mol, nodes, materials, function , lambdaFunc, font,
location, only, negate, format)
#labelByPropertiesGuiDescr = {'widgetType':'Menu', 'menuBarName':'menuRoot',
# 'menuButtonName':'Label', 'menuEntryLabel':'by Properties'}
LabelByPropertiesGUI = CommandGUI()
LabelByPropertiesGUI.addMenuCommand('menuRoot', 'Display', 'by Properties',
cascadeName= 'Label')
LabelByExpressionGUI = CommandGUI()
LabelByExpressionGUI.addMenuCommand('menuRoot', 'Display', 'by Expression',
cascadeName= 'Label')
commandList = [
{'name':'labelByProperty','cmd': LabelByProperties(), 'gui': LabelByPropertiesGUI},
{'name':'labelByExpression','cmd': LabelByExpression(), 'gui': LabelByExpressionGUI}
]
def initModule(viewer):
for dict in commandList:
file to edit from a file browser.
"""
from ViewerFramework.VFCommand import CommandGUI
from AutoDockTools.autogpfCommands import GpfSetGpo,\
GpfMacroInit, GpfLoadDefaults, GpfEditor, GpfInitLigand, GpfWriter,\
SelectCenter, SetUpCovalentMap4, SetBoxParameters, SetOtherOptions,\
Gpf4ParameterFileSelector, Gpf4ParameterFileEditor, GpfMergeNonPolarHs,\
Gpf4SetMapTypes, Gpf4SetAtomTypes, Gpf4MacroInit, Gpf4MacroReader,\
Gpf4MacroChooser, Gpf4InitLigand, Gpf4LigandChooser, Gpf4LigReader,\
Gpf4FlexResChooser, Gpf4FlexResReader, Gpf4Writer, menuText, gridOpts,\
messages, checkHasGpo, box, cenSph, cenCross
GpfLoadDefaultsGUI = CommandGUI()
GpfLoadDefaultsGUI.addMenuCommand('AutoTools4Bar', menuText['AutoGpfMB'],\
menuText['ReadGpfMB'])
GpfEditorGUI = CommandGUI()
GpfEditorGUI.addMenuCommand('AutoTools4Bar', menuText['AutoGpfMB'],\
menuText['EditGpfMB'])
GpfWriterGUI = CommandGUI()
GpfWriterGUI.addMenuCommand('AutoTools4Bar', menuText['AutoGpfMB'], \
menuText['WriteGpfMB'], cascadeName=menuText['WriteMB'])
SetUpCovalentMap4GUI = CommandGUI()
SetUpCovalentMap4GUI.addMenuCommand('AutoTools4Bar', menuText['AutoGpfMB'], \
menuText['SetUpCovalentMap4'], cascadeName = menuText['SetMapTypesMB'])
"""
from ViewerFramework.VFCommand import CommandGUI
from AutoDockTools.autostartCommands import ADKill, ADProcessManager,\
AutoStarter, AutoGridStarter, AutoDockStarter, AddAutoDockHost, removePCs,\
entropiaPresent, menuText
if entropiaPresent:
from Entropia.EntropiaDef import entropia_job_dir
from Entropia.EntropiaUI import EntropiaUI
from Entropia.EntropiaEx import EntropiaError
import ftplib
ADProcessManagerGUI=CommandGUI()
ADProcessManagerGUI.addMenuCommand('AutoTools4Bar', menuText['StartMB'], menuText['processManagerMB'])
AutoGridStarterGUI=CommandGUI()
AutoGridStarterGUI.addMenuCommand('AutoTools4Bar', menuText['StartMB'], menuText['startGridMB'])
AutoDockStarterGUI=CommandGUI()
AutoDockStarterGUI.addMenuCommand('AutoTools4Bar', menuText['StartMB'], menuText['startDockMB'])
AddAutoDockHostGUI=CommandGUI()
AddAutoDockHostGUI.addMenuCommand('AutoTools4Bar', menuText['StartMB'], menuText['editHostsMB'])
commandList = [
{'name':'AD4start_autogrid','cmd':AutoGridStarter(),'gui':AutoGridStarterGUI},
#print 'acceptorList=', acceptorList
return self.doitWrapper(node,
paramDict,
reset=self.resetVar.get(),
topCommand=0)
BuildStrutsBondsGUICommandGuiDescr = {
'widgetType': 'Menu',
'menuBarName': 'menuRoot',
'menuButtonName': 'Struts Bonds',
'menuEntryLabel': 'Set Params + Build',
}
# 'menuCascadeName':'Build'}
BuildStrutsBondsGUICommandGUI = CommandGUI()
BuildStrutsBondsGUICommandGUI.addMenuCommand(
'menuRoot',
'Struts Bonds',
'Set Parms + Build',
) # cascadeName = 'Build')
class BuildStrutsBonds(MVCommand):
"""This command finds hydrogen donor atoms within 2.4*percentCutoff angstrom distance of hydrogen acceptor atoms. It builds and returns a dictionary atDict whose keys are hydrogen atoms (or hydrogenbond donor atoms if there are no hydrogens) and whose values are potential h-bond acceptors and distances to these atoms, respectively
\nPackage : Pmv
\nModule : StrutsCommands
\nClass : BuildStrutsBonds
\nCommand : buildStruts
\nSynopsis:\n
atDict <- buildStruts(group, paramDict, **kw)
## sys.stdout = sys.__stdout__
## # Save the pyShell stdin and redirect it to the main Python
## # interpreter only works if the main interpreter has been
## # started in a interactive mode.
## self.vf.pyShellstdin = sys.stdin
## sys.stdin = sys.__stdin__
## # Save the pyShell stderr and redirect it to the main Python
## # interpreter only works if the main interpreter has been
## # started in a interactive mode.
## self.vf.pyShellstderr = sys.stderr
## sys.stderr = sys.__stderr__
# HideGUI command GUI.
HideGUI = CommandGUI()
HideGUI.addMenuCommand('menuRoot',
'File',
'Hide VF GUI...',
cascadeName='Preferences')
class ShowGUICommand(Command):
"""Allow to show the ViewerFrameworkGUI at any time
\nPackage : Pmv
\nModule : customizeVFGUICommands
\nClass : ShowGUICommand
\nCommand : ShowGUI
\nSynopsis:\n
None <- ShowGUI(**kw)
"""
import Tkinter
from ViewerFramework.VFCommand import CommandGUI
from AutoDockTools.autotorsCommands import rootSph, markSph,\
menuText, AtorsMoleculeChooser, MAXTORS, AdtSetMode,\
AtorsReader, Ators4MoleculeChooser, Ators4Reader, AtorsRefWriter, \
RigidMolecule, RigidMolecule4, AUTOTORSWriter, AUTOTORS4Writer, AUTOTORS4RandomWriter,\
MarkRoot, SelectRoot, SetTorsionNumberGUICommand, SetTorsionNumber, \
AutoRoot, SetRotatableBonds, DefiningRotatableBonds, SetBondRotatableFlag,\
CheckAromatic, StopCheckAromatic, SetCarbonNames, ChangeAromaticCutOff, \
TogglerootSphere, AutoAutoTors, StopAutoTors, AtorsInit, AtorsInitMol, \
ProcessCharges, ProcessBonds, rootSph, markSph, check_autotors_geoms,\
MAXTORS, menuText, warningText, checkMolCharges,\
autoMergeNPHS, set_autoMergeNPHS
Ators41MoleculeChooserGUI=CommandGUI()
Ators41MoleculeChooserGUI.addMenuCommand('AutoTools41Bar', menuText['AutoTorsMB'], menuText['Choose Molecule4'], cascadeName = menuText['Input Molecule'])
Ators41ReaderGUI = CommandGUI()
Ators41ReaderGUI.addMenuCommand('AutoTools41Bar', menuText['AutoTorsMB'], menuText['Read Molecule4'], cascadeName = menuText['Input Molecule'])
AtorsRefWriterGUI = CommandGUI()
AtorsRefWriterGUI.addMenuCommand('AutoTools41Bar', menuText['AutoTorsMB'], menuText['Ref Molecule'], cascadeName = menuText['Input Molecule'])
RigidMolecule41GUI = CommandGUI()
RigidMolecule41GUI.addMenuCommand('AutoTools41Bar', menuText['AutoTorsMB'], menuText['Rigid Molecule4'], cascadeName = menuText['Input Molecule'])
i = 0
for f in faces:
for n in range(ntr):
if (n/2)*2 == n:
new_faces[i] = [f[n], f[n+1], f[n+2]]
else:
new_faces[i] = [f[n+2], f[n+1], f[n]]
i = i + 1
return new_faces
def dismiss_cb(self):
"""Withdraws the GUI."""
self.cmdForms['sl'].withdraw()
self.isDisplayed=0
SLGUI = CommandGUI()
SLGUI.addMenuCommand('menuRoot', 'SL','Operate objects', index=1)
class SaveBsptCommand(MVCommand):
"""Command to save a Bspt set in a file."""
def __init__(self):
MVCommand.__init__(self)
self.isDisplayed=0
#self.sl = SLGeom()
def checkDependencies(self):
try:
from SpatialLogic import geometrylib
except:
print "WARNING: Spatial Logic module not found"
}
Specs.define_field(specEntry)
else: return None
if not (Specs.DefFieldsDict.has_key('x') and
Specs.DefFieldsDict.has_key('y') and
Specs.DefFieldsDict.has_key('z')):
msg = "specs for atom coordinates (x,y,z) are missing"
self.warningMsg(msg)
return None
return Specs
genPDBReaderGuiDescr = {'widgetType':'menuRoot', 'menuBarName':'File',
'menuButtonName':'Read PDB with Gen Parser ...',
'index':0}
GenPDBReaderGUI = CommandGUI()
GenPDBReaderGUI.addMenuCommand('menuRoot', 'File',
'Read PDB with Gen Parser ...',index=0)
FieldNames = ('serial', 'name', 'altLoc', 'resName', 'chainID',
'resSeq', 'iCode', 'x', 'y', 'z', 'occupancy',
'tempFactor', 'segID', 'element', 'charge', 'other')
variableTypes = ('int', 'character', 'float', 'alphabetic', 'string')
specEntries = ('field_name', 'var_type', 'from', 'to', 'index')
class DefinePdbSpecifications(MVCommand):
""" class to define some pdb specifications in a dictionary and save them
in a file """
file to edit from a file browser.
"""
from ViewerFramework.VFCommand import CommandGUI
from AutoDockTools.autogpfCommands import GpfSetGpo,\
GpfLoadDefaults, GpfMacroInit, CheckMacroAtomTypes,\
GpfMacroReader, GpfMacroChooser, GpfAddSol, GpfInitLigand,\
GpfLigandChooser, GpfLigReader, GpfEditor, GpfWriter,\
SelectCenter, SetMapTypes, SetUpCovalentMap,\
DefineNewAtomParms, SetBoxParameters, SetOtherOptions,\
GpfMergeNonPolarHs, menuText, gridOpts,\
messages, checkHasGpo, box, cenSph, cenCross, autodockElementDict,\
setAutoDockElements, getSideLengths, checkFile
GpfLoadDefaultsGUI = CommandGUI()
GpfLoadDefaultsGUI.addMenuCommand('AutoTools3Bar', menuText['AutoGpfMB'],\
menuText['ReadGpfMB'])
GpfMacroReaderGUI = CommandGUI()
GpfMacroReaderGUI.addMenuCommand('AutoTools3Bar', menuText['AutoGpfMB'],\
menuText['ReadMacro'], cascadeName = menuText['MacromoleculeMB'])
GpfMacroChooserGUI = CommandGUI()
GpfMacroChooserGUI.addMenuCommand('AutoTools3Bar',
menuText['AutoGpfMB'],
menuText['ChooseMacro'],
cascadeName=menuText['MacromoleculeMB'])
GpfAddSolGUI = CommandGUI()
GpfAddSolGUI.addMenuCommand('AutoTools3Bar',
executable = sys.executable
if os.name == 'nt':
executable = executable.replace("\\", """\\\\""")
cmd = executable
cmd += ' -c "import time,os;time.sleep(1);os.system(\''
script = self.vf.help_about.path_data.split(
'script : ')[1].split('\n')[0]
if os.name == 'nt':
script = script.replace("\\", """\\\\""")
script = r'\"' + script + r'\"'
cmd += executable + " " + script + "')\""
if os.name == 'nt':
#cmd = cmd.replace("\\","""\\\\""")
cmd = 'start ' + cmd.encode()
else:
cmd += ' &'
subprocess.Popen(cmd, shell=True)
os._exit(0)
UpdateGUI = CommandGUI()
UpdateGUI.addMenuCommand('menuRoot', 'Help', 'Update', separatorAbove=1)
commandList = [{'name': 'update', 'cmd': Update(), 'gui': UpdateGUI}]
def initModule(viewer):
for _dict in commandList:
viewer.addCommand(_dict['cmd'], _dict['name'], _dict['gui'])
'variable': self.levelVar,
'value': level,
'justify': 'left',
'activebackground': self.levelColors[level],
'selectcolor': self.levelColors[level],
'command': self.setLevel_cb
},
'gridcfg': {
'sticky': 'we'
}
})
ifd.append({
'name': 'dismiss',
'widgetType': Tkinter.Button,
'defaultValue': 1,
'wcfg': {
'text': 'Dismiss',
'command': self.Close_cb
},
'gridcfg': {
'sticky': 'we'
}
})
self.form = self.vf.getUserInput(self.ifd, modal=0, blocking=0)
self.form.root.protocol('WM_DELETE_WINDOW', self.Close_cb)
MVSetSelectionLevelGUI = CommandGUI()
MVSetSelectionLevelGUI.addMenuCommand('menuRoot', 'Select',
'Set Selection Level')
* The results of the previous steps are written to a file. The user selects a filename via a filebrowser. By convention, the file should have a .dpf extension. If no macromolecule has been selected, it is not possible to write a grid parameter file and the user gets a warning message to that effect. Likewise, the types of the maps to be calculated must be set before the grid parameter file is written and a warning message to this effect appears if the types have not been set.
(A checkbutton, "DONE", allows the user to withdraw the autoTools menuBar)
"""
from ViewerFramework.VFCommand import CommandGUI
from AutoDockTools.autodpfCommands import DpfSetDpo, DpfLoadDefaults,\
Dpf4MacroSelector, Dpf4FlexResSelector, Dpf4MacroChooser,\
Dpf4InitLigand, Dpf4LigandChooser, Dpf4LigPDBQReader,\
DpfEditor, Dpf4SAWriter, Dpf4GAWriter, Dpf4LSWriter,\
Dpf4GALSWriter, Dpf4ClusterWriter, SimAnneal, GA,\
LS, SetDockingRunParms, SetAutoDock4Parameters, StopAutoDpf, menuText,\
checkHasDpo, sortKeyList, setDpoFields
DpfLoadDefaultsGUI = CommandGUI()
DpfLoadDefaultsGUI.addMenuCommand('AutoTools4Bar', menuText['AutoDpfMB'], menuText['ReadDpfMB'])
Dpf4MacroSelectorGUI=CommandGUI()
Dpf4MacroSelectorGUI.addMenuCommand('AutoTools4Bar', menuText['AutoDpfMB'],\
menuText['ReadMacro4'], cascadeName = menuText['MacromoleculeMB'])
Dpf4FlexResSelectorGUI=CommandGUI()
Dpf4FlexResSelectorGUI.addMenuCommand('AutoTools4Bar', menuText['AutoDpfMB'],\
menuText['ReadFlexRes4'], cascadeName = menuText['MacromoleculeMB'])
Dpf4MacroChooserGUI=CommandGUI()
Dpf4MacroChooserGUI.addMenuCommand('AutoTools4Bar', menuText['AutoDpfMB'],\
## def guiCallback(self,**kw):
## folderPath = dirChoose(self.vf.GUI.ROOT)
## if folderPath:
## print folderPath,type(folderPath)
## ## get all the *.vu file from folderPath,
## ## create filelist
## from glob import glob
## filelist = glob(str(folderPath)+'/*.vu')
## if filelist:
## if self.vf.userpref['expandNodeLogString']['value'] == 0:
## self.nodeLogString = "self.getSelection()"
## apply(self.doitWrapper, (self.vf.getSelection(),filelist),kw)
loadVectGUI = CommandGUI()
loadVectGUI.addMenuCommand('menuRoot', 'VectField', 'loadVect')
####### VU Field ###################
class loadVUFile(MVCommand):
""" Command to a load a VU file to display"""
def __init__(self):
MVCommand.__init__(self)
self.fileTypes =[('VU file',"*.vu")]
self.fileBrowserTitle = "Read VU File"
self.lastDir = "."
def onAddCmdToViewer(self):
if not self.vf.commands.has_key('loadVect'):
command=self.destroy)
b.pack(side='left')
notebook.setnaturalsize()
else:
self.master.deiconify()
self.master.lift()
def destroy(self):
self.master.destroy()
self.master = None
def openurl(self, evt=None):
import webbrowser
webbrowser.open('http://mgltools.scripps.edu')
def register(self):
self.master.withdraw()
from mglutil.splashregister.register import Register_User
Register_User(self.vf.help_about.version)
AboutGUI = CommandGUI()
AboutGUI.addMenuCommand('menuRoot', 'Help', 'About', separatorAbove=1)
commandList = [{'name': 'about', 'cmd': About(), 'gui': AboutGUI}]
def initModule(viewer):
for _dict in commandList:
viewer.addCommand(_dict['cmd'], _dict['name'], _dict['gui'])
def setLevel_cb(self, level):
col = self.vf.ICmdCaller.levelColors
c = (col[level][0]/1.5,col[level][1]/1.5,col[level][2]/1.5)
self.LevelOption._menubutton.configure(
background = TkColor(c),
activebackground = TkColor(col[level]))
if level=='Atom':
self.vf.setIcomLevel(Atom)
elif level=='Residue':
self.vf.setIcomLevel(Residue)
elif level=='Chain':
self.vf.setIcomLevel(Chain)
elif level=='Molecule':
self.vf.setIcomLevel(Molecule)
PCOMGUI = CommandGUI()
from moleculeViewer import ICONPATH
PCOMGUI.addToolBar('PCOM', icon1 = 'mouse.gif', icon_dir=ICONPATH,
balloonhelp = 'Picking COMmands', index = 0)
class MVBindCmdToKey(MVCommand):
def __init__(self, func=None):
MVCommand.__init__(self, func=None)
otherKeys = ['Escape', 'F1', 'F2', 'F3', 'F4', 'F5', 'F6', 'F7', 'F8',
'F9', 'Tab', 'space', 'Return', 'Insert', 'Delete',
'Home', 'End', 'Prior', 'Next', 'Up', 'Down', 'Left',
'Right', 'Caps_Lock', 'Num_Lock', 'BackSpace']
self.bindings = {}
StatesPlayerWidget,
ShowAutoDockStatesBaseCmd,
ShowAutoDockStates,
ShowAutoDockStatesByEnergy,
ShowAutoDockPopulation,
ShowAutoDockStatesHISTOGRAM,
ShowAutoDockClusteringStates,
ReadAutoDockClusteringStates,
WriteAutoDockStates,
WriteAutoDockClustering,
MakeAutoDockCLUSTERING,
MakeAutoDockSubsetCLUSTERING,
)
ADChooseMacroGUI = CommandGUI()
ADChooseMacroGUI.addMenuCommand(
"AutoTools4Bar", menuText["AnalyzeMB"], menuText["chooseMacro"], cascadeName=menuText["MoleculesMB"]
)
ADReadMacroGUI = CommandGUI()
ADReadMacroGUI.addMenuCommand(
"AutoTools4Bar", menuText["AnalyzeMB"], menuText["readMacro"], cascadeName=menuText["MoleculesMB"]
)
ADEPDBMolGUI = CommandGUI()
ADEPDBMolGUI.addMenuCommand(
"AutoTools4Bar", menuText["AnalyzeMB"], menuText["epdbMol"], cascadeName=menuText["GridsMB"]
)
'widgetType':Tkinter.Button,
'wcfg':{'text':'Dismiss',
'command':self.dismissCB},
'gridcfg':{'column':3, 'row':10,'sticky':'ew'}})
self.form = self.vf.getUserInput(idf, modal = 0, blocking = 0)
lb = idf.entryByName['selectedGeometries']['widget'].lb
lb.bind("<ButtonRelease-1>", self.updateProps, '+')
e1 = idf.entryByName['pigment']['widget']
e1.bind("<Return>", self.bindPigment)
e2 = idf.entryByName['finish']['widget']
e2.bind("<Return>", self.bindFinish)
povrayGuiDescr = {'widgetType':'Menu', 'menuBarName':'menuRoot',
'menuButtonName':'File',
'menuEntryLabel':'Povray', 'index':0}
PovrayGUI = CommandGUI()
PovrayGUI.addMenuCommand('menuRoot', 'File', 'Povray', index = 0)
commandList = [
{'name':'povray','cmd': Povray(), 'gui': PovrayGUI},
]
def initModule(viewer):
for dict in commandList:
viewer.addCommand(dict['cmd'], dict['name'], dict['gui'])
packW = ebn['packList']['widget']
packs = packW.getcurselection()
# Nothing selected
if len(packs) == 0:
return
packName = packs[0]
if not self.citations.has_key(packName): return
citation = self.citations[packName]
citWidget = ebn['citation']['widget']
citWidget.setvalue(citation)
def guiCallback(self):
form = self.showForm('chooseCitation', modal=0, blocking=0)
citationCommandGUI = CommandGUI()
citationCommandGUI.addMenuCommand('menuRoot', 'Help', 'Citation Information')
class CiteThisSceneCommand(Command):
"""Command that helps to cite references used in a given scene
\nPackage : Pmv
\nModule : helpCommands
\nClass : CiteThisSceneCommand
"""
def buildFormDescr(self, formName):
if formName == 'citationHelp':
idf = InputFormDescr(title="Choose Package")
citeKeys = self.vf.showCitation.citations.keys()
txt = """
#tagModified=False)
self.lines.Set(vertices=self.lineVertices,
type=GL.GL_LINE_STRIP,
faces=self.faces,
freshape=1)
#tagModified=False)
elif len(self.lineVertices) == 1 and len(self.labelCenters) == 1:
#this fixes case of stepping back over 1st label
self.labels.Set(vertices=[])
#self.labels.Set(vertices=[], tagModified=False)
self.lines.Set(vertices=[])
#self.lines.Set(vertices=[], tagModified=False)
MeasureDistanceGUICommandGUI = CommandGUI()
MeasureDistanceGUICommandGUI.addMenuCommand('menuRoot',
'Display',
'Distance (Shift Pick)',
cascadeName='Measure')
class MeasureAngleGUICommand(MeasureGUICommand):
"""Accumulates picked atoms.Draws fans, lines and labels labelling the angle between trios of selected atoms (color-coded orange).Userpref 'measureAngleSL' sets the 'snakeLength' which is how many angle measureDisplays can be seen at the same time.When more than that number are measured, the first angle measured is no longer labeled.
\nPackage : Pmv
\nModule : measureCommands
\nClass : MeasureAngleGUICommand
\nCommand : measureAngleGC
\nSynopsis:\n
angle/None<---measureAngleGC(atoms)
\nRequired Argument:\n
Dpf4ClusterWriter,
SimAnneal,
GA,
LS,
SetDockingRunParms,
SetAutoDock4Parameters,
SetAutoDock41Parameters,
StopAutoDpf,
menuText,
checkHasDpo,
sortKeyList,
setDpoFields,
)
DpfLoadDefaultsGUI = CommandGUI()
DpfLoadDefaultsGUI.addMenuCommand("AutoTools41Bar", menuText["AutoDpfMB"], menuText["ReadDpfMB"])
Dpf4MacroSelectorGUI = CommandGUI()
Dpf4MacroSelectorGUI.addMenuCommand(
"AutoTools41Bar", menuText["AutoDpfMB"], menuText["ReadMacro4"], cascadeName=menuText["MacromoleculeMB"]
)
Dpf4FlexResSelectorGUI = CommandGUI()
Dpf4FlexResSelectorGUI.addMenuCommand(
"AutoTools41Bar", menuText["AutoDpfMB"], menuText["ReadFlexRes4"], cascadeName=menuText["MacromoleculeMB"]
)
def guiCallback(self):
"""called each time the 'read ->Grid' sequence is pressed"""
gridFile = self.vf.askFileOpen(types=[('grid data files', '*.*')],
title = 'Grid File:')
if gridFile is not None and len(gridFile):
self.doitWrapper(gridFile, redraw=0)
gridReaderGuiDescr = {'widgetType':'Menu', 'menuBarName':'menuRoot',
'menuButtonName':'Grid', 'menuEntryLabel':'Grid',
'menuCascadeName':'read'}
GridReaderGUI = CommandGUI()
GridReaderGUI.addMenuCommand('menuRoot', 'Grid', 'Grid', cascadeName='read')
class AutoGridReader(MVCommand):
""" Command to load autogrid data files, creating an 'AutoGrid' object
\nPackage : Pmv
\nModule : GridCommands
\nClass : AutoGridReader
\nCommand : readAUTOGRID
\nSynopsis:\n
None <- readAUTOGRID(gridFile, **kw)
\nRequired Arguments:\n
gridFile --- path to the autogrid data file
'gridcfg':{'sticky':'we' }})
idf.append({ 'widgetType':StringSelectorGUI,
'parent':'mobgroup',
#'defaultValue':self.vf.Mols[1].name+", , , ",
'tooltip':'Please select the mobile nodes set. By default the mobile nodes will be the second molecule loaded in the viewer',
'name':'smobNodes',
'wcfg':{ 'molSet': self.vf.Mols,
'vf': self.vf,
'all':1,
'crColor':(0.,0.,1.),'forceEmpty':1,
},
'gridcfg':{'row':-1, 'sticky':'we' }})
return idf
SuperimposeAtomsCommandGUI = CommandGUI()
## SuperimposeAtomsGUICommandGUI.addMenuCommand('menuRoot', 'Compute',
## 'superimpose Atom Pairs',
## cascadeName = "Superimpose")
SuperimposeAtomsCommandGUI.addMenuCommand('menuRoot', 'Compute',
'Superimpose Atom Pairs')
commandList = [
{'name':'superimposeAtoms', 'cmd':SuperimposeAtomsCommand(),
'gui':None},
## {'name':'superimposeAtomsGC2', 'cmd':SuperimposeAtomsGUICommand(),
## 'gui':SuperimposeAtomsCommandGUI},
{'name':'superimposeGUI', 'cmd':SuperimposeAtomsGUICommand(),
'gui':SuperimposeAtomsCommandGUI},
levelLabels = ['Molecule ', 'Chain ',
'Residue ', 'Atom ']
self.levelVar.set("Molecule")
for level, levlabel in zip(levels, levelLabels):
ifd.append({'name':level,
'widgetType': Tkinter.Radiobutton,
'wcfg':{'text':levlabel,
'variable':self.levelVar,
'value':level,
'justify':'left',
'activebackground':self.levelColors[level],
'selectcolor':self.levelColors[level],
'command':self.setLevel_cb},
'gridcfg':{'sticky':'we'}})
ifd.append({'name':'dismiss',
'widgetType':Tkinter.Button,
'defaultValue':1,
'wcfg':{'text':'Dismiss',
'command':self.Close_cb},
'gridcfg':{'sticky':'we'}
})
self.form = self.vf.getUserInput(self.ifd, modal=0, blocking=0)
self.form.root.protocol('WM_DELETE_WINDOW',self.Close_cb)
MVSetSelectionLevelGUI = CommandGUI()
MVSetSelectionLevelGUI.addMenuCommand('menuRoot', 'Select','Set Selection Level')
self,
event=None,
):
name = self.vf.__class__.__name__
file = self.vf.askFileOpen(types=[('%s scripts' % name, '*.py'),
('Resource file', '*.rc'),
('All Files', '*.*')],
title="read %s script file:" % name)
if file:
self.doitWrapper(file, redraw=0)
if hasattr(self.vf, 'recentFiles'):
self.vf.recentFiles.add(file, self.name)
# Source Command GUI
SourceGUI = CommandGUI()
SourceGUI.addMenuCommand('menuRoot',
'File',
'Python Scripts',
cascadeName='Import',
cascadeIndex=1)
## SaveSessionCommand Command GUI
#SaveSessionCommandGUI = CommandGUI()
#SaveSessionCommandGUI.addMenuCommand('menuRoot', 'File',
#'Current Session', cascadeName='Save', index=1)
# SetUserPreference Command GUI
SetUserPreferenceGUI = CommandGUI()
SetUserPreferenceGUI.addMenuCommand('menuRoot',
'File',
# $Header: /opt/cvs/python/packages/share1.5/Pmv/bondsCommandsGUI.py,v 1.3 2009/08/13 20:21:23 sargis Exp $
from ViewerFramework.VFCommand import CommandGUI, CommandProxy
class BuildBondsByDistanceProxy(CommandProxy):
def __init__(self, vf, gui):
CommandProxy.__init__(self, vf, gui)
from Pmv.bondsCommands import BuildBondsByDistance
command = BuildBondsByDistance()
self.vf.addCommand(command, 'buildBondsByDistance', self.gui)
BuildBondsByDistanceGUI = CommandGUI()
BuildBondsByDistanceGUI.addMenuCommand('menuRoot',
'Edit',
'Build By Distance',
cascadeName='Bonds')
class AddBondsGUICommandProxy(CommandProxy):
def guiCallback(self, **kw):
if self.command:
self.command.guiCallback(**kw)
else:
from Pmv.bondsCommands import AddBondsGUICommand
command = AddBondsGUICommand()
loaded = self.vf.addCommand(command, 'addBondsGC', self.gui)
if loaded:
command = loaded
self.command = command
self.command.guiCallback(**kw)
command=self.register)
reg.pack(side = 'left')
b = Tkinter.Button(self.master,text=' Close ',
command=self.destroy)
b.pack(side = 'left')
notebook.setnaturalsize()
else:
self.master.deiconify()
self.master.lift()
def destroy(self):
self.master.destroy()
self.master = None
def openurl(self, evt=None):
import webbrowser
webbrowser.open('http://mgltools.scripps.edu')
def register(self):
self.master.withdraw()
from mglutil.splashregister.register import Register_User
Register_User(self.vf.help_about.version)
AboutGUI = CommandGUI()
AboutGUI.addMenuCommand('menuRoot', 'Help', 'About',separatorAbove = 1)
commandList = [{'name':'about','cmd':About(),'gui':AboutGUI}]
def initModule(viewer):
for _dict in commandList:
viewer.addCommand(_dict['cmd'],_dict['name'],_dict['gui'])
* The results of the previous steps are written to a file. The user selects a filename via a filebrowser. By convention, the file should have a .dpf extension. If no macromolecule has been selected, it is not possible to write a grid parameter file and the user gets a warning message to that effect. Likewise, the types of the maps to be calculated must be set before the grid parameter file is written and a warning message to this effect appears if the types have not been set.
(A checkbutton, "DONE", allows the user to withdraw the autoTools menuBar)
"""
from ViewerFramework.VFCommand import CommandGUI
from AutoDockTools.autodpfCommands import DpfSetDpo, DpfLoadDefaults,\
DpfMacroSelector, DpfMacroChooser, DpfInitLigand, DpfLigandChooser,\
DpfLigPDBQReader, DpfEditor, DpfSAWriter, DpfGAWriter, DpfLSWriter, DpfGALSWriter, \
DpfClusterWriter, SimAnneal, GA, LS, SetDockingRunParms, StopAutoDpf,\
menuText, checkHasDpo, sortKeyList, setDpoFields
DpfLoadDefaultsGUI = CommandGUI()
DpfLoadDefaultsGUI.addMenuCommand('AutoTools3Bar', menuText['AutoDpfMB'],
menuText['ReadDpfMB'])
DpfMacroSelectorGUI = CommandGUI()
DpfMacroSelectorGUI.addMenuCommand('AutoTools3Bar', menuText['AutoDpfMB'],\
menuText['ReadMacro'], cascadeName = menuText['MacromoleculeMB'])
DpfMacroChooserGUI = CommandGUI()
DpfMacroChooserGUI.addMenuCommand('AutoTools3Bar', menuText['AutoDpfMB'],\
menuText['ChooseMacro'], cascadeName = menuText['MacromoleculeMB'])
DpfInitLigandGUI = CommandGUI()
DpfInitLigandGUI.addMenuCommand('AutoTools3Bar',
menuText['AutoDpfMB'],
menuText['AdjustLigand'],
from AutoDockTools.autoanalyzeCommands import menuText,\
checkHasInitializedDockings, hideShowHide, toggleShowHide,\
checkNameStr, ADChooseMacro, ADReadMacro, ADEPDBMol,\
ADSeeSpots, ADShowBindingSite, ADMakeAllGrids, ADGetOutput,\
ADGetAGrid, ADSelectDLG, ADDeleteDLG, ADGetDirDLGs, ADGetDLG,\
ClusterDockingChooser, ModelDockingChooser, ADDrawHistogram,\
ADMacroLigandChart, ADDockingChooser, ReadAutoDockStates,\
StatesPlayerWidget, ShowAutoDockStatesBaseCmd, ShowAutoDockStates,\
ShowAutoDockStatesByEnergy, ShowAutoDockPopulation,\
ShowAutoDockStatesHISTOGRAM, ShowAutoDockClusteringStates,\
ReadAutoDockClusteringStates, WriteAutoDockStates,\
WriteAutoDockClustering, MakeAutoDockCLUSTERING,\
MakeAutoDockSubsetCLUSTERING
ADChooseMacroGUI=CommandGUI()
ADChooseMacroGUI.addMenuCommand('AutoTools4Bar', menuText['AnalyzeMB'],
menuText['chooseMacro'], cascadeName = menuText['MoleculesMB'])
ADReadMacroGUI=CommandGUI()
ADReadMacroGUI.addMenuCommand('AutoTools4Bar', menuText['AnalyzeMB'],
menuText['readMacro'], cascadeName = menuText['MoleculesMB'])
ADEPDBMolGUI=CommandGUI()
ADEPDBMolGUI.addMenuCommand('AutoTools4Bar', menuText['AnalyzeMB'],
menuText['epdbMol'], cascadeName = menuText['GridsMB'])
ADSeeSpotsGUI=CommandGUI()
'name': 'smobNodes',
'wcfg': {
'molSet': self.vf.Mols,
'vf': self.vf,
'all': 1,
'crColor': (0., 0., 1.),
'forceEmpty': 1,
},
'gridcfg': {
'row': -1,
'sticky': 'we'
}
})
return idf
SuperimposeAtomsCommandGUI = CommandGUI()
## SuperimposeAtomsGUICommandGUI.addMenuCommand('menuRoot', 'Compute',
## 'superimpose Atom Pairs',
## cascadeName = "Superimpose")
SuperimposeAtomsCommandGUI.addMenuCommand('menuRoot', 'Compute',
'Superimpose Atom Pairs')
commandList = [
{
'name': 'superimposeAtoms',
'cmd': SuperimposeAtomsCommand(),
'gui': None
},
## {'name':'superimposeAtomsGC2', 'cmd':SuperimposeAtomsGUICommand(),
## 'gui':SuperimposeAtomsCommandGUI},
{
def deleteViews(self):
""" Remove all existing views. """
for b in self.viewsContainer.interior().grid_slaves():
b.destroy()
self.views = {}
self.allViews = 0
for d in self.viewsDirectors.values():
if d.gui:
d.gui.root.destroy()
d.gui = None
d = None
self.viewsDirectors = {}
self.representations = {}
ViewsCommandGUI = CommandGUI()
ViewsCommandGUI.addMenuCommand('menuRoot',
'3D Graphics',
'Show Views Panel',
index=10)
from mglutil.gui.BasicWidgets.Tk.customizedWidgets import SaveButton, LoadButton
class SaveViewsToFile(MVCommand):
"""This command allows the user to save created views to two files:
*_views.py ( orientation) and *_repr.db(representation). These files are used to
restore the saved views (ReadViews Command). The saved orientations and representations
could also be loaded (separately) whith the DejaVu Viewer GUI."""
def buildFormDescr(self, formName):
if formName == 'saveViewsToFile':
"""
from ViewerFramework.VFCommand import CommandGUI
from AutoDockTools.autogpfCommands import GpfSetGpo,\
GpfMacroInit, GpfLoadDefaults, GpfEditor, GpfInitLigand, GpfWriter,\
SelectCenter, SetUpCovalentMap4, SetBoxParameters, SetOtherOptions,\
Gpf4ParameterFileSelector, Gpf4ParameterFileEditor, GpfMergeNonPolarHs,\
Gpf4SetMapTypes, Gpf4SetAtomTypes, Gpf4MacroInit, Gpf4MacroReader,\
Gpf4MacroChooser, Gpf4InitLigand, Gpf4LigandChooser, Gpf4LigReader,\
Gpf4FlexResChooser, Gpf4FlexResReader, Gpf4Writer, menuText, gridOpts,\
messages, checkHasGpo, box, cenSph, cenCross
GpfLoadDefaultsGUI = CommandGUI()
GpfLoadDefaultsGUI.addMenuCommand('AutoTools4Bar', menuText['AutoGpfMB'],\
menuText['ReadGpfMB'])
GpfEditorGUI= CommandGUI()
GpfEditorGUI.addMenuCommand('AutoTools4Bar', menuText['AutoGpfMB'],\
menuText['EditGpfMB'])
GpfWriterGUI= CommandGUI()
GpfWriterGUI.addMenuCommand('AutoTools4Bar', menuText['AutoGpfMB'], \
menuText['WriteGpfMB'], cascadeName=menuText['WriteMB'])
SetUpCovalentMap4GUI = CommandGUI()
"""
from ViewerFramework.VFCommand import CommandGUI
from AutoDockTools.autostartCommands import ADKill, ADProcessManager,\
AutoStarter, AutoGridStarter, AutoDockStarter, AddAutoDockHost, removePCs,\
entropiaPresent, menuText
from AutoDockTools.autostartCommands import VinaStarter
if entropiaPresent:
from Entropia.EntropiaDef import entropia_job_dir
from Entropia.EntropiaUI import EntropiaUI
from Entropia.EntropiaEx import EntropiaError
import ftplib
ADProcessManagerGUI = CommandGUI()
ADProcessManagerGUI.addMenuCommand('AutoTools41Bar', menuText['StartMB'],
menuText['processManagerMB'])
AutoGridStarterGUI = CommandGUI()
AutoGridStarterGUI.addMenuCommand('AutoTools41Bar', menuText['StartMB'],
menuText['startGridMB'])
AutoDockStarterGUI = CommandGUI()
AutoDockStarterGUI.addMenuCommand('AutoTools41Bar', menuText['StartMB'],
menuText['startDockMB'])
VinaStarterGUI = CommandGUI()
VinaStarterGUI.addMenuCommand('AutoTools41Bar', menuText['StartMB'],
menuText['startVinaMB'])
* The results of the previous steps are written to a file. The user selects a filename via a filebrowser. By convention, the file should have a .dpf extension. If no macromolecule has been selected, it is not possible to write a grid parameter file and the user gets a warning message to that effect. Likewise, the types of the maps to be calculated must be set before the grid parameter file is written and a warning message to this effect appears if the types have not been set.
(A checkbutton, "DONE", allows the user to withdraw the autoTools menuBar)
"""
from ViewerFramework.VFCommand import CommandGUI
from AutoDockTools.autodpfCommands import DpfSetDpo, DpfLoadDefaults,\
Dpf4MacroSelector, Dpf4FlexResSelector, Dpf4MacroChooser,\
Dpf4InitLigand, Dpf4LigandChooser, Dpf4LigPDBQReader,\
DpfEditor, Dpf41SAWriter, Dpf41GAWriter, Dpf41LSWriter,\
Dpf41GALSWriter, Dpf4ClusterWriter, SimAnneal, GA,\
LS, SetDockingRunParms, SetAutoDock4Parameters, SetAutoDock41Parameters,\
StopAutoDpf, menuText, checkHasDpo, sortKeyList, setDpoFields
DpfLoadDefaultsGUI = CommandGUI()
DpfLoadDefaultsGUI.addMenuCommand('AutoTools41Bar', menuText['AutoDpfMB'],
menuText['ReadDpfMB'])
Dpf4MacroSelectorGUI = CommandGUI()
Dpf4MacroSelectorGUI.addMenuCommand('AutoTools41Bar', menuText['AutoDpfMB'],\
menuText['ReadMacro4'], cascadeName = menuText['MacromoleculeMB'])
Dpf4FlexResSelectorGUI = CommandGUI()
Dpf4FlexResSelectorGUI.addMenuCommand('AutoTools41Bar', menuText['AutoDpfMB'],\
menuText['ReadFlexRes4'], cascadeName = menuText['MacromoleculeMB'])
Dpf4MacroChooserGUI = CommandGUI()
Dpf4MacroChooserGUI.addMenuCommand('AutoTools41Bar', menuText['AutoDpfMB'],\
menuText['ChooseMacro4'], cascadeName = menuText['MacromoleculeMB'])
req._username = username
req._passwd = passwd
resp = gamaLoginService.loginUserMyProxy(req)
f = open(self.proxy_gama, "w")
f.write(resp._loginUserMyProxyReturn)
f.close()
if self.RememberLogin_var.get():
file = open(self.rc_ad,'w')
user = self.cmdForms['default'].descr.entryByName\
['UserName_Entry']['widget'].get()
passwd = self.cmdForms['default'].descr.entryByName\
['Password_Entry']['widget'].get()
file.write("User:%s\nPassword:%s\n"%(user,passwd))
self.login = True
WebServicesGUI=CommandGUI()
WebServicesGUI.addMenuCommand('AutoToolsBar', menuText['StartMB'], "Web Services...")
commandList = [{'name':'ADweb_services','cmd':WebServices(),'gui':WebServicesGUI}]
WebServices4GUI=CommandGUI()
WebServices4GUI.addMenuCommand('AutoTools4Bar', menuText['StartMB'], "Web Services...")
def initModule(viewer):
if not hasattr(viewer, 'ADweb_services') and hasattr(viewer, 'GUI')\
and hasattr(viewer.GUI, 'currentADTBar'):
viewer.addCommand(WebServices(),'ADweb_services',WebServices4GUI)
#else:
# for _dict in commandList:
# viewer.addCommand(_dict['cmd'],_dict['name'],_dict['gui'])
self.ifd.entryByName['gridPointsXEnd']['widget'].set(
atom.coords[0])
self.ifd.entryByName['gridPointsYEnd']['widget'].set(
atom.coords[1])
self.ifd.entryByName['gridPointsZEnd']['widget'].set(
atom.coords[2])
self.endCross.Set(vertices=((atom.coords[0], atom.coords[1],
atom.coords[2]), ))
self.vf.GUI.VIEWER.Redraw()
def openPklData(self):
self.vf.AutoLigandMovieCommand(self.fileBaseName + '_flood.pkl')
AutoLigandCommandGUI = CommandGUI()
AutoLigandCommandGUI.addMenuCommand('menuRoot',
'Compute',
'Run AutoLigand...',
cascadeName="AutoLigand")
class OpenMovieCommand(MVCommand):
"GUI that opens saved movie of fill file."
def __init__(self, func=None):
MVCommand.__init__(self, func)
self.floodFile = None
def guiCallback(self):
file = self.vf.askFileOpen(types=[('Saved Flood File', '*.pkl'),
os.remove(os.path.join(self.vf.rcFolder,"colorByAtom_map.py"))
except:
pass
from Pmv.pmvPalettes import AtomElements
self.vf.colorByAtomType.palette = ColorPalette('Atom Elements', colorDict=AtomElements,
lookupMember='element')
geoms = self.vf.colorByAtomType.getAvailableGeoms(self.vf.Mols)
self.cleanup()
self.vf.colorByAtomType(self.vf.Mols, geoms)
def doit(self):
self.vf.colorByAtomType.palette.configure(ramp=self.paletteGUI.ramp, labels=self.paletteGUI.labels)
self.vf.colorByAtomType.palette.configureCmap()
self.vf.colorByAtomType.palette.write(os.path.join(self.vf.rcFolder,"colorByAtom_map.py"))
EditColorPaletteByAtomTypeGUI = CommandGUI()
EditColorPaletteByAtomTypeGUI.addMenuCommand('menuRoot',
'Edit',
'Edit Color by Atom Type',
cascadeName='Color Palettes')
class EditColorPaletteByResidueType(MVCommand):
def onAddCmdToViewer(self):
if not self.vf.commands.has_key('colorByResidueType'):
self.vf.loadCommand('colorCommands', 'colorByResidueType', 'Pmv', topCommand = 0)
self.vf.colorByResidueType.palette.read(os.path.join(self.vf.rcFolder,"colorByResidueType_map.py"))
def guiCallback(self):
self.paletteGUI = PaletteChooser(apply_cb=self.apply, makeDefault_cb=self.doit,
## # Save the pyShell stdin and redirect it to the main Python
## # interpreter only works if the main interpreter has been
## # started in a interactive mode.
## self.vf.pyShellstdin = sys.stdin
## sys.stdin = sys.__stdin__
## # Save the pyShell stderr and redirect it to the main Python
## # interpreter only works if the main interpreter has been
## # started in a interactive mode.
## self.vf.pyShellstderr = sys.stderr
## sys.stderr = sys.__stderr__
# HideGUI command GUI.
HideGUI = CommandGUI()
HideGUI.addMenuCommand('menuRoot', 'File', 'Hide VF GUI...',
cascadeName='Preferences')
class ShowGUICommand(Command):
"""Allow to show the ViewerFrameworkGUI at any time
\nPackage : Pmv
\nModule : customizeVFGUICommands
\nClass : ShowGUICommand
\nCommand : ShowGUI
\nSynopsis:\n
None <- ShowGUI(**kw)
"""
def __call__(self,**kw):
""" None <- ShowGUI(**kw)
at0, at1, at2, at3 = self.atomList
angle = self.extslider.get()
if self.torsionType.get() == '1':
self.vf.setTorsion(at0, at1, at2, at3, angle)
else:
self.vf.setRelativeTorsion(at1, at2, angle)
setTorsionGuiDescr = {
'widgetType': 'Menu',
'menuBarName': 'menuRoot',
'menuButtonName': 'Set Torsion Angle',
'menuEntryLabel': 'Show Set Torsion Panel',
'index': 0
}
SetTorsionGUI = CommandGUI()
SetTorsionGUI.addMenuCommand('menuRoot',
'Edit',
'Set Torsion',
cascadeName='Torsion Angles')
class TorsionAngle:
def __init__(self, atom1, atom2, atom3, atom4):
self.molecule = atom1.top
self.name_string = atom1.name + "-" + atom2.name + "-" + atom3.name + "-" + atom4.name
self.atom1 = atom1
self.atom2 = atom2
self.atom3 = atom3
self.atom4 = atom4
self.mov_atoms = self.molecule.subTree(atom2, atom3,
cb = self.vf.playTrajectory.ifd.entryByName['trs']['widget']
sl = cb.component('scrolledlist')
trajnames = self.vf.Trajectories.keys()
sl.setlist(trajnames)
cb.selectitem(name)
return name
else: return None
def __call__(self, trajFile, ask=False, **kw):
"""trajName<-openTrajectory(trajFile)
open aand parse a trajectory file (.trr or .xtc)."""
self.doitWrapper(trajFile, ask)
OpenTrajectoryGUI = CommandGUI()
OpenTrajectoryGUI.addMenuCommand('menuRoot', "Trajectory", "Read...")
#OpenTrajectoryGUI.addMenuCommand('menuRoot', 'File',
# 'Trajectory (Gromacs)', cascadeName='Read', index=3)
class PlayTrajectoryCommand (MVCommand):
"""This class allows the user to select/read a trajectory and a corresponding molecule.
It invokes TrajPlayer interface to play selected trajectory"""
def __init__(self):
MVCommand.__init__(self)
self.trajectory = None
self.player = None
return
if self.minZ < atom.coords[2] > self.maxZ:
return
self.ifd.entryByName['gridPointsX']['widget'].set(atom.coords[0])
self.ifd.entryByName['gridPointsY']['widget'].set(atom.coords[1])
self.ifd.entryByName['gridPointsZ']['widget'].set(atom.coords[2])
self.cross.Set(visible=1)
self.cross.Set(vertices=((atom.coords[0], atom.coords[1], atom.coords[2]),))
self.vf.GUI.VIEWER.Redraw()
def openPklData(self):
self.vf.AutoLigandMovieCommand(self.fileBaseName+'_flood.pkl')
AutoLigandCommandGUI = CommandGUI()
AutoLigandCommandGUI.addMenuCommand('menuRoot', 'Compute', 'Run AutoLigand...',
cascadeName="AutoLigand")
class OpenMovieCommand(MVCommand):
"GUI that opens saved movie of fill file."
def __init__(self, func=None):
MVCommand.__init__(self, func)
self.floodFile = None
def guiCallback(self):
file = self.vf.askFileOpen(types=[('Saved Flood File', '*.pkl'),('All Files', '*')],
title='Open Saved Flood File')
if file:
"""
if type(nodes) is types.StringType:
self.nodeLogString = "'"+nodes+"'"
self.vf.resetUndo(topCommand=0)
apply ( self.doitWrapper, (nodes,), kw )
deleteMoleculeGuiDescr = {'widgetType':'Menu', 'menuBarName':'menuRoot',
'menuButtonName':'Edit',
'menuCascadeName':'Delete',
'menuEntryLabel':'Molecule',
'index':0}
DeleteMoleculeGUI = CommandGUI()
DeleteMoleculeGUI.addMenuCommand('menuRoot', 'Edit', 'Delete Molecule',
cascadeName = 'Delete')
class DeleteAllMolecules(MVCommand):
"""Command to delete all molecules from the MoleculeViewer
\nPackage : Pmv
\nModule : deleteCommands
\nClass : DeleteAllMolecules
\nCommand : deleteAllMolecules
\nSynopsis:\n
None<---deleteAllMolecules( **kw)
\nRequired Arguments:\n
It resets the undo stack automatically.\n
def __call__(self, *args, **kw):
"""None <--- buildDNA(name,seq,**kw)
\nnodes---TreeNodeSet holding the current selection
\ncolors---list of rgb tuple.
\ngeomsToColor---list of the name of geometries to color,default is 'all'
"""
status = self.doitWrapper(
*args, **kw) #apply( self.doitWrapper, (name, seq), kw)
return status
def guiCallback(self):
status = self.doitWrapper()
autoPACKGUI = CommandGUI()
autoPACKGUI.addMenuCommand('menuRoot', 'Compute', 'autoPack')
commandList = [
{
'name': 'autoPACK',
'cmd': AutoPACKCommand(),
'gui': autoPACKGUI
},
]
def initModule(viewer):
for dict in commandList:
viewer.addCommand(dict['cmd'], dict['name'], dict['gui'])
def alignment_cb(self, event=None):
if not hasattr(self.vf,'alignment'):
self.vf.alignment = Alignment()
if not hasattr(self.vf,'alnEditor'):
self.vf.alnEditor = PmvAlignmentEditor(vf=self.vf)
self.vf.alnEditor.alignment = self.vf.alignment
else:
self.vf.alnEditor.redraw()
self.vf.alnEditor.master.deiconify()
for mol in self.vf.Mols:
if mol.name not in self.vf.alignment.seqNames:
self.vf.alnEditor.getSequence(mol)
SuperImposeAtomsGUICommandGUI = CommandGUI()
SuperImposeAtomsGUICommandGUI.addMenuCommand('menuRoot', 'Compute',
'superimposeAtoms',
cascadeName = "Superimpose")
class SuperimposeCoordsCommand(MVCommand):
def onAddCmdToViewer(self):
if not self.vf.commands.has_key('superimposeAtoms'):
self.vf.loadCommand('superImposeCommands', 'superimposeAtoms',
'Pmv', topCommand = 0)
import Tkinter
from ViewerFramework.VFCommand import CommandGUI
from AutoDockTools.autotorsCommands import rootSph, markSph,\
menuText, AtorsMoleculeChooser, MAXTORS, AdtSetMode,\
AtorsReader, Ators4MoleculeChooser, Ators4Reader, AtorsRefWriter, \
RigidMolecule, RigidMolecule4, AUTOTORSWriter, AUTOTORS4Writer, AUTOTORS4RandomWriter,\
MarkRoot, SelectRoot, SetTorsionNumberGUICommand, SetTorsionNumber, \
AutoRoot, SetRotatableBonds, DefiningRotatableBonds, SetBondRotatableFlag,\
CheckAromatic, StopCheckAromatic, SetCarbonNames, ChangeAromaticCutOff, \
TogglerootSphere, AutoAutoTors, StopAutoTors, AtorsInit, AtorsInitMol, \
ProcessCharges, ProcessBonds, rootSph, markSph, check_autotors_geoms,\
MAXTORS, menuText, warningText, checkMolCharges,\
autoMergeNPHS, set_autoMergeNPHS
Ators41MoleculeChooserGUI = CommandGUI()
Ators41MoleculeChooserGUI.addMenuCommand(
'AutoTools41Bar',
menuText['AutoTorsMB'],
menuText['Choose Molecule4'],
cascadeName=menuText['Input Molecule'])
Ators41ReaderGUI = CommandGUI()
Ators41ReaderGUI.addMenuCommand('AutoTools41Bar',
menuText['AutoTorsMB'],
menuText['Read Molecule4'],
cascadeName=menuText['Input Molecule'])
AtorsRefWriterGUI = CommandGUI()
AtorsRefWriterGUI.addMenuCommand('AutoTools41Bar',
menuText['AutoTorsMB'],
""" Remove all existing views. """
for b in self.viewsContainer.interior().grid_slaves():
b.destroy()
self.views = {}
self.allViews = 0
for d in self.viewsDirectors.values():
if d.gui:
d.gui.root.destroy()
d.gui = None
d = None
self.viewsDirectors={}
self.representations = {}
ViewsCommandGUI = CommandGUI()
ViewsCommandGUI.addMenuCommand('menuRoot', '3D Graphics','Show Views Panel',
index = 10)
from mglutil.gui.BasicWidgets.Tk.customizedWidgets import SaveButton, LoadButton
class SaveViewsToFile(MVCommand):
"""This command allows the user to save created views to two files:
*_views.py ( orientation) and *_repr.db(representation). These files are used to
restore the saved views (ReadViews Command). The saved orientations and representations
could also be loaded (separately) whith the DejaVu Viewer GUI."""
def buildFormDescr(self, formName):
if formName=='saveViewsToFile':
if self.vf.commands.has_key("viewsPanel"):
if len(self.vf.viewsPanel.views) == 0:
geom.Set(instanceMatrices=matrices)#packing
if not molecule.geomContainer.geoms.has_key('Unit Cell'):
fractCoords=((1,1,0),(0,1,0),(0,0,0),(1,0,0),(1,1,1),(0,1,1),
(0,0,1),(1,0,1))
coords = []
coords = molecule.crystal.toCartesian(fractCoords)
box=Box('Unit Cell', vertices=coords)
self.vf.GUI.VIEWER.AddObject(box, parent=geom)
molecule.geomContainer.geoms['Unit Cell'] = box
def showUnitCell(self, molecule):
visible = not molecule.geomContainer.geoms['Unit Cell'].visible
molecule.geomContainer.geoms['Unit Cell'].Set(visible=visible)
def showPacking(self, molecule):
geom = molecule.geomContainer.geoms['master']
if len(geom.instanceMatricesFortran) >= 2:
geom.Set(instanceMatrices=[numpy.eye(4,4)])
else:
matrices = instanceMatricesFromGroup(molecule)
geom.Set(instanceMatrices=matrices)
CrystalCommandGUI = CommandGUI()
CrystalCommandGUI.addMenuCommand('menuRoot', 'Display', 'Crystal')
commandList = [{'name':'crystalCommand','cmd':CrystalCommand(),'gui':CrystalCommandGUI}]
def initModule(viewer):
for _dict in commandList:
viewer.addCommand(_dict['cmd'],_dict['name'],_dict['gui'])
"""Write STL file ( molecules, filename )"""
self.doit(atoms, filename)
def guiCallback(self):
newfile = self.vf.askFileSave(types = [('STL files', '*.stl'),],
title = 'Select STL files:')
print 'filename: ', newfile
if newfile != None:
self.doit(self.vf.getSelection(), newfile)
writeSTLGuiDescr = {'widgetType':'Menu', 'menuBarName':'menuRoot',
'menuButtonName':'File',
'menuEntryLabel':'Write STL'}
WriteSTLGUI = CommandGUI()
WriteSTLGUI.addMenuCommand('menuRoot', 'File', 'Write STL')
class WriteColoredM(MVCommand):
def onAddCmdToViewer(self):
if not self.vf.commands.has_key('msmsMol'):
self.vf.loadCommand('msmsCommands', 'msmsMol', 'Pmv',
topCommand = 0)
def writeCMsurface(self, mol, filename):
"""Write the MSMS surface corresponding to all selected molecules
in the .m format with rbg color for each vertex"""
if not hasattr(mol.geomContainer, 'msms'): #surface not computed
self.vf.msmsMol.guiCallback()
"""
from ViewerFramework.VFCommand import CommandGUI
from AutoDockTools.autoflexCommands import AF_MacroReader,\
AF_MacroChooser, AF_SelectResidues, AF_ProcessResidues,\
AF_ProcessHingeResidues, AF_EditHinge, AF_SetHinge,\
AF_SetBondRotatableFlag, AF_StepBack, AF_FlexFileWriter,\
AF_RigidFileWriter, AF_LigandDirectoryWriter, menuText
AF_MacroReaderGUI=CommandGUI()
AF_MacroReaderGUI.addMenuCommand('AutoTools4Bar', menuText['AutoFlexMB'], \
menuText['Read Macro'], cascadeName = menuText['InputMB'])
AF_MacroChooserGUI=CommandGUI()
AF_MacroChooserGUI.addMenuCommand('AutoTools4Bar', menuText['AutoFlexMB'],
menuText['Choose Macro'], cascadeName = menuText['InputMB'])
AF_SelectResiduesGUI = CommandGUI()
AF_SelectResiduesGUI.addMenuCommand('AutoTools4Bar', menuText['AutoFlexMB'],menuText['Set Residues'])
AF_ProcessResiduesGUI = CommandGUI()
AF_ProcessHingeResiduesGUI = CommandGUI()
AF_EditHingeGUI = CommandGUI()
AF_EditHingeGUI.addMenuCommand('AutoTools4Bar', menuText['AutoFlexMB'],\
apply(self.doitWrapper, (filename,), kw)
def guiCallback(self, event=None,):
name = self.vf.__class__.__name__
file = self.vf.askFileOpen(types=[('%s scripts'%name, '*.py'),
('Resource file','*.rc'),
('All Files', '*.*')],
title="read %s script file:"%name)
if file:
self.doitWrapper(file, redraw=0)
if hasattr(self.vf, 'recentFiles'):
self.vf.recentFiles.add(file, self.name)
# Source Command GUI
SourceGUI = CommandGUI()
SourceGUI.addMenuCommand('menuRoot', 'File', 'Python Scripts',
cascadeName='Import', cascadeIndex=1)
## SaveSessionCommand Command GUI
#SaveSessionCommandGUI = CommandGUI()
#SaveSessionCommandGUI.addMenuCommand('menuRoot', 'File',
#'Current Session', cascadeName='Save', index=1)
# SetUserPreference Command GUI
SetUserPreferenceGUI = CommandGUI()
SetUserPreferenceGUI.addMenuCommand('menuRoot', 'File', 'Set...',
cascadeName='Preferences'
)
## # SetCmdParam Command GUI
## SetCmdParamGUI = CommandGUI()
class ColorCommandProxy(CommandProxy):
def guiCallback(self, **kw):
if self.command:
self.command.guiCallback(**kw)
else:
from Pmv.colorCommands import ColorCommand
command = ColorCommand()
loaded = self.vf.addCommand(command, 'color', self.gui)
if loaded:
command = loaded
self.command = command
self.command.guiCallback(**kw)
ColorGUI = CommandGUI()
ColorGUI.addMenuCommand('menuRoot', 'Color', 'Choose Color')
class ColorByAtomTypeProxy(CommandProxy):
def guiCallback(self, **kw):
if self.command:
self.command.guiCallback(**kw)
else:
from Pmv.colorCommands import ColorByAtomType
command = ColorByAtomType()
loaded = self.vf.addCommand(command, 'colorByAtomType', self.gui)
if loaded:
command = loaded
self.command = command
self.command.guiCallback(**kw)
#for k in sets__.keys():
for k in self.vf.sets.keys():
ifd.append({'name': k,
'widgetType':Tkinter.Checkbutton,
'wcfg':{ 'text': k,
'variable': Tkinter.IntVar(),
'command': None},
'gridcfg':{'sticky':Tkinter.W,'row':gridrow,'column':0,
'columnspan':2},
})
gridrow = gridrow + 1
return ifd
ExportSetsGUI = CommandGUI() # adds ok/cancel
ExportSetsGUI.addMenuCommand('menuRoot', 'Select', 'Add to Vision',
cascadeName='Export Sets')
commandList = [
{'name':'vision', 'cmd':VisionCommand(), 'gui':VisionCommandGUI},
{'name':'exportSets', 'cmd':ExportSets(), 'gui':ExportSetsGUI},
]
def initModule(viewer):
for dict in commandList:
viewer.addCommand(dict['cmd'], dict['name'], dict['gui'])
box = Box('Unit Cell', vertices=coords)
self.vf.GUI.VIEWER.AddObject(box, parent=geom)
molecule.geomContainer.geoms['Unit Cell'] = box
def showUnitCell(self, molecule):
visible = not molecule.geomContainer.geoms['Unit Cell'].visible
molecule.geomContainer.geoms['Unit Cell'].Set(visible=visible)
def showPacking(self, molecule):
geom = molecule.geomContainer.geoms['master']
if len(geom.instanceMatricesFortran) >= 2:
geom.Set(instanceMatrices=[numpy.eye(4, 4)])
else:
matrices = instanceMatricesFromGroup(molecule)
geom.Set(instanceMatrices=matrices)
CrystalCommandGUI = CommandGUI()
CrystalCommandGUI.addMenuCommand('menuRoot', 'Display', 'Crystal')
commandList = [{
'name': 'crystalCommand',
'cmd': CrystalCommand(),
'gui': CrystalCommandGUI
}]
def initModule(viewer):
for _dict in commandList:
viewer.addCommand(_dict['cmd'], _dict['name'], _dict['gui'])
def alignment_cb(self, event=None):
if not hasattr(self.vf,'alignment'):
self.vf.alignment = Alignment()
if not hasattr(self.vf,'alnEditor'):
self.vf.alnEditor = PmvAlignmentEditor(vf=self.vf)
self.vf.alnEditor.alignment = self.vf.alignment
else:
self.vf.alnEditor.redraw()
self.vf.alnEditor.master.deiconify()
for mol in self.vf.Mols:
if mol.name not in self.vf.alignment.seqNames:
self.vf.alnEditor.getSequence(mol)
SuperImposeAtomsGUICommandGUI = CommandGUI()
SuperImposeAtomsGUICommandGUI.addMenuCommand('menuRoot', 'Compute',
'superimposeAtoms',
cascadeName = "Superimpose")
class SuperimposeCoordsCommand(MVCommand):
def onAddCmdToViewer(self):
if not self.vf.commands.has_key('superimposeAtoms'):
self.vf.loadCommand('superImposeCommands', 'superimposeAtoms',
'Pmv', topCommand = 0)
