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()
ADSeeSpotsGUI.addMenuCommand('AutoTools3Bar', menuText['AnalyzeMB'],
menuText['seeSpots'], cascadeName = menuText['DockingLogMB'])
"""
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'])
SetBoxParametersGUI = CommandGUI()
SetBoxParametersGUI.addMenuCommand('AutoTools4Bar', menuText['AutoGpfMB'], \
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)
def doit(self, refAtoms, inAtoms, inAllAtoms = None):
"""
The SuperimposeCoordsCommand takes two set of Atoms of the same length
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)
\nRequired Arguments:\n
group1 --- atoms\n
group2 --- atoms\n
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:
viewer.addCommand(dict['cmd'], dict['name'], dict['gui'])
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'])
"""
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},
{'name':'AD4start_autodock','cmd':AutoDockStarter(),'gui':AutoDockStarterGUI},
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"
def guiCallback(self):
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 """
def __init__(self):
""" constructor """
"""
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',
menuText['AutoGpfMB'],
menuText['AddSol'],
return
val['buildIsHelix']=0
sheet2DName = val['sheet2DName']
del val['sheet2DName']
ctlAtmName = val['ctlAtms']
del val['ctlAtms']
torsAtmName = val['torsAtms']
del val['torsAtms']
if self.vf.userpref['expandNodeLogString']['value'] == 0:
self.nodeLogString = "self.getSelection()"
apply(self.doitWrapper,(self.vf.getSelection(),sheet2DName ,
ctlAtmName, torsAtmName), val)
ComputeSheet2DGUI = CommandGUI()
ComputeSheet2DGUI.addMenuCommand('menuRoot', 'Compute', 'sheet2D')
class DisplayPath3DCommand(MVCommand):
"""This Command displays the computed sheet2D for each chain of the contained in the current selection.
\nPackage : Pmv
\nModule : extrusionCommands
\nClass : DisplayPath3DCommand
\nCommand name : displayPath3D
\nSynopsis:\n
None <- displayPath3D(self, nodes, negate=False, only=False, **kw)
\nRequired Arguments:\n
nodes --- any set for MolKit nodes describing molecular components
"""
def __init__(self, func=None):
MVCommand.__init__(self, func)
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')
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')
(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'],\
menuText['ChooseMacro4'], cascadeName = menuText['MacromoleculeMB'])
## # 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)
"""
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'])
## 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'):
self.vf.loadCommand('vectfieldCommands', 'loadVect', 'Pmv',
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'])
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 = """
This widget helps you cite the use of appropriate packages in your publication.
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
atoms --- atom(s)
\nangle --- returned when the number of atoms is a multiple of 3
"""
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()
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
"""
#'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},
{'name':'superimpose', 'cmd':SuperimposeCommand(),
'gui':None},
{'name':'transformAtoms', 'cmd':TransformAtomsCommand(),
'gui':None},
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')
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
# $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'],
cascadeName=menuText['SetLigandParmsMB'])
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()
ADSeeSpotsGUI.addMenuCommand('AutoTools4Bar', menuText['AnalyzeMB'],
menuText['seeSpots'], cascadeName = menuText['DockingLogMB'])
'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
},
{
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:
return
"""
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
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'])
AddAutoDockHostGUI = CommandGUI()
AddAutoDockHostGUI.addMenuCommand('AutoTools41Bar', menuText['StartMB'],
* 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'])
Dpf4InitLigandGUI = CommandGUI()
Dpf4InitLigandGUI.addMenuCommand('AutoTools41Bar', menuText['AutoDpfMB'],\
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['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'),
('All Files', '*')],
title='Open Saved Flood File')
if file:
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,
restoreDefault_cb = self.restoreDefault,
labels=self.vf.colorByResidueType.palette.labels,
ramp=self.vf.colorByResidueType.palette.ramp)
## # 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)
"""
if not kw.has_key('redraw'):
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,
self.molecule.allAtoms)
self.currentAngle = self.measureAngle(self.atom1, self.atom2,
self.atom3, self.atom4)
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
self.isDisplayed = 0
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:
self.doitWrapper(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'])
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)
def doit(self, refAtoms, inAtoms, inAllAtoms = None):
"""
The SuperimposeCoordsCommand takes two set of Atoms of the same length
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'])
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:
return
else:
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'])
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'],\
menuText['Edit Hinge'])
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()
## SetCmdParamGUI.addMenuCommand('menuRoot', 'File', 'Set command parameters',
## cascadeName='Preferences'
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'])
"""
idf_dict = self.showForm('template')
# get the kw key:value pairs from the gui
self.doitWrapper(*(), **idf_dict)
def doit(self, **kw):
"""The GUI command calls the real command here
"""
# process keyword args here
self.vf.ADpilot_Cluster()
ADpilot_ClusterGUI = CommandGUI()
ADpilot_ClusterGUI.addMenuCommand('AutoToolsBar',
menuText['AutoPilotMB'],
menuText['ClusterMB'],
cascadeName=menuText['DatabaseMB'])
#
# Template command and GUICommand
#
class ADpilot_Template(MVCommand):
"""A template command"""
#
# the signiture for __call__ must be compatible with that of doit!!!
#
def __call__(self, **kw):
"""This method is invoked by saying self.vf.ADpilot_Template
in the Python Shell.