def _invalidateCacheCB(trigName, molecule, resChanges):
# we need to wait for the sequences to update themselves, so...
additions = [r for r in resChanges.created if r.molecule == molecule]
if additions:
from chimera import triggers
triggers.addHandler("monitor changes", _cacheCheck,
(molecule, additions))
def __init__(self): self.managers = [] self.geomClasses = [] self.interface = None self._suspendQueues = None from SimpleSession import SAVE_SESSION triggers.addHandler(SAVE_SESSION, self._sessionSaveCB, None)
def fillInUI(self, parent):
parent.columnconfigure(0, weight=1)
row = 1
fl = Hybrid.Scrollable_List(parent, 'Fits', 10, self.fit_selection_cb)
fl.heading.configure(font='TkFixedFont')
fl.listbox.configure(font='TkFixedFont', width=70)
self.listbox_heading = fl.heading
self.fit_listbox = fl.listbox
self.list_fits = []
fl.frame.grid(row=row, column=0, sticky='news')
parent.rowconfigure(row, weight=1)
row += 1
self.fit_listbox.bind('<KeyPress-Delete>', self.delete_fit_cb)
op = Hybrid.Popup_Panel(parent, resize_dialog=False)
opf = op.frame
opf.grid(row=row, column=0, sticky='news')
opf.grid_remove()
opf.columnconfigure(0, weight=1)
self.options_panel = op.panel_shown_variable
row += 1
orow = 0
cb = op.make_close_button(opf)
cb.grid(row=orow, column=1, sticky='e')
sm = Hybrid.Checkbutton_Entries(opf, True,
'Smooth motion between fits ',
(3, '10'), ' steps')
sm.frame.grid(row=orow, column=0, sticky='nw')
orow += 1
self.smooth_motion, self.smooth_steps = sm.variables
cl = Hybrid.Checkbutton(
opf, 'Show clash volume fraction between symmetric copies', False)
cl.button.grid(row=orow, column=0, sticky='w')
orow += 1
self.show_clash = cl.variable
cl.callback(self.show_clash_cb)
self.refill_list() # Set heading
from SimpleSession import SAVE_SESSION
from chimera import triggers, CLOSE_SESSION
triggers.addHandler(SAVE_SESSION, self.save_session_cb, None)
triggers.addHandler(CLOSE_SESSION, self.close_session_cb, None)
add_fit_list_menu_entry()
def __init__(self, frame_params, open_states):
self.frame_count = 0
self.frame_params = frame_params
self.open_states = open_states
from chimera import triggers as t
self.handler = t.addHandler('new frame', self.new_frame_cb, None)
def __map(self, event):
if self._handlers:
return
for triggers, trigName, cb, data in getattr(self, '_triggers', []):
self._handlers.append(
(triggers, trigName, triggers.addHandler(trigName, cb, data)))
self._modelsChange()
def __init__(self,
molecule,
category,
probeRadius=1.4,
allComponents=True,
vertexDensity=2.0):
SurfaceModel.__init__(self)
name = 'MSMS %s surface of %s' % (category, molecule.name)
SurfaceModel.__setattr__(self, 'name', name)
SurfaceModel.__setattr__(self, 'piecesAreSelectable', True)
SurfaceModel.__setattr__(self, 'oneTransparentLayer', True)
init = {
'molecule': molecule,
'colorMode': self.ByAtom,
'visibilityMode': self.ByAtom,
'density': vertexDensity,
'probeRadius': probeRadius,
'category': category,
'allComponents': allComponents,
'atomMap': None, # vertex number to Atom
'surface_piece': None,
'srf': None, # MSMS surface object
'triData': None, # MSMS triangle data
'areaSES': 0.0,
'areaSAS': 0.0,
'calculationFailed': False,
}
self.__dict__.update(init)
from _surface import SurfacePiece
self.surface_piece_defaults = {
'drawMode': self.Filled,
'lineWidth': 1.0,
'pointSize': 1.0,
'useLighting': True,
'twoSidedLighting': True,
'smoothLines': False,
'transparencyBlendMode': SurfacePiece.SRC_ALPHA_DST_1_MINUS_ALPHA,
}
self.update_surface()
# Detect changes in atom color, atom surfaceColor, atom surfaceOpacity,
# molecule color, atom surfaceDisplay.
from chimera import triggers as t
self.molecule_handler = t.addHandler('Molecule', self.molecule_cb,
None)
# Detect when surface or molecule deleted.
from chimera import addModelClosedCallback
addModelClosedCallback(self, self.surface_closed_cb)
addModelClosedCallback(self.molecule, self.molecule_closed_cb)
import Surface
Surface.set_coloring_method('msms', self, self.custom_coloring)
Surface.set_visibility_method('msms', self, self.custom_visibility)
def __map(self, event): if self._handlers: return for triggers, trigName, cb, data in getattr(self, '_triggers', []): self._handlers.append((triggers, trigName, triggers.addHandler(trigName, cb, data))) self._modelsChange()
def realtime_cb(self):
from chimera import triggers as t
if self.realtime_update.get():
if self.xform_handler is None:
h = t.addHandler('OpenState', self.xform_changed_cb, None)
self.xform_handler = h
elif self.xform_handler:
t.deleteHandler('OpenState', self.xform_handler)
self.xform_handler = None
def realtime_cb(self):
from chimera import triggers as t
if self.realtime_update.get():
if self.xform_handler is None:
h = t.addHandler('OpenState', self.xform_changed_cb, None)
self.xform_handler = h
elif self.xform_handler:
t.deleteHandler('OpenState', self.xform_handler)
self.xform_handler = None
def show(self):
from MultAlignViewer.HeaderSequence import \
DynamicStructureHeaderSequence
DynamicStructureHeaderSequence.show(self)
if self._motionHandler == None:
from chimera import triggers, MOTION_STOP
self._motionHandler = triggers.addHandler(MOTION_STOP,
self.refresh, None)
if len(self.mav.associations) < 2:
self.mav.status("Need at least two associated"
" structures", color="red")
def __init__(self, molecule, category, probeRadius = 1.4,
allComponents = True, vertexDensity = 2.0):
SurfaceModel.__init__(self)
name = 'MSMS %s surface of %s' % (category, molecule.name)
SurfaceModel.__setattr__(self, 'name', name)
SurfaceModel.__setattr__(self, 'piecesAreSelectable', True)
SurfaceModel.__setattr__(self, 'oneTransparentLayer', True)
init = {
'molecule': molecule,
'colorMode': self.ByAtom,
'visibilityMode': self.ByAtom,
'density': vertexDensity,
'probeRadius': probeRadius,
'category': category,
'allComponents': allComponents,
'atomMap': None, # vertex number to Atom
'surface_piece': None,
'srf': None, # MSMS surface object
'triData': None, # MSMS triangle data
'areaSES': 0.0,
'areaSAS': 0.0,
'calculationFailed': False,
}
self.__dict__.update(init)
from _surface import SurfacePiece
self.surface_piece_defaults = {
'drawMode': self.Filled,
'lineWidth': 1.0,
'pointSize': 1.0,
'useLighting': True,
'twoSidedLighting': True,
'smoothLines': False,
'transparencyBlendMode': SurfacePiece.SRC_ALPHA_DST_1_MINUS_ALPHA,
}
self.update_surface()
# Detect changes in atom color, atom surfaceColor, atom surfaceOpacity,
# molecule color, atom surfaceDisplay.
from chimera import triggers as t
self.molecule_handler = t.addHandler('Molecule', self.molecule_cb, None)
# Detect when surface or molecule deleted.
from chimera import addModelClosedCallback
addModelClosedCallback(self, self.surface_closed_cb)
addModelClosedCallback(self.molecule, self.molecule_closed_cb)
import Surface
Surface.set_coloring_method('msms', self, self.custom_coloring)
Surface.set_visibility_method('msms', self, self.custom_visibility)
def __init__(self):
self.speed = 1
self.dominant = True # Don't simultaneously rotate and translate
self.zoom = True # Z-motion zooms.
self.all_models = False # Move inactive models.
self.fly_mode = False # Control camera instead of models.
from chimera import nogui
if nogui:
return
try:
self.device = find_device()
except:
return # Connection failed. TODO: report failure.
if self.device:
from chimera import triggers as t
t.addHandler('new frame', self.check_space_navigator, None)
def __init__(self):
self.speed = 1
self.dominant = True # Don't simultaneously rotate and translate
self.zoom = True # Z-motion zooms.
self.all_models = False # Move inactive models.
self.fly_mode = False # Control camera instead of models.
from chimera import nogui
if nogui:
return
try:
self.device = find_device()
except:
return # Connection failed. TODO: report failure.
if self.device:
from chimera import triggers as t
t.addHandler('new frame', self.check_space_navigator, None)
def play_stop_cb(self):
from chimera import triggers
if self.play_handler:
triggers.deleteHandler('new frame', self.play_handler)
self.play_handler = None
self.play_stop_button['text'] = 'Play'
else:
h = triggers.addHandler('new frame', self.next_time_cb, None)
self.play_handler = h
self.play_stop_button['text'] = 'Stop'
def show(self):
from MultAlignViewer.HeaderSequence import \
DynamicStructureHeaderSequence
DynamicStructureHeaderSequence.show(self)
if self._motionHandler == None:
from chimera import triggers, MOTION_STOP
self._motionHandler = triggers.addHandler(MOTION_STOP,
self.refresh, None)
if len(self.mav.associations) < 2:
self.mav.status("Need at least two associated"
" structures",
color="red")
def track_surface_changes(self, surface):
from _surface import SurfaceModel
if isinstance(surface, SurfaceModel):
if self.surface_change_handler is None:
from chimera import triggers as t
h = t.addHandler('SurfacePiece', self.surface_changed_cb, None)
self.surface_change_handler = h
elif self.surface_change_handler:
from chimera import triggers as t
t.deleteHandler('SurfacePiece', self.surface_change_handler)
self.surface_change_handler = None
def register_new_marker_handler(self, register):
if register:
if self.new_marker_handler == None:
from chimera import triggers
h = triggers.addHandler('Atom', self.new_marker_cb, None)
self.new_marker_handler = h
else:
if self.new_marker_handler:
from chimera import triggers
triggers.deleteHandler('Atom', self.new_marker_handler)
self.new_marker_handler = None
def rotate_box(self, rotate):
self.activate_models(not rotate)
from chimera import triggers as t
rt = self.rotation_handler
if rotate:
if rt is None:
self.rotation_handler = t.addHandler('OpenState',
self.rotation_cb, None)
elif rt:
t.deleteHandler('OpenState', rt)
self.rotation_handler = None
def one_command():
'Show command-line and return to shortcuts after entering one command'
show_command_line()
from chimera import triggers as t
from Midas.midas_ui import triggerName as command_entered_trigger
def enable_shortcuts(trigger_name, handler, command_text):
t.deleteHandler(command_entered_trigger, handler[0])
import Accelerators
Accelerators.activate_accelerators(True)
h = []
h.append(t.addHandler(command_entered_trigger, enable_shortcuts, h))
def register_apple_event_handler():
from tkgui import windowSystem
if windowSystem == 'aqua':
return # ArgvCollector2._dooneevent() crashes Chimera on Aqua.
if not is_display_accessible():
return
avc2 = ArgvCollector2()
AEV_TRIGGER = 'new frame'
from chimera import triggers
AEV_tHandler = triggers.addHandler(AEV_TRIGGER, avc2._dooneevent, None)
def delete_ae_handler(triggerName, handler, data):
from chimera import triggers
try:
triggers.deleteHandler(AEV_TRIGGER, handler)
except (KeyError, ValueError):
pass
# when chimera exits, want to stop checking for Apple Events
triggers.addHandler("Chimera exit", delete_ae_handler, AEV_tHandler)
def play(self, f, fmin, fmax, fstep, f_changed_cb, fdir = None, steps = None):
self.f = f
self.fmin = fmin
self.fmax = fmax
self.fstep = fstep
self.f_changed_cb = f_changed_cb
self.steps = steps
if not fdir is None:
if fdir >= 0: self.step_direction = 1
else: self.step_direction = -1
if self.play_handler is None:
from chimera import triggers
h = triggers.addHandler('new frame', self.next_frame_cb, None)
self.play_handler = h
def __init__(self, molecule, *args, **kw):
Sequence.__init__(self, *args, **kw)
self.residues = []
self.resMap = {}
self.molecule = molecule
# allow numberingStart to be dynamic
self._numberingStart = self.numberingStart
delattr(self, 'numberingStart')
self.fromSeqres = None
# since bound methods are "first class" objects, using
# proxies to them doesn't work as you would expect
# (the proxy immediately becomes invalid), so...
from chimera import triggers, update, triggerSet
from weakref import proxy
def wrapper1(a1, a2, a3, s=proxy(self)):
s._delMoleculeCB(a1, a2, a3)
self._removeHandlerID = triggers.addHandler("Molecule",
wrapper1, None)
def wrapper2(a1, a2, a3, s=proxy(self)):
s._residueCB(a1, a2, a3)
if update.inTriggerProcessing:
# avoid handling expensive and redundant pending
# Residue trigger callback
def mcCB(*args):
self._residueHandlerID = triggers.addHandler("Residue",
wrapper2, None)
return triggerSet.ONESHOT
triggers.addHandler("monitor changes", mcCB, None)
else:
self._residueHandlerID = triggers.addHandler("Residue",
wrapper2, None)
from chimera.triggerSet import TriggerSet
self.triggers = TriggerSet()
self.triggers.addTrigger(self.TRIG_DELETE)
self.triggers.addTrigger(self.TRIG_MODIFY)
def register_apple_event_handler():
from tkgui import windowSystem
if windowSystem == 'aqua':
return # ArgvCollector2._dooneevent() crashes Chimera on Aqua.
if not is_display_accessible():
return
avc2 = ArgvCollector2()
AEV_TRIGGER = 'new frame'
from chimera import triggers
AEV_tHandler = triggers.addHandler(AEV_TRIGGER, avc2._dooneevent, None)
def delete_ae_handler(triggerName, handler, data):
from chimera import triggers
try:
triggers.deleteHandler(AEV_TRIGGER, handler)
except (KeyError, ValueError):
pass
# when chimera exits, want to stop checking for Apple Events
triggers.addHandler("Chimera exit", delete_ae_handler, AEV_tHandler)
def toplevel_volume_menu(action='toggle'):
if action == 'show-delayed':
from chimera import triggers
arg = []
h = triggers.addHandler('new frame', delayed_show, arg)
arg.append(h)
return
if action == 'toggle':
if volume_menu_shown_preference():
action = 'hide'
else:
action = 'show'
if action == 'show':
create_toplevel_volume_menu()
set_volume_menu_shown_preference(True)
elif action == 'hide':
remove_toplevel_volume_menu()
set_volume_menu_shown_preference(False)
def toplevel_volume_menu(action = 'toggle'):
if action == 'show-delayed':
from chimera import triggers
arg = []
h = triggers.addHandler('new frame', delayed_show, arg)
arg.append(h)
return
if action == 'toggle':
if volume_menu_shown_preference():
action = 'hide'
else:
action = 'show'
if action == 'show':
create_toplevel_volume_menu()
set_volume_menu_shown_preference(True)
elif action == 'hide':
remove_toplevel_volume_menu()
set_volume_menu_shown_preference(False)
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
t.addHandler(SAVE_SESSION, save_session, None)
def start(self):
self.inext = self.istart
from chimera import triggers as t
self.handler = t.addHandler('new frame', self.frame_cb, None)
def map(self, event=None):
from chimera import triggers
self.sel_handler = triggers.addHandler('selection changed',
self.selection_cb, None)
def fsc_plot(fscMap):
fig = update_plot(fscMap)
from chimera import triggers
h = triggers.addHandler('OpenState', motion_cb, (fscMap, fig))
def __init__(self, typeName, *args, **kw):
from chimera import triggers
triggers.addHandler(typeName, self._trigCB, None)
dict.__init__(self, *args, **kw)
def mcCB(*args):
self._residueHandlerID = triggers.addHandler("Residue",
wrapper2, None)
return triggerSet.ONESHOT
def getSequences(molecule, asDict=False):
"""return all non-trivial sequences in a molecule
This function is also available as molecule.sequences(...)
returns a list of sequences for the given molecule, one sequence per
multi-residue chain. The sequence name is "Chain X" where X is
the chain ID, or "Principal chain" if there is no chain ID.
The 'residues' attribute of each sequence is a list of the
residues for that sequence, and the attribute 'resmap' is a
dictionary that maps residue to sequence position (zero-based).
The 'residues' attribute will self-delete if the corresponding
model is closed.
If 'asDict' is true, return a dictionary of Sequences keyed on
chain ID (can throw AssertionError if multiple chains have same ID),
otherwise return a list.
"""
from chimera import bondsBetween, openModels, triggers
from copy import copy
def connected(res1, res2):
if res1.id.chainId != ' ' \
and res1.id.chainId == res2.id.chainId \
and not res1.isHet and not res2.isHet:
return True
return bondsBetween(res1, res2, onlyOne=True)
if hasattr(molecule, '_SequenceSequences'):
seqList, seqDict, trigIDs = molecule._SequenceSequences
if asDict:
if seqDict is not None:
return copy(seqDict)
else:
return copy(seqList)
chain = None
prevRes = None
seqs = []
# don't start a sequence until we've seen two residues in the chain
for res in molecule.residues:
# if a residue has only one heavy atom, and that is connected
# to only one other heavy atom, then don't put the residue
# in the sequence
#
# if heavy is connected to no other heavy atom (presumably
# metal or ion), end the chain
atomLists = res.atomsMap.values()
# take only one atom in each list, to avoid counting
# alternate locations as multiple atoms
atoms = map(lambda l: l[0], atomLists)
heavys = filter(lambda a: a.element.number > 1, atoms)
chainBreak = prevRes == None
if len(heavys) == 0:
continue
# heavys more reliably connected than hydrogens
if prevRes and not connected(prevRes, res):
didMod = 0
if seq:
for sr in seq.residues:
if connected(sr, res):
didMod = 1
if didMod:
continue
chainBreak = 1
elif prevRes and prevRes.id == res.id and len(heavys) == 1:
continue
elif chain is not None:
# HET residues in named chains get the chain name,
# but in blank chains they get 'het' -- allow for this
truePrevID = chain
trueResID = res.id.chainId
if truePrevID != trueResID:
if truePrevID in (" ", "het"):
prevID = " "
else:
prevID = truePrevID
if trueResID in (" ", "het"):
resID = " "
else:
resID = trueResID
if resID != prevID:
chainBreak = 1
if chainBreak:
# if chain ID changes in middle of connected chain
# need to remember new chain ID...
chain = res.id.chainId
startRes = res
prevRes = res
seq = None
continue # to avoid starting single-residues chains
if not seq:
if not chain or chain == " ":
name = PRINCIPAL
chain = " "
else:
name = CHAIN_FMT % chain
seq = StructureSequence(startRes.molecule, name)
seq.chain = chain
seqs.append(seq)
seq.append(startRes)
seq.append(res)
prevRes = res
sd = {}
for seq in seqs[:]:
# set 'fromSeqres' in this loop so that all sequences have it
seq.fromSeqres = None
if seq.chain in sd:
# a sequence of all 'X' residues or all het loses
if str(seq).replace('X', ' ').isspace() \
or len([r for r in seq.residues if not r.isHet]) == 0:
seqs.remove(seq)
continue
elif str(sd[seq.chain]).replace('X', ' ').isspace() \
or len([r for r in sd[seq.chain].residues
if not r.isHet]) == 0:
seqs.remove(sd[seq.chain])
sd[seq.chain] = seq
continue
if asDict:
raise AssertionError("Multiple chains with"
" same ID: '%s'" % seq.chain)
sd = None
break
sd[seq.chain] = seq
# use full sequence if available...
seqresSeqs = seqresSequences(molecule, asDict=True)
for chain, seq in sd.items():
try:
srSeq = seqresSeqs[chain]
except (KeyError, TypeError):
continue
seq.fromSeqres = True
if len(srSeq) == len(seq):
# no adjustment needed
continue
if len(srSeq) < len(seq):
seq.fromSeqres = False
import replyobj
replyobj.warning("SEQRES record for chain %s of %s is incomplete.\n"
"Ignoring record as basis for sequence." % (chain, molecule))
continue
from MultAlignViewer.structAssoc import estimateAssocParams, tryAssoc
estLen, segments, gaps = estimateAssocParams(seq)
# if a jump in numbering is in an unresolved part of the
# structure, the estimated length can be too long...
estLen = min(estLen, len(srSeq))
try:
# since gapping a structure sequence is considered an
# "error", need to allow a lot more errors than normal...
matchMap, numErrors = tryAssoc(srSeq, seq, segments, gaps, estLen,
maxErrors=int(len(seq)/2))
except ValueError:
seq.fromSeqres = False
continue
for i in range(len(srSeq)):
if i in matchMap:
del matchMap[i]
else:
seq.residues.insert(i, None)
seq.resMap = matchMap
seq[:] = srSeq[:]
# try to avoid identical names
baseNames = {}
for seq in seqs:
baseNames.setdefault(seq.name, []).append(seq)
for baseName, sameNamedSeqs in baseNames.items():
if len(sameNamedSeqs) > 1:
for i, seq in enumerate(sameNamedSeqs):
seq.name += " [%d]" % (i+1)
if hasattr(molecule, '_SequenceSequences'):
# deregister from previous sequence's triggers...
# (don't destroy the old sequences, may be in use elsewhere)
seqList, seqDict, trigIDs = molecule._SequenceSequences
for i, seq in enumerate(seqList):
seq.triggers.deleteHandler(seq.TRIG_DELETE, trigIDs[i])
else:
# invalidate the sequences cache if residues added/deleted
molecule.__cacheHandlerID = triggers.addHandler('Residue',
_invalidateCacheCB, molecule)
# register for current sequence's triggers
trigIDs = []
for seq in seqs:
trigIDs.append(
seq.triggers.addHandler(seq.TRIG_DELETE, _delSeq, None))
molecule._SequenceSequences = (seqs, sd, trigIDs)
if asDict:
return copy(sd)
return copy(seqs)
def __init__(self, parent, status):
self.status = status
self.parent = parent
import Pmw, Tkinter
row = 0
parent.columnconfigure(0, weight=1)
parent.columnconfigure(1, weight=1)
Tkinter.Button(parent, text="Define axes...", pady=0,
command=self._createAxesCB).grid(row=row, column=0)
Tkinter.Button(parent, text="Define plane...", pady=0,
command=self._createPlaneCB).grid(row=row, column=1)
row += 1
from CGLtk.Table import SortableTable
self.table = SortableTable(parent)
self.table.grid(row=row, column=0, columnspan=2, sticky="nsew")
parent.rowconfigure(row, weight=1)
self.table.addColumn("Name", "name", format="%s ")
self.table.addColumn(" ", "model.color", format=(False, True))
idCol = self.table.addColumn("ID", "id")
self.table.addColumn("Shown", "model.display", format=bool)
self.table.addColumn("Length", "length", format="%4.1f", font="TkFixedFont")
self.table.addColumn("Radius", "radius", format="%4.1f", font="TkFixedFont")
self.table.setData(geomManager.items)
self.table.sortBy(idCol)
self.table.launch(browseCmd=self._tableCB)
row += 1
selGroup = Pmw.Group(parent, tag_text="Choosing in table...")
selGroup.grid(row=row, column=0, columnspan=3, sticky='ew')
row += 1
cbFrame = selGroup.interior()
cbFrame.columnconfigure(0, weight=1)
cbFrame.columnconfigure(1, weight=1)
self.geomSelObjVar = Tkinter.IntVar(parent)
self.geomSelObjVar.set(prefs[AXIS_SEL_OBJ])
Tkinter.Checkbutton(cbFrame, variable=self.geomSelObjVar,
text="selects object").grid(row=0, column=0)
self.geomSelObjVar.trace_variable("w", self._selModeChangeCB)
self.geomSelAtomsVar = Tkinter.IntVar(parent)
self.geomSelAtomsVar.set(prefs[AXIS_SEL_ATOMS])
Tkinter.Checkbutton(cbFrame, variable=self.geomSelAtomsVar,
text="selects atoms").grid(row=0, column=1)
self.geomSelAtomsVar.trace_variable("w", self._selModeChangeCB)
self.buttons = []
self.buttons.append(Tkinter.Button(parent, text="Delete", pady=0,
state='disabled', command=self._deleteItemsCB))
self.buttons[-1].grid(row=row, column=0, sticky='e')
self.buttons.append(Tkinter.Button(parent, text="Rename", pady=0,
state='disabled', command=self._renameItems))
self.buttons[-1].grid(row=row, column=1, sticky='w')
self.renameDialogs = {}
row += 1
f = Tkinter.Frame(parent)
f.grid(row=row, column=0, columnspan=2)
row += 1
self.buttons.append(Tkinter.Button(f, text="Report distance", pady=0,
state='disabled', command=self._atomsDistanceCB))
self.buttons[-1].grid(row=0, column=0)
Tkinter.Label(f, text="to selected atoms"
).grid(row=0, column=1)
geomManager.registerInterface(self)
if geomManager.items:
self._selHandlerID = triggers.addHandler("selection changed",
self._selChangeCB, None)
def fillInUI(self, parent):
self.key_buffer = ''
self.key_callback_registered = None
self.time_out_id = None
import Accelerators
self.preferences = Accelerators.accelerator_preferences_category()
self.top = parent.winfo_toplevel()
self.top.wm_withdraw() # Do not show automatically when dialog created
parent.columnconfigure(0, weight = 1)
row = 0
import Tkinter
from CGLtk import Hybrid
al = Hybrid.Scrollable_List(parent, 'Available shortcuts', 10,
self.accelerator_selection_cb)
self.accelerator_listbox = al.listbox
al.frame.grid(row = row, column = 0, sticky = 'news')
parent.rowconfigure(row, weight = 1)
row = row + 1
fi = Hybrid.Entry(parent, 'Filter list ', 20)
fi.entry.bind('<KeyRelease>', self.filter_cb)
fi.frame.grid(row = row, column = 0, sticky = 'ew')
self.filter_text = fi.variable
row = row + 1
ao = Hybrid.Checkbutton(parent, 'Enable keyboard shortcuts', False)
ao.button.grid(row = row, column = 0, sticky = 'w')
row = row + 1
ao.callback(self.activate_accelerators_cb)
self.active_var = ao.variable
from chimera import statusline
sl = Hybrid.Checkbutton(parent, 'Show main window status line',
statusline.status_line_shown())
sl.button.grid(row = row, column = 0, sticky = 'w')
row = row + 1
sl.callback(self.status_line_cb)
self.status_line_var = sl.variable
from chimera import triggers
triggers.addHandler('status line', self.status_line_visibility_cb, None)
rf = Tkinter.Frame(parent)
rf.grid(row = row, column = 0, sticky = 'w')
row = row + 1
rb = Tkinter.Button(rf, text = 'Load', command = self.load_cb)
rb.grid(row = 0, column = 0, sticky = 'w')
afl = Tkinter.Label(rf, text = ' shortcuts file')
afl.grid(row = 0, column = 1, sticky = 'w')
path = self.preferences['path'] # Path might be None
af = Hybrid.Entry(parent, '', 20, path)
af.entry.xview_moveto(1) # show right most part of path
af.entry.bind('<KeyPress-Return>', self.load_cb)
af.frame.grid(row = row, column = 0, sticky = 'ew')
row = row + 1
self.accelerator_file = af.variable
tot = self.preferences['time out']
tm = Hybrid.Entry(parent, 'Key press time-out (seconds) ', 3, tot)
tm.frame.grid(row = row, column = 0, sticky = 'w')
row = row + 1
self.time_out = tm.variable
self.time_out.add_callback(self.time_out_changed_cb)
#
# Specify a label width so dialog is not resized for long messages.
#
msg = Tkinter.Label(parent, width = 30, anchor = 'w', justify = 'left')
msg.grid(row = row, column = 0, sticky = 'ew')
row = row + 1
self.message_label = msg
self.load_accelerators()
def addItems(self, items):
if len(items) == len(geomManager.items):
self._selHandlerID = triggers.addHandler("selection changed",
self._selChangeCB, None)
self.table.setData(geomManager.items)
def start(self):
self.inext = self.istart
from chimera import triggers as t
self.handler = t.addHandler('new frame', self.frame_cb, None)
def map(self, *args):
self.handler = triggers.addHandler("CoordSet",
self._trajCheck, None)
self._trajCheck()
def showAniso(self, targets, color=None, scale=1.0, smoothing=1,
showEllipsoid=True, ellipsoidTransparency=None,
axisColor=None, axisFactor=None, axisThickness=0.01,
ellipseColor=None, ellipseFactor=None, ellipseThickness=0.02):
"""targets can be an iterable of atoms or molecules
color of None means match the atom color.
showing outer ellipsoid controlled with 'showEllipsoid'
if 'ellipsoidTransparency' is not None, then the color's
transparency is set to that fraction.
'axisFactor' is a multiplicative factor of how long the displayed
axes lengths are versus the ellipsoid axes. If 'axisFactor'
is None then no axes are displayed.
'ellipseFactor' is similar to 'axisFactor', but for the major
ellipses.
"""
molMap = self._makeMolMap(targets)
self.removeAniso(molMap)
noneShowing = not self._surfMap
newlyShown = 0
for m, atoms in molMap.items():
if not m.display:
continue
surfMap = self._surfMap.setdefault(m, {})
if surfMap:
model = surfMap["model"]
else:
import _surface
model = _surface.SurfaceModel()
surfMap["model"] = model
openModels.add([model], sameAs=m, hidden=True)
for a in atoms:
if not a.display or a.hide:
continue
if not hasattr(a, "anisoU"):
continue
noneColor = a.color
if noneColor is None:
noneColor = a.molecule.color
if showEllipsoid:
if color is None:
_ellipsoidColor = noneColor
else:
_ellipsoidColor = color
else:
_ellipsoidColor = None
if axisFactor is None:
_axisColor = None
elif axisColor is None:
_axisColor = noneColor
else:
_axisColor = axisColor
if ellipseFactor is None:
_ellipseColor = None
elif ellipseColor is None:
_ellipseColor = noneColor
else:
_ellipseColor = ellipseColor
surfMap[a] = self._makePieces(model, a, (_ellipsoidColor,
_axisColor, _ellipseColor), ellipsoidTransparency, scale,
smoothing, axisFactor, ellipseFactor, axisThickness,
ellipseThickness)
newlyShown += 1
# can't look up 'molecule' in deleted atoms,
# so remember it...
self._atomMolLookup[a] = a.molecule
if noneShowing and self._surfMap:
self._handlerID = triggers.addHandler('Atom',
self._atomCB, None)
return newlyShown
def __init__(self):
self._surfMap = {}
self._atomMolLookup = {}
self._cylinderCache = {}
from SimpleSession import SAVE_SESSION
triggers.addHandler(SAVE_SESSION, self._sessionSaveCB, None)
def __init__(self, typeName, *args, **kw): from chimera import triggers triggers.addHandler(typeName, self._trigCB, None) dict.__init__(self, *args, **kw)
# -----------------------------------------------------------------------------
# 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
t.addHandler(SAVE_SESSION, save_session, None)
