def setRRCByName(r, name):
rrc = findRRC(name)
if rrc:
rrc.setResidue(r)
else:
from chimera import replyobj
replyobj.error("cannot find ribbon residue class named %s" % name)
def apply(self, vFunc = None, eFunc = None):
sel = selection.ItemizedSelection()
sels = [] # used as a stack when selections get composited
funcGlobals = {
"__doc__": None,
"__name__": "CodeItemizedSelection",
"__builtins__": __builtins__
}
if self.models is None:
sm = chimera.openModels.list()
else:
sm = self.models
funcLocals = {
"models": sm,
"molecules": filter(lambda m, M=Molecule:
isinstance(m, M), sm),
"sel": sel,
"sels": sels,
"selection": selection
}
try:
exec self.codeObj in funcGlobals, funcLocals
except:
from chimera import replyobj
replyobj.error(" CodeItemizedSelection failed\n")
s = apply(traceback.format_exception,
sys.exc_info())
replyobj.message(string.join(s, ''))
sel.apply(vFunc, eFunc)
def prompt_message(DBG, TXT_TMP, SB, EB):
DBG = DBG + SB + TXT_TMP + EB
from chimera import replyobj
replyobj.error(TXT_TMP)
return DBG
def focus():
disped = [x for x in selAtoms() + selBonds() if x.shown()]
ribbons = [
x for x in selResidues()
if x.ribbonDisplay and x.hasRibbon() and x.molecule.display
]
disped.extend(ribbons)
disped.extend([
p for p in selectedSurfacePieces()
if p.display and p.model.display and p.triangleCount > 0
])
if not disped:
from chimera import replyobj
replyobj.error(
"No target atoms/bonds/ribbons/surfaces currently shown\n")
return
sel = selection.ItemizedSelection()
sel.add(disped)
sel.addImplied(edges=False)
from Midas import window, cofr
window(sel)
from chimera import openModels as om
if selection.currentEmpty():
from chimera import viewing, viewer
om.cofrMethod = viewing.defaultCofrMethod
viewer.clipping = False
else:
om.cofrMethod = om.CenterOfView
def Apply(self):
if not self.getPaths():
from chimera import replyobj
replyobj.error("No phylogeny file specified.\n")
self.enter()
return
self.mav.usePhylogenyFile(self.getPaths()[0])
def Apply(self):
if not self.getPaths():
replyobj.error("No EPS save file specified.\n")
self.enter()
return
self.mav.saveAssocInfo(self.getPaths()[0],
namingStyle=self.namingStyle.get())
def Apply(self):
if not self.getPaths():
from chimera import replyobj
replyobj.error("No phylogeny file specified.\n")
self.enter()
return
self.mav.usePhylogenyFile(self.getPaths()[0])
def Apply(self):
if not self.getPaths():
replyobj.error("No file specified.\n")
self.enter()
return
for path in self.getPaths():
self.mav.readHeaderFile(path)
def open_output_data_items(self, outdir, outfiles):
"""open_output_data_items(outdir, outfiles) - output menu.
Input:
outdir output file directory
outfiles output file
Add output data items in outfiles in outdir directory, to
output data menu.
"""
if len(outfiles) == 0:
return
filepaths = map(lambda outfile: os.path.join(outdir, outfile),
outfiles)
filepaths_valid = filter(lambda p: os.path.isfile(p), filepaths)
self.output_panel.data_open_cb(filepaths_valid)
if len(filepaths_valid) < len(outfiles):
msg = 'Some or all output files not found!\n'
self.status(msg, color='red', blankAfter=10)
replyobj.error(msg)
return
def statusCB(self):
self.task.updateStatus(self.opal.currentStatus())
if not self.opal.isFinished():
self.opal.queryStatus()
return
self.task = None
fileMap = self.opal.getOutputs()
if self.opal.isFinished() > 0:
# Successful completion
self.finishCB(self.getURLContent(
fileMap[self.outputFile]))
else:
# Failed
from chimera import replyobj
replyobj.error("blastpdb %s failed; "
"see Reply Log for more information"
% self.queryName)
try:
self.showURLContent("blastpdb stdout",
fileMap["stdout"])
except KeyError:
pass
try:
self.showURLContent("blastpdb stderr",
fileMap["stderr"])
except KeyError:
pass
def _makeXSection(self):
try:
checkXSection(self.closed, self.points)
except ValueError, s:
from chimera import replyobj
replyobj.error(s)
return False
def Apply(self):
if not self.getPaths():
replyobj.error("No file specified.\n")
self.enter()
return
for path in self.getPaths():
self.mav.readHeaderFile(path)
def browse(self):
if self.menuOption.var.get() == self.menuoptions[0]:
modellist = chimera.openModels.list(
modelTypes=[chimera.Molecule])
# if no molecules (and i mean MOLECULES)
# are open in chimera...
if not modellist:
replyobj.error('There are no molecules open')
return
if len(modellist) > 1:
modellist = chooseModels(self.parent,
modelTypes=[chimera.Molecule])
if modellist:
#print 'writing pdb to file...'
# make a pdb file for the model
self._removeTempFile()
self.var.set(self._writeTempFile(modellist))
self.displayVar.set(modellist[0].name)
#print 'set file name.'
else:
if hasattr(self, '_openDialog'):
self._openDialog.enter()
return
from OpenSave import OpenModeless
self._openDialog = OpenModeless(command=self._openCB,
title='Select %s' % self.name, multiple=0,
historyID="Delphi PDB", compressed=False)
def Apply(self):
if not self.getPaths():
replyobj.error("No header save file specified.\n")
self.enter()
return
self.mav.saveHeader(self.getPaths()[0], self.headerChoice.get(),
omitNoValue=self.omitNoValueVar.get())
def apply(self, vFunc=None, eFunc=None):
sel = selection.ItemizedSelection()
sels = [] # used as a stack when selections get composited
funcGlobals = {
"__doc__": None,
"__name__": "CodeItemizedSelection",
"__builtins__": __builtins__
}
if self.models is None:
sm = chimera.openModels.list()
else:
sm = self.models
funcLocals = {
"models": sm,
"molecules": filter(lambda m, M=Molecule: isinstance(m, M), sm),
"sel": sel,
"sels": sels,
"selection": selection
}
try:
exec self.codeObj in funcGlobals, funcLocals
except:
from chimera import replyobj
replyobj.error(" CodeItemizedSelection failed\n")
s = apply(traceback.format_exception, sys.exc_info())
replyobj.message(string.join(s, ''))
sel.apply(vFunc, eFunc)
def _createRotation(self):
selBonds = selection.currentBonds()
if len(selBonds) == 1:
addRotation(selBonds[0])
return
replyobj.error("Exactly one bond must be selected "
"in graphics window\n")
def fileName(self):
paths = self.getPaths()
if not paths:
from chimera import replyobj
replyobj.error("No file selected\n")
return
return paths[0]
def setXSectionByName(r, name):
xs = findXSection(name)
if xs:
xs.setResidue(r)
else:
from chimera import replyobj
replyobj.error("cannot find ribbon XS named %s" % name)
def _makeXSection(self): try: checkXSection(self.closed, self.points) except ValueError, s: from chimera import replyobj replyobj.error(s) return False
def cmdAddNonstdCharge(residues, netCharge, method="am1", gaffType=True):
from Midas.midas_text import MidasError
if not residues:
raise MidasError("No such residues")
resName, numAtoms = residues[0].type, len(residues[0].atoms)
for r in residues[1:]:
if r.type != resName:
raise MidasError("Residues not all the same type"
" (%s != %s)" % (resName, r.type))
if numAtoms != len(r.atoms):
raise MidasError("Residues have differing number of"
" atoms (%d != %d)" % (numAtom, len(r.atoms)))
if not chimera.nogui:
from AddH.gui import checkNoHyds
checkNoHyds(
residues,
lambda residues=residues, nc=netCharge, method=method, gt=gaffType,
status=replyobj.status: addNonstandardResCharges(
residues, nc, method=method, gaffType=gt, status=status),
process)
return
try:
addNonstandardResCharges(residues,
netCharge,
method=method,
gaffType=gaffType,
status=replyobj.status)
except ChargeError, v:
replyobj.error(str(v))
def _removeAngle(self, remove=None):
if len(self.angleInfo) == 0:
replyobj.error("No angles to remove\n")
return
if remove is None:
if len(self.angleInfo) == 1:
remove = self.angleInfo
else:
remove = self.angleTable.selected()
if not remove:
replyobj.error("Must select angle(s) in table\n")
return
for rm in remove:
self.angleInfo.remove(rm)
self.angleTable.setData(self.angleInfo)
if len(self.angleInfo) == 0:
self.angleButtons.button("Remove").config(
state='disabled')
from SimpleSession import SAVE_SESSION
chimera.triggers.deleteHandler(SAVE_SESSION, self._angleSesTrigID)
if self._osHandler:
stillNeedHandler = False
for info in self.angleInfo:
models = dict.fromkeys([a.molecule
for a in info[0]])
if len(models) > 1:
stillNeedHandler = True
break
if not stillNeedHandler:
chimera.triggers.deleteHandler('OpenState',
self._osHandler)
self._osHandler = None
def fileName(self):
paths = self.getPaths()
if not paths:
from chimera import replyobj
replyobj.error("No file selected\n")
return
return paths[0]
def setXSectionByName(r, name):
xs = findXSection(name)
if xs:
xs.setResidue(r)
else:
from chimera import replyobj
replyobj.error("cannot find ribbon XS named %s" % name)
def _errorRateCB(self): if not self.errorRateEntry.valid(): replyobj.error( "Bad auto-association error rate value.\n") return self.mav.prefs[ASSOC_ERROR_RATE] = int( self.errorRateEntry.get())
def _sessionRestore(self, info):
from SimpleSession import idLookup
for bondID, anchorID, delta, rotID in info:
bond = idLookup(bondID)
dup = False
for br in self.rotations.values():
if br.bond == bond:
from chimera import replyobj
replyobj.error("Active torsion in session file same as"
" existing active torsion; skipping")
dup = True
break
if dup:
continue
anchorSide = idLookup(anchorID)
if delta:
# need to make rotation have same delta as original
bondRot = BondRot(bond)
bondRot.angle = (-delta, anchorSide)
bondRot.destroy()
if rotID in self.rotations:
rotID = None
br = self.rotationForBond(bond, requestedID=rotID)
br.anchorSide = anchorSide
if delta:
br.set(delta)
def get_morph_models(self):
"""get_morph_models() - get init and final morph models
Output:
model0 morph model initial (None if invalid)
model1 morph model final (None if invalid)
Return the inital and final morph models,
after checking.
"""
morph0 = self.morph_init_menu.getvalue()
morph1 = self.morph_final_menu.getvalue()
morph0 = self.check_morph_model(morph0)
morph1 = self.check_morph_model(morph1)
if morph0 == None or morph1 == None:
return None, None
morph0_path = morph0.openedAs[0]
morph1_path = morph1.openedAs[0]
if morph0_path == morph1_path:
msg = 'Select 2 different PDB models!\n'
self.status(msg, color='red', blankAfter=10)
replyobj.error(msg)
return None, None
return morph0, morph1
def Apply(self):
if not self.getPaths():
replyobj.error("No EPS save file specified.\n")
self.enter()
return
self.mav.saveAssocInfo(self.getPaths()[0],
namingStyle=self.namingStyle.get())
def _read_mask_parameters(self, param_id, param_type):
if param_id not in range(18):
return None
param_tag_set = ['p0 ','p1 ','p2 ',
'size - x ','size - y ','size - z ',
'origin - x ','origin - y ','origin - z ',
'app - x ','app - y ','app - z ',
'tx ','ty ','tz ',
'az ','alt','phi']
param_tag = param_tag_set[param_id]
mask_param = self.mask_parameters[param_id]
try:
if param_type == 'float_type':
param = float(mask_param.variable.get())
elif param_type == 'int_type':
param = int(mask_param.variable.get())
except:
msg = 'Check parameter %s value!\n' % param_tag
self.status(msg, color='red', blankAfter=10)
replyobj.error(msg)
return None
return param
def __newWrap(self):
mav, prefPrefix = self.__dialog.mav, self.__prefPrefix
if self.__wrapVar.get() == 0:
mav.prefs[prefPrefix + WRAP_IF] = 0
mav.prefs[prefPrefix + WRAP] = 1
elif self.__wrapVar.get() == 1:
mav.prefs[prefPrefix + WRAP_IF] = 0
mav.prefs[prefPrefix + WRAP] = 0
else:
mav.prefs[prefPrefix + WRAP_IF] = 1
valid = 0
if self.__lineWidthEntry.valid():
lineWidth = 10 * int(self.__lineWidthEntry.get())
if lineWidth > 0:
valid = 1
mav.prefs[prefPrefix + LINE_WIDTH] = lineWidth
if not valid:
replyobj.error("Line width must be positive integer\n")
if not prefPrefix:
valid = 0
if self.__wrapThresholdEntry.valid():
threshold = int(self.__wrapThresholdEntry.get())
if threshold > 0:
valid = 1
mav.prefs[prefPrefix + WRAP_THRESHOLD] = threshold
if not valid:
replyobj.error("'Number of sequences for line wrapping'"
" must be positive integer\n")
if (len(mav.seqs) == 1) == bool(prefPrefix):
self.__callback()
def browse(self):
if self.menuOption.var.get() == self.menuoptions[0]:
modellist = chimera.openModels.list(modelTypes=[chimera.Molecule])
# if no molecules (and i mean MOLECULES)
# are open in chimera...
if not modellist:
replyobj.error('There are no molecules open')
return
if len(modellist) > 1:
modellist = chooseModels(self.parent,
modelTypes=[chimera.Molecule])
if modellist:
#print 'writing pdb to file...'
# make a pdb file for the model
self._removeTempFile()
self.var.set(self._writeTempFile(modellist))
self.displayVar.set(modellist[0].name)
#print 'set file name.'
else:
if hasattr(self, '_openDialog'):
self._openDialog.enter()
return
from OpenSave import OpenModeless
self._openDialog = OpenModeless(command=self._openCB,
title='Select %s' % self.name,
multiple=0,
historyID="Delphi PDB",
compressed=False)
def _getMatchResidues(self, match, mol):
# Since the match sequence may be a subset of the
# entire PDB structure, we cannot do the same thing
# as for the reference model where we created the
# match sequence from the structure. Instead, we
# find the best match of match sequence to
# structure sequence using Needleman&Wunsch, and
# then pull the residues corresponding to the
# match sequence.
matchSeq = [ s for s in match.sequence if s != '-' ]
parts = match.pdb.split('_')
try:
chain = parts[1]
except IndexError:
chain = ' '
seq = None
for s in mol.sequences():
if s.chain == chain or chain is None:
seq = s
break
else:
replyobj.error("%s: chain '%s' not found\n"
% (match.pdb, chain))
return None
self.loaded[match] = mol
return self._getResidues(matchSeq, seq.sequence, seq.residues)
def __newWrap(self):
mav, prefPrefix = self.__dialog.mav, self.__prefPrefix
if self.__wrapVar.get() == 0:
mav.prefs[prefPrefix + WRAP_IF] = 0
mav.prefs[prefPrefix + WRAP] = 1
elif self.__wrapVar.get() == 1:
mav.prefs[prefPrefix + WRAP_IF] = 0
mav.prefs[prefPrefix + WRAP] = 0
else:
mav.prefs[prefPrefix + WRAP_IF] = 1
valid = 0
if self.__lineWidthEntry.valid():
lineWidth = 10 * int(self.__lineWidthEntry.get())
if lineWidth > 0:
valid = 1
mav.prefs[prefPrefix + LINE_WIDTH] = lineWidth
if not valid:
replyobj.error("Line width must be positive integer\n")
if not prefPrefix:
valid = 0
if self.__wrapThresholdEntry.valid():
threshold = int(self.__wrapThresholdEntry.get())
if threshold > 0:
valid = 1
mav.prefs[prefPrefix + WRAP_THRESHOLD] = threshold
if not valid:
replyobj.error("'Number of sequences for line wrapping'"
" must be positive integer\n")
if (len(mav.seqs) == 1) == bool(prefPrefix):
self.__callback()
def Apply(self):
paths_and_types = file_descriptions_to_types(self.getPathsAndTypes())
grids, error_message = open_grid_files(paths_and_types)
if error_message:
from chimera import replyobj
replyobj.error(error_message)
self.grid_objects_cb(grids)
def Apply(self):
if not self.getPaths():
from chimera import replyobj
replyobj.error("No coloring file specified.\n")
self.enter()
return
self.mav.useColoringFile(self.getPaths()[0],
makeDefault=self.defaultVar.get())
def validate(self):
for field in self.fields:
field.invoke()
if not field.valid():
replyobj.error("Invalid value for %s\n" %
field.cget("label_text"))
return False
return True
def setRRCByName(r, name):
rrc = findRRC(name)
if rrc:
rrc.setResidue(r)
else:
from chimera import replyobj
replyobj.error("cannot find ribbon residue class named %s"
% name)
def validate(self):
for field in self.fields:
field.invoke()
if not field.valid():
replyobj.error("Invalid value for %s\n" %
field.cget("label_text"))
return False
return True
def Apply(self):
paths_and_types = file_descriptions_to_types(self.getPathsAndTypes())
grids, error_message = open_grid_files(paths_and_types)
if error_message:
from chimera import replyobj
replyobj.error(error_message)
self.grid_objects_cb(grids)
def morph_apply(self):
"""morph_apply() - applies appropriate morphing
Applies appropriate morphing after Apply button
is specified. Checks values and passes a message if
incorrect parameters.
"""
# check input data exists
if self.data_item == None:
name = '%s' % (self.data_panel.data_menu.variable.get())
msg = 'Input data %s not found!\n' % name
self.status(msg, color='red', blankAfter=15)
replyobj.error(msg)
return
# get input file path, name, and size in pixels
infile_path = str(self.data_item.path)
infile = str(self.data_item.name)
infile_size = self.data_item.size
# get morph models
morph0, morph1 = self.get_morph_models()
if (morph0 == None or morph1 == None):
return
# get morph parameters
morph_type = self.morph_type.variable.get()
if morph_type == self.morph_choices[0]:
frac, thr, filt = self.get_simple_morph_param()
# check and set output name
self.output_item = None
outfile = str(self.data_output.variable.get())
if (outfile == '') or (outfile == infile):
first_part, last_part = self.name_and_dot_suffix(infile)
outfile = '%s-m%s' % (first_part, last_part)
msg = 'Using default output file %s\n'% outfile
replyobj.info(msg)
self.data_output.variable.set(outfile)
# output
out_dir = os.getcwd()
out_files = [outfile]
# run morph command
seg_sucess = 0
if morph_type == self.morph_choices[0]:
seg_success = self.morph_apply_simple(self.data_item,
morph0, morph1, outfile, frac, thr, filt)
# open output
if seg_success:
self.open_output_data_items(out_dir, out_files)
self.enter()
return
def _changeSlab(self, event = None):
self.model.useClipThickness = self.slabVar.get()
try:
thick = float(self.slabThicknessVar.get())
except ValueError:
replyobj.error("Invalid slab thickness.\n")
return
self.model.clipThickness = thick
def _changeSlab(self, event=None):
self.model.useClipThickness = self.slabVar.get()
try:
thick = float(self.slabThicknessVar.get())
except ValueError:
replyobj.error("Invalid slab thickness.\n")
return
self.model.clipThickness = thick
def _createDistance(self):
"""'Create distance' callback"""
selAtoms = selection.currentAtoms()
if len(selAtoms) != 2:
replyobj.error("Exactly two atoms must be selected "
"in graphics window\n")
return
addDistance(*tuple(selAtoms))
def Apply(self):
if not self.getPaths():
replyobj.error("No EPS save file specified.\n")
self.enter()
return
self.mav.saveEPS(self.getPaths()[0],
colorMode=self.colorMode.get(),
rotate=self.orientation.get(),
extent=self.extent.get(),
hideNodes=self.hideNodes.get())
def setScalingByName(r, name):
try:
sc = userScaling[name]
except KeyError:
try:
sc = systemScaling[name]
except KeyError:
from chimera import replyobj
replyobj.error("no ribbon scaling named \"%s\"" % name)
return
sc.setResidue(r)
def _handleRequest(self, function_cb, check): if check: # make sure all options are properly filled out for pagetitle, optionsgroup in self.options: for grouptitle, optionslist in optionsgroup: for option in optionslist: error = option.checkError() if error: replyobj.error(error) return function_cb(self.options)
def setScalingByName(r, name):
try:
sc = userScaling[name]
except KeyError:
try:
sc = systemScaling[name]
except KeyError:
from chimera import replyobj
replyobj.error("no ribbon scaling named \"%s\"" % name)
return
sc.setResidue(r)
def _sessionRestore(self, data):
if not data:
return
version = data.get("version")
try:
f = self._restoreVersionMap[version]
except KeyError:
replyobj.error("Version %d of NormalModesTable not supported "
"in this version of Chimera.\n" % version)
else:
f(self, data)
def _handleRequest(self, function_cb, check):
if check:
# make sure all options are properly filled out
for pagetitle, optionsgroup in self.options:
for grouptitle, optionslist in optionsgroup:
for option in optionslist:
error = option.checkError()
if error:
replyobj.error(error)
return
function_cb(self.options)
def Apply(self):
path = self.getPaths()[0]
surf = self.surfList.getvalue()
if not surf:
replyobj.error("No surface chosen to save.\n")
return
from WriteDMS import writeDMS
replyobj.status("Writing DMS surface to %s\n" % path)
writeDMS(surf, path, writeNormals=self.saveNormalsVar.get(),
displayedOnly=self.displayedOnlyVar.get())
replyobj.status("Wrote DMS surface to %s\n" % path)
def _finish(self, results):
if self.blastTable is None:
# We already quit, so UI is gone
return
from Parser import Parser
import os.path
try:
self.parser = Parser(self.basename, results,
self.program == "psiblast")
except SyntaxError, s:
replyobj.error("BLAST error: %s\n" % s)
return
def _removeDistance(self):
if len(self.distances) == 1:
removeDistance(self.distances[0])
return
if len(self.distances) == 0:
replyobj.error("No distances to remove\n")
return
if not self.distTable.selected():
replyobj.error("Must select distance in table\n")
return
for d in self.distTable.selected():
removeDistance(d)
def checkEntries(self, user=None, email=None, **kw):
##check if name is in valid format
if user == '' or not ',' in user:
replyobj.error("Please re-enter Name in the form 'Last, First'.\n")
return False
##check that they've entered a valid email address
if email == '' or not ('@' in email):
replyobj.error("Please enter a valid email address.\n")
return False
return True
def saveui_save(self, name):
if name in Reserved:
from chimera import replyobj
replyobj.error("%s is a reserved name. "
"Please choose a different name." % name)
return False
try:
checkXSection(self.closed, self.points)
except ValueError, s:
from chimera import replyobj
replyobj.error(s)
return False
def Apply(self):
if not self.getPaths():
replyobj.error("No pseudobond file chosen\n")
lineWidth = self.lineWidth.get()
prefs["line width"] = lineWidth
for path in self.getPaths():
readPBinfo(path, category=self.catName.get(),
clearCategory=self.clearCat.get(),
lineWidth=lineWidth, drawMode=None,
leftModel=str(self.leftModel.get()),
rightModel=str(self.rightModel.get()),
defColor=None)
def Apply(self):
molList = chimera.openModels.list(modelTypes=[chimera.Molecule])
selList = self.molecules.curselection()
if len(selList) != 1:
return
molName, molId, molSubid = self.molList[int(selList[0])]
for m in molList:
if m.id == molId and m.subid == molSubid:
mol = m
break
else:
replyobj.error('No selected molecule')
return
base.initialize()
wrl = vrml.Transform()
helices = base.displayHelices(mol, self.helixColor,
self.helixFixedRadius.get(),
self.helixRadius.get(),
self.helixSplit.get(),
self.helixSplitRatio.get())
for node in helices:
wrl.addChild(node)
strands = base.displayStrands(mol, self.strandColor,
self.strandFixedWidth.get(),
self.strandWidth.get(),
self.strandFixedThickness.get(),
self.strandThickness.get(),
self.strandSplit.get(),
self.strandSplitRatio.get())
for node in strands:
wrl.addChild(node)
if self.displayTurns.get():
turns = base.displayTurns(mol, self.turnColor,
self.turnWidth.get(),
self.turnThickness.get())
for node in turns:
wrl.addChild(node)
base.deinitialize()
if not helices and not strands and not turns:
replyobj.error('No helices, sheets, nor turns found')
return
try:
chimera.openModels.close(self.openModels[mol])
except KeyError:
pass
mList = chimera.openModels.open(vrml.vrml(wrl),
type='VRML',
sameAs=mol,
identifyAs='%s - Pipes and Planks' %
mol.name)
self.openModels[mol] = mList[0]
self.openModels[mList[0]] = None
def report_memory_error(size, value_type):
from numpy import dtype, product, float
vtype = dtype(value_type)
tsize = vtype.itemsize
bytes = product(size, dtype=float) * float(tsize)
mbytes = bytes / 2**20
sz = ','.join(['%d' % s for s in size])
e = ('Could not allocate %.0f Mbyte array of size %s and type %s.\n' %
(mbytes, sz, vtype.name))
from chimera import replyobj, CancelOperation
replyobj.error(e)
raise CancelOperation, e
def Apply(self):
from ModelPanel import ModelPanel
from chimera import dialogs
mp = dialogs.find(ModelPanel.name, create=1)
sels = mp.selected()
if len(sels) != 1:
replyobj.error("Must choose exactly one model"
" in model panel.\n")
return
refXform = sels[0].openState.xform
for model in self.models:
model.openState.xform = refXform
def Apply(self):
mols = self.molListBox.getvalue()
if not mols:
self.enter()
replyobj.error("No models chosen in dialog\n")
return
for path in self.getPaths():
setAttrs = addAttributes(path, models=mols,
log=self.doLog.get(),
raiseAttrDialog=self.openDialog.get())
if setAttrs == []:
replyobj.error("No attributes were set from"
" file %s\n" % path)
def saveui_save(self, name):
if name in Reserved:
from chimera import replyobj
replyobj.error("%s is a reserved name. "
"Please choose a different name."
% name)
return False
try:
checkXSection(self.closed, self.points)
except ValueError, s:
from chimera import replyobj
replyobj.error(s)
return False
