cb('toggle_surface_selectability', False))
add_accelerators()
# -----------------------------------------------------------------------------
# Register sop command.
#
def sop_cmd(cmdname, args):
from Surface.sopcommand import sop_command
sop_command(cmdname, args)
from Midas.midas_text import addCommand
addCommand('sop', sop_cmd, help=True)
# -----------------------------------------------------------------------------
# Register attributes of SurfaceModel and SurfacePiece.
# TODO: Make all use of SurfaceModel import Surface instead of _surface.
#
from Surface import inspect
# -----------------------------------------------------------------------------
# Save surfaces in session file.
#
def save_session(trigger, arg, file):
from Surface import session
session.save_surface_state(file)
from AddCharge import cmdAddStdCharge, \
cmdAddNonstdCharge, cmdAddAllCharge
from Midas.midas_text import doExtensionFunc, MidasError
if not args:
mode = 'a'
else:
fields = args.split(None, 1)
if len(fields) > 1:
fullMode, args = fields
else:
fullMode = fields[0]
args = ""
mode = fullMode[0].lower()
if mode == 's':
func = cmdAddStdCharge
specInfo = [("spec", "molecules", "molecules")]
elif mode == 'n':
func = cmdAddNonstdCharge
specInfo = [("resSpec", "residues", "residues")]
elif mode == 'a':
func = cmdAddAllCharge
specInfo = [("spec", "molecules", "molecules")]
else:
raise MidasError("Unknown mode for %s: %s" % (cmdName,fullMode))
doExtensionFunc(func, args, specInfo=specInfo)
from Midas.midas_text import addCommand
addCommand("addcharge", cmdAddCharge, help=True, changesDisplay=False)
self.module('gui').AddionsDialog.name)
return None
chimera.extension.manager.registerExtension(AddionsEMO(__file__))
def cmdAddions(cmdName, args):
from Midas.midas_text import doExtensionFunc, MidasError
from Addions import ValidIontypes, initiateAddions
fields = args.split(" ")
if len(fields) ==0:
raise MidasError("No arguments were given for solvate.")
iontype = fields[0]
if not( shape in ValidIontypes ):
raise MidasError("Unknown solvent shape: " + fields[1])
numion = fields[1]
import chimera
mols = chimera.openModels.list(modelTypes=[chimera.Molecule])
initiateAdions( mols, shape, model, extent, center, chimera.replyobj.status)
from Midas.midas_text import addCommand
addCommand("adions", cmdAddions, help=True)
def name(self):
return 'Keyboard Shortcuts'
def description(self):
return 'Shows dialog listing keyboard shortcuts.'
def categories(self):
return ['General Controls']
def icon(self):
return None
def activate(self):
self.module().show_accelerator_dialog()
return None
# -----------------------------------------------------------------------------
#
chimera.extension.manager.registerExtension(Accelerator_Browser_EMO(__file__))
# ----------------------------------------------------------------------------
# Add 'ac' Midas command to turn on accelerators.
#
def accel_cmd(cmdname, args):
from Accelerators import accelerator_command
accelerator_command(cmdname, args)
from Midas.midas_text import addCommand
addCommand('ac', accel_cmd, None, help = True, changesDisplay = True)
# ----------------------------------------------------------------------------
# Check for auto-start
#
import Accelerators
Accelerators.autostart_accelerators()
return 'find hydrogen bonds'
def categories(self):
return ['Structure Analysis', 'Surface/Binding Analysis']
def icon(self):
return self.path('hbond.png')
def activate(self):
self.module('gui').showUI()
return None
chimera.extension.manager.registerExtension(FindHBondEMO(__file__))
def cmdHBonds(cmdName, args):
from Midas.midas_text import doExtensionFunc
from FindHBond import createHBonds
doExtensionFunc(createHBonds, args,
specInfo=[("spec", "models", "molecules")])
def cmdUnHBonds(cmdName, args):
from Midas.midas_text import doExtensionFunc, MidasError
import chimera
mgr = chimera.PseudoBondMgr.mgr()
pbg = mgr.findPseudoBondGroup("hydrogen bonds")
if pbg:
chimera.openModels.close([pbg])
else:
raise MidasError, "No hydrogen bonds to remove"
from Midas.midas_text import addCommand
addCommand("hbonds", cmdHBonds, revFunc=cmdUnHBonds, help=True)
addCommand("findhbond", cmdHBonds, revFunc=cmdUnHBonds, help=True)
def cmd_cone(cmdName, args):
from Midas.midas_text import doExtensionFunc
from Chimera_BILD import cone
doExtensionFunc(cone, args)
def cmd_cylinder(cmdName, args):
from Midas.midas_text import doExtensionFunc
from Chimera_BILD import cylinder
doExtensionFunc(cylinder, args)
def cmd_sphere(cmdName, args):
from Midas.midas_text import doExtensionFunc
from Chimera_BILD import sphere
doExtensionFunc(sphere, args)
def cmd_vector(cmdName, args):
from Midas.midas_text import doExtensionFunc
from Chimera_BILD import vector
doExtensionFunc(vector, args)
addCommand("arrow", cmd_arrow)
addCommand("box", cmd_box)
addCommand("cone", cmd_cone)
addCommand("cylinder", cmd_cylinder)
addCommand("sphere", cmd_sphere)
addCommand("vector", cmd_vector)
return self.path('icon.png')
def categories(self):
return ['Structure Analysis']
def activate(self):
import chimera.dialogs
chimera.dialogs.display(self.module('gui').AnisoDialog.name)
return None
chimera.extension.manager.registerExtension(AnisoEMO(__file__))
def cmdAniso(cmdName, args):
import Aniso
from Midas.midas_text import doExtensionFunc
doExtensionFunc(Aniso.aniso, args, specInfo=[("spec", "targets", "atoms")])
def cmdUnaniso(cmdName, args):
import Aniso
from Midas.midas_text import doExtensionFunc
doExtensionFunc(Aniso.unaniso,
args,
specInfo=[("spec", "targets", "atoms")])
from Midas.midas_text import addCommand
addCommand("aniso", cmdAniso, revFunc=cmdUnaniso, help=True)
# -----------------------------------------------------------------------------
# Register mcopy command.
#
def mcopy_cmd(cmdname, args):
from MoleculeCopy import mcopy_command
mcopy_command(cmdname, args)
from Midas.midas_text import addCommand
addCommand('mcopy', mcopy_cmd, help = True)
# -----------------------------------------------------------------------------
# Register shape command.
#
def shape_cmd(cmdname, args):
from Shape import shape_command
shape_command(cmdname, args)
from Midas.midas_text import addCommand
addCommand('shape', shape_cmd, help=True)
# -----------------------------------------------------------------------------
# Register surface resize mouse mode keyboard shortcut.
#
def resize_mouse_mode():
from Shape.resizemode import enable_resize_surface_mouse_mode as e
e(one_use=True)
from Accelerators import add_accelerator
add_accelerator('sz', 'Resize selected surfaces', resize_mouse_mode)
import os
import os.path
import chimera.extension
class BlastEMO(chimera.extension.EMO):
def name(self):
return "Blast Protein"
def description(self):
return "find similar protein sequences using BLAST"
def categories(self):
return ["Sequence"]
def activate(self):
from chimera.dialogs import display
display(self.module("gui").BlastChainDialog.name)
def cmdLine(self, cmdName, args):
self.module("cmdline").run(cmdName, args)
def modelPanel(self, molecules):
self.module("gui").run(molecules[0])
emo = BlastEMO(__file__)
chimera.extension.manager.registerExtension(emo)
from Midas.midas_text import addCommand
addCommand("blast", emo.cmdLine, help=True, changesDisplay=False)
addCommand("psiblast", emo.cmdLine, help=True, changesDisplay=False)
def activate(self):
from chimera.dialogs import display
display(self.module('gui').mmmdDialog.name)
return None
def cmdMMMD(self, cmdName, args):
from Midas.midas_text import doExtensionFunc
func = getattr(self.module('cmdline'), cmdName)
doExtensionFunc(func,
args,
specInfo=[("spec", "molecules", "molecules")])
def modelPanelMM_CB(self, molecules):
self.module('modelpanel').minimize(molecules)
def modelPanelMD_CB(self, molecules):
self.module('modelpanel').dynamics(molecules)
emo = mmmdEMO(__file__)
chimera.extension.manager.registerExtension(emo)
import ModelPanel
ModelPanel.addButton("minimize...", emo.modelPanelMM_CB, defaultFrequent=False)
#ModelPanel.addButton("run MD", emo.modelPanelMD_CB)
from Midas.midas_text import addCommand
addCommand("minimize", emo.cmdMMMD, help=True)
#addCommand("dynamics", emo.cmdMMMD, help=True)
return 'Find local energy minimum of molecules'
def categories(self):
return ['Structure Editing']
#def icon(self):
# return self.path("Template.png")
def activate(self):
from chimera.dialogs import display
display(self.module('gui').mmmdDialog.name)
return None
def cmdMMMD(self, cmdName, args):
from Midas.midas_text import doExtensionFunc
func = getattr(self.module('cmdline'), cmdName)
doExtensionFunc(func, args,
specInfo=[("spec", "molecules", "molecules")])
def modelPanelMM_CB(self, molecules):
self.module('modelpanel').minimize(molecules)
def modelPanelMD_CB(self, molecules):
self.module('modelpanel').dynamics(molecules)
emo = mmmdEMO(__file__)
chimera.extension.manager.registerExtension(emo)
import ModelPanel
ModelPanel.addButton("minimize...", emo.modelPanelMM_CB, defaultFrequent=False)
#ModelPanel.addButton("run MD", emo.modelPanelMD_CB)
from Midas.midas_text import addCommand
addCommand("minimize", emo.cmdMMMD, help=True)
#addCommand("dynamics", emo.cmdMMMD, help=True)
fi.register(descrip, open_cb, suffixes, prefix_list,
canDecompress = False, category = fi.VOLUME,
batch = batch)
# -----------------------------------------------------------------------------
#
register_file_types()
# -----------------------------------------------------------------------------
# Register volume command.
#
def volume_cmd(cmdname, args):
from VolumeViewer.volumecommand import volume_command
volume_command(cmdname, args)
from Midas.midas_text import addCommand
addCommand('volume', volume_cmd, help = True)
# -----------------------------------------------------------------------------
# Delay importing module until function is actually called.
#
def function(name):
def f(*args, **kw):
from VolumeViewer import shortcuts
getattr(shortcuts, name)(*args, **kw)
return f
# -----------------------------------------------------------------------------
# Register keyboard shortcuts.
#
ks = (('bv', 'Make volume bounding selected atoms from periodic volume',
'bounding_map'),
def description(self):
return 'Find steric clashes or atomic contacts'
def icon(self):
return self.path('dc2.png')
def categories(self):
return ['Structure Analysis', 'Surface/Binding Analysis']
def activate(self):
import chimera.dialogs
chimera.dialogs.display(
self.module('gui').DetectClashDialog.name)
return None
chimera.extension.manager.registerExtension(DetectClashEMO(__file__))
def cmdDetectClash(cmdName, args):
import DetectClash
from Midas.midas_text import doExtensionFunc
doExtensionFunc(DetectClash.cmdDetectClash, args,
specInfo=[("atomSpec", "testAtoms", "atoms")])
def cmdUndetectClash(cmdName, args):
import DetectClash
if DetectClash._continuousID != None:
from chimera import triggers
triggers.deleteHandler('OpenState', DetectClash._continuousID)
DetectClash._continuousID = None
DetectClash.nukeGroup()
from Midas.midas_text import addCommand
addCommand("findclash", cmdDetectClash, revFunc=cmdUndetectClash, help=True)
def open_cb(path, ftype=name):
from VolumeViewer import open_volume_file
vlist = open_volume_file(path, ftype, open_models = False,
show_data = False, show_dialog = False)
import chimera
if len(vlist) > 0 and not chimera.nogui:
from SurfaceColor.gui import show_surface_color_dialog
d = show_surface_color_dialog()
d.use_electrostatics_colormap()
# TODO: Should set volume menu entry, but volumes are not yet opened.
return vlist
suffixes = map(lambda s: '.' + s, suffix_list) # fileInfo wants '.'
import chimera
fi = chimera.fileInfo
fi.register(descrip, open_cb, suffixes, prefix_list,
canDecompress = False, category = fi.VOLUME, batch = batch)
# -----------------------------------------------------------------------------
#
register_file_types()
# -----------------------------------------------------------------------------
# Register scolor command.
#
def scolor_cmd(cmdname, args):
from SurfaceColor import scolor
scolor.scolor_command(cmdname, args)
from Midas.midas_text import addCommand
addCommand('scolor', scolor_cmd, scolor_cmd, help = True)
addCommand('scolour', scolor_cmd, scolor_cmd, help = True)
def activate(self):
#from chimera.dialogs import display
#display(self.module('gui').AddHDialog.name)
return None
def modelPanelCB(self, molecules):
self.module('gui').CombineDialog(models=molecules)
emo = CombineEMO(__file__)
#chimera.extension.manager.registerExtension(emo)
import ModelPanel
ModelPanel.addButton("copy/combine...",
emo.modelPanelCB,
balloon="Combine molecular models into new model",
moleculesOnly=True)
def cmdCombine(cmdName, args):
from Midas.midas_text import doExtensionFunc
import Combine
doExtensionFunc(Combine.cmdCombine,
args,
specInfo=[("spec", "mols", "molecules"),
("refSpec", "refMol", "molecules")])
from Midas.midas_text import addCommand
addCommand("combine", cmdCombine, help=True)
from AddCharge import cmdAddStdCharge, \
cmdAddNonstdCharge, cmdAddAllCharge
from Midas.midas_text import doExtensionFunc, MidasError
if not args:
mode = 'a'
else:
fields = args.split(None, 1)
if len(fields) > 1:
fullMode, args = fields
else:
fullMode = fields[0]
args = ""
mode = fullMode[0].lower()
if mode == 's':
func = cmdAddStdCharge
specInfo = [("spec", "molecules", "molecules")]
elif mode == 'n':
func = cmdAddNonstdCharge
specInfo = [("resSpec", "residues", "residues")]
elif mode == 'a':
func = cmdAddAllCharge
specInfo = [("spec", "molecules", "molecules")]
else:
raise MidasError("Unknown mode for %s: %s" % (cmdName, fullMode))
doExtensionFunc(func, args, specInfo=specInfo)
from Midas.midas_text import addCommand
addCommand("addcharge", cmdAddCharge, help=True, changesDisplay=False)
if shape == "cap":
if len(fields) != 4:
raise MidasError(
"Syntax for solvate cap: solvate cap solvent_model center radius"
)
center = fields[2]
extent = fields[3]
else:
center = ""
extent = fields[2]
import chimera
mols = chimera.openModels.list(modelTypes=[chimera.Molecule])
if not chimera.nogui:
from AddH.gui import checkNoHyds
checkNoHyds(
mols,
lambda mols=mols, shape=shape, model=model, extent=extent, center=
center, status=chimera.replyobj.status: initiateSolvate(
mols, shape, model, extent, center, status),
process="solvation")
return
initiateSolvate(mols, shape, model, extent, center,
chimera.replyobj.status)
from Midas.midas_text import addCommand
addCommand("solvate", cmdSolvate, help=True)
return 'match conformer members of two ensembles'
def categories(self):
return ['Structure Comparison', 'MD/Ensemble Analysis']
def activate(self):
self.module('choose').EnsembleMatchCB()
# Instance will register itself
return None
class EnsembleClusterEMO(chimera.extension.EMO):
def name(self):
return 'Ensemble Cluster'
def description(self):
return 'cluster conformer members of an ensemble'
def categories(self):
return ['Structure Comparison', 'MD/Ensemble Analysis']
def activate(self):
self.module('choose').EnsembleClusterCB()
# Instance will register itself
return None
chimera.extension.manager.registerExtension(TileStructuresEMO(__file__))
chimera.extension.manager.registerExtension(EnsembleMatchEMO(__file__))
chimera.extension.manager.registerExtension(EnsembleClusterEMO(__file__))
# Register tile command.
def tile_cmd(cmdname, args):
from EnsembleMatch import tilecommand
tilecommand.tile_command(cmdname, args)
from Midas.midas_text import addCommand
addCommand('tile', tile_cmd, tile_cmd, help = True)
# -----------------------------------------------------------------------------
# Register measure command.
#
def measure_cmd(cmdname, args):
import Measure
Measure.measure_command(cmdname, args)
from Midas.midas_text import addCommand
addCommand('measure', measure_cmd, help=True)
# -----------------------------------------------------------------------------
# Register topography command to surface from volume plane.
#
def topo(*args):
from Topography import topography_command
topography_command(*args)
from Midas.midas_text import addCommand
addCommand('topography', topo, help=True)
#
def fsc_plot(fscMap):
fig = update_plot(fscMap)
from chimera import triggers
h = triggers.addHandler('OpenState', motion_cb, (fscMap, fig))
# -----------------------------------------------------------------------------
#
def motion_cb(trigger_name, mf, trigger_data):
if 'transformation change' in trigger_data.reasons:
fsc_map, fig = mf
update_plot(fsc_map, fig)
# -----------------------------------------------------------------------------
#
def fscplot_cmd(cmdname, args):
from Commands import volume_arg, parse_arguments
req_args = [('fscMap', volume_arg)]
kw = parse_arguments(cmdname, args, req_args)
fsc_plot(**kw)
# -----------------------------------------------------------------------------
#
from Midas.midas_text import addCommand
addCommand('fscplot', fscplot_cmd)
if len(fields) > 1:
return fields
else:
return fields[0], ""
else:
for i in range(1, len(args)):
if args[i] == '"':
if args[i - 1] == '\\':
continue
return args[1:i], args[i+1:].strip()
from chimera import UserError
raise UserError("unterminated quoted string")
emo = ViewDockEMO(__file__)
chimera.extension.manager.registerExtension(emo)
from Midas.midas_text import addCommand
addCommand("viewdock", emo.cmdViewdock, help=True)
try:
import Midi
except ImportError:
# Nothing out there for sound
pass
else:
class HearDockEMO(chimera.extension.EMO):
def name(self):
return 'HearDock'
def description(self):
return 'display, sonify and manage dock results'
def categories(self):
return ['Surface/Binding Analysis']
def icon(self):
def activate(self):
import chimera.dialogs
chimera.dialogs.display(self.module('gui').DetectClashDialog.name)
return None
chimera.extension.manager.registerExtension(DetectClashEMO(__file__))
def cmdDetectClash(cmdName, args):
import DetectClash
from Midas.midas_text import doExtensionFunc
doExtensionFunc(DetectClash.cmdDetectClash,
args,
specInfo=[("atomSpec", "testAtoms", "atoms")])
def cmdUndetectClash(cmdName, args):
import DetectClash
if DetectClash._continuousID != None:
from chimera import triggers
triggers.deleteHandler('OpenState', DetectClash._continuousID)
DetectClash._continuousID = None
DetectClash.nukeGroup()
from Midas.midas_text import addCommand
addCommand("findclash", cmdDetectClash, revFunc=cmdUndetectClash, help=True)
def description(self):
return 'align sequences/structures'
def categories(self):
return ['Structure Comparison']
def icon(self):
return self.path('matchmaker.png')
def activate(self, molecules=None):
from chimera import dialogs
d = dialogs.display(self.module('gui').MatchMaker.name)
if molecules:
d.refMolList.setvalue(molecules[0])
d.matchMolList.setvalue(molecules[1:])
d.showSeqVar.set(False)
return None
emo = MatchMakerEMO(__file__)
chimera.extension.manager.registerExtension(emo)
if not chimera.nogui:
import ModelPanel
ModelPanel.addButton("match...", emo.activate, minModels=2,
moleculesOnly=True, balloon="align sequences/structures")
def cmdMatchMaker(cmdName, args):
from MatchMaker import cmdMatch
from Midas.midas_text import doExtensionFunc
doExtensionFunc(cmdMatch, args, specInfo=[("refSpec", "refSel", None),
("matchSpec", "matchSel", None)])
from Midas.midas_text import addCommand
addCommand("mmaker", cmdMatchMaker, help=True)
addCommand("matchmaker", cmdMatchMaker, help=True)
# -----------------------------------------------------------------------------
# Register measure command.
#
def measure_cmd(cmdname, args):
import Measure
Measure.measure_command(cmdname, args)
from Midas.midas_text import addCommand
addCommand('measure', measure_cmd, help = True)
help = "add/change attributes of atoms/residues/models"
def name(self):
return 'Define Attribute'
def description(self):
return self.help
def categories(self):
return ['Structure Analysis']
def activate(self):
from chimera import dialogs
dialogs.display(self.module('gui').AddAttrDialog.name)
return None
chimera.extension.manager.registerExtension(AddAttrEMO(__file__))
def cmdAddAttr(cmdName, args):
from AddAttr import addAttributes
from Midas.midas_text import doExtensionFunc
doExtensionFunc(addAttributes,
args,
specInfo=[("spec", "models", "molecules")])
from Midas.midas_text import addCommand
addCommand("defattr", cmdAddAttr, help=True, changesDisplay=False)
def icon(self):
return None
def activate(self):
self.module('gui').show_volume_filter_dialog()
return None
manager.registerExtension(Volume_Filter_EMO(__file__))
# -----------------------------------------------------------------------------
# Register vop command.
#
def vop_cmd(cmdname, args):
from VolumeFilter.vopcommand import vop_command
vop_command(cmdname, args)
from Midas.midas_text import addCommand
addCommand('vop', vop_cmd, help = True)
# ---------------------------------------------------------------------------
# Register keyboard shortcuts for filtering.
#
def fourier():
from VolumeFilter import fourier_transform
fourier_transform()
def laplace():
from VolumeFilter import laplacian
laplacian()
from Accelerators import add_accelerator
add_accelerator('FT', 'Fourier transform active volume', fourier)
add_accelerator('LT', 'Calculate Laplacian active volume', laplace)
from median import make_test_volume
model = fields[1]
if not( model in ValidSolventModels ):
raise MidasError("Unknown solvent model: " + fields[2])
if shape=="cap":
if len(fields) != 4:
raise MidasError("Syntax for solvate cap: solvate cap solvent_model center radius")
center = fields[2]
extent = fields[3]
else:
center = ""
extent = fields[2]
import chimera
mols = chimera.openModels.list(modelTypes=[chimera.Molecule])
if not chimera.nogui:
from AddH.gui import checkNoHyds
checkNoHyds(mols, lambda mols=mols, shape=shape, model=model,
extent=extent, center=center, status=
chimera.replyobj.status: initiateSolvate(mols, shape,
model, extent, center, status), process="solvation")
return
initiateSolvate( mols, shape, model, extent, center, chimera.replyobj.status)
from Midas.midas_text import addCommand
addCommand("solvate", cmdSolvate, help=True)
def name(self):
return 'Combine Molecular Models'
def description(self):
return 'combine molecular models'
def categories(self):
return []
def icon(self):
return None
def activate(self):
#from chimera.dialogs import display
#display(self.module('gui').AddHDialog.name)
return None
def modelPanelCB(self, molecules):
self.module('gui').CombineDialog(models=molecules)
emo = CombineEMO(__file__)
#chimera.extension.manager.registerExtension(emo)
import ModelPanel
ModelPanel.addButton("copy/combine...", emo.modelPanelCB,
balloon="Combine molecular models into new model", moleculesOnly=True)
def cmdCombine(cmdName, args):
from Midas.midas_text import doExtensionFunc
import Combine
doExtensionFunc(Combine.cmdCombine, args,
specInfo=[("spec", "mols", "molecules"),
("refSpec", "refMol", "molecules")])
from Midas.midas_text import addCommand
addCommand("combine", cmdCombine, help=True)
# arguments (raising MidasError if any are found) and directly calling
# the mainchain() function otherwise. As implemented here, using
# doExtensionFunc, if the user does provide arguments then
# doExtensionFunc will raise an error complaining that there
# were unknown keyword arguments supplied.
from Midas.midas_text import doExtensionFunc
doExtensionFunc(mainchain, args)
# The function for "~mainchain"
def revMainchainCmd(cmdName, args):
# We are going to implement ~mainchain as a synonym for "display",
# so we import runCommand which simplifies doing that.
from chimera import runCommand
from Midas import MidasError
if args:
# Raising MidasError will cause the error message
# to show up in the status line as red text
raise MidasError("~mainchain takes no arguments")
# runCommand takes any legal command-line command and executes it.
runCommand("display")
# Now actually register the "mainchain" command with the command interpreter
# by using addCommand(). The first argument is the command name and the
# second is the callback function for doing the work. The 'revFunc' keyword
# specifies the function to implement "~mainchain". The 'help' keyword has
# been omitted, therefore no help will be provided.
from Midas.midas_text import addCommand
addCommand("mainchain", mainchainCmd, revFunc=revMainchainCmd)
# All rights reserved. This software provided pursuant to a
# license agreement containing restrictions on its disclosure,
# duplication and use. This notice must be embedded in or
# attached to all copies, including partial copies, of the
# software or any revisions or derivations thereof.
# --- UCSF Chimera Copyright ---
import chimera.extension
class NucleotideEMO(chimera.extension.EMO):
def name(self):
return 'Nucleotides'
def description(self):
return 'abstract A, C, G, T, and U'
def categories(self):
return ['Depiction']
def icon(self):
return self.path('na.png')
def activate(self):
self.module('gui').gui()
return None
chimera.extension.manager.registerExtension(NucleotideEMO(__file__))
# Register nucleotides command.
def nucleotides(cmdname, args):
from NucleicAcids.cmd import nucleotides
nucleotides(cmdname, args)
from Midas.midas_text import addCommand
addCommand('nucleotides', nucleotides, help=True)
class ColorKeyEMO(chimera.extension.EMO):
def name(self):
return 'Color Key'
def description(self):
return 'place color key'
def categories(self):
return ['Utilities']
def icon(self):
return self.path('keyIcon.png')
def activate(self):
from chimera import dialogs
d = dialogs.display(self.module('gui').IlabelDialog.name)
d.notebook.selectpage(d.COLOR_KEY)
return None
chimera.extension.manager.registerExtension(ColorKeyEMO(__file__))
def doLabel2DCmd(cmdName, args):
from Midas.midas_text import doExtensionFunc
from Midas import MidasError
import Ilabel
try:
doExtensionFunc(Ilabel.processLabel2DCmd, args)
except MidasError, what:
raise
from Midas.midas_text import addCommand
addCommand("2dlabels", doLabel2DCmd, help=True)
for pbg in mgr.pseudoBondGroups:
unsel.extend(filter(lambda pb: pb not in selEdges,
pbg.pseudoBonds))
return unsel
def unselResidues():
from chimera.selection import currentResidues
selResidues = currentResidues(asDict=True)
unsel = []
for m in chimera.openModels.list(modelTypes=[chimera.Molecule]):
unsel.extend(filter(lambda r: r not in selResidues, m.residues))
return unsel
def unselMolecules():
from chimera.selection import currentMolecules
selMolecules = currentMolecules(asDict=True)
return filter(lambda m: m not in selMolecules,
chimera.openModels.list(modelTypes=[chimera.Molecule]))
def unselModels():
from chimera.selection import currentGraphs
selModels = currentGraphs(asDict=True)
return filter(lambda m: m not in selModels, chimera.openModels.list())
def midasCmd(cmdName, typedArgs):
from Midas.midas_text import doExtensionFunc
doExtensionFunc(writeSel, typedArgs)
from Midas.midas_text import addCommand
addCommand("writesel", midasCmd, help=True)
def name(self):
return 'Thermal Ellipsoids'
def description(self):
return 'show/hide atomic displacement ellipsoids'
def icon(self):
return self.path('icon.png')
def categories(self):
return ['Structure Analysis']
def activate(self):
import chimera.dialogs
chimera.dialogs.display(
self.module('gui').AnisoDialog.name)
return None
chimera.extension.manager.registerExtension(AnisoEMO(__file__))
def cmdAniso(cmdName, args):
import Aniso
from Midas.midas_text import doExtensionFunc
doExtensionFunc(Aniso.aniso, args,
specInfo=[("spec", "targets", "atoms")])
def cmdUnaniso(cmdName, args):
import Aniso
from Midas.midas_text import doExtensionFunc
doExtensionFunc(Aniso.unaniso, args,
specInfo=[("spec", "targets", "atoms")])
from Midas.midas_text import addCommand
addCommand("aniso", cmdAniso, revFunc=cmdUnaniso, help=True)
import chimera.extension
class BlastEMO(chimera.extension.EMO):
def name(self):
return "Blast Protein"
def description(self):
return "find similar protein sequences using BLAST"
def categories(self):
return ["Sequence"]
def activate(self):
from chimera.dialogs import display
display(self.module("gui").BlastChainDialog.name)
def cmdLine(self, cmdName, args):
self.module("cmdline").run(cmdName, args)
def modelPanel(self, molecules):
self.module("gui").run(molecules[0])
emo = BlastEMO(__file__)
chimera.extension.manager.registerExtension(emo)
from Midas.midas_text import addCommand
addCommand("blast", emo.cmdLine, help=True, changesDisplay=False)
addCommand("psiblast", emo.cmdLine, help=True, changesDisplay=False)
# -----------------------------------------------------------------------------
# Register command to make a molecule model from a mesh.
#
def mesh_to_molecule(*args):
import MeshToMolecule
MeshToMolecule.mesh_to_molecule(*args)
from Midas.midas_text import addCommand
addCommand('meshmol', mesh_to_molecule, help = True)
# -----------------------------------------------------------------------------
# Register topography command to surface from volume plane.
#
def topo(*args):
from Topography import topography_command
topography_command(*args)
from Midas.midas_text import addCommand
addCommand('topography', topo, help = True)
# --- UCSF Chimera Copyright ---
#
# $Id: ChimeraExtension.py 26655 2009-01-07 22:02:30Z gregc $
import chimera.extension
class AddAttrEMO(chimera.extension.EMO):
help = "add/change attributes of atoms/residues/models"
def name(self):
return 'Define Attribute'
def description(self):
return self.help
def categories(self):
return ['Structure Analysis']
def activate(self):
from chimera import dialogs
dialogs.display(self.module('gui').AddAttrDialog.name)
return None
chimera.extension.manager.registerExtension(AddAttrEMO(__file__))
def cmdAddAttr(cmdName, args):
from AddAttr import addAttributes
from Midas.midas_text import doExtensionFunc
doExtensionFunc(addAttributes, args,
specInfo=[("spec", "models", "molecules")])
from Midas.midas_text import addCommand
addCommand("defattr", cmdAddAttr, help=True, changesDisplay=False)
# -----------------------------------------------------------------------------
# Register fly command.
#
def fly_cmd(cmdname, args):
import Fly
Fly.fly_command(cmdname, args)
from Midas.midas_text import addCommand
addCommand('fly', fly_cmd, help = True)
# def description(self):
# return 'Substructure Alignment'
# def categories(self):
# return ['InsiliChem']
# def icon(self):
# pass
# def activate(self):
# pass
# chimera.extension.manager.registerExtension(SubAlignEMO(__file__))
def cmd_subalign(cmdName, args):
from Midas.midas_text import doExtensionFunc
from subalign.core import cmd_align
doExtensionFunc(cmd_align, args, specInfo=[("refSpec", "reference_sel", None),
("probeSpec", "probe_sel", None)])
def cmd_subrmsd(cmdName, args):
from Midas.midas_text import doExtensionFunc
from subalign.core import cmd_rmsd
doExtensionFunc(cmd_rmsd, args, specInfo=[("refSpec", "reference_sel", None),
("probeSpec", "probe_sel", None)])
addCommand("subalign", cmd_subalign)
addCommand("subrmsd", cmd_subrmsd)
class EnsembleClusterEMO(chimera.extension.EMO):
def name(self):
return 'Ensemble Cluster'
def description(self):
return 'cluster conformer members of an ensemble'
def categories(self):
return ['Structure Comparison', 'MD/Ensemble Analysis']
def activate(self):
self.module('choose').EnsembleClusterCB()
# Instance will register itself
return None
chimera.extension.manager.registerExtension(TileStructuresEMO(__file__))
chimera.extension.manager.registerExtension(EnsembleMatchEMO(__file__))
chimera.extension.manager.registerExtension(EnsembleClusterEMO(__file__))
# Register tile command.
def tile_cmd(cmdname, args):
from EnsembleMatch import tilecommand
tilecommand.tile_command(cmdname, args)
from Midas.midas_text import addCommand
addCommand('tile', tile_cmd, tile_cmd, help=True)
#
chimera.extension.manager.registerExtension(Crystal_Contacts_EMO(__file__))
# -----------------------------------------------------------------------------
#
def show_contacts(distance=1.0):
import chimera
for m in chimera.openModels.list(modelTypes=[chimera.Molecule]):
from CrystalContacts import show_crystal_contacts
show_crystal_contacts(m, distance)
from Accelerators import add_accelerator
add_accelerator('xx', 'Show crystal contacts', show_contacts)
# -----------------------------------------------------------------------------
#
def crystal_contacts_command(cmdname, args):
from CrystalContacts.command import crystal_contacts
crystal_contacts(cmdname, args)
# -----------------------------------------------------------------------------
#
from Midas.midas_text import addCommand
addCommand('crystalcontacts', crystal_contacts_command, help=True)
return 'Rotamers'
def description(self):
return 'choose side-chain rotamers'
def categories(self):
return ['Structure Editing']
def icon(self):
return self.path('beanie.png')
def activate(self):
self.module('gui')._prd()
return None
chimera.extension.manager.registerExtension(FindHBondEMO(__file__))
def cmdRotamers(cmdName, args):
from Midas.midas_text import doExtensionFunc
from Rotamers import useBestRotamers
doExtensionFunc(useBestRotamers,
args,
specInfo=[("spec", "targets", "residues"),
("densitySpec", "density", "models")])
from Midas.midas_text import addCommand
addCommand("swapaa", cmdRotamers, help=True)
import chimera.dialogs
chimera.dialogs.display(self.module('gui').AddionsDialog.name)
return None
chimera.extension.manager.registerExtension(AddionsEMO(__file__))
def cmdAddions(cmdName, args):
from Midas.midas_text import doExtensionFunc, MidasError
from Addions import ValidIontypes, initiateAddions
fields = args.split(" ")
if len(fields) == 0:
raise MidasError("No arguments were given for solvate.")
iontype = fields[0]
if not (shape in ValidIontypes):
raise MidasError("Unknown solvent shape: " + fields[1])
numion = fields[1]
import chimera
mols = chimera.openModels.list(modelTypes=[chimera.Molecule])
initiateAdions(mols, shape, model, extent, center, chimera.replyobj.status)
from Midas.midas_text import addCommand
addCommand("adions", cmdAddions, help=True)
# -----------------------------------------------------------------------------
# Register shape command.
#
def shape_cmd(cmdname, args):
from Shape import shape_command
shape_command(cmdname, args)
from Midas.midas_text import addCommand
addCommand('shape', shape_cmd, help = True)
# -----------------------------------------------------------------------------
# Register surface resize mouse mode keyboard shortcut.
#
def resize_mouse_mode():
from Shape.resizemode import enable_resize_surface_mouse_mode as e
e(one_use = True)
from Accelerators import add_accelerator
add_accelerator('sz', 'Resize selected surfaces', resize_mouse_mode)
cb('show_surfaces_as_mesh'))
aa('Sc', 'Split connected surface pieces',
cb('split_selected_surfaces', False))
aa('ts', 'Toggle surface selectability',
cb('toggle_surface_selectability', False))
add_accelerators()
# -----------------------------------------------------------------------------
# Register sop command.
#
def sop_cmd(cmdname, args):
from Surface.sopcommand import sop_command
sop_command(cmdname, args)
from Midas.midas_text import addCommand
addCommand('sop', sop_cmd, help = True)
# -----------------------------------------------------------------------------
# Register attributes of SurfaceModel and SurfacePiece.
# TODO: Make all use of SurfaceModel import Surface instead of _surface.
#
from Surface import inspect
# -----------------------------------------------------------------------------
# Save surfaces in session file.
#
def save_session(trigger, arg, file):
from Surface import session
session.save_surface_state(file)
from SimpleSession import SAVE_SESSION
from chimera import triggers as t
# -----------------------------------------------------------------------------
# Register command to make a molecule model from a mesh.
#
def mesh_to_molecule(*args):
import MeshToMolecule
MeshToMolecule.mesh_to_molecule(*args)
from Midas.midas_text import addCommand
addCommand('meshmol', mesh_to_molecule, help=True)
from Midas.midas_text import doExtensionFunc, addCommand
from plipgui.core import cmd_plip, cmd_unplip
class PLIPExtension(chimera.extension.EMO):
def name(self):
return 'Tangram PLIP'
def description(self):
return 'Protein-Ligand Interaction Profiler'
def categories(self):
return ['InsiliChem']
def icon(self):
return
def activate(self):
self.module('gui').showUI()
def _cmd_plip(cmdName, args):
doExtensionFunc(cmd_plip, args, specInfo=[("selSpec", "selection", None)])
def _cmd_unplip(cmdName, args):
doExtensionFunc(cmd_unplip, args)
addCommand("plip", _cmd_plip, revFunc=_cmd_unplip)
chimera.extension.manager.registerExtension(PLIPExtension(__file__))
# --- UCSF Chimera Copyright ---
# Copyright (c) 2006 Regents of the University of California.
# All rights reserved. This software provided pursuant to a
# license agreement containing restrictions on its disclosure,
# duplication and use. This notice must be embedded in or
# attached to all copies, including partial copies, of the
# software or any revisions or derivations thereof.
# --- UCSF Chimera Copyright ---
import chimera.extension
class MorphEMO(chimera.extension.EMO):
def name(self):
return 'Morph Conformations'
def description(self):
return 'Interpolate among molecular conformations'
def categories(self):
return ['Structure Comparison']
def icon(self):
return self.path('morph.png')
def activate(self):
self.module('gui').MorphDialog()
return None
def cmdMorph(self, cmdName, args):
self.module('cmdline').run(cmdName, args)
emo = MorphEMO(__file__)
chimera.extension.manager.registerExtension(emo)
from Midas.midas_text import addCommand
addCommand("morph", emo.cmdMorph, help=True)
def description(self):
return "Show 2D structure diagram"
def categories(self):
return ["Utilities"]
def icon(self):
return self.path("SDicon.png")
def activate(self):
from chimera.dialogs import display
display(self.module("gui").StructureDiagramDialog.name)
return None
def cmdLine(self, cmdName, args):
self.module("cmdline").run(cmdName, args)
def modelPanelCB(self, molecules):
self.module("modelpanel").callback(molecules)
emo = StructureDiagramEMO(__file__)
# Don't register if no GUI
chimera.extension.manager.registerExtension(emo)
# Don't add if no Model Panel button
import ModelPanel
ModelPanel.addButton("2D Diagram", emo.modelPanelCB,
moleculesOnly=True,
defaultFrequent=False,
balloon="draw molecules in 2D")
# Don't register if no command line (Shame on you!)
from Midas.midas_text import addCommand
addCommand("struct2d", emo.cmdLine, help=True, changesDisplay=False)
# function below and simply test for the presence of any
# arguments (raising MidasError if any are found) and directly calling
# the mainchain() function otherwise. As implemented here, using
# doExtensionFunc, if the user does provide arguments then
# doExtensionFunc will raise an error complaining that there
# were unknown keyword arguments supplied.
from Midas.midas_text import doExtensionFunc
doExtensionFunc(mainchain, args)
# The function for "~mainchain"
def revMainchainCmd(cmdName, args):
# We are going to implement ~mainchain as a synonym for "display",
# so we import runCommand which simplifies doing that.
from chimera import runCommand
from Midas import MidasError
if args:
# Raising MidasError will cause the error message
# to show up in the status line as red text
raise MidasError("~mainchain takes no arguments")
# runCommand takes any legal command-line command and executes it.
runCommand("display")
# Now actually register the "mainchain" command with the command interpreter
# by using addCommand(). The first argument is the command name and the
# second is the callback function for doing the work. The 'revFunc' keyword
# specifies the function to implement "~mainchain". The 'help' keyword has
# been omitted, therefore no help will be provided.
from Midas.midas_text import addCommand
addCommand("mainchain", mainchainCmd, revFunc=revMainchainCmd)
