def show_dialog(closeOld=True):
from chimera import dialogs
d = dialogs.find(ISeg_Dialog.name, create=False)
if d:
if closeOld:
d.toplevel_widget.update_idletasks()
d.Close()
d.toplevel_widget.update_idletasks()
else:
return d
dialogs.register(ISeg_Dialog.name, ISeg_Dialog, replace=True)
d = dialogs.find(ISeg_Dialog.name, create=True)
# Avoid transient dialog resizing when created and mapped for first time.
d.toplevel_widget.update_idletasks()
d.enter()
return d
replyobj.error("No attributes were set from"
" file %s\n" % path)
def fillInUI(self, parent):
OpenModeless.fillInUI(self, parent)
from chimera.widgets import MoleculeScrolledListBox
self.molListBox = MoleculeScrolledListBox(self.clientArea,
listbox_selectmode="extended",
labelpos="w", label_text="Restrict to models:")
self.molListBox.grid(row=0, column=0, sticky="nsew")
self.clientArea.rowconfigure(0, weight=1)
self.clientArea.columnconfigure(0, weight=1)
checkButtonFrame = Tkinter.Frame(self.clientArea)
checkButtonFrame.grid(row=1, column=0)
self.openDialog = Tkinter.IntVar(parent)
self.openDialog.set(True)
Tkinter.Checkbutton(checkButtonFrame, variable=self.openDialog,
text="Open Render/Select by Attribute").grid(
row=0, column=0, sticky='w')
self.doLog = Tkinter.IntVar(parent)
self.doLog.set(False)
Tkinter.Checkbutton(checkButtonFrame,
text="Send match info to Reply Log",
variable=self.doLog).grid(row=1, column=0, sticky='w')
from chimera import dialogs
dialogs.register(AddAttrDialog.name, AddAttrDialog)
#
def float_variable_value(v, default=None):
try:
return float(v.get())
except:
return default
# -----------------------------------------------------------------------------
#
def scale_bar_dialog(create=0):
from chimera import dialogs
return dialogs.find(Scalebar_Dialog.name, create=create)
# -----------------------------------------------------------------------------
#
def show_scale_bar():
from chimera import dialogs
return dialogs.display(Scalebar_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Scalebar_Dialog.name, Scalebar_Dialog, replace=1)
from chimera.baseDialog import ModelessDialog
import Tkinter
import Pmw
class SeqPickerDialog(ModelessDialog):
title = 'Show Model Sequence'
buttons = ('Show', 'Close')
default = 'Show'
keepShown = 'Show'
name = "model sequence chooser"
help = "ContributedSoftware/multalignviewer/multalignviewer.html#individual"
def fillInUI(self, parent):
from chimera.widgets import MoleculeChainScrolledListBox
self.molListBox = MoleculeChainScrolledListBox(parent,
listbox_selectmode="extended", labelpos="w",
# some fancy footwork so that double click honors
# the "keep shown" dialog setting
dblclickcommand=lambda *args: getattr(self, 'Show')(),
label_text="Show sequence for:")
self.molListBox.grid(row=0, column=0, sticky="news")
parent.rowconfigure(0, weight=1)
parent.columnconfigure(0, weight=1)
def Apply(self):
from base import seqCmd
seqCmd(self.molListBox.getvalue())
from chimera import dialogs
dialogs.register(SeqPickerDialog.name, SeqPickerDialog)
listbox.insert('end', line)
limit = dcache.size
used = reduce(lambda t, d: t + d.size, dlist, 0)
heading = ('%d objects using %.0f of %.0f Mb' %
(len(dlist), used / mb, limit / mb))
heading = heading + '\nSize (Mb) In use Description'
self.object_list_heading['text'] = heading
# ---------------------------------------------------------------------------
#
def data_cache(self):
from VolumeData import data_cache
return data_cache
# -----------------------------------------------------------------------------
#
def show_memory_use_dialog():
from chimera import dialogs
return dialogs.display(Memory_Use_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Memory_Use_Dialog.name, Memory_Use_Dialog, replace=1)
if isinstance(a, Volume) and isinstance(b, Molecule):
return 1
return cmp((a.id, a.subid), (b.id, b.subid))
# -----------------------------------------------------------------------------
#
from Matrix import transformation_description
# -----------------------------------------------------------------------------
#
def fit_map_dialog(create=False):
from chimera import dialogs
return dialogs.find(Fit_Map_Dialog.name, create=create)
# -----------------------------------------------------------------------------
#
def show_fit_map_dialog():
from chimera import dialogs
return dialogs.display(Fit_Map_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Fit_Map_Dialog.name, Fit_Map_Dialog, replace=True)
v = float(entry.getvalue())
ssMatrix[key] = v
ssMatrix[(key[1], key[0])] = v
return ssMatrix
def resetParams(self):
self.ssMixture.set(defaults[SS_MIXTURE])
self._ssSetText(self.ssMixture.get())
for key, value in defaults[SS_SCORES].items():
self._entryMatrix[key].setvalue(str(value))
self._hgapEntry.setvalue(str(defaults[HELIX_OPEN]))
self._sgapEntry.setvalue(str(defaults[STRAND_OPEN]))
self._ogapEntry.setvalue(str(defaults[OTHER_OPEN]))
def _hideShowSSParams(self):
if self._ssParamFrame.winfo_ismapped():
self._ssParamFrame.grid_forget()
self._ssParamButton.configure(text=self._ssButTexts[0])
else:
self._ssParamFrame.grid(row=1, column=0, columnspan=2, sticky='ew')
self._ssParamButton.configure(text=self._ssButTexts[1])
def _ssSetText(self, val):
self._ssTextVar.set("Include secondary structure score"
" (%d%%)" % int(100 * float(val)))
from chimera import dialogs
dialogs.register(MatchMaker.name, MatchMaker)
return model
# -------------------------------------------------------------------------
# Main dialog
# -------------------------------------------------------------------------
def track_xform_dialog(create=0):
"""track_xform_dialog(create=0) - look for Track Transform dialog.
If create = 1, then creates a new dialog if dialog does not exist.
"""
from chimera import dialogs
return dialogs.find(TrackXformDialog.name, create=create)
def show_track_xform_dialog():
"""show_track_xform_dialog() - shows the Track Transform dialog.
"""
from chimera import dialogs
return dialogs.display(TrackXformDialog.name)
# -------------------------------------------------------------------------
# Register dialog with Chimera
# -------------------------------------------------------------------------
from chimera import dialogs
dialogs.register(TrackXformDialog.name, TrackXformDialog, replace=1)
# -------------------------------------------------------------------------
n, f = c.nearFar center = chimera.Point(cx, cy, n) return center # ----------------------------------------------------------------------------- # def volume_path_dialog(): import VolumePath d = VolumePath.volume_path_dialog(create = True) return d # ----------------------------------------------------------------------------- # def volume_eraser_dialog(create = False): from chimera import dialogs return dialogs.find(Volume_Eraser_Dialog.name, create=create) # ----------------------------------------------------------------------------- # def show_volume_eraser_dialog(): from chimera import dialogs return dialogs.display(Volume_Eraser_Dialog.name) # ----------------------------------------------------------------------------- # from chimera import dialogs dialogs.register(Volume_Eraser_Dialog.name, Volume_Eraser_Dialog, replace = 1)
self.MOVE_MOLECULE: m.MOVE_MOLECULE,
self.MOVE_CHAIN: m.MOVE_CHAIN,
self.MOVE_SECONDARY_STRUCTURE: m.MOVE_SECONDARY_STRUCTURE
}
import move
move.set_mouse_mode(mmap[self.mode.get()])
# -----------------------------------------------------------------------------
#
def movement_mode_dialog(create=0):
from chimera import dialogs
return dialogs.find(Movement_Mouse_Mode_Dialog.name, create=create)
# -----------------------------------------------------------------------------
#
def show_movement_mode_dialog():
from chimera import dialogs
return dialogs.display(Movement_Mouse_Mode_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Movement_Mouse_Mode_Dialog.name,
Movement_Mouse_Mode_Dialog,
replace=1)
c.set_cap_color(color)
c.set_style(self.cap_style.get() == 'mesh')
from CGLtk import Hybrid
sf = Hybrid.float_variable_value(self.subdivision_factor, 1.0)
c.set_subdivision_factor(sf)
cap_offset = Hybrid.float_variable_value(self.cap_offset,
c.default_cap_offset)
c.set_cap_offset(cap_offset)
c.show_caps()
else:
c.unshow_caps()
# -----------------------------------------------------------------------------
#
def capper_dialog(create = 0):
from chimera import dialogs
return dialogs.find(Capper_Dialog.name, create=create)
# -----------------------------------------------------------------------------
#
def show_capper_dialog():
from chimera import dialogs
return dialogs.display(Capper_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Capper_Dialog.name, Capper_Dialog, replace = 1)
delattr(self, '_presetDeleteDialog')
return
deletions = self._presetDeleteDialog.getvalue()
remaining = [ps for ps in prefs[PRESETS] if ps[0] not in deletions]
prefs[PRESETS] = remaining
for name in deletions:
self.presetsMenu.delete(name)
self._presetDeleteDialog.destroy()
delattr(self, '_presetDeleteDialog')
def _prob2scaling(self):
try:
prob = float(self.calculator.getvalue()) / 100.0
if prob < 0.0 or prob >= 1.0:
raise ValueError("bad prob")
except ValueError:
from chimera import UserError
raise UserError("Probability must be >= 0 and < 100")
from Aniso import prob2scale
self._modFromCalc = True
self.scaling.setvalue("%g" % prob2scale(prob))
self._modFromCalc = False
def _scaleTypingCB(self):
if not self._modFromCalc:
self.calculator.setvalue("")
from chimera import dialogs
dialogs.register(AnisoDialog.name, AnisoDialog)
attribute_name = 'value_' + v.name
import AtomDensity
attribute_name = AtomDensity.replace_special_characters(
attribute_name, '_')
AtomDensity.set_atom_volume_values(m, v, attribute_name)
AtomDensity.show_attribute_histogram(m, attribute_name)
# -----------------------------------------------------------------------------
#
def atom_density_dialog(create=0):
from chimera import dialogs
return dialogs.find(Atom_Density_Dialog.name, create=create)
# -----------------------------------------------------------------------------
#
def show_atom_density_dialog():
from chimera import dialogs
return dialogs.display(Atom_Density_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Atom_Density_Dialog.name, Atom_Density_Dialog, replace=1)
def mesh_surface_piece(self):
import FlattenIcosahedron
mlist = FlattenIcosahedron.multiscale_models()
for m in mlist:
sm = m.surface_model()
if hasattr(sm, 'flattened_icosahedron_mesh'):
g = sm.flattened_icosahedron_mesh
return g
return None
# -----------------------------------------------------------------------------
#
def flatten_icosahedron_dialog(create = False):
from chimera import dialogs
return dialogs.find(Flatten_Icosahedron_Dialog.name, create=create)
# -----------------------------------------------------------------------------
#
def show_flatten_icosahedron_dialog():
from chimera import dialogs
return dialogs.display(Flatten_Icosahedron_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Flatten_Icosahedron_Dialog.name, Flatten_Icosahedron_Dialog,
replace = True)
def Apply(self):
from AddCharge import initiateAddCharges
from AddH.gui import checkNoHyds
mols = self.molList.getvalue()
chargeModel = self.chargeModel.getvalue()
chargeMethod = self.chargeMethod.getvalue()
checkNoHyds(mols, lambda mols=mols: initiateAddCharges(
cb=self.cb, models=mols, chargeModel=chargeModel,
method=chargeMethod, status=chimera.replyobj.status,
labelStandard=self.labelStandardVar.get(),
labelNonstandard=self.labelNonstandardVar.get()),
self.process)
from chimera import dialogs
dialogs.register(AddChargesDialog.name, AddChargesDialog)
class NonstandardChargeDialog(ModelessDialog):
title = "Specify Net Charges"
help = "ContributedSoftware/addcharge/addcharge.html#antechamber"
buttons = ('OK', 'Cancel')
oneshot = True
def __init__(self, cb, unchargedResidues, unchargedAtoms,
method, status, gaffType, showCharges=False):
self.cb = cb
self.unchargedResidues = unchargedResidues
self.unchargedAtoms = unchargedAtoms
self.status = status
self.method = method
self.gaffType = gaffType
def activate(self):
from chimera import dialogs
dialogs.display(
self.module().ShowAttrDialog.name).configure(mode="Render")
return None
chimera.extension.manager.registerExtension(ShowAttrEMO(__file__))
def showDialog(models, mode):
import ShowAttr
from chimera import dialogs
d = dialogs.display(ShowAttr.ShowAttrDialog.name)
d.configure(models=models, mode=mode)
def showSaveAttr():
import ShowAttr
return ShowAttr.SaveAttrDialog()
from chimera import dialogs
dialogs.register("SaveAttrDialog", showSaveAttr)
import ModelPanel
ModelPanel.addButton("render/sel by attr...",
lambda models, sd=showDialog: sd(models, "Render"),
balloon=ShowAttrEMO.help)
Airs.p2c.gui()
# -------------------------------------------------------------------------
# Main dialog
# -------------------------------------------------------------------------
def airs_dialog(create=0):
"""airs_dialog(create=0) - look for AIRS dialog.
If create = 1, then creates a new dialog if dialog does not exist.
"""
from chimera import dialogs
return dialogs.find(AIRS_Dialog.name, create=create)
def show_airs_dialog():
"""show_airs_dialog() - shows the AIRS dialog.
"""
from chimera import dialogs
return dialogs.display(AIRS_Dialog.name)
# -------------------------------------------------------------------------
# Register dialog with Chimera.
# -------------------------------------------------------------------------
from chimera import dialogs
dialogs.register(AIRS_Dialog.name,AIRS_Dialog,replace=1)
# -------------------------------------------------------------------------
def seg_marker_dialog(create=0):
"""Looks for Segment Marker dialog.
seg_marker_dialog(create=0)
If create = 1, then creates a new dialog if dialog does not exist.
"""
from chimera import dialogs
return dialogs.find(Segment_Marker.name, create=create)
# -------------------------------------------------------------------------
# Main dialog.
#
def show_seg_marker_dialog():
"""Shows the Segment Marker dialog.
show_seg_marker_dialog()
"""
from chimera import dialogs
return dialogs.display(Segment_Marker.name)
# -------------------------------------------------------------------------
# Register dialog with Chimera.
#
from chimera import dialogs
dialogs.register(Segment_Marker.name,Segment_Marker,replace=1)
# -------------------------------------------------------------------------
selOnly=selOnly)
replyobj.status("Wrote multiple models to %s\n" % path)
def _modelsChange(self, *args):
# can't query listbox, since it hangs off of same trigger
if len(openModels.listIds()) > 1:
self.untransformedButton.grid_forget()
self.relativeFrame.grid(row=self._rfRow,
column=0, sticky='w')
else:
self.relativeFrame.grid_forget()
self.untransformedButton.grid(row=self._rfRow,
column=0, sticky='w')
def _trajCheck(self, *args):
haveTraj = False
for m in self.modelList.getvalue():
if len(m.coordSets) > 1:
haveTraj = True
break
if haveTraj == self.haveTraj:
return
self.haveTraj = haveTraj
if self.haveTraj:
self.frameSave.grid(row=self._fsRow, column=0,
sticky='w')
else:
self.frameSave.grid_forget()
from chimera import dialogs
dialogs.register(WritePDBdialog.name, WritePDBdialog)
help = "color or change depiction of atoms/residues\nbased on attribute values"
def name(self):
return 'Render by Attribute'
def description(self):
return self.help
def categories(self):
return ['Depiction', 'Structure Analysis']
def activate(self):
from chimera import dialogs
dialogs.display(self.module().ShowAttrDialog.name).configure(
mode="Render")
return None
chimera.extension.manager.registerExtension(ShowAttrEMO(__file__))
def showDialog(models, mode):
import ShowAttr
from chimera import dialogs
d = dialogs.display(ShowAttr.ShowAttrDialog.name)
d.configure(models=models, mode=mode)
def showSaveAttr():
import ShowAttr
return ShowAttr.SaveAttrDialog()
from chimera import dialogs
dialogs.register("SaveAttrDialog", showSaveAttr)
import ModelPanel
ModelPanel.addButton("render/sel by attr...", lambda models, sd=showDialog:
sd(models, "Render"), balloon=ShowAttrEMO.help)
if len(mols) == len(noHyds): msg += "No models have hydrogens.\n" else: msg += "The following models have no" \ " hydrogens:\n" for nh in noHyds: msg += "\t%s (%s)\n" % (nh.name, nh.oslIdent()) msg += "You can add hydrogens using the AddH tool.\n" msg += "What would you like to do?" from AddH.gui import NoHydsDialog userChoice = NoHydsDialog(msg).run(chimera.tkgui.app) if userChoice == "cancel": return elif userChoice == "add hydrogens": from AddH.gui import AddHDialog AddHDialog(title="Add Hydrogens for Solvate", models=noHyds, useHBonds=True, oneshot=True, cb=lambda mols=mols: initiateSolvate(mols,self.method, self.solvent, self.extentValue.get(), self.centerValue.get(), chimera.replyobj.status)) return initiateSolvate(mols, self.method, self.solvent, self.extentValue.get(), self.centerValue.get(), chimera.replyobj.status) from chimera import dialogs dialogs.register(SolvateDialog.name, SolvateDialog)
# ---------------------------------------------------------------------------
#
def Ok(self):
self.Cancel()
# ---------------------------------------------------------------------------
#
def cell_size(self):
fields = self.cell_size_var.get().split()
if len(fields) != 3:
return None
try:
csize = map(int, fields)
except ValueError:
return None
if filter(lambda s: s <= 0, csize):
return None
return tuple(csize)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Cell_Size_Dialog.name, Cell_Size_Dialog, replace=1)
(v, mid, program, name, parserData, serviceData,
tableData) = sessionData
mol = idLookup(mid)
seq = None
showOne = False
elif version == 2:
(v, mid, seq, program, name, parserData, serviceData,
tableData) = sessionData
mol = idLookup(mid)
showOne = False
elif version == 3:
(v, mid, ss, seq, program, name, showOne,
parserData, serviceData, tableData) = sessionData
if mid is not None:
mol = idLookup(mid)
elif ss is not None:
mol = chimera.Sequence.restoreSequence(ss)
else:
mol = None
else:
raise ValueError("unknown blastpdb version: %s" % str(version))
BlastResultsDialog(mol=mol, seq=seq, sessionData=(program, name,
showOne,
parserData,
serviceData,
tableData))
from chimera import dialogs
dialogs.register(BlastChainDialog.name, BlastChainDialog)
dialogs.register(BlastDialog.name, BlastDialog)
elif userChoice == "continue":
cb()
class NoHydsDialog(ModalDialog):
title = "No Hydrogens..."
help = "UsersGuide/midas/addcharge.html#needH"
buttons = ('Abort', 'Add Hydrogens', 'Continue Anyway')
default = 'Add Hydrogens'
oneshot = True
def __init__(self, msg):
self.msg = msg
ModalDialog.__init__(self)
def fillInUI(self, parent):
import Tkinter
message = Tkinter.Label(parent, text=self.msg)
message.grid(sticky='nsew')
def Abort(self):
self.Cancel("cancel")
def AddHydrogens(self):
self.Cancel("add hydrogens")
def ContinueAnyway(self):
self.Cancel("continue")
from chimera import dialogs
dialogs.register(AddHDialog.name, AddHDialog)
return nbfont
# -------------------------------------------------------------------------
# Main dialog
# -------------------------------------------------------------------------
def seg_read_dialog(create=0):
"""seg_read_dialog(create=0) - look for Segment Read dialog.
If create = 1, then creates a new dialog if dialog does not exist.
"""
from chimera import dialogs
return dialogs.find(Segment_Read.name, create=create)
def show_seg_read_dialog():
"""show_seg_read_dialog() - shows the Segment Read dialog.
"""
from chimera import dialogs
return dialogs.display(Segment_Read.name)
# -------------------------------------------------------------------------
# Register dialog with Chimera.
# -------------------------------------------------------------------------
from chimera import dialogs
dialogs.register(Segment_Read.name,Segment_Read,replace=1)
# -------------------------------------------------------------------------
return nbfont
# -------------------------------------------------------------------------
# Main dialog
# -------------------------------------------------------------------------
def seg_mask_dialog(create=0):
"""seg_mask_dialog(create=0) - look for Segment Mask dialog.
If create = 1, then creates a new dialog if dialog does not exist.
"""
from chimera import dialogs
return dialogs.find(Segment_Mask.name, create=create)
def show_seg_mask_dialog():
"""show_seg_mask_dialog() - shows the Segment Mask dialog.
"""
from chimera import dialogs
return dialogs.display(Segment_Mask.name)
# -------------------------------------------------------------------------
# Register dialog with Chimera.
# -------------------------------------------------------------------------
from chimera import dialogs
dialogs.register(Segment_Mask.name,Segment_Mask,replace=1)
# -------------------------------------------------------------------------
ostates = {}
for m in chimera.openModels.list(all=1):
ostates[m.openState] = 1
active_ostates = filter(lambda ostate: ostate.active, ostates.keys())
for ostate in active_ostates:
ostate.globalXform(xform)
# -----------------------------------------------------------------------------
#
def volume_path_dialog():
import VolumePath
return VolumePath.volume_path_dialog(create=1)
# -----------------------------------------------------------------------------
#
def show_phantom_dialog():
from chimera import dialogs
return dialogs.display(Phantom_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Phantom_Dialog.name, Phantom_Dialog, replace=1)
# ---------------------------------------------------------------------------
#
def chosen_surface(self):
sm = self.surface_menu
surface = sm.getvalue()
return surface
# -----------------------------------------------------------------------------
#
def surface_zone_dialog(create=0):
from chimera import dialogs
return dialogs.find(Surface_Zone_Dialog.name, create=create)
# -----------------------------------------------------------------------------
#
def show_surface_zone_dialog():
from chimera import dialogs
return dialogs.display(Surface_Zone_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Surface_Zone_Dialog.name, Surface_Zone_Dialog, replace=1)
return
self.set_canvas_image(self.image)
def Save(self):
if self.image is None:
return
def save(okay, dialog, self=self):
if not okay:
return
paths_and_types = dialog.getPathsAndTypes()
if len(paths_and_types) == 0:
return
path, format = paths_and_types[0]
self.image.save(path, format)
from OpenSave import SaveModeless
SaveModeless(title='Save Image',
filters=[('JPEG', '*.jpg', '.jpg'),
('PNG', '*.png', '.png'),
('TIFF', '*.tif', '.tif')],
command=save)
# ------------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(ImageViewer.name, ImageViewer, replace=True)
from chimera import runCommand
from Midas import MidasError
try:
runCommand('movie reset')
except MidasError:
pass # Suppress error when user already reset movie by other means.
self.Close()
# -----------------------------------------------------------------------------
#
def morph_map_dialog(create=False):
from chimera import dialogs
return dialogs.find(Morph_Map_Dialog.name, create=create)
# -----------------------------------------------------------------------------
#
def show_morph_map_dialog():
from chimera import dialogs
return dialogs.display(Morph_Map_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Morph_Map_Dialog.name, Morph_Map_Dialog, replace=True)
else:
self.numion = "specific"
self.numionEntry.config( state="normal" )
def Apply(self):
from chimera import UserError, replyobj
if self.iontype=="":
self.enter()
raise UserError("No ion type chosen.")
if self.numion =="specific":
self.numion = self.numionValue.get()
if self.numion=="":
self.enter()
raise UserError(" number of ion is not given." )
else:
assert self.numion=="neutralize"
from Addions import initiateAddions
mols = self.molList.getvalue()
from AddCharge.gui import checkNoCharges
checkNoCharges(mols, lambda ur, ua, mols=mols: initiateAddions(
mols, self.iontype, self.numion, replyobj.status),
"ion addition")
from chimera import dialogs
dialogs.register(AddionsDialog.name, AddionsDialog)
labels = FONT_STYLE_LABELS
values = FONT_STYLE_VALUES
from Ilabel import FONT_TYPEFACE_LABELS, FONT_TYPEFACE_VALUES
class FontTypeface(SymbolicEnumOption):
attribute = "fontName"
labels = FONT_TYPEFACE_LABELS
values = FONT_TYPEFACE_VALUES
from OpenSave import OpenModeless
class ReadFileDialog(OpenModeless):
title = "Read 2D Labels Info"
def fillInUI(self, parent):
OpenModeless.fillInUI(self, parent)
self.deleteExistingVar = Tkinter.IntVar(parent)
self.deleteExistingVar.set(False)
Tkinter.Checkbutton(self.clientArea,
variable=self.deleteExistingVar,
text="Delete existing labels").grid()
from chimera import dialogs
dialogs.register(IlabelDialog.name, IlabelDialog)
borderwidth=0)
hlist.item_create(row, 3, itemtype="window",
window=toggle,
style=self._checkButtonStyle)
row += 1
def _updateHisListingData(self):
newData = {}
default = {
'delta': 'HID',
'epsilon': 'HIE',
'both': 'HIP',
self.HB: 'HID'
}[self.hisDefault.getvalue()]
for m in [s.molecule for s in self.surfListBox.getvalue()]:
for r in m.residues:
if r.type not in ["HIS", "HIE", "HIP", "HID"]:
continue
try:
newData[r] = self.hisListingData[r]
except KeyError:
if r.type == 'HIS':
newData[r] = default
else:
newData[r] = r.type
self.hisListingData = newData
from chimera import dialogs
dialogs.register(EspDialog.name, EspDialog)
paths = dialog.getPaths()
if not paths:
replyobj.warning("No save file selected; aborting save.\n")
return
saveSession(paths[0])
chimera.setLastSession(paths[0])
class SaveSessionDialog(SaveModeless):
name = "Save Session"
title = "Choose Session Save File"
def __init__(self):
SaveModeless.__init__(self, command=_saveCB,
filters=[("Chimera session", ["*.py"], ".py")],
historyID="SimpleSession", compressed=True)
dialogs.register(SaveSessionDialog.name, SaveSessionDialog)
def _openCB(okayed, dialog):
if not okayed:
return
for path in dialog.getPaths():
chimera.openModels.open(path, type="Python")
chimera.setLastSession(path)
class OpenSessionDialog(OpenModeless):
name = "Open Session"
title = "Choose Previously Saved Chimera Session File"
def __init__(self):
OpenModeless.__init__(self, command=_openCB,
filters=[("Chimera session", ["*.py"])],
def mouse_mode_icon(file_name):
import os.path
icon_path = os.path.join(os.path.dirname(__file__), file_name)
from PIL import Image
image = Image.open(icon_path)
from chimera import chimage
from chimera import tkgui
icon = chimage.get(image, tkgui.app)
return icon
# -----------------------------------------------------------------------------
#
def constrained_move_dialog(create=0):
from chimera import dialogs
return dialogs.find(Constrained_Move_Dialog.name, create=create)
# -----------------------------------------------------------------------------
#
def show_constrained_move_dialog():
from chimera import dialogs
return dialogs.display(Constrained_Move_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Constrained_Move_Dialog.name, Constrained_Move_Dialog,
replace = 1)
3,
itemtype="window",
window=toggle,
style=self._checkButtonStyle)
row += 1
def _updateHisListingData(self):
newData = {}
default = {
'delta': 'HID',
'epsilon': 'HIE',
'both': 'HIP',
self.HB: 'HID'
}[self.hisDefault.getvalue()]
for m in [s.molecule for s in self.surfListBox.getvalue()]:
for r in m.residues:
if r.type not in ["HIS", "HIE", "HIP", "HID"]:
continue
try:
newData[r] = self.hisListingData[r]
except KeyError:
if r.type == 'HIS':
newData[r] = default
else:
newData[r] = r.type
self.hisListingData = newData
from chimera import dialogs
dialogs.register(EspDialog.name, EspDialog)
from AddCharge import knownChargeModels, defaultChargeModel
from chimera import dialogs
self.parmsetOption = Pmw.OptionMenu(self.clientArea,
labelpos='w', label_text="Select force field type: ",
initialitem=defaultChargeModel, items=knownChargeModels)
# not always shown; remember row number
self._msmRow = row
self.parmsetOption.grid(row=row, column=0, sticky='w')
row += 1
def Apply(self):
paths = self.getPaths()
path = paths[0]
model = self.modelMenu.getvalue()
if not model:
self.enter()
raise UserError("No model chosen to save.")
from WritePrmtop import writePrmtop
from AddCharge.gui import checkNoCharges
chargeModel = self.parmsetOption.getvalue()
checkNoCharges([model], lambda ur, ua, model=model,
path=paths[0], parmset=chargeModel[6:]:
writePrmtop(model, path, parmset, unchargedAtoms=ua),
"prmtop output", chargeModel=chargeModel)
from chimera.dialogs import register
register(WritePrmtopDialog.name, WritePrmtopDialog)
title="Write 2D Labels Info") self._writeFileDialog.enter() from chimera.tkoptions import SymbolicEnumOption oglFont = chimera.OGLFont from Ilabel import FONT_STYLE_LABELS, FONT_STYLE_VALUES class FontStyle(SymbolicEnumOption): attribute = "style" labels = FONT_STYLE_LABELS values = FONT_STYLE_VALUES from Ilabel import FONT_TYPEFACE_LABELS, FONT_TYPEFACE_VALUES class FontTypeface(SymbolicEnumOption): attribute = "fontName" labels = FONT_TYPEFACE_LABELS values = FONT_TYPEFACE_VALUES from OpenSave import OpenModeless class ReadFileDialog(OpenModeless): title="Read 2D Labels Info" def fillInUI(self, parent): OpenModeless.fillInUI(self, parent) self.deleteExistingVar = Tkinter.IntVar(parent) self.deleteExistingVar.set(False) Tkinter.Checkbutton(self.clientArea, variable=self.deleteExistingVar, text="Delete existing labels").grid() from chimera import dialogs dialogs.register(IlabelDialog.name, IlabelDialog)
def simple_distance_dialog(create=0):
"""Looks for Measure Stick dialog.
simple_distance_dialog(create=0)
If create = 1, then creates a new dialog if dialog does not exist.
"""
from chimera import dialogs
return dialogs.find(Measure_Stick.name, create=create)
# -------------------------------------------------------------------------
# Main dialog.
#
def show_simple_distance_dialog():
"""Shows the Measure Stick dialog.
show_simple_distance_dialog()
"""
from chimera import dialogs
return dialogs.display(Measure_Stick.name)
# -------------------------------------------------------------------------
# Register dialog with Chimera.
#
from chimera import dialogs
dialogs.register(Measure_Stick.name,Measure_Stick,replace=1)
# -------------------------------------------------------------------------
hide_diagonals = (b,b,b,b,b,b,b,b,b,b,b,b)
if surface_model:
# Replace the geometry of the first piece.
p = surface_model.surfacePieces[0]
p.geometry = vlist, qlist
p.triangleAndEdgeMask = hide_diagonals
else:
import _surface
surface_model = _surface.SurfaceModel()
rgba = tuple(rgb) + (1,)
piece = surface_model.addPiece(vlist, qlist, rgba)
piece.displayStyle = piece.Mesh
piece.useLighting = False
piece.triangleAndEdgeMask = hide_diagonals
piece.outline_box = True
return surface_model
# -----------------------------------------------------------------------------
#
def show_unit_cell_dialog():
from chimera import dialogs
return dialogs.display(Unit_Cell_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Unit_Cell_Dialog.name, Unit_Cell_Dialog, replace = 1)
sf = Hybrid.float_variable_value(self.subdivision_factor, 1.0)
c.set_subdivision_factor(sf)
cap_offset = Hybrid.float_variable_value(self.cap_offset,
c.default_cap_offset)
c.set_cap_offset(cap_offset)
c.show_caps()
else:
c.unshow_caps()
# -----------------------------------------------------------------------------
#
def capper_dialog(create=0):
from chimera import dialogs
return dialogs.find(Capper_Dialog.name, create=create)
# -----------------------------------------------------------------------------
#
def show_capper_dialog():
from chimera import dialogs
return dialogs.display(Capper_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Capper_Dialog.name, Capper_Dialog, replace=1)
},
increment=0.1)
self.scale.pack(side=Tkinter.BOTTOM,
expand=Tkinter.FALSE,
fill=Tkinter.X)
from chimera.widgets import ModelScrolledListBox
self.modListBox = ModelScrolledListBox(parent,
listbox_selectmode="extended",
labelpos="n",
label_text="Models")
self.modListBox.pack(side=Tkinter.LEFT,
expand=Tkinter.TRUE,
fill=Tkinter.BOTH)
def Apply(self):
modList = self.modListBox.getvalue()
if len(modList) == 0:
import chimera
raise chimera.UserError("No models selected")
ef = self.scale.component("entryfield")
if not ef.valid():
import chimera
raise chimera.UserError(ScaleErrorText)
s = float(ef.getvalue())
import base
base.tile(modList, s)
from chimera import dialogs
dialogs.register(TileStructuresCB.name, TileStructuresCB)
if self.surface_model:
import chimera
chimera.openModels.close([self.surface_model])
# ---------------------------------------------------------------------------
#
def surface_closed_cb(self, event = None):
self.surface_model = None
self.surface_piece = None
# -----------------------------------------------------------------------------
#
def icosahedron_dialog(create = 0):
from chimera import dialogs
return dialogs.find(Icosahedron_Dialog.name, create=create)
# -----------------------------------------------------------------------------
#
def show_icosahedron_dialog():
from chimera import dialogs
return dialogs.display(Icosahedron_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Icosahedron_Dialog.name, Icosahedron_Dialog, replace = 1)
from CGLtk.Hybrid import float_variable_value
d = float_variable_value(self.contact_distance)
if d == None:
self.message('Distance value required')
return
make_copies = self.copy_molecule.get()
from CrystalContacts import show_crystal_contacts
cm = show_crystal_contacts(m, d, make_copies, replace = True)
# -----------------------------------------------------------------------------
#
def crystal_contacts_dialog(create = False):
from chimera import dialogs
return dialogs.find(Crystal_Contacts_Dialog.name, create=create)
# -----------------------------------------------------------------------------
#
def show_crystal_contacts_dialog():
from chimera import dialogs
return dialogs.display(Crystal_Contacts_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Crystal_Contacts_Dialog.name, Crystal_Contacts_Dialog,
replace = True)
def Options(self):
self.options_panel.set(not self.options_panel.get())
# ---------------------------------------------------------------------------
#
def chosen_surface(self):
sm = self.surface_menu
surface = sm.getvalue()
return surface
# -----------------------------------------------------------------------------
#
def dust_dialog(create = False):
from chimera import dialogs
return dialogs.find(Dust_Dialog.name, create=create)
# -----------------------------------------------------------------------------
#
def show_dust_dialog():
from chimera import dialogs
return dialogs.display(Dust_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Dust_Dialog.name, Dust_Dialog, replace = True)
msec = int(1000 * time_out)
self.time_out_id = self.top.after(msec, self.time_out_cb)
# ---------------------------------------------------------------------------
#
def time_out_value(self):
try:
return float(self.time_out.get())
except ValueError:
return None
# ---------------------------------------------------------------------------
#
def time_out_cb(self):
self.time_out_id = None
self.key_buffer = ''
self.status('')
# ---------------------------------------------------------------------------
#
def time_out_changed_cb(self):
self.preferences['time out'] = self.time_out.get()
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Accelerator_Browser.name, Accelerator_Browser, replace = 1)
'ctrl button 1': ('1', ['Ctrl']),
'button 2': ('2', []),
'ctrl button 2': ('2', ['Ctrl']),
'button 3': ('3', []),
'ctrl button 3': ('3', ['Ctrl'])
}
bspec = name_to_bspec[bname]
return bspec
# -----------------------------------------------------------------------------
#
def blob_picker_dialog(create=False):
from chimera import dialogs
return dialogs.find(Blob_Picker_Dialog.name, create=create)
# -----------------------------------------------------------------------------
#
def show_blob_picker_dialog():
from chimera import dialogs
return dialogs.display(Blob_Picker_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Blob_Picker_Dialog.name, Blob_Picker_Dialog, replace=1)
buttons.append(name) buttons.sort(lambda a, b: cmp(a.lower(), b.lower())) index = buttons.index(name) if index == len(buttons)-1: addFunc = actionButtons.add else: addFunc = actionButtons.insert kw['beforeComponent'] = buttons[index+1] but = apply(addFunc, (name,), kw) but.config(default='disabled') if balloon: help.register(but, balloon=balloon) from chimera import dialogs dialogs.register(ModelPanel.name, ModelPanel) def _setAttr(m, field, value, openState=0): if openState: setattr(m.openState, field, value) else: setattr(m, field, value) # functions used in model panel button; could be called directly also def setModelField(models, field, value, openState=0): for m in models: _setAttr(m, field, value, openState) def setModelFieldOnly(models, field, onVal=1, offVal=0, openState=0): # turn off first, then on, so that models not in the models list # that nonetheless have shared openStates get the 'on' value
for d in dlist:
refs = sys.getrefcount(d.value) - 2
line = '%8.1f %6d %s' % (d.size / mb, refs , d.description)
listbox.insert('end', line)
limit = dcache.size
used = reduce(lambda t, d: t + d.size, dlist, 0)
heading = ('%d objects using %.0f of %.0f Mb' %
(len(dlist), used/mb, limit/mb))
heading = heading + '\nSize (Mb) In use Description'
self.object_list_heading['text'] = heading
# ---------------------------------------------------------------------------
#
def data_cache(self):
from VolumeData import data_cache
return data_cache
# -----------------------------------------------------------------------------
#
def show_memory_use_dialog():
from chimera import dialogs
return dialogs.display(Memory_Use_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Memory_Use_Dialog.name, Memory_Use_Dialog, replace = 1)
line = line.strip()
colon = line.find(':')
if colon == -1 or colon + 1 == len(line):
osInfo[i] = escape(line)
continue
osInfo[i] = '<i>%s</i>%s' % (escape(line[:colon]), escape(line[colon:]))
info = "%s%s" % (openglInfo, '<br>'.join(osInfo))
return info
from chimera import dialogs, replyobj
from BugReportGUI import BugReportGUI, BugNotification
def displayDialog(wait=False):
if dialogs.find(BugReportGUI.name):
replyobj.status("Bug report already in progress!",
color="red", blankAfter=15)
return None
else:
br_gui = dialogs.display(BugReportGUI.name, wait)
return br_gui
def bugNotify(explanation, description):
BugNotification(explanation, description)
dialogs.register(BugReportGUI.name, BugReportGUI)
return [], False
# ---------------------------------------------------------------------------
#
def Options(self):
self.options_panel.set(not self.options_panel.get())
# -----------------------------------------------------------------------------
#
def saxs_dialog(create=False):
from chimera import dialogs
return dialogs.find(SAXS_Dialog.name, create=create)
# -----------------------------------------------------------------------------
#
def show_saxs_dialog():
from chimera import dialogs
return dialogs.display(SAXS_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(SAXS_Dialog.name, SAXS_Dialog, replace=True)
start, end = path[:-4], ".mol2"
else:
start, end = path, ""
for m in models:
modelPath = start + m.oslIdent()[1:] + end
replyobj.status("Writing %s (%s) to %s\n" %
(m.name, m.oslIdent(), modelPath))
writeMol2(m, modelPath, **kw)
replyobj.status("Wrote %s (%s) to %s\n" %
(m.name, m.oslIdent(), modelPath))
return
kw["multimodelHandling"] = key
# write multiple models to single file
replyobj.status("Writing multiple models to %s\n" % path)
writeMol2(models, path, **kw)
replyobj.status("Wrote multiple models to %s\n" % path)
def _modelsChange(self, *args):
if len(openModels.listIds()) > 1:
self.untransformedButton.grid_forget()
self.relativeFrame.grid(row=self._rfRow,
column=0, sticky='w')
else:
self.relativeFrame.grid_forget()
self.untransformedButton.grid(row=self._rfRow,
column=0, sticky='w')
from chimera.dialogs import register
register(WriteMol2Dialog.name, WriteMol2Dialog)
chimera.setLastSession(paths[0])
class SaveSessionDialog(SaveModeless):
name = "Save Session"
title = "Choose Session Save File"
def __init__(self):
SaveModeless.__init__(self,
command=_saveCB,
filters=[("Chimera session", ["*.py"], ".py")],
historyID="SimpleSession",
compressed=True)
dialogs.register(SaveSessionDialog.name, SaveSessionDialog)
def _openCB(okayed, dialog):
if not okayed:
return
for path in dialog.getPaths():
chimera.openModels.open(path, type="Python")
chimera.setLastSession(path)
class OpenSessionDialog(OpenModeless):
name = "Open Session"
title = "Choose Previously Saved Chimera Session File"
def __init__(self):
start_time = t
elapsed_time = 0
while elapsed_time < averaging_interval:
function()
count = count + 1
t = time.time() # use wall clock time
elapsed_time = t - start_time
if elapsed_time == 0:
rate = 0
else:
rate = count / float(elapsed_time)
return rate
# -----------------------------------------------------------------------------
#
def show_benchmark_dialog():
from chimera import dialogs
return dialogs.display(Benchmark_Dialog.name)
# -----------------------------------------------------------------------------
#
from chimera import dialogs
dialogs.register(Benchmark_Dialog.name, Benchmark_Dialog, replace=1)
#dialogs.register(Benchmark_Dialog.name, Benchmark_Dialog)
pass def insert(self, pos, text): self['text'] = text def get(self): return self['text'] def index(self, *args, **kw): return 0 def selection_present(self): return 0 def xview(self, *args, **kw): pass def icursor(self, *args, **kw): pass from chimera import dialogs dialogs.register(StructMeasure.name, StructMeasure) def addRotation(bond): d = dialogs.find(StructMeasure.name) import types br = bondRotMgr.rotationForBond(bond, create=False) if br == None: br = bondRotMgr.rotationForBond(bond) else: d.enter() d.setCategoryMenu(BONDROTS) return br def addAngle(atoms): d = dialogs.display(StructMeasure.name) d._createAngle(atoms)
