""" qtgui/mgPreferences.py: CCP4MG Molecular Graphics Program Copyright (C) 2001-2008 University of York, CCLRC Copyright (C) 2009-2011 University of York Copyright (C) 2012 STFC This library is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License version 3, modified in accordance with the provisions of the license to address the requirements of UK law. You should have received a copy of the modified GNU Lesser General Public License along with this library. If not, copies may be downloaded from http://www.ccp4.ac.uk/ccp4license.php This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. """ from PyQt4 import QtGui,QtCore from global_definitions import * import guiUtils import MolLabel import functools #----------------------------------------------------------------------- #----------------------------------------------------------------------- #----------------------------------------------------------------------- class preferenceButtons(QtGui.QFrame): #----------------------------------------------------------------------- #----------------------------------------------------------------------- #----------------------------------------------------------------------- def __init__(self,parent): QtGui.QFrame.__init__(self,parent) layout = QtGui.QHBoxLayout() text = dict ( apply = 'Apply', reset = 'Reset defaults', help = 'Help', close = 'Close' ) for item in ['apply','reset','help','close']: #widget = QtGui.QPushButton(text[item],parent) widget = QtGui.QToolButton(parent) widget.setText(text[item]) widget.setSizePolicy(QtGui.QSizePolicy.Expanding,QtGui.QSizePolicy.Preferred) widget.setObjectName(item) layout.addWidget(widget) if item == "apply": menu = QtGui.QMenu(self) applyAll = menu.addAction("Apply to all") widget.setMenu(menu) applyAll.setObjectName('apply_all') self.setLayout(layout) #----------------------------------------------------------------------- #----------------------------------------------------------------------- #----------------------------------------------------------------------- class preferencesBrowser(QtGui.QDialog): #----------------------------------------------------------------------- #----------------------------------------------------------------------- #----------------------------------------------------------------------- typeNode = 1001 typeLeaf = 1002 plugin_preferences = [] def show(self): self.loadNewWidget(self.visibleWidget.objectName()) QtGui.QDialog.show(self) def __init__(self,parent=None,height=400,width=350): super(preferencesBrowser,self).__init__(parent) self.scrollHeight = height self.visibleWidget = None self.container_width= width top_layout = QtGui.QVBoxLayout() layout = QtGui.QHBoxLayout() layout.setSizeConstraint(QtGui.QLayout.SetFixedSize) # LHS tree widget to select preference mode scroll = QtGui.QScrollArea(self) self.tree = self.drawTree('model_drawing_style') scroll.setWidget(self.tree ) scroll.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) scroll.setMinimumHeight(height) scroll.setMinimumWidth(150) self.tree.setMinimumHeight(height) layout.addWidget(scroll) self.connect(self.tree,QtCore.SIGNAL('itemSelectionChanged()'),self.handleTreeClick) # RHS container for chosen preference widget scroll = QtGui.QScrollArea(self) scroll.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff) self.scrollWidth=scroll.verticalScrollBar().height() scroll.setMinimumHeight(height) scroll.setMinimumWidth(width+self.scrollWidth) scrollLayout = QtGui.QVBoxLayout() scrollLayout.setContentsMargins(0,0,0,0) self.scrollHead = QtGui.QLabel() scrollLayout.addWidget(self.scrollHead) scrollLayout.addWidget(scroll) layout.addLayout(scrollLayout,10) #layout.addWidget(scroll,10) self.container = scroll self.buttons = preferenceButtons(self) for item in ['apply','reset','help','close']: self.connect(self.buttons.findChild(QtGui.QWidget,item),QtCore.SIGNAL('clicked(bool)'),guiUtils.partial(self.handleButtons,item)) self.buttons.findChild(QtGui.QAction,'apply_all') self.buttons.findChild(QtGui.QAction,'apply_all').setEnabled(False) self.connect(self.buttons.findChild(QtGui.QAction,'apply_all'),QtCore.SIGNAL('triggered(bool)'),guiUtils.partial(self.handleButtons,'apply_all')) top_layout.addItem(layout) top_layout.addWidget(self.buttons) self.setLayout(top_layout) self.window().setWindowTitle('Preferences') self.loadNewWidget('model_drawing_style') self.connect(DISPLAYTABLE(),QtCore.SIGNAL("CustomDrawingStyleChanged"),self.handleCustomDrawingStyleChanged) def handleCustomDrawingStyleChanged(self): self.loadNewWidget(self.visibleWidget.objectName()) #----------------------------------------------------------------------- def handleButtons(self,item): #----------------------------------------------------------------------- if item == 'apply': self.visibleWidget.apply() elif item == 'reset': self.visibleWidget.resetDefaults() elif item == 'help': self.visibleWidget.help() elif item == 'close': self.window().close() elif item == 'apply_all': self.visibleWidget.applyAll() else: print "Unknown request:",item #----------------------------------------------------------------------- def drawTree(self,selected=''): #----------------------------------------------------------------------- import types selected_item = None tree = QtGui.QTreeWidget() treeDef = self.getGuiDef('preferenceGroups') for node in treeDef: mdef = self.getGuiDef(node) if mdef: item = QtGui.QTreeWidgetItem([node],preferencesBrowser.typeNode) tree.addTopLevelItem(item) for action in mdef: item0 = self.makeTreeWidgetItem(action) if item0: item.addChild(item0) if action == selected: selected_item = item0 tree.headerItem().setHidden(1) if selected and selected_item: tree.setCurrentItem(selected_item) return tree #----------------------------------------------------------------------- def makeTreeWidgetItem(self,name): #----------------------------------------------------------------------- adef = self.getActionDef(name) #print "adef",adef if adef: item = QtGui.QTreeWidgetItem([adef.get('text','')],preferencesBrowser.typeLeaf) #icon = QtGui.QIcon(guiUtils.loadPixmap(adef.get('icon','unknown'))) #item.setIcon(0,icon) #icon.setSizeHint(0,QtCore.QSize(32,32)) item.setText(1,adef.get('text','')) toolTip = adef.get('toolTip') if toolTip: item.setToolTip(0,toolTip) item.setData(1,QtCore.Qt.UserRole,QtCore.QVariant(name)) else: item = None return item #----------------------------------------------------------------------- def loadNewWidget(self,mode): #----------------------------------------------------------------------- if mode == 'font_browser': self.buttons.findChild(QtGui.QAction,'apply_all').setEnabled(True) else: self.buttons.findChild(QtGui.QAction,'apply_all').setEnabled(False) self.scrollHead.setText("") self.scrollHead.hide() # Check not already loaded # Ignore this now (SJM 13/9/2010), we sometimes want to update the contents, # which are defined here. #if self.visibleWidget and mode == self.visibleWidget.objectName(): return # Close existing visible widget if self.visibleWidget: self.visibleWidget.close() # Find or create appropriate preference widget self.visibleWidget = self.findChild(QtGui.QWidget,mode) # See above, we might be redrawing "model_drawing_style". if self.visibleWidget and self.visibleWidget.objectName()!="model_drawing_style": self.visibleWidget.show() else: if mode == 'pick_atom_label_style': self.visibleWidget = pickAtomLabelStyleGui(self,params=PICKLABEL().getparams(),width=self.container_width) elif mode == 'moldisp_atom_label_style': self.visibleWidget = moldispAtomLabelStyleGui(self,width=self.container_width,params=PM('atom_label_params').getparams()) self.visibleWidget.setObjectName('GenericMolLabel') self.visibleWidget.connect(self.visibleWidget,QtCore.SIGNAL('apply'),self.visibleWidget.applyDefaultMolLabel) elif mode == 'HBond_drawing_style': self.visibleWidget = hbondStyleGui(self,pm=PM('HBond_drawing_style'),width=self.container_width) elif mode == 'font_browser': import FontBrowser self.visibleWidget = FontBrowser.FontBrowser(self,params=FONTMANAGER().getparams()) elif mode == 'mouse_bindings': import MouseBindings self.visibleWidget = MouseBindings.MouseBindings(self,params=MAINWINDOW().mouseBindings()) else: pm = PM(mode) if pm: #print "loadNewWidget getCustomGui", pm.getCustomGui() import services if isinstance(pm,services.ColourSchemeManager): self.visibleWidget = colourManagerGui(self,pm=pm,width=self.container_width) else: self.visibleWidget = paramsManagerGui(self,pm=pm,width=self.container_width) if hasattr(pm,"apply_action") and callable(pm.apply_action): self.visibleWidget.connect(self.visibleWidget,QtCore.SIGNAL('apply'),pm.apply_action) if mode == "model_drawing_style": obj_list = get_dispobj(object_type='MolDisp') customs = [] for o in obj_list: if hasattr(o,'drawingStylePM'): customs.append(o) print o if len(customs)>0: text = "Caution some objects have custom drawing styles:
" for i,cust in zip(range(len(customs)),customs): text = text+cust.parent.name_label+':' if len(cust.SelHandle.label) > 16: text = text + str(cust.SelHandle.label)[0:16] +'...' else: text = text + str(cust.SelHandle.label) text = text + "("+cust.style_label+")" if i < len(customs)-1: text = text + "
" self.scrollHead.setText(text) self.scrollHead.show() self.visibleWidget.show() else: return self.visibleWidget.setObjectName(mode) adef = self.getActionDef(mode) self.window().setWindowTitle('Preferences '+ adef.get('text','')) # Put the new widget in the container self.container.setWidget(self.visibleWidget) #print "loadNewWidget width",self.visibleWidget.width(),self.container.width(),self.container.verticalScrollBar().height() self.container.setMinimumWidth(self.visibleWidget.width()+self.scrollWidth) self.setMinimumWidth(self.visibleWidget.width()+self.scrollWidth+self.tree.width()) help_button = self.buttons.findChild(QtGui.QWidget,'help') if help_button: help_button.setEnabled(True) if help_button and hasattr(self.visibleWidget,"_has_no_help_") and self.visibleWidget._has_no_help_: help_button.setEnabled(False) if help_button and hasattr(self.visibleWidget,"pm") and getattr(self.visibleWidget.pm,'help','') and getattr(self.visibleWidget.pm,'help','') == '_has_no_help_': help_button.setEnabled(False) #----------------------------------------------------------------------- def getGuiDef(self,name): #----------------------------------------------------------------------- #print "Preferences.getGuiDef",name if name == "preferenceGroups": return [ "Model display" , 'Model colours', 'Model analysis', 'Surfaces', 'Maps', 'Display', 'Images and movies', 'Behaviour', 'Tools', 'Applications', 'Plugins preferences' ] if name == "Model display": return ['model_drawing_style','HBond_drawing_style','moldisp_atom_label_style','pick_atom_label_style'] if name == "Model colours": import services return services.ColourSchemeManager.colour_pref_alias if name == "Model analysis": return ['HBond_param','Contacts_param','SecStr_param','SASArea_param'] if name == 'Surfaces': return ['surface_drawing_style','Surface_electro'] if name == "Display": return ['render_quality','font_browser','Animation_param','stereo_prefs','ambient_occlusion_prefs','miscell_prefs'] if name == "Maps": return ['MapDispParamsManager'] if name == "Images and movies": #return ['screenshot_preferences','movie_preferences','povray_preferences'] return ['screenshot_preferences','movie_preferences'] if name == 'Behaviour': return ['user_interface','mouse_bindings','save_session_options','centre_mode','advanced_options'] if name == 'Tools': return ['download_preferences'] if name == 'Plugins preferences': return self.plugin_preferences #----------------------------------------------------------------------- def getActionDef(self,name=''): #----------------------------------------------------------------------- # Give definitions for actions for each item in the preferences # selection gui. Note that QActions are currently *NOT* created # but they may be so they can appear of other menus in future name = str(name) if name == 'pick_atom_label_style': return dict ( text = "Pick atom label style", slot = guiUtils.partial(self.loadNewWidget,'pick_atom_label_style'), toolTip = 'Set label content and maximum number of labels on picked atoms' ) if name == 'moldisp_atom_label_style': return dict ( text = "Atom label style", slot = guiUtils.partial(self.loadNewWidget,'moldisp_atom_label_style'), toolTip = 'Set label content and select which atoms are labelled' ) if name == 'hbond_style': return dict ( text = "HBond drawing style", slot = guiUtils.partial(self.loadNewWidget,'hbond_style'), toolTip = 'Set default drawing style and labelling for Hydrogen bonds' ) if name == 'font_browser': return dict ( text = 'Fonts', slot = guiUtils.partial(self.loadNewWidget,'font_browser'), toolTip = 'Change the default fonts for atom labels, legend etc.', ) if name == 'mouse_bindings': return dict ( text = 'Mouse bindings', slot = guiUtils.partial(self.loadNewWidget,'mouse_bindings'), toolTip = 'Change the mouse binding for rotate,translate,zoom etc', ) import services if services.ColourSchemeManager.colour_pref_alias.count(name): return dict ( text = services.ColourSchemeManager.colour_pref_menu[ services.ColourSchemeManager.colour_pref_alias.index(name)], slot = guiUtils.partial(self.loadNewWidget,name) ) pm = PM(name) #print 'mgpreferences',name,pm if pm: return dict ( text = pm.getTitle(), slot = guiUtils.partial(self.loadNewWidget,name) ) return {} #----------------------------------------------------------------------- def handleTreeClick(self): #----------------------------------------------------------------------- item = self.tree.currentItem() if item.type() != preferencesBrowser.typeLeaf: return adef = self.getActionDef(item.data(1,QtCore.Qt.UserRole).toString()) #print "handleTreeClick",adef widget = apply(adef['slot'],[],{}) #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- class preferenceGui(QtGui.QWidget): #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- def __init__(self,parent,width=350): QtGui.QWidget.__init__(self,parent) self.setFixedWidth(width) self.block_signal = 0 #------------------------------------------------------------------- def setBlockSignal(self,block=0): #------------------------------------------------------------------- #print "setBlockSignal",block self.block_signal = block #------------------------------------------------------------------- def resetDefaults(self): #------------------------------------------------------------------- #print 'resetDefaults',self.defaults() self.setParams(self.defaults()) #------------------------------------------------------------------- def apply(self): #------------------------------------------------------------------- #print "preferenceGui apply" self.emit(QtCore.SIGNAL('apply')) def help(self): self.emit(QtCore.SIGNAL('help')) #------------------------------------------------------------------- def handleChange(self): #------------------------------------------------------------------- #print "paramsManagerGui.handleChange" if not self.block_signal: self.emit(QtCore.SIGNAL('changed')) #------------------------------------------------------------------- def handleChange1(self,p): #------------------------------------------------------------------- #print "paramsManagerGui.handleChange1" if not self.block_signal: self.emit(QtCore.SIGNAL('changed')) #------------------------------------------------------------------- def defaults(self): #------------------------------------------------------------------- return {} def setParams(self,params={},**kw): pass def getParams(self): return {} class ScrollEater(QtCore.QObject): def __init__(self,parent=None): QtCore.QObject.__init__(self,parent) self.receiver = None def setScrollReceiver(self,receiver): self.receiver = receiver def eventFilter(self, obj, event): if event.type() == QtCore.QEvent.Wheel: #Eat wheel events if self.receiver is not None: QtGui.QApplication.sendEvent(self.receiver,event) return True else: #standard event processing return QtCore.QObject.eventFilter(self, obj, event) #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- class paramsManagerGui(preferenceGui): #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- def __init__(self,parent,pm,width=350): preferenceGui.__init__(self,parent,width=width) self.pm = pm self.setObjectName(pm.name) self.draw() self.setParams(self.pm.getparams()) #------------------------------------------------------------------- def getDirectory(self,widget,text): #------------------------------------------------------------------- import mgWidgets fd = mgWidgets.MGOpenFileDialog(self,title=self.tr(text)) self.connect(fd,QtCore.SIGNAL('open'),fd.close) self.connect(fd,QtCore.SIGNAL('open'),widget.setText) fd.setModal(True) fd.show() #------------------------------------------------------------------- def draw(self): #------------------------------------------------------------------- import mgWidgets self.window().setWindowTitle(self.pm.getTitle()) layout = QtGui.QVBoxLayout() scrollEater = ScrollEater(self) scrollEater.setScrollReceiver(self) for name in self.pm.getGuiDef(): defn = self.pm.getParamDef(name) #print "paramsManagerGui.draw",name,defn style = defn.get('style','lineedit') widget= None if style == 'fileedit': widget = QtGui.QLineEdit(self) locationButton = QtGui.QPushButton("...") self.connect(widget,QtCore.SIGNAL('editingFinished()'),self.handleChange) self.connect(locationButton,QtCore.SIGNAL('clicked(bool)'),functools.partial(self.getDirectory,widget,defn.get('label',''))) elif style == 'spacer': size = defn.get('size',30) layout.addSpacing(size) elif style == 'label': # This is a dummy widget widget = QtGui.QLabel(self) elif style == 'lineedit': widget = QtGui.QLineEdit(self) self.connect(widget,QtCore.SIGNAL('editingFinished()'),self.handleChange) if defn.get('type',''): val = None if defn['type'] == float: val = QtGui.QDoubleValidator(self) elif defn['type'] == int: val = QtGui.QIntValidator(self) if val: widget.setValidator(val) if defn.get('max','') != '': val.setTop(defn['max']) if defn.get('min','') != '': val.setBottom(defn['max']) elif style == 'spinbox': if defn.get('type',int) == int: widget = QtGui.QSpinBox(self) self.connect(widget,QtCore.SIGNAL('valueChanged(int)'),self.handleChange) else: widget = QtGui.QDoubleSpinBox(self) self.connect(widget,QtCore.SIGNAL('valueChanged(double)'),self.handleChange) widget.installEventFilter(scrollEater) if defn.get('max','') != '': widget.setMaximum(defn['max']) if defn.get('min','') != '': widget.setMinimum(defn['min']) if defn.get('step','') != '': widget.setSingleStep(defn['step']) elif style == 'checkbox': widget = QtGui.QCheckBox(self) self.connect(widget,QtCore.SIGNAL('stateChanged(int)'),self.handleChange) elif style == 'combobox': widget = QtGui.QComboBox(self) widget.installEventFilter(scrollEater) for item in defn.get('menu',[]): widget.addItem(QtCore.QString(item)) if defn.get('onchange','') != '': widget.connect(widget,QtCore.SIGNAL("currentIndexChanged(const QString&)"),functools.partial(defn.get('onchange',''),self)) elif style == 'doublecolourslider': widget = mgWidgets.DoubleColourSlider(self) if defn.get('min','') != '' and defn.get('max','') != '': widget.slider.setRange(defn['min'],defn['max']) if defn.get('lowerValue','') != '': widget.slider.lowerSpin.setValue(defn['lowerValue']) if defn.get('upperValue','') != '': widget.slider.upperSpin.setValue(defn['upperValue']) if defn.get('lowerColour','') != '': widget.lowColourCombo.set_colour(defn['lowerColour']) if defn.get('upperColour','') != '': widget.highColourCombo.set_colour(defn['upperColour']) elif style == 'colourcombo': widget = mgWidgets.mgColourCombo(self,'red',browser=1) widget.installEventFilter(scrollEater) if widget: line = QtGui.QWidget(self) line_layout = QtGui.QHBoxLayout(line) line_layout.setContentsMargins(0,0,0,0) #line_layout.setSpacing(0) widget.setObjectName(name) #widget.setMaximumWidth(100) label = QtGui.QLabel(defn.get('label',''),self) line_layout.addWidget(label) line_layout.addWidget(widget) line_layout.setAlignment(label,QtCore.Qt.AlignLeft) line_layout.setAlignment(widget,QtCore.Qt.AlignRight) line.setLayout(line_layout) if style == 'fileedit': line_layout.addWidget(locationButton) locationButton.setMaximumWidth(20) layout.addWidget(line) #buttons = self.drawButtons() #layout.addWidget(buttons) self.setLayout(layout) if hasattr(self.pm,"onCreate") and callable(self.pm.onCreate): self.pm.onCreate(self) #------------------------------------------------------------------- def setParams(self,params={},**kw): #------------------------------------------------------------------- import mgWidgets params.update(kw) #print "paramsManagerGui.setParams",params self.setBlockSignal(1) for key,value in params.items(): widget = self.findChild(QtGui.QWidget,key) if widget: if isinstance(widget,QtGui.QLineEdit): widget.setText(QtCore.QString(value)) elif isinstance(widget,QtGui.QAbstractSpinBox): widget.setValue(value) elif isinstance(widget,QtGui.QCheckBox): widget.setChecked(value) elif isinstance(widget,mgWidgets.mgColourCombo): widget.setCurrentIndex(widget.findText(value)) elif isinstance(widget,QtGui.QComboBox): defn = self.pm.getParamDef(key) ii = -1 if defn.get('alias',[]).count(value): ii = defn.get('alias',[]).index(value) elif defn.get('menu',[]).count(value): ii = defn.get('menu',[]).index(value) #print "paramsManagerGui.setParams",key,value,ii,defn.get('alias',[]), defn.get('menu',[]) if ii>=0: widget.setCurrentIndex(ii) self.setBlockSignal(0) #------------------------------------------------------------------- def getParams(self): #------------------------------------------------------------------- import mgWidgets params= {} for key in self.pm.getGuiDef(): widget = self.findChild(QtGui.QWidget,key) if widget: if isinstance(widget,QtGui.QLineEdit): params[key] = str(widget.text()) elif isinstance(widget,QtGui.QAbstractSpinBox): params[key] = widget.value() elif isinstance(widget,QtGui.QCheckBox): params[key] = int(widget.isChecked()) elif isinstance(widget,mgWidgets.mgColourCombo): params[key] = widget.get_colour() elif isinstance(widget,QtGui.QComboBox): defn = self.pm.getParamDef(key) alias_list = defn.get('alias',[]) if not alias_list: alias_list=defn.get('menu',[]) params[key] = alias_list[widget.currentIndex()] elif isinstance(widget,mgWidgets.DoubleColourSlider): params.update(widget.getValues()) #print "paramsManagerGui.getParams",params return params #------------------------------------------------------------------- def defaults(self): #------------------------------------------------------------------- return self.pm.getDefaults() #------------------------------------------------------------------- def help(self): #------------------------------------------------------------------- target = getattr(self.pm,'help','') plugin = getattr(self.pm,'plugin','') if target: HELPBROWSER().loadMgHelp(target,plugin=plugin) #------------------------------------------------------------------- def apply(self): #------------------------------------------------------------------- # Update the ParamsManager self.pm.setparams(self.getParams()) # Emit an apply signal in case something else is connected to it preferenceGui.apply(self) #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- class colourManagerGui(preferenceGui): #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- interpolate_menu = ['no interpolation','around colour wheel','between RGB values'] interpolate_alias = ['NO','HSV','RGB'] direction_menu = ['clockwise','anti-clockwise'] def __init__(self,parent,pm,width=350): preferenceGui.__init__(self,parent,width=width) self.pm = pm self.setObjectName(pm.name) #print "colourManagerGui to draw",self.pm.name self.draw(width) self.setParams(self.pm.getparams()) #------------------------------------------------------------------- def draw(self,width=350): #------------------------------------------------------------------- import mgWidgets self.window().setWindowTitle('Colour '+self.pm.getTitle()) layout = QtGui.QVBoxLayout() height=0 scrollEater = ScrollEater(self) scrollEater.setScrollReceiver(self) if self.pm.getParamDef('ranges').get('type','str')=='float': line_layout = QtGui.QHBoxLayout() widget = QtGui.QLabel('Below range',self) line_layout.addWidget(widget) widget = mgWidgets.mgColourCombo(self,'magenta') widget.installEventFilter(scrollEater) widget.setObjectName('colour0') line_layout.addWidget(widget) widget = QtGui.QLabel('above range',self) line_layout.addWidget(widget) widget = mgWidgets.mgColourCombo(self,'magenta') widget.installEventFilter(scrollEater) widget.setObjectName('colourn') line_layout.addWidget(widget) height = height+widget.height() layout.addLayout(line_layout) line_layout = QtGui.QHBoxLayout() widget = QtGui.QLabel('Interpolate between colours:',self) line_layout.addWidget(widget) widget = QtGui.QComboBox(self) for label in colourManagerGui.interpolate_menu: widget.addItem(QtCore.QString(label)) widget.installEventFilter(scrollEater) widget.setObjectName('interpolate_mode') line_layout.addWidget(widget) height = height+widget.height() layout.addLayout(line_layout) line_layout = QtGui.QHBoxLayout() widget = QtGui.QLabel('RGB interpolation around colour wheel:',self) line_layout.addWidget(widget) widget = QtGui.QComboBox(self) for label in colourManagerGui.direction_menu: widget.addItem(QtCore.QString(label)) widget.installEventFilter(scrollEater) widget.setObjectName('colour_wheel_direction') line_layout.addWidget(widget) height = height+widget.height() layout.addLayout(line_layout) self.fixed_content_height = height + 40 ifEditable = self.pm.getParamDef('ranges').get('extensible',1) self.exFrame = mgWidgets.extendingFrame(self,widget=colourLine,ifEditable=ifEditable,width=width-30,ifApply=0,height=self.parent().container.height()-self.fixed_content_height) layout.addWidget(self.exFrame) self.setLayout(layout) #------------------------------------------------------------------- def setParams(self,params={},**kw): #------------------------------------------------------------------- import mgWidgets params.update(kw) widget = self.findChild(QtGui.QComboBox,'interpolate_mode') if widget and params.has_key('interpolate_mode') and colourManagerGui.interpolate_alias.count(params['interpolate_mode']): widget.setCurrentIndex( colourManagerGui.interpolate_alias.index(params['interpolate_mode'])) widget = self.findChild(QtGui.QComboBox,'colour_wheel_direction') if widget and params.has_key('colour_wheel_direction') and colourManagerGui.direction_menu.count(params['colour_wheel_direction']): widget.setCurrentIndex( colourManagerGui.direction_menu.index(params['colour_wheel_direction'])) if params.has_key('colours') and params.has_key('ranges'): if self.pm.getParamDef('ranges').get('type','str')=='float': self.findChild(mgWidgets.mgColourCombo,'colour0').set_colour(params['colours'][0]) self.findChild(mgWidgets.mgColourCombo,'colourn').set_colour(params['colours'][-1]) pars = { 'ranges' : params['ranges'][1:-1], 'colours' : params['colours'][1:-1] } self.setBlockSignal(1) self.exFrame.setParams(pars) self.setBlockSignal(0) else: self.setBlockSignal(1) self.exFrame.setParams(params) self.setBlockSignal(0) #------------------------------------------------------------------- def getParams(self): #------------------------------------------------------------------- import mgWidgets params = self.exFrame.getParams({'ranges':[],'colours':[]}) if self.pm.getParamDef('ranges').get('type','str')=='float': params['ranges'].insert(0,0.0) params['ranges'].append(0.0) params['colours'].insert(0,str(self.findChild(mgWidgets.mgColourCombo,'colour0').get_colour())) params['colours'].append(str(self.findChild(mgWidgets.mgColourCombo,'colourn').get_colour())) params['interpolate_mode']=colourManagerGui.interpolate_alias[self.findChild(QtGui.QComboBox,'interpolate_mode').currentIndex()] params['colour_wheel_direction']=colourManagerGui.direction_menu[self.findChild(QtGui.QComboBox,'colour_wheel_direction').currentIndex()] #print "colourManagerGui.getParams",params return params #------------------------------------------------------------------- def defaults(self): #------------------------------------------------------------------- return self.pm.getDefaults() #------------------------------------------------------------------- def apply(self): #------------------------------------------------------------------- # Update the ParamsManager #print "colourManagerGui.apply" self.pm.setparams(self.getParams()) # Emit an apply signal in case something else is connected to it preferenceGui.apply(self) import rebuild rebuild.UpdateDisplay() #-------------------------------------------------------------------- def help(self): #-------------------------------------------------------------------- HELPBROWSER().loadMgHelp(file='model.html#colour') #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- class colourLine(QtGui.QWidget): #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- def __init__(self,parent=None): import mgWidgets QtGui.QWidget.__init__(self,parent) #print "ColourBlendLine parent",parent layout = QtGui.QHBoxLayout() layout.setContentsMargins(0,0,0,0) layout.setSpacing(0) scrollEater = ScrollEater(self) scrollEater.setScrollReceiver(self) # get a definition for the 'ranges' parameter defn = self.parent().pm.getParamDef('ranges') style = defn.get('style','lineedit') #print "colourLine defn",defn,'style',style if style == 'label': widget = QtGui.QLabel(self) elif style == 'lineedit': widget = QtGui.QLineEdit(self) elif style == 'spinbox': if defn.get('type','float') == 'float': widget = QtGui.QDoubleSpinBox(self) else: widget = QtGui.QSpinBox(self) widget.setMinimum(defn.get('min',0.0)) widget.setMaximum(defn.get('max',1.0)) widget.setSingleStep(defn.get('step',0.1)) widget.setObjectName('ranges') widget.setToolTip('Data value') layout.addWidget(widget) widget = mgWidgets.mgColourCombo(self,'magenta',browser=1) widget.installEventFilter(scrollEater) widget.setObjectName('colours') widget.setToolTip('Colour') layout.addWidget(widget) self.setLayout(layout) #----------------------------------------------------------------------- def setDefault(self): #----------------------------------------------------------------------- self.findChild(QtGui.QWidget,'ranges').setValue(0.0) self.findChild(QtGui.QWidget,'colours').set_colour('magenta') #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- class atomLabelStyle(preferenceGui): #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- def __init__(self,parent,params={},width=350,**kw): preferenceGui.__init__(self,parent,width=width) #QtGui.QWidget.__init__(self,parent) self.autoUpdate = 1 self.draw() pars = self.defaults() pars.update(params) pars.update(kw) self.setParams(pars) #------------------------------------------------------------------- def defaults(self): #------------------------------------------------------------------- return dict ( label_style = MolLabel.DEFAULT_LABEL_STYLE, truncate_mol_name_length = 6, truncate_mol_name = 0 ) #------------------------------------------------------------------- def setParams(self,params={},**kw): #------------------------------------------------------------------- params.update(kw) #print "atomLabelStyle.setParams",params self.setBlockSignal(1) if params.has_key('truncate_mol_name'): self.findChild(QtGui.QWidget,'truncate_mol_name').setChecked(params['truncate_mol_name']) if params.has_key('truncate_mol_name_length'): self.findChild(QtGui.QWidget,'truncate_mol_name_length').setValue(params['truncate_mol_name_length']) if params.has_key('label_style'): ll = min(len(params['label_style']),len(MolLabel.LABEL_STYLE_PARAM)) for ii in range(0,ll): widget = self.findChild(QtGui.QWidget,MolLabel.LABEL_STYLE_PARAM[ii]) if widget: widget.setChecked(params['label_style'][ii]) self.setBlockSignal(0) #------------------------------------------------------------------- def getParams(self): #------------------------------------------------------------------- pars = {} pars['truncate_mol_name'] = self.findChild(QtGui.QWidget,'truncate_mol_name').isChecked() pars['truncate_mol_name_length'] = self.findChild(QtGui.QWidget,'truncate_mol_name_length').value() label_style = [] for item in MolLabel.LABEL_STYLE_PARAM: label_style.append(int(self.findChild(QtGui.QWidget,item).isChecked())) pars['label_style'] = label_style #print "getParams",pars return pars #------------------------------------------------------------------- def draw(self): #------------------------------------------------------------------- layout = self.layout() line = QtGui.QWidget() line_layout = QtGui.QHBoxLayout() widget = QtGui.QCheckBox('Truncate model name to',self) if self.autoUpdate: self.connect(widget,QtCore.SIGNAL('released()'),self.apply) widget.setObjectName('truncate_mol_name') line_layout.addWidget(widget) widget = QtGui.QSpinBox(self) widget.setObjectName('truncate_mol_name_length') widget.setRange(0,100) if self.autoUpdate: self.connect(widget,QtCore.SIGNAL('valueChanged(int)'),self.apply) line_layout.addWidget(widget) line_layout.addStretch() line.setLayout(line_layout) nr = layout.rowCount() layout.addWidget(line,nr,0,1,2) nr = nr + 1 ii = -1 for order in MolLabel.LABEL_STYLE_GUI_ORDER: label = MolLabel.LABEL_STYLE_PARAM[order] widget = QtGui.QCheckBox(MolLabel.LABEL_STYLE_ALIAS[order],self) widget.setObjectName(label) ii = ii + 1 layout.addWidget(widget,nr+ii/2,ii%2,1,1) if self.autoUpdate: self.connect(widget,QtCore.SIGNAL('released()'),self.apply) #----------------------------------------------------------------------- def setDefault(self): #----------------------------------------------------------------------- self.setParams(self.defaults()) #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- class pickAtomLabelStyleGui(atomLabelStyle): #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- def __init__(self,parent,params={},width=350,**kw): params.update(kw) atomLabelStyle.__init__(self,parent,params,width=width) #------------------------------------------------------------------- def setParams(self,params={},**kw): #------------------------------------------------------------------- params.update(kw) self.setBlockSignal(1) atomLabelStyle.setParams(self,params) if params.has_key('max_labels'): self.findChild(QtGui.QWidget,'max_labels').setValue(params['max_labels']) self.setBlockSignal(1) #------------------------------------------------------------------- def getParams(self): #------------------------------------------------------------------- pars = atomLabelStyle.getParams(self) pars['max_labels'] = self.findChild(QtGui.QWidget,'max_labels').value() return pars #------------------------------------------------------------------- def defaults (self): #------------------------------------------------------------------- defs = atomLabelStyle.defaults(self) defs['max_labels'] = 20 return defs #------------------------------------------------------------------- def draw(self): #------------------------------------------------------------------- layout = QtGui.QGridLayout() self.setLayout(layout) atomLabelStyle.draw(self) line = QtGui.QWidget() line_layout = QtGui.QHBoxLayout() widget = QtGui.QLabel('Maximum number of picked atom labels') line_layout.addWidget(widget) widget = QtGui.QSpinBox(self) widget.setObjectName('max_labels') widget.setRange(0,999) line_layout.addWidget(widget) line_layout.addStretch() line.setLayout(line_layout) self.layout().addWidget(line,0,0,1,2) if self.autoUpdate: self.connect(widget,QtCore.SIGNAL('valueChanged(int)'),self.apply) #------------------------------------------------------------------- def apply(self): #------------------------------------------------------------------- #print "in apply" PICKLABEL().setparams(self.getParams()) #-------------------------------------------------------------------- def help(self): #-------------------------------------------------------------------- HELPBROWSER().loadMgHelp(file='display_menu.html#picked_atom_labels') #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- class moldispAtomLabelStyleGui(atomLabelStyle): #------------------------------------------------------------------- #------------------------------------------------------------------- #------------------------------------------------------------------- def __init__(self,parent,params={},width=350,**kw): #print "moldispAtomLabelStyleGui init params",params params.update(kw) atomLabelStyle.__init__(self,parent,params,width=width) #------------------------------------------------------------------- def setParams(self,params={},**kw): #------------------------------------------------------------------- params.update(kw) self.setBlockSignal(1) atomLabelStyle.setParams(self,params) if params.has_key('label_select'): idx = 0 if MolLabel.LABEL_SELECTION_MENU.count(params['label_select']): idx = MolLabel.LABEL_SELECTION_MENU.index(params['label_select']) elif MolLabel.LABEL_SELECTION_ALIAS.count(params['label_select']): idx = MolLabel.LABEL_SELECTION_ALIAS.index(params['label_select']) self.findChild(QtGui.QWidget,'label_select').setCurrentIndex(idx) self.setBlockSignal(0) #------------------------------------------------------------------- def getParams(self): #------------------------------------------------------------------- pars = atomLabelStyle.getParams(self) idx = self.findChild(QtGui.QWidget,'label_select').currentIndex() pars['label_select'] = MolLabel.LABEL_SELECTION_ALIAS[idx] return pars #------------------------------------------------------------------- def defaults (self): #------------------------------------------------------------------- defs = atomLabelStyle.defaults(self) defs['label_select'] = 'no' return defs #------------------------------------------------------------------- def draw(self): #------------------------------------------------------------------- layout = QtGui.QGridLayout() self.setLayout(layout) #line = QtGui.QWidget() #line_layout = QtGui.QHBoxLayout() #label = QtGui.QLabel('Atom label style') #line_layout.addWidget(label) #line_layout.addStretch() #line.setLayout(line_layout) #self.layout().addWidget(line,0,0,1,2) scrollEater = ScrollEater(self) scrollEater.setScrollReceiver(self) line = QtGui.QWidget() line_layout = QtGui.QHBoxLayout() widget = QtGui.QLabel('Put labels on') line_layout.addWidget(widget) widget = QtGui.QComboBox(self) widget.setObjectName('label_select') for item in MolLabel.LABEL_SELECTION_MENU: widget.addItem(item) widget.installEventFilter(scrollEater) line_layout.addWidget(widget) line_layout.addStretch() line.setLayout(line_layout) self.layout().addWidget(line,0,0,1,2) atomLabelStyle.draw(self) if self.autoUpdate: self.connect(widget,QtCore.SIGNAL('currentIndexChanged(int)'),self.apply) #-------------------------------------------------------------------- def help(self): #-------------------------------------------------------------------- HELPBROWSER().loadMgHelp(file='display_menu.html#atom_labels') #----------------------------------------------------------------------- def applyDefaultMolLabel(self): #----------------------------------------------------------------------- # Handle the apply for the gui to the default mollabels # - beware same class used for individual instances if MolLabel PM('atom_label_params').setparams(self.getParams()) import rebuild rebuild.UpdateDisplay() #-------------------------------------------------------------------- #-------------------------------------------------------------------- #-------------------------------------------------------------------- class hbondStyleGui(paramsManagerGui): #-------------------------------------------------------------------- #-------------------------------------------------------------------- #-------------------------------------------------------------------- #-------------------------------------------------------------------- def __init__(self,parent,pm=None,params={},width=350,doContacts=True,doHbonds=True): #-------------------------------------------------------------------- self.hbonds = doHbonds self.contacts = doContacts paramsManagerGui.__init__(self,parent,pm=pm,width=width) #-------------------------------------------------------------------- def draw(self): #-------------------------------------------------------------------- self.window().setWindowTitle(self.pm.getTitle()) layout = QtGui.QGridLayout() widget = QtGui.QLabel('Draw hydrogen bonds as',self) layout.addWidget(widget,0,0,1,2) if not self.hbonds: widget.hide() group = QtGui.QButtonGroup(self) widget = QtGui.QRadioButton('lines',self) widget.setObjectName('style_lines') group.addButton(widget) self.connect(widget,QtCore.SIGNAL('released()'),self.handleChange) layout.addWidget(widget,1,0,1,1) if not self.hbonds: widget.hide() widget = QtGui.QRadioButton('cylinders',self) widget.setObjectName('style_cylinders') group.addButton(widget) self.connect(widget,QtCore.SIGNAL('released()'),self.handleChange) layout.addWidget(widget,1,1,1,1) if not self.hbonds: widget.hide() widget = QtGui.QLabel('with width',self) layout.addWidget(widget,2,0,1,1) if not self.hbonds: widget.hide() widget = QtGui.QSpinBox(self) widget.setRange(1,8) widget.setObjectName('line_width') self.connect(widget,QtCore.SIGNAL('valueChanged(int)'),self.handleChange1) layout.addWidget(widget,2,1,1,1) if not self.hbonds: widget.hide() widget = QtGui.QCheckBox('Label with distance/bond length',self) widget.setObjectName('label_mode') layout.addWidget(widget,3,0,1,2) self.connect(widget,QtCore.SIGNAL('stateChanged(int)'),self.handleChange1) if not self.hbonds: widget.hide() widget = QtGui.QFrame(self) widget.setFrameShape(QtGui.QFrame.HLine); widget.setFrameShadow(QtGui.QFrame.Sunken); layout.addWidget(widget,5,0,1,2) if not self.contacts or not self.hbonds: widget.hide() widget = QtGui.QLabel('Draw contacts as',self) layout.addWidget(widget,6,0,1,2) if not self.contacts: widget.hide() group2 = QtGui.QButtonGroup(self) widget = QtGui.QRadioButton('lines',self) widget.setObjectName('contacts_style_lines') group2.addButton(widget) self.connect(widget,QtCore.SIGNAL('released()'),self.handleChange) layout.addWidget(widget,7,0,1,1) if not self.contacts: widget.hide() widget = QtGui.QRadioButton('cylinders',self) widget.setObjectName('contacts_style_cylinders') group2.addButton(widget) self.connect(widget,QtCore.SIGNAL('released()'),self.handleChange) layout.addWidget(widget,7,1,1,1) if not self.contacts: widget.hide() widget = QtGui.QLabel('with width',self) layout.addWidget(widget,8,0,1,1) if not self.contacts: widget.hide() widget = QtGui.QSpinBox(self) widget.setRange(1,8) widget.setObjectName('contacts_line_width') self.connect(widget,QtCore.SIGNAL('valueChanged(int)'),self.handleChange1) layout.addWidget(widget,8,1,1,1) if not self.contacts: widget.hide() widget = QtGui.QCheckBox('Label with distance/bond length',self) widget.setObjectName('contacts_label_mode') layout.addWidget(widget,9,0,1,2) self.connect(widget,QtCore.SIGNAL('stateChanged(int)'),self.handleChange1) if not self.contacts: widget.hide() self.setLayout(layout) #-------------------------------------------------------------------- def setParams(self,params={},**kw): #-------------------------------------------------------------------- params.update(kw) self.setBlockSignal(1) if params.has_key('contacts_line_style'): self.findChild(QtGui.QWidget,'contacts_style_lines').setChecked(params['contacts_line_style']=='lines') self.findChild(QtGui.QWidget,'contacts_style_cylinders').setChecked(params['contacts_line_style']=='cylinders') if params.has_key('contacts_line_width'): self.findChild(QtGui.QWidget,'contacts_line_width').setValue(params['contacts_line_width']) if params.has_key('contacts_label_mode'): self.findChild(QtGui.QWidget,'contacts_label_mode').setChecked(params['contacts_label_mode']) if params.has_key('line_style'): self.findChild(QtGui.QWidget,'style_lines').setChecked(params['line_style']=='lines') self.findChild(QtGui.QWidget,'style_cylinders').setChecked(params['line_style']=='cylinders') if params.has_key('line_width'): self.findChild(QtGui.QWidget,'line_width').setValue(params['line_width']) if params.has_key('label_mode'): self.findChild(QtGui.QWidget,'label_mode').setChecked(params['label_mode']) self.setBlockSignal(0) #-------------------------------------------------------------------- def getParams(self): #-------------------------------------------------------------------- params = {} if self.findChild(QtGui.QWidget,'contacts_style_lines').isChecked(): params['contacts_line_style']='lines' else: params['contacts_line_style']='cylinders' params['contacts_line_width'] = self.findChild(QtGui.QWidget,'contacts_line_width').value() params['contacts_label_mode'] = self.findChild(QtGui.QWidget,'contacts_label_mode').isChecked() if self.findChild(QtGui.QWidget,'style_lines').isChecked(): params['line_style']='lines' else: params['line_style']='cylinders' params['line_width'] = self.findChild(QtGui.QWidget,'line_width').value() params['label_mode'] = self.findChild(QtGui.QWidget,'label_mode').isChecked() return params