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)