class DnaGeneratorPropertyManager(PM_Dialog, DebugMenuMixin):
"""
The DnaGeneratorPropertyManager class provides a Property Manager
for the "Build > Atoms" command.
@ivar title: The title that appears in the property manager header.
@type title: str
@ivar pmName: The name of this property manager. This is used to set
the name of the PM_Dialog object via setObjectName().
@type name: str
@ivar iconPath: The relative path to the PNG file that contains a
22 x 22 icon image that appears in the PM header.
@type iconPath: str
@ivar validSymbols: Miscellaneous symbols that may appear in the sequence
(but are ignored). The hyphen '-' is a special case
that must be dealt with individually; it is not
included because it can confuse regular expressions.
@type validSymbols: QString
"""
title = "DNA"
pmName = title
iconPath = "ui/actions/Tools/Build Structures/DNA.png"
validSymbols = QString(' <>~!@#%&_+`=$*()[]{}|^\'"\\.;:,/?')
# The following class variables guarantee the UI's menu items
# are synchronized with their action code. The arrays should
# not be changed, unless an item is removed or inserted.
# Changes should be made via only the _action... variables.
# e.g., Change _action_Complement from "Complement"
# to "Complement Sequences". The menu item will
# change and its related code will need no update.
_action_Complement = "Complement"
_action_Reverse = "Reverse"
_action_RemoveUnrecognized = 'Remove unrecognized letters'
_action_ConvertUnrecognized = 'Convert unrecognized letters to "N"'
_actionChoices = [
"Action", "---", _action_Complement, _action_Reverse,
_action_RemoveUnrecognized, _action_ConvertUnrecognized
]
_modeltype_PAM3 = "PAM3"
_modeltype_PAM5 = "PAM5"
_modeltype_Atomistic = "Atomistic" # deprecated
_modelChoices = [_modeltype_PAM3, _modeltype_PAM5]
def __init__(self):
"""
Constructor for the DNA Generator property manager.
"""
PM_Dialog.__init__(self, self.pmName, self.iconPath, self.title)
DebugMenuMixin._init1(self)
msg = "Edit the DNA parameters and select <b>Preview</b> to \
preview the structure. Click <b>Done</b> to insert it into \
the model."
# This causes the "Message" box to be displayed as well.
# setAsDefault=True causes this message to be reset whenever
# this PM is (re)displayed via show(). Mark 2007-06-01.
self.MessageGroupBox.insertHtmlMessage(msg, setAsDefault=True)
def _addGroupBoxes(self):
"""
Add the DNA Property Manager group boxes.
"""
self._pmGroupBox1 = PM_GroupBox(self, title="Strand Sequence")
self._loadGroupBox1(self._pmGroupBox1)
self._pmGroupBox2 = PM_GroupBox(self, title="DNA Parameters")
self._loadGroupBox2(self._pmGroupBox2)
self._pmGroupBox3 = PM_GroupBox(self, title="Endpoints")
self._loadGroupBox3(self._pmGroupBox3)
def _loadGroupBox1(self, pmGroupBox):
"""
Load widgets in group box 1.
"""
# Duplex Length
self.duplexLengthSpinBox = \
PM_DoubleSpinBox( pmGroupBox,
label = "Duplex Length: ",
value = 0,
setAsDefault = False,
minimum = 0,
maximum = 34000,
singleStep = self.getDuplexRise("B-DNA"),
decimals = 3,
suffix = ' Angstroms')
self.connect(self.duplexLengthSpinBox, SIGNAL("valueChanged(double)"),
self.duplexLengthChanged)
# Strand Length
self.strandLengthSpinBox = \
PM_SpinBox( pmGroupBox,
label = "Strand Length :",
value = 0,
setAsDefault = False,
minimum = 0,
maximum = 10000,
suffix = ' bases' )
self.connect(self.strandLengthSpinBox, SIGNAL("valueChanged(int)"),
self.strandLengthChanged)
# New Base choices
newBaseChoices = []
for theBase in basesDict.keys():
newBaseChoices = newBaseChoices \
+ [ theBase + ' (' \
+ basesDict[theBase]['Name'] + ')' ]
try:
defaultBaseChoice = basesDict.keys().index('N')
except:
defaultBaseChoice = 0
# Strand Sequence
self.sequenceTextEdit = \
PM_TextEdit( pmGroupBox,
label = "",
spanWidth = True )
self.sequenceTextEdit.setCursorWidth(2)
self.sequenceTextEdit.setWordWrapMode(QTextOption.WrapAnywhere)
self.connect(self.sequenceTextEdit, SIGNAL("textChanged()"),
self.sequenceChanged)
self.connect(self.sequenceTextEdit, SIGNAL("cursorPositionChanged()"),
self.cursorPosChanged)
# Actions
self.actionsComboBox = \
PM_ComboBox( pmGroupBox,
label = '',
choices = self._actionChoices,
index = 0,
setAsDefault = True,
spanWidth = True )
# If SIGNAL("activate(const QString&)") is used, we get a TypeError.
# This is a bug that needs Bruce. Using currentIndexChanged(int) as
# a workaround, but there is still a bug when the "Reverse" action
# is selected. Mark 2007-08-15
self.connect(self.actionsComboBox, SIGNAL("currentIndexChanged(int)"),
self.actionsComboBoxChanged)
def _loadGroupBox2(self, pmGroupBox):
"""
Load widgets in group box 2.
"""
self.modelComboBox = \
PM_ComboBox( pmGroupBox,
label = "Model :",
choices = self._modelChoices,
setAsDefault = True)
self.conformationComboBox = \
PM_ComboBox( pmGroupBox,
label = "Conformation :",
choices = ["B-DNA"],
setAsDefault = True)
self.connect(self.conformationComboBox,
SIGNAL("currentIndexChanged(int)"),
self.conformationComboBoxChanged)
self.basesPerTurnComboBox= \
PM_ComboBox( pmGroupBox,
label = "Bases Per Turn :",
choices = ["10.0", "10.5", "10.67"],
setAsDefault = True)
# I may decide to reintroduce "base-pair chunks" at a later time.
# Please talk to me if you have a strong feeling about including
# this. Mark 2007-08-19.
createChoices = ["Strand chunks", \
"Single chunk" ]
#@ "Base-pair chunks"]
self.createComboBox = \
PM_ComboBox( pmGroupBox,
label = "Create :",
choices = createChoices,
index = 0,
setAsDefault = True,
spanWidth = False )
def _loadGroupBox3(self, pmGroupBox):
"""
Load widgets in group box 3.
"""
self._endPoint1GroupBox = PM_GroupBox(pmGroupBox, title="Endpoint1")
self._endPoint2GroupBox = PM_GroupBox(pmGroupBox, title="Endpoint2")
# Point 1
self.x1SpinBox = \
PM_DoubleSpinBox( self._endPoint1GroupBox,
label = \
"ui/actions/Properties Manager/X_Coordinate.png",
value = 0,
setAsDefault = True,
minimum = -100.0,
maximum = 100.0,
decimals = 3,
suffix = ' Angstroms')
self.y1SpinBox = \
PM_DoubleSpinBox( self._endPoint1GroupBox,
label = \
"ui/actions/Properties Manager/Y_Coordinate.png",
value = 0,
setAsDefault = True,
minimum = -100.0,
maximum = 100.0,
decimals = 3,
suffix = ' Angstroms')
self.z1SpinBox = \
PM_DoubleSpinBox( self._endPoint1GroupBox,
label = \
"ui/actions/Properties Manager/Z_Coordinate.png",
value = 0,
setAsDefault = True,
minimum = -100.0,
maximum = 100.0,
decimals = 3,
suffix = ' Angstroms')
# Point 2
self.x2SpinBox = \
PM_DoubleSpinBox( self._endPoint2GroupBox,
label = \
"ui/actions/Properties Manager/X_Coordinate.png",
value = 10.0,
setAsDefault = True,
minimum = -100.0,
maximum = 100.0,
decimals = 3,
suffix = ' Angstroms')
self.y2SpinBox = \
PM_DoubleSpinBox( self._endPoint2GroupBox,
label = \
"ui/actions/Properties Manager/Y_Coordinate.png",
value = 0,
setAsDefault = True,
minimum = -100.0,
maximum = 100.0,
decimals = 3,
suffix = ' Angstroms')
self.z2SpinBox = \
PM_DoubleSpinBox( self._endPoint2GroupBox,
label = \
"ui/actions/Properties Manager/Z_Coordinate.png",
value = 0,
setAsDefault = True,
minimum = -100.0,
maximum = 100.0,
decimals = 3,
suffix = ' Angstroms')
def _addWhatsThisText(self):
"""
What's This text for some of the widgets in the
DNA Property Manager.
@note: Many PM widgets are still missing their "What's This" text.
"""
self.conformationComboBox.setWhatsThis("""<b>Conformation</b>
<p>There are three DNA geometries, A-DNA, B-DNA,
and Z-DNA. Only B-DNA and Z-DNA are currently supported.</p>""")
self.sequenceTextEdit.setWhatsThis("""<b>Strand Sequence</b>
<p>Type in the strand sequence you want to generate here (5' => 3')<br>
<br>
Recognized base letters:<br>
<br>
A = Adenosine<br>
C = Cytosine<br>
G = Guanosine<br>
T = Thymidine<br>
N = aNy base<br>
X = Unassigned<br>
<br>
Other base letters currently recognized:<br>
<br>
B = C,G, or T<br>
D = A,G, or T<br>
H = A,C, or T<br>
V = A,C, or G<br>
R = A or G (puRine)<br>
Y = C or T (pYrimidine)<br>
K = G or T (Keto)<br>
M = A or C (aMino)<br>
S = G or C (Strong -3H bonds)<br>
W = A or T (Weak - 2H bonds)<br>
</p>""")
self.actionsComboBox.setWhatsThis("""<b>Action</b>
<p>Select an action to perform on the sequence.</p>""")
def conformationComboBoxChanged(self, inIndex):
"""
Slot for the Conformation combobox. It is called whenever the
Conformation choice is changed.
@param inIndex: The new index.
@type inIndex: int
"""
self.basesPerTurnComboBox.clear()
conformation = self.conformationComboBox.currentText()
if conformation == "B-DNA":
self.basesPerTurnComboBox.insertItem(0, "10.0")
self.basesPerTurnComboBox.insertItem(1, "10.5")
self.basesPerTurnComboBox.insertItem(2, "10.67")
#10.5 is the default value for Bases per turn.
#So set the current index to 1
self.basesPerTurnComboBox.setCurrentIndex(1)
elif conformation == "Z-DNA":
self.basesPerTurnComboBox.insertItem(0, "12.0")
elif inIndex == -1:
# Caused by clear(). This is tolerable for now. Mark 2007-05-24.
conformation = "B-DNA" # Workaround for "Restore Defaults".
pass
else:
msg = redmsg("conformationComboBoxChanged(): \
Error - unknown DNA conformation. Index = " + inIndex)
env.history.message(msg)
self.duplexLengthSpinBox.setSingleStep(
self.getDuplexRise(conformation))
def modelComboBoxChanged(self, inIndex):
"""
Slot for the Model combobox. It is called whenever the
Model choice is changed.
@param inIndex: The new index.
@type inIndex: int
"""
conformation = self._modelChoices[inIndex]
self.disconnect(self.conformationComboBox,
SIGNAL("currentIndexChanged(int)"),
self.conformationComboBoxChanged)
self.conformationComboBox.clear() # Generates signal!
if conformation == self._modeltype_PAM3:
self.conformationComboBox.addItem("B-DNA")
elif conformation == self._modeltype_PAM5:
self.conformationComboBox.addItem("B-DNA")
elif conformation == self._modeltype_Atomistic:
self.conformationComboBox.addItem("B-DNA")
self.conformationComboBox.addItem("Z-DNA")
elif inIndex == -1:
# Caused by clear(). This is tolerable for now. Mark 2007-05-24.
pass
else:
msg = "Error - unknown model representation. Index = " + inIndex
env.history.message(redmsg(msg))
self.connect(self.conformationComboBox,
SIGNAL("currentIndexChanged(int)"),
self.conformationComboBoxChanged)
# GroupBox3 slots (and other methods) supporting the Strand Sequence groupbox.
def getDuplexRise(self, inConformation):
"""
Return the 'rise' between base pairs of the
specified DNA type (conformation).
@param inConformation: The current conformation.
@type inConformation: int
"""
return dnaDict[str(inConformation)]['DuplexRise']
def synchronizeLengths(self):
"""
Guarantees the values of the duplex length and strand length
spinboxes agree with the strand sequence (textedit).
"""
self.updateStrandLength()
self.updateDuplexLength()
return
# Added :jbirac 20070613:
def duplexLengthChanged(self, inDuplexLength):
"""
Slot for the duplex length spinbox, called whenever the value of the
Duplex Length spinbox changes.
@param inDuplexLength: The duplex length.
@type inDuplexLength: float
"""
conformation = self.conformationComboBox.currentText()
duplexRise = self.getDuplexRise(conformation)
newStrandLength = inDuplexLength / duplexRise + 0.5
newStrandLength = int(newStrandLength)
self.strandLengthChanged(newStrandLength)
def updateDuplexLength(self): # Added :jbirac 20070615:
"""
Update the Duplex Length spinbox; always the length of the
strand sequence multiplied by the 'rise' of the duplex. This
method is called by slots of other controls (i.e., this itself
is not a slot.)
"""
conformation = self.conformationComboBox.currentText()
newDuplexLength = self.getDuplexRise( conformation ) \
* self.getSequenceLength()
self.disconnect(self.duplexLengthSpinBox,
SIGNAL("valueChanged(double)"),
self.duplexLengthChanged)
self.duplexLengthSpinBox.setValue(newDuplexLength)
self.connect(self.duplexLengthSpinBox, SIGNAL("valueChanged(double)"),
self.duplexLengthChanged)
# Renamed from length_changed :jbirac 20070613:
def strandLengthChanged(self, inStrandLength):
"""
Slot for the Strand Length spin box, called whenever the value of the
Strand Length spin box changes.
@param inStrandLength: The number of bases in the strand sequence.
@type inStrandLength: int
"""
theSequence = self.getPlainSequence()
sequenceLen = len(theSequence)
lengthChange = inStrandLength - self.getSequenceLength()
# Preserve the cursor's position/selection
cursor = self.sequenceTextEdit.textCursor()
#cursorPosition = cursor.position()
selectionStart = cursor.selectionStart()
selectionEnd = cursor.selectionEnd()
if inStrandLength < 0:
return # Should never happen.
if lengthChange < 0:
# If length is less than the previous length,
# simply truncate the current sequence.
theSequence.chop(-lengthChange)
elif lengthChange > 0:
# If length has increased, add the correct number of base
# letters to the current strand sequence.
numNewBases = lengthChange
# Get current base selected in combobox.
chosenBase = 'X' # Unassigned.
basesToAdd = chosenBase * numNewBases
theSequence.append(basesToAdd)
else:
env.history.message(
orangemsg("strandLengthChanged(): Length has not changed."))
self.setSequence(theSequence)
return
# Renamed from updateLength :jbirac 20070613:
def updateStrandLength(self):
"""
Update the Strand Length spinbox; always the length of the strand
sequence.
"""
self.disconnect(self.strandLengthSpinBox, SIGNAL("valueChanged(int)"),
self.strandLengthChanged)
self.strandLengthSpinBox.setValue(self.getSequenceLength())
self.connect(self.strandLengthSpinBox, SIGNAL("valueChanged(int)"),
self.strandLengthChanged)
return
def sequenceChanged(self):
"""
Slot for the Strand Sequence textedit widget.
Assumes the sequence changed directly by user's keystroke in the
textedit. Other methods...
"""
cursorPosition = self.getCursorPosition()
theSequence = self.getPlainSequence()
# Disconnect while we edit the sequence.
self.disconnect(self.sequenceTextEdit, SIGNAL("textChanged()"),
self.sequenceChanged)
# How has the text changed?
if theSequence.length() == 0: # There is no sequence.
self.updateStrandLength()
self.updateDuplexLength()
else:
# Insert the sequence; it will be "stylized" by setSequence().
self.setSequence(theSequence)
# Reconnect to respond when the sequence is changed.
self.connect(self.sequenceTextEdit, SIGNAL("textChanged()"),
self.sequenceChanged)
self.synchronizeLengths()
return
def getPlainSequence(self, inOmitSymbols=False):
"""
Returns a plain text QString (without HTML stylization)
of the current sequence. All characters are preserved (unless
specified explicitly), including valid base letters, punctuation
symbols, whitespace and invalid letters.
@param inOmitSymbols: Omits characters listed in self.validSymbols.
@type inOmitSymbols: bool
@return: The current DNA sequence in the PM.
@rtype: QString
"""
outSequence = self.sequenceTextEdit.toPlainText()
if inOmitSymbols:
# This may look like a sloppy piece of code, but Qt's QRegExp
# class makes it pretty tricky to remove all punctuation.
theString = '[<>' \
+ str( QRegExp.escape(self.validSymbols) ) \
+ ']|-'
outSequence.remove(QRegExp(theString))
return outSequence
def stylizeSequence(self, inSequence):
"""
Converts a plain text string of a sequence (including optional
symbols) to an HTML rich text string.
@param inSequence: A DNA sequence.
@type inSequence: QString
@return: The sequence.
@rtype: QString
"""
outSequence = str(inSequence)
# Verify that all characters (bases) in the sequence are "valid".
invalidSequence = False
basePosition = 0
sequencePosition = 0
invalidStartTag = "<b><font color=black>"
invalidEndTag = "</b>"
previousChar = chr(1) # Null character; may be revised.
# Some characters must be substituted to preserve
# whitespace and tags in HTML code.
substituteDict = {' ': ' ', '<': '<', '>': '>'}
while basePosition < len(outSequence):
theSeqChar = outSequence[basePosition]
if (theSeqChar in basesDict or theSeqChar in self.validSymbols):
# Close any preceding invalid sequence segment.
if invalidSequence == True:
outSequence = outSequence[:basePosition] \
+ invalidEndTag \
+ outSequence[basePosition:]
basePosition += len(invalidEndTag)
invalidSequence = False
# Color the valid characters.
if theSeqChar != previousChar:
# We only need to insert 'color' tags in places where
# the adjacent characters are different.
if theSeqChar in basesDict:
theTag = '<font color=' \
+ basesDict[ theSeqChar ]['Color'] \
+ '>'
elif not previousChar in self.validSymbols:
# The character is a 'valid' symbol to be greyed
# out. Only one 'color' tag is needed for a
# group of adjacent symbols.
theTag = '<font color=dimgrey>'
else:
theTag = ''
outSequence = outSequence[:basePosition] \
+ theTag + outSequence[basePosition:]
basePosition += len(theTag)
# Any <space> character must be substituted with an
# ASCII code tag because the HTML engine will collapse
# whitespace to a single <space> character; whitespace
# is truncated from the end of HTML by default.
# Also, many symbol characters must be substituted
# because they confuse the HTML syntax.
#if str( outSequence[basePosition] ) in substituteDict:
if outSequence[basePosition] in substituteDict:
#theTag = substituteDict[theSeqChar]
theTag = substituteDict[outSequence[basePosition]]
outSequence = outSequence[:basePosition] \
+ theTag \
+ outSequence[basePosition + 1:]
basePosition += len(theTag) - 1
else:
# The sequence character is invalid (but permissible).
# Tags (e.g., <b> and </b>) must be inserted at both the
# beginning and end of a segment of invalid characters.
if invalidSequence == False:
outSequence = outSequence[:basePosition] \
+ invalidStartTag \
+ outSequence[basePosition:]
basePosition += len(invalidStartTag)
invalidSequence = True
basePosition += 1
previousChar = theSeqChar
#basePosition += 1
# Specify that theSequence is definitely HTML format, because
# Qt can get confused between HTML and Plain Text.
outSequence = "<html>" + outSequence
outSequence += "</html>"
return outSequence
def setSequence(self, inSequence, inStylize=True, inRestoreCursor=True):
"""
Replace the current strand sequence with the new sequence text.
@param inSequence: The new sequence.
@type inSequence: QString
@param inStylize: If True, inSequence will be converted from a plain
text string (including optional symbols) to an HTML
rich text string.
@type inStylize: bool
@param inRestoreCursor: Not implemented yet.
@type inRestoreCursor: bool
@attention: Signals/slots must be managed before calling this method.
The textChanged() signal will be sent to any connected widgets.
"""
cursor = self.sequenceTextEdit.textCursor()
selectionStart = cursor.selectionStart()
selectionEnd = cursor.selectionEnd()
if inStylize:
inSequence = self.stylizeSequence(inSequence)
self.sequenceTextEdit.insertHtml(inSequence)
if inRestoreCursor:
cursor.setPosition(min(selectionStart, self.getSequenceLength()),
QTextCursor.MoveAnchor)
cursor.setPosition(min(selectionEnd, self.getSequenceLength()),
QTextCursor.KeepAnchor)
self.sequenceTextEdit.setTextCursor(cursor)
return
def getSequenceLength(self):
"""
Returns the number of characters in
the strand sequence textedit widget.
"""
theSequence = self.getPlainSequence(inOmitSymbols=True)
outLength = theSequence.length()
return outLength
def getCursorPosition(self):
"""
Returns the cursor position in the
strand sequence textedit widget.
"""
cursor = self.sequenceTextEdit.textCursor()
return cursor.position()
def cursorPosChanged(self):
"""
Slot called when the cursor position changes.
"""
cursor = self.sequenceTextEdit.textCursor()
if 0:
env.history.message(
greenmsg("cursorPosChanged: Selection (" +
str(cursor.selectionStart()) + " thru " +
str(cursor.selectionEnd()) + ')'))
return
def actionsComboBoxChanged(self, inIndex):
"""
Slot for the Actions combobox. It is called whenever the
Action choice is changed.
@param inIndex: The index of the selected action choice.
@type inIndex: int
"""
if inIndex == 0: # Very important.
return
actionName = str(self.actionsComboBox.currentText())
self.actionsComboBox.setCurrentIndex(0) # Generates signal!
self.invokeAction(actionName)
return
def invokeAction(self, inActionName):
"""
Applies an action on the current sequence displayed in the PM.
@param inActionName: The action name.
@type inActionName: str
@return: The sequence after the action has been applied.
@rtype: str
"""
sequence, allKnown = self._getSequence()
outResult = ""
if inActionName == self._action_Complement:
outResult = getComplementSequence(sequence)
elif inActionName == self._action_Reverse:
outResult = getReverseSequence(sequence)
elif inActionName == self._action_ConvertUnrecognized:
outResult = replaceUnrecognized(sequence, replaceBase='N')
self.setSequence(outResult)
elif inActionName == self._action_RemoveUnrecognized:
outResult = replaceUnrecognized(sequence, replaceBase='')
self.setSequence(outResult)
return
class ColorScheme_PropertyManager(Command_PropertyManager):
"""
The ColorScheme_PropertyManager class provides a Property Manager
for choosing background and other colors for the Choose Color toolbar command
as well as the View/Color Scheme command
@ivar title: The title that appears in the property manager header.
@type title: str
@ivar pmName: The name of this property manager. This is used to set
the name of the PM_Dialog object via setObjectName().
@type name: str
@ivar iconPath: The relative path to the PNG file that contains a
22 x 22 icon image that appears in the PM header.
@type iconPath: str
"""
title = "Color Scheme"
pmName = title
iconPath = "ui/actions/View/ColorScheme.png"
def __init__( self, command ):
"""
Constructor for the property manager.
"""
self.currentWorkingDirectory = env.prefs[workingDirectory_prefs_key]
_superclass.__init__(self, command)
self.showTopRowButtons( PM_DONE_BUTTON | \
PM_WHATS_THIS_BUTTON)
msg = "Edit the color scheme for NE1, including the background color, "\
"hover highlighting and selection colors, etc."
self.updateMessage(msg)
def connect_or_disconnect_signals(self, isConnect):
"""
Connect or disconnect widget signals sent to their slot methods.
This can be overridden in subclasses. By default it does nothing.
@param isConnect: If True the widget will send the signals to the slot
method.
@type isConnect: boolean
"""
if isConnect:
change_connect = self.win.connect
else:
change_connect = self.win.disconnect
# Favorite buttons signal-slot connections.
change_connect( self.applyFavoriteButton,
SIGNAL("clicked()"),
self.applyFavorite)
change_connect( self.addFavoriteButton,
SIGNAL("clicked()"),
self.addFavorite)
change_connect( self.deleteFavoriteButton,
SIGNAL("clicked()"),
self.deleteFavorite)
change_connect( self.saveFavoriteButton,
SIGNAL("clicked()"),
self.saveFavorite)
change_connect( self.loadFavoriteButton,
SIGNAL("clicked()"),
self.loadFavorite)
# background color setting combo box.
change_connect( self.backgroundColorComboBox,
SIGNAL("activated(int)"),
self.changeBackgroundColor )
#hover highlighting style combo box
change_connect(self.hoverHighlightingStyleComboBox,
SIGNAL("currentIndexChanged(int)"),
self.changeHoverHighlightingStyle)
change_connect(self.hoverHighlightingColorComboBox,
SIGNAL("editingFinished()"),
self.changeHoverHighlightingColor)
#selection style combo box
change_connect(self.selectionStyleComboBox,
SIGNAL("currentIndexChanged(int)"),
self.changeSelectionStyle)
change_connect(self.selectionColorComboBox,
SIGNAL("editingFinished()"),
self.changeSelectionColor)
def changeHoverHighlightingColor(self):
"""
Slot method for Hover Highlighting color chooser.
Change the (3D) hover highlighting color.
"""
color = self.hoverHighlightingColorComboBox.getColor()
env.prefs[hoverHighlightingColor_prefs_key] = color
return
def changeHoverHighlightingStyle(self, idx):
"""
Slot method for Hover Highlighting combobox.
Change the (3D) hover highlighting style.
"""
env.prefs[hoverHighlightingColorStyle_prefs_key] = HHS_INDEXES[idx]
def changeSelectionStyle(self, idx):
"""
Slot method for Selection color style combobox.
Change the (3D) Selection color style.
"""
env.prefs[selectionColorStyle_prefs_key] = SS_INDEXES[idx]
def changeSelectionColor(self):
"""
Slot method for Selection color chooser.
Change the (3D) Selection color.
"""
color = self.selectionColorComboBox.getColor()
env.prefs[selectionColor_prefs_key] = color
return
def show(self):
"""
Shows the Property Manager. Extends superclass method.
"""
self._updateAllWidgets()
_superclass.show(self)
def _addGroupBoxes( self ):
"""
Add the Property Manager group boxes.
"""
self._pmGroupBox1 = PM_GroupBox( self,
title = "Favorites")
self._loadGroupBox1( self._pmGroupBox1 )
self._pmGroupBox2 = PM_GroupBox( self,
title = "Background")
self._loadGroupBox2( self._pmGroupBox2 )
self._pmGroupBox3 = PM_GroupBox( self,
title = "Highlighting and Selection")
self._loadGroupBox3( self._pmGroupBox3 )
self._updateAllWidgets()
def _loadGroupBox1(self, pmGroupBox):
"""
Load widgets in group box.
"""
# Other info
# Not only loads the factory default settings but also all the favorite
# files stored in the ~/Nanorex/Favorites/DnaDisplayStyle directory
favoriteChoices = ['Factory default settings']
#look for all the favorite files in the favorite folder and add them to
# the list
from platform_dependent.PlatformDependent import find_or_make_Nanorex_subdir
_dir = find_or_make_Nanorex_subdir('Favorites/ColorScheme')
for file in os.listdir(_dir):
fullname = os.path.join( _dir, file)
if os.path.isfile(fullname):
if fnmatch.fnmatch( file, "*.txt"):
# leave the extension out
favoriteChoices.append(file[0:len(file)-4])
self.favoritesComboBox = \
PM_ComboBox( pmGroupBox,
choices = favoriteChoices,
spanWidth = True)
# PM_ToolButtonRow ===============
# Button list to create a toolbutton row.
# Format:
# - QToolButton, buttonId, buttonText,
# - iconPath,
# - tooltip, shortcut, column
BUTTON_LIST = [
( "QToolButton", 1, "APPLY_FAVORITE",
"ui/actions/Properties Manager/ApplyColorSchemeFavorite.png",
"Apply Favorite", "", 0),
( "QToolButton", 2, "ADD_FAVORITE",
"ui/actions/Properties Manager/AddFavorite.png",
"Add Favorite", "", 1),
( "QToolButton", 3, "DELETE_FAVORITE",
"ui/actions/Properties Manager/DeleteFavorite.png",
"Delete Favorite", "", 2),
( "QToolButton", 4, "SAVE_FAVORITE",
"ui/actions/Properties Manager/SaveFavorite.png",
"Save Favorite", "", 3),
( "QToolButton", 5, "LOAD_FAVORITE",
"ui/actions/Properties Manager/LoadFavorite.png",
"Load Favorite", \
"", 4)
]
self.favsButtonGroup = \
PM_ToolButtonRow( pmGroupBox,
title = "",
buttonList = BUTTON_LIST,
spanWidth = True,
isAutoRaise = False,
isCheckable = False,
setAsDefault = True,
)
self.favsButtonGroup.buttonGroup.setExclusive(False)
self.applyFavoriteButton = self.favsButtonGroup.getButtonById(1)
self.addFavoriteButton = self.favsButtonGroup.getButtonById(2)
self.deleteFavoriteButton = self.favsButtonGroup.getButtonById(3)
self.saveFavoriteButton = self.favsButtonGroup.getButtonById(4)
self.loadFavoriteButton = self.favsButtonGroup.getButtonById(5)
def _loadGroupBox2(self, pmGroupBox):
"""
Load widgets in group box.
"""
#background color combo box
self.backgroundColorComboBox = \
PM_ComboBox( pmGroupBox,
label = "Color:",
spanWidth = False)
self._loadBackgroundColorItems()
self.enableFogCheckBox = \
PM_CheckBox( pmGroupBox, text = "Enable fog" )
connect_checkbox_with_boolean_pref( self.enableFogCheckBox, fogEnabled_prefs_key )
return
def _loadGroupBox3(self, pmGroupBox):
"""
Load widgets in group box.
"""
# hover highlighting style and color
self.hoverHighlightingStyleComboBox = \
PM_ComboBox( pmGroupBox,
label = "Highlighting:",
)
self._loadHoverHighlightingStyleItems()
hhColorList = [yellow, orange, red, magenta,
cyan, blue, white, black, gray]
hhColorNames = ["Yellow (default)", "Orange", "Red", "Magenta",
"Cyan", "Blue", "White", "Black", "Other color..."]
self.hoverHighlightingColorComboBox = \
PM_ColorComboBox(pmGroupBox,
colorList = hhColorList,
colorNames = hhColorNames,
color = env.prefs[hoverHighlightingColor_prefs_key]
)
# selection style and color
self.selectionStyleComboBox = \
PM_ComboBox( pmGroupBox,
label = "Selection:",
)
self._loadSelectionStyleItems()
selColorList = [darkgreen, green, orange, red,
magenta, cyan, blue, white, black,
gray]
selColorNames = ["Dark green (default)", "Green", "Orange", "Red",
"Magenta", "Cyan", "Blue", "White", "Black",
"Other color..."]
self.selectionColorComboBox = \
PM_ColorComboBox(pmGroupBox,
colorList = selColorList,
colorNames = selColorNames,
color = env.prefs[selectionColor_prefs_key]
)
return
def _updateAllWidgets(self):
"""
Update all the PM widgets. This is typically called after applying
a favorite.
"""
self._updateBackgroundColorComboBoxIndex()
self.updateCustomColorItemIcon(RGBf_to_QColor(env.prefs[backgroundColor_prefs_key]))
self.hoverHighlightingStyleComboBox.setCurrentIndex(HHS_INDEXES.index(env.prefs[hoverHighlightingColorStyle_prefs_key]))
self.hoverHighlightingColorComboBox.setColor(env.prefs[hoverHighlightingColor_prefs_key])
self.selectionStyleComboBox.setCurrentIndex(SS_INDEXES.index(env.prefs[selectionColorStyle_prefs_key]))
self.selectionColorComboBox.setColor(env.prefs[selectionColor_prefs_key])
return
def _loadSelectionStyleItems(self):
"""
Load the selection color style combobox with items.
"""
for selectionStyle in SS_OPTIONS:
self.selectionStyleComboBox.addItem(selectionStyle)
return
def _loadHoverHighlightingStyleItems(self):
"""
Load the hover highlighting style combobox with items.
"""
for hoverHighlightingStyle in HHS_OPTIONS:
self.hoverHighlightingStyleComboBox.addItem(hoverHighlightingStyle)
return
def _loadBackgroundColorItems(self):
"""
Load the background color combobox with all the color options and sets
the current background color
"""
backgroundIndexes = [bg_BLUE_SKY, bg_EVENING_SKY, bg_SEAGREEN,
bg_BLACK, bg_WHITE, bg_GRAY, bg_CUSTOM]
backgroundNames = ["Blue Sky (default)", "Evening Sky", "Sea Green",
"Black", "White", "Gray", "Custom..."]
backgroundIcons = ["Background_BlueSky", "Background_EveningSky",
"Background_SeaGreen",
"Background_Black", "Background_White",
"Background_Gray", "Background_Custom"]
backgroundIconsDict = dict(zip(backgroundNames, backgroundIcons))
backgroundNamesDict = dict(zip(backgroundIndexes, backgroundNames))
for backgroundName in backgroundNames:
basename = backgroundIconsDict[backgroundName] + ".png"
iconPath = os.path.join("ui/dialogs/Preferences/",
basename)
self.backgroundColorComboBox.addItem(geticon(iconPath),
backgroundName)
self._updateBackgroundColorComboBoxIndex() # Not needed, but OK.
return
def _updateBackgroundColorComboBoxIndex(self):
"""
Set current index in the background color combobox.
"""
if self.win.glpane.backgroundGradient:
self.backgroundColorComboBox.setCurrentIndex(self.win.glpane.backgroundGradient - 1)
else:
if (env.prefs[ backgroundColor_prefs_key ] == black):
self.backgroundColorComboBox.setCurrentIndex(bg_BLACK)
elif (env.prefs[ backgroundColor_prefs_key ] == white):
self.backgroundColorComboBox.setCurrentIndex(bg_WHITE)
elif (env.prefs[ backgroundColor_prefs_key ] == gray):
self.backgroundColorComboBox.setCurrentIndex(bg_GRAY)
else:
self.backgroundColorComboBox.setCurrentIndex(bg_CUSTOM)
return
def changeBackgroundColor(self, idx):
"""
Slot method for the background color combobox.
"""
#print "changeBackgroundColor(): Slot method called. Idx =", idx
if idx == bg_BLUE_SKY:
self.win.glpane.setBackgroundGradient(idx + 1)
elif idx == bg_EVENING_SKY:
self.win.glpane.setBackgroundGradient(idx + 1)
elif idx == bg_SEAGREEN:
self.win.glpane.setBackgroundGradient(idx + 1)
elif idx == bg_BLACK:
self.win.glpane.setBackgroundColor(black)
elif idx == bg_WHITE:
self.win.glpane.setBackgroundColor(white)
elif idx == bg_GRAY:
self.win.glpane.setBackgroundColor(gray)
elif idx == bg_CUSTOM:
#change background color to Custom Color
self.chooseCustomBackgroundColor()
else:
msg = "Unknown color idx=", idx
print_compact_traceback(msg)
self.win.glpane.gl_update() # Needed!
return
def chooseCustomBackgroundColor(self):
"""
Choose a custom background color.
"""
c = QColorDialog.getColor(RGBf_to_QColor(self.win.glpane.getBackgroundColor()), self)
if c.isValid():
self.win.glpane.setBackgroundColor(QColor_to_RGBf(c))
self.updateCustomColorItemIcon(c)
else:
# User cancelled. Need to reset combobox to correct index.
self._updateBackgroundColorComboBoxIndex()
return
def updateCustomColorItemIcon(self, qcolor):
"""
Update the custom color item icon in the background color combobox
with I{qcolor}.
"""
pixmap = QPixmap(16, 16)
pixmap.fill(qcolor)
self.backgroundColorComboBox.setItemIcon(bg_CUSTOM, QIcon(pixmap))
return
def applyFavorite(self):
"""
Apply the color scheme settings stored in the current favorite
(selected in the combobox) to the current color scheme settings.
"""
# Rules and other info:
# The user has to press the button related to this method when he loads
# a previously saved favorite file
current_favorite = self.favoritesComboBox.currentText()
if current_favorite == 'Factory default settings':
env.prefs.restore_defaults(colorSchemePrefsList)
# set it back to blue sky
self.win.glpane.setBackgroundGradient(1)
else:
favfilepath = getFavoritePathFromBasename(current_favorite)
loadFavoriteFile(favfilepath)
if env.prefs[backgroundGradient_prefs_key]:
self.win.glpane.setBackgroundGradient(env.prefs[backgroundGradient_prefs_key])
else:
self.win.glpane.setBackgroundColor(env.prefs[backgroundColor_prefs_key])
#self.hoverHighlightingColorComboBox.setColor(env.prefs[hoverHighlightingColor_prefs_key])
#self.selectionColorComboBox.setColor(env.prefs[selectionColor_prefs_key])
self._updateAllWidgets()
self.win.glpane.gl_update()
return
def addFavorite(self):
"""
Adds a new favorite to the user's list of favorites.
"""
# Rules and other info:
# - The new favorite is defined by the current color scheme
# settings.
# - The user is prompted to type in a name for the new
# favorite.
# - The color scheme settings are written to a file in a special
# directory on the disk
# (i.e. $HOME/Nanorex/Favorites/ColorScheme/$FAV_NAME.txt).
# - The name of the new favorite is added to the list of favorites in
# the combobox, which becomes the current option.
# Existence of a favorite with the same name is checked in the above
# mentioned location and if a duplicate exists, then the user can either
# overwrite and provide a new name.
# Prompt user for a favorite name to add.
from widgets.simple_dialogs import grab_text_line_using_dialog
ok1, name = \
grab_text_line_using_dialog(
title = "Add new favorite",
label = "favorite name:",
iconPath = "ui/actions/Properties Manager/AddFavorite.png",
default = "" )
if ok1:
# check for duplicate files in the
# $HOME/Nanorex/Favorites/ColorScheme/ directory
fname = getFavoritePathFromBasename( name )
if os.path.exists(fname):
#favorite file already exists!
_ext= ".txt"
ret = QMessageBox.warning( self, "Warning!",
"The favorite file \"" + name + _ext + "\"already exists.\n"
"Do you want to overwrite the existing file?",
"&Overwrite", "&Cancel", "",
0, # Enter == button 0
1) # Escape == button 1
if ret == 0:
#overwrite favorite file
ok2, text = writeColorSchemeToFavoritesFile(name)
indexOfDuplicateItem = self.favoritesComboBox.findText(name)
self.favoritesComboBox.removeItem(indexOfDuplicateItem)
print "Add Favorite: removed duplicate favorite item."
else:
env.history.message("Add Favorite: cancelled overwriting favorite item.")
return
else:
ok2, text = writeColorSchemeToFavoritesFile(name)
else:
# User cancelled.
return
if ok2:
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
msg = "New favorite [%s] added." % (text)
else:
msg = "Can't add favorite [%s]: %s" % (name, text) # text is reason why not
env.history.message(msg)
return
def deleteFavorite(self):
"""
Deletes the current favorite from the user's personal list of favorites
(and from disk, only in the favorites folder though).
@note: Cannot delete "Factory default settings".
"""
currentIndex = self.favoritesComboBox.currentIndex()
currentText = self.favoritesComboBox.currentText()
if currentIndex == 0:
msg = "Cannot delete '%s'." % currentText
else:
self.favoritesComboBox.removeItem(currentIndex)
# delete file from the disk
deleteFile= getFavoritePathFromBasename( currentText )
os.remove(deleteFile)
msg = "Deleted favorite named [%s].\n" \
"and the favorite file [%s.txt]." \
% (currentText, currentText)
env.history.message(msg)
return
def saveFavorite(self):
"""
Writes the current favorite (selected in the combobox) to a file, any
where in the disk that
can be given to another NE1 user (i.e. as an email attachment).
"""
cmd = greenmsg("Save Favorite File: ")
env.history.message(greenmsg("Save Favorite File:"))
current_favorite = self.favoritesComboBox.currentText()
favfilepath = getFavoritePathFromBasename(current_favorite)
#Check to see if favfilepath exists first
if not os.path.exists(favfilepath):
msg = "%s does not exist" % favfilepath
env.history.message(cmd + msg)
return
formats = \
"Favorite (*.txt);;"\
"All Files (*.*)"
directory = self.currentWorkingDirectory
saveLocation = directory + "/" + current_favorite + ".txt"
fn = QFileDialog.getSaveFileName(
self,
"Save Favorite As", # caption
saveLocation, #where to save
formats, # file format options
QString("Favorite (*.txt)") # selectedFilter
)
if not fn:
env.history.message(cmd + "Cancelled")
else:
#remember this directory
dir, fil = os.path.split(str(fn))
self.setCurrentWorkingDirectory(dir)
saveFavoriteFile(str(fn), favfilepath)
return
def setCurrentWorkingDirectory(self, dir = None):
if os.path.isdir(dir):
self.currentWorkingDirectory = dir
self._setWorkingDirectoryInPrefsDB(dir)
else:
self.currentWorkingDirectory = getDefaultWorkingDirectory()
def _setWorkingDirectoryInPrefsDB(self, workdir = None):
"""
[private method]
Set the working directory in the user preferences database.
@param workdir: The fullpath directory to write to the user pref db.
If I{workdir} is None (default), there is no change.
@type workdir: string
"""
if not workdir:
return
workdir = str(workdir)
if os.path.isdir(workdir):
workdir = os.path.normpath(workdir)
env.prefs[workingDirectory_prefs_key] = workdir # Change pref in prefs db.
else:
msg = "[" + workdir + "] is not a directory. Working directory was not changed."
env.history.message( redmsg(msg))
return
def loadFavorite(self):
"""
Prompts the user to choose a "favorite file" (i.e. *.txt) from disk to
be added to the personal favorites list.
"""
# If the file already exists in the favorites folder then the user is
# given the option of overwriting it or renaming it
env.history.message(greenmsg("Load Favorite File:"))
formats = \
"Favorite (*.txt);;"\
"All Files (*.*)"
directory = self.currentWorkingDirectory
if directory == '':
directory= getDefaultWorkingDirectory()
fname = QFileDialog.getOpenFileName(self,
"Choose a file to load",
directory,
formats)
if not fname:
env.history.message("User cancelled loading file.")
return
else:
dir, fil = os.path.split(str(fname))
self.setCurrentWorkingDirectory(dir)
canLoadFile = loadFavoriteFile(fname)
if canLoadFile == 1:
#get just the name of the file for loading into the combobox
favName = os.path.basename(str(fname))
name = favName[0:len(favName)-4]
indexOfDuplicateItem = self.favoritesComboBox.findText(name)
#duplicate exists in combobox
if indexOfDuplicateItem != -1:
ret = QMessageBox.warning( self, "Warning!",
"The favorite file \"" + name +
"\"already exists.\n"
"Do you want to overwrite the existing file?",
"&Overwrite", "&Rename", "&Cancel",
0, # Enter == button 0
1 # button 1
)
if ret == 0:
self.favoritesComboBox.removeItem(indexOfDuplicateItem)
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
ok2, text = writeColorSchemeToFavoritesFile(name)
msg = "Overwrote favorite [%s]." % (text)
env.history.message(msg)
elif ret == 1:
# add new item to favorites folder as well as combobox
self.addFavorite()
else:
#reset the display setting values to factory default
factoryIndex = self.favoritesComboBox.findText(
'Factory default settings')
self.favoritesComboBox.setCurrentIndex(factoryIndex)
env.prefs.restore_defaults(colorSchemePrefsList)
# set it back to blue sky
self.win.glpane.setBackgroundGradient(1)
self.win.glpane.gl_update()
env.history.message("Cancelled overwriting favorite file.")
return
else:
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
msg = "Loaded favorite [%s]." % (name)
env.history.message(msg)
if env.prefs[backgroundGradient_prefs_key]:
self.win.glpane.setBackgroundGradient(env.prefs[backgroundGradient_prefs_key])
else:
self.win.glpane.setBackgroundColor(env.prefs[backgroundColor_prefs_key])
self.win.glpane.gl_update()
return
def _addWhatsThisText( self ):
"""
What's This text for widgets in the Color Scheme Property Manager.
"""
from ne1_ui.WhatsThisText_for_PropertyManagers import WhatsThis_ColorScheme_PropertyManager
WhatsThis_ColorScheme_PropertyManager(self)
def _addToolTipText(self):
"""
Tool Tip text for widgets in the Color Scheme Property Manager.
"""
#modify this for color schemes
from ne1_ui.ToolTipText_for_PropertyManagers import ToolTip_ColorScheme_PropertyManager
ToolTip_ColorScheme_PropertyManager(self)
class ProteinDisplayStyle_PropertyManager(Command_PropertyManager):
"""
The ProteinDisplayStyle_PropertyManager class provides a Property Manager
for the B{Display Style} command on the flyout toolbar in the
Build > Protein mode.
@ivar title: The title that appears in the property manager header.
@type title: str
@ivar pmName: The name of this property manager. This is used to set
the name of the PM_Dialog object via setObjectName().
@type name: str
@ivar iconPath: The relative path to the PNG file that contains a
22 x 22 icon image that appears in the PM header.
@type iconPath: str
"""
title = "Edit Protein Display Style"
pmName = title
iconPath = "ui/actions/Edit/EditProteinDisplayStyle.png"
def __init__( self, command ):
"""
Constructor for the property manager.
"""
self.currentWorkingDirectory = env.prefs[workingDirectory_prefs_key]
_superclass.__init__(self, command)
self.showTopRowButtons( PM_DONE_BUTTON | \
PM_WHATS_THIS_BUTTON)
msg = "Modify the protein display settings below."
self.updateMessage(msg)
def connect_or_disconnect_signals(self, isConnect = True):
"""
Connect or disconnect widget signals sent to their slot methods.
This can be overridden in subclasses. By default it does nothing.
@param isConnect: If True the widget will send the signals to the slot
method.
@type isConnect: boolean
"""
if isConnect:
change_connect = self.win.connect
else:
change_connect = self.win.disconnect
# Favorite buttons signal-slot connections.
change_connect( self.applyFavoriteButton,
SIGNAL("clicked()"),
self.applyFavorite)
change_connect( self.addFavoriteButton,
SIGNAL("clicked()"),
self.addFavorite)
change_connect( self.deleteFavoriteButton,
SIGNAL("clicked()"),
self.deleteFavorite)
change_connect( self.saveFavoriteButton,
SIGNAL("clicked()"),
self.saveFavorite)
change_connect( self.loadFavoriteButton,
SIGNAL("clicked()"),
self.loadFavorite)
#Display group box signal slot connections
change_connect(self.proteinStyleComboBox,
SIGNAL("currentIndexChanged(int)"),
self.changeProteinDisplayStyle)
change_connect(self.smoothingCheckBox,
SIGNAL("stateChanged(int)"),
self.smoothProteinDisplay)
change_connect(self.scaleComboBox,
SIGNAL("currentIndexChanged(int)"),
self.changeProteinDisplayScale)
change_connect(self.splineDoubleSpinBox,
SIGNAL("valueChanged(double)"),
self.changeProteinSplineValue)
change_connect(self.scaleFactorDoubleSpinBox,
SIGNAL("valueChanged(double)"),
self.changeProteinScaleFactor)
#color groupbox
change_connect(self.proteinComponentComboBox,
SIGNAL("currentIndexChanged(int)"),
self.chooseProteinComponent)
change_connect(self.proteinAuxComponentComboBox,
SIGNAL("currentIndexChanged(int)"),
self.chooseAuxilliaryProteinComponent)
change_connect(self.customColorComboBox,
SIGNAL("editingFinished()"),
self.chooseCustomColor)
change_connect(self.auxColorComboBox,
SIGNAL("editingFinished()"),
self.chooseAuxilliaryColor)
#change_connect(self.discColorCheckBox,
# SIGNAL("stateChanged(int)"),
# self.setDiscreteColors)
change_connect(self.helixColorComboBox,
SIGNAL("editingFinished()"),
self.chooseHelixColor)
change_connect(self.strandColorComboBox,
SIGNAL("editingFinished()"),
self.chooseStrandColor)
change_connect(self.coilColorComboBox,
SIGNAL("editingFinished()"),
self.chooseCoilColor)
#Protein Display methods
def changeProteinDisplayStyle(self, idx):
"""
Change protein display style
@param idx: index of the protein display style combo box
@type idx: int
"""
env.prefs[proteinStyle_prefs_key] = idx
return
def changeProteinDisplayQuality(self, idx):
env.prefs[proteinStyleQuality_prefs_key] = idx
return
def smoothProteinDisplay(self, state):
"""
Smoooth protein display.
@param state: state of the smooth protein display check box.
@type state: int
"""
if state == Qt.Checked:
env.prefs[proteinStyleSmooth_prefs_key] = True
else:
env.prefs[proteinStyleSmooth_prefs_key] = False
return
def changeProteinDisplayScale(self, idx):
"""
Change protein display scale
@param idx: index of the protein display scaling choices combo box
@type idx: int
"""
env.prefs[proteinStyleScaling_prefs_key] = idx
return
def changeProteinSplineValue(self, val):
"""
Change protein display resolution
@param val: value in the protein display resolution double spinbox
@type val: double
"""
env.prefs[proteinStyleQuality_prefs_key] = val
return
def changeProteinScaleFactor(self, val):
"""
Change protein display scale factor
@param val: value in the protein display scale factor double spinbox
@type val: double
"""
env.prefs[proteinStyleScaleFactor_prefs_key] = val
return
def chooseProteinComponent(self, idx):
"""
Choose protein component to set the color of
@param idx: index of the protein component choices combo box
@type idx: int
"""
env.prefs[proteinStyleColors_prefs_key] = idx
return
def chooseAuxilliaryProteinComponent(self, idx):
"""
Choose auxilliary protein component to set the color of
@param idx: index of the auxilliary protein component choices combo box
@type idx: int
"""
env.prefs[proteinStyleAuxColors_prefs_key] = idx - 1
return
def chooseCustomColor(self):
"""
Choose custom color of the chosen protein component
"""
color = self.customColorComboBox.getColor()
env.prefs[proteinStyleCustomColor_prefs_key] = color
return
def chooseAuxilliaryColor(self):
"""
Choose custom color of the chosen auxilliary protein component
"""
color = self.auxColorComboBox.getColor()
env.prefs[proteinStyleAuxCustomColor_prefs_key] = color
return
def chooseHelixColor(self):
"""
Choose helix color
"""
color = self.helixColorComboBox.getColor()
env.prefs[proteinStyleHelixColor_prefs_key] = color
return
def chooseStrandColor(self):
"""
Choose strand color
"""
color = self.strandColorComboBox.getColor()
env.prefs[proteinStyleStrandColor_prefs_key] = color
return
def chooseCoilColor(self):
"""
Choose coil color
"""
color = self.coilColorComboBox.getColor()
env.prefs[proteinStyleCoilColor_prefs_key] = color
return
def setDiscreteColors(self, state):
"""
Set discrete colors.
@param state: state of the set discrete colors check box.
@type state: int
"""
if state == Qt.Checked:
env.prefs[proteinStyleColorsDiscrete_prefs_key] = True
else:
env.prefs[proteinStyleColorsDiscrete_prefs_key] = False
return
def show_OLD(self):
"""
Shows the Property Manager.Extends superclass method.
"""
#@REVIEW: See comment in CompareProteins_PropertyManager
self.sequenceEditor = self.win.createProteinSequenceEditorIfNeeded()
self.sequenceEditor.hide()
self.updateProteinDisplayStyleWidgets()
_superclass.show(self)
def show(self):
"""
Shows the Property Manager. Extends superclass method
"""
_superclass.show(self)
#@REVIEW: Is it safe to do the follwoing before calling superclass.show()?
#-- Ninad 2008-10-02
# Force the Global Display Style to "DNA Cylinder" so the user
# can see the display style setting effects on any DNA in the current
# model. The current global display style will be restored when leaving
# this command (via self.close()).
self.originalDisplayStyle = self.o.displayMode
# TODO: rename that public attr of GLPane (widely used)
# from displayMode to displayStyle. [bruce 080910 comment]
self.o.setGlobalDisplayStyle(diPROTEIN)
# Update all PM widgets, .
# note: It is important to update the widgets by blocking the
# 'signals'. If done in the reverse order, it will generate signals
#when updating the PM widgets (via updateDnaDisplayStyleWidgets()),
#causing unneccessary repaints of the model view.
self.updateProteinDisplayStyleWidgets()#@@@ blockSignals = True)
return
def close(self):
"""
Closes the Property Manager. Extends superclass method.
"""
_superclass.close(self)
# Restore the original global display style.
self.o.setGlobalDisplayStyle(self.originalDisplayStyle)
return
def _addGroupBoxes( self ):
"""
Add the Property Manager group boxes.
"""
self._pmGroupBox1 = PM_GroupBox( self,
title = "Favorites")
self._loadGroupBox1( self._pmGroupBox1 )
self._pmGroupBox2 = PM_GroupBox( self,
title = "Display")
self._loadGroupBox2( self._pmGroupBox2 )
self._pmGroupBox3 = PM_GroupBox( self,
title = "Color")
self._loadGroupBox3( self._pmGroupBox3 )
def _loadGroupBox1(self, pmGroupBox):
"""
Load widgets in group box.
@param pmGroupBox: group box that contains various favorite buttons
@see: L{PM_GroupBox}
"""
# Other info
# Not only loads the factory default settings but also all the favorite
# files stored in the ~/Nanorex/Favorites/ProteinDisplayStyle directory
favoriteChoices = ['Factory default settings']
#look for all the favorite files in the favorite folder and add them to
# the list
from platform_dependent.PlatformDependent import find_or_make_Nanorex_subdir
_dir = find_or_make_Nanorex_subdir('Favorites/ProteinDisplayStyle')
for file in os.listdir(_dir):
fullname = os.path.join( _dir, file)
if os.path.isfile(fullname):
if fnmatch.fnmatch( file, "*.txt"):
# leave the extension out
favoriteChoices.append(file[0:len(file)-4])
self.favoritesComboBox = \
PM_ComboBox( pmGroupBox,
choices = favoriteChoices,
spanWidth = True)
self.favoritesComboBox.setWhatsThis(
"""<b> List of Favorites </b>
<p>
Creates a list of favorite Protein display styles. Once favorite
styles have been added to the list using the Add Favorite button,
the list will display the chosen favorites.
To change the current favorite, select a current favorite from
the list, and push the Apply Favorite button.""")
# PM_ToolButtonRow ===============
# Button list to create a toolbutton row.
# Format:
# - QToolButton, buttonId, buttonText,
# - iconPath,
# - tooltip, shortcut, column
BUTTON_LIST = [
( "QToolButton", 1, "APPLY_FAVORITE","ui/actions/Properties Manager/ApplyPeptideDisplayStyleFavorite.png",
"Apply Favorite", "", 0),
( "QToolButton", 2, "ADD_FAVORITE",
"ui/actions/Properties Manager/AddFavorite.png","Add Favorite", "", 1),
( "QToolButton", 3, "DELETE_FAVORITE", "ui/actions/Properties Manager/DeleteFavorite.png",
"Delete Favorite", "", 2),
( "QToolButton", 4, "SAVE_FAVORITE",
"ui/actions/Properties Manager/SaveFavorite.png",
"Save Favorite", "", 3),
( "QToolButton", 5, "LOAD_FAVORITE",
"ui/actions/Properties Manager/LoadFavorite.png",
"Load Favorite", \
"", 4)
]
self.favsButtonGroup = \
PM_ToolButtonRow( pmGroupBox,
title = "",
buttonList = BUTTON_LIST,
spanWidth = True,
isAutoRaise = False,
isCheckable = False,
setAsDefault = True,
)
self.favsButtonGroup.buttonGroup.setExclusive(False)
self.applyFavoriteButton = self.favsButtonGroup.getButtonById(1)
self.addFavoriteButton = self.favsButtonGroup.getButtonById(2)
self.deleteFavoriteButton = self.favsButtonGroup.getButtonById(3)
self.saveFavoriteButton = self.favsButtonGroup.getButtonById(4)
self.loadFavoriteButton = self.favsButtonGroup.getButtonById(5)
def _loadGroupBox2(self, pmGroupBox):
"""
Load widgets in group box.
@param pmGroupBox: group box that contains protein display choices
@see: L{PM_GroupBox}
"""
proteinStyleChoices = ['CA trace (wire)',
'CA trace (cylinders)',
'CA trace (ball and stick)',
'Tube',
'Ladder',
'Zigzag',
'Flat ribbon',
'Solid ribbon',
'Cartoons',
'Fancy cartoons',
'Peptide tiles'
]
self.proteinStyleComboBox = \
PM_ComboBox( pmGroupBox,
label = "Style:",
choices = proteinStyleChoices,
setAsDefault = True)
scaleChoices = ['Constant', 'Secondary structure', 'B-factor']
self.scaleComboBox = \
PM_ComboBox( pmGroupBox,
label = "Scaling:",
choices = scaleChoices,
setAsDefault = True)
self.scaleFactorDoubleSpinBox = \
PM_DoubleSpinBox( pmGroupBox,
label = "Scaling factor:",
value = 1.00,
setAsDefault = True,
minimum = 0.1,
maximum = 3.0,
decimals = 1,
singleStep = 0.1 )
self.splineDoubleSpinBox = \
PM_DoubleSpinBox( pmGroupBox,
label = "Resolution:",
value = 3,
setAsDefault = True,
minimum = 2,
maximum = 8,
decimals = 0,
singleStep = 1 )
self.smoothingCheckBox = \
PM_CheckBox( pmGroupBox,
text = "Smoothing",
setAsDefault = True)
def _loadGroupBox3(self, pmGroupBox):
"""
Load widgets in group box.
@param pmGroupBox: group box that contains various color choices
@see: L{PM_GroupBox}
"""
colorChoices = ['Chunk', 'Chain', 'Order', 'Hydropathy', 'Polarity',
'Acidity', 'Size', 'Character', 'Number of contacts',
'Secondary structure type', 'Secondary structure order',
'B-factor', 'Occupancy', 'Custom']
self.proteinComponentComboBox = \
PM_ComboBox( pmGroupBox,
label = "Color by:",
choices = colorChoices,
setAsDefault = True)
colorList = [orange, yellow, red, magenta,
cyan, blue, white, black, gray]
colorNames = ["Orange(default)", "Yellow", "Red", "Magenta",
"Cyan", "Blue", "White", "Black", "Other color..."]
self.customColorComboBox = \
PM_ColorComboBox(pmGroupBox,
colorList = colorList,
colorNames = colorNames,
label = "Custom:",
color = orange,
setAsDefault = True)
colorChoices1 = [ 'Same as main color', 'Lighter', 'Darker',
'Gray', 'Custom']
self.proteinAuxComponentComboBox = \
PM_ComboBox( pmGroupBox,
label = "Aux:",
choices = colorChoices1,
setAsDefault = True)
colorListAux = [orange, yellow, red, magenta,cyan, blue, white, black, gray]
colorNamesAux = ["Orange(default)", "Yellow", "Red", "Magenta", "Cyan",
"Blue", "White", "Black", "Other color..."]
self.auxColorComboBox = \
PM_ColorComboBox(pmGroupBox,
colorList = colorListAux,
colorNames = colorNamesAux,
label = "Custom aux:",
color = gray,
setAsDefault = True)
#self.discColorCheckBox = \
# PM_CheckBox( pmGroupBox,
# text = "Discretize colors",
# setAsDefault = True
# )
#
colorListHelix = [red, yellow, gray, magenta,
cyan, blue, white, black, orange]
colorNamesHelix = ["Red(default)", "Yellow", "Gray", "Magenta",
"Cyan", "Blue", "White", "Black", "Other color..."]
self.helixColorComboBox = \
PM_ColorComboBox(pmGroupBox,
colorList = colorListHelix,
colorNames = colorNamesHelix,
label = "Helix:",
color = red,
setAsDefault = True)
colorListStrand = [cyan, yellow, gray, magenta,
red, blue, white, black, orange]
colorNamesStrand = ["Cyan(default)", "Yellow", "Gray", "Magenta",
"Red", "Blue", "White", "Black", "Other color..."]
self.strandColorComboBox = \
PM_ColorComboBox(pmGroupBox,
colorList = colorListStrand,
colorNames = colorNamesStrand,
label = "Strand:",
color = cyan,
setAsDefault = True)
self.coilColorComboBox = \
PM_ColorComboBox(pmGroupBox,
colorList = colorListAux,
colorNames = colorNamesAux,
label = "Coil:",
color = orange,
setAsDefault = True)
def updateProteinDisplayStyleWidgets( self ):
"""
Updates all the Protein Display style widgets based on the current pref keys
values
"""
self.proteinStyleComboBox.setCurrentIndex(env.prefs[proteinStyle_prefs_key])
self.splineDoubleSpinBox.setValue(env.prefs[proteinStyleQuality_prefs_key])
if env.prefs[proteinStyleSmooth_prefs_key] == True:
self.smoothingCheckBox.setCheckState(Qt.Checked)
else:
self.smoothingCheckBox.setCheckState(Qt.Unchecked)
self.scaleComboBox.setCurrentIndex(env.prefs[proteinStyleScaling_prefs_key])
self.scaleFactorDoubleSpinBox.setValue(env.prefs[proteinStyleScaleFactor_prefs_key])
self.proteinComponentComboBox.setCurrentIndex(env.prefs[proteinStyleColors_prefs_key])
self.customColorComboBox.setColor(env.prefs[proteinStyleCustomColor_prefs_key])
self.proteinAuxComponentComboBox.setCurrentIndex(env.prefs[proteinStyleAuxColors_prefs_key])
self.auxColorComboBox.setColor(env.prefs[proteinStyleAuxCustomColor_prefs_key])
#if env.prefs[proteinStyleColorsDiscrete_prefs_key] == True:
# self.discColorCheckBox.setCheckState(Qt.Checked)
#else:
# self.discColorCheckBox.setCheckState(Qt.Unchecked)
self.helixColorComboBox.setColor(env.prefs[proteinStyleHelixColor_prefs_key])
self.strandColorComboBox.setColor(env.prefs[proteinStyleStrandColor_prefs_key])
self.coilColorComboBox.setColor(env.prefs[proteinStyleCoilColor_prefs_key])
return
def applyFavorite(self):
"""
Apply a favorite to the current display chosen in the favorites combo box
"""
current_favorite = self.favoritesComboBox.currentText()
if current_favorite == 'Factory default settings':
env.prefs.restore_defaults(proteinDisplayStylePrefsList)
else:
favfilepath = getFavoritePathFromBasename(current_favorite)
loadFavoriteFile(favfilepath)
self.updateProteinDisplayStyleWidgets()
return
def addFavorite(self):
"""
create and add favorite to favorites directory and favorites combo box
in PM
@note: Rules and other info:
- The new favorite is defined by the current Protein display style
settings.
- The user is prompted to type in a name for the new
favorite.
- The Protein display style settings are written to a file in a special
directory on the disk
(i.e. $HOME/Nanorex/Favorites/ProteinDisplayStyle/$FAV_NAME.txt).
- The name of the new favorite is added to the list of favorites in
the combobox, which becomes the current option.
Existence of a favorite with the same name is checked in the above
mentioned location and if a duplicate exists, then the user can either
overwrite and provide a new name.
"""
# Prompt user for a favorite name to add.
from widgets.simple_dialogs import grab_text_line_using_dialog
ok1, name = \
grab_text_line_using_dialog(
title = "Add new favorite",
label = "favorite name:",
iconPath = "ui/actions/Properties Manager/AddFavorite.png",
default = "" )
if ok1:
# check for duplicate files in the
# $HOME/Nanorex/Favorites/DnaDisplayStyle/ directory
fname = getFavoritePathFromBasename( name )
if os.path.exists(fname):
#favorite file already exists!
_ext= ".txt"
ret = QMessageBox.warning( self, "Warning!",
"The favorite file \"" + name + _ext + "\"already exists.\n"
"Do you want to overwrite the existing file?",
"&Overwrite", "&Cancel", "",
0, # Enter == button 0
1) # Escape == button 1
if ret == 0:
#overwrite favorite file
ok2, text = writeProteinDisplayStyleSettingsToFavoritesFile(name)
indexOfDuplicateItem = self.favoritesComboBox.findText(name)
self.favoritesComboBox.removeItem(indexOfDuplicateItem)
print "Add Favorite: removed duplicate favorite item."
else:
env.history.message("Add Favorite: cancelled overwriting favorite item.")
return
else:
ok2, text = writeProteinDisplayStyleSettingsToFavoritesFile(name)
else:
# User cancelled.
return
if ok2:
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
msg = "New favorite [%s] added." % (text)
else:
msg = "Can't add favorite [%s]: %s" % (name, text) # text is reason why not
env.history.message(msg)
return
def deleteFavorite(self):
"""
Delete favorite file from the favorites directory
"""
currentIndex = self.favoritesComboBox.currentIndex()
currentText = self.favoritesComboBox.currentText()
if currentIndex == 0:
msg = "Cannot delete '%s'." % currentText
else:
self.favoritesComboBox.removeItem(currentIndex)
# delete file from the disk
deleteFile= getFavoritePathFromBasename( currentText )
os.remove(deleteFile)
msg = "Deleted favorite named [%s].\n" \
"and the favorite file [%s.txt]." \
% (currentText, currentText)
env.history.message(msg)
return
def saveFavorite(self):
"""
Save favorite file in a user chosen location
"""
cmd = greenmsg("Save Favorite File: ")
env.history.message(greenmsg("Save Favorite File:"))
current_favorite = self.favoritesComboBox.currentText()
favfilepath = getFavoritePathFromBasename(current_favorite)
formats = \
"Favorite (*.txt);;"\
"All Files (*.*)"
directory = self.currentWorkingDirectory
saveLocation = directory + "/" + current_favorite + ".txt"
fn = QFileDialog.getSaveFileName(
self,
"Save Favorite As", # caption
favfilepath, #where to save
formats, # file format options
QString("Favorite (*.txt)") # selectedFilter
)
if not fn:
env.history.message(cmd + "Cancelled")
else:
dir, fil = os.path.split(str(fn))
self.setCurrentWorkingDirectory(dir)
saveFavoriteFile(str(fn), favfilepath)
return
def setCurrentWorkingDirectory(self, dir = None):
"""
Set dir as current working diretcory
@param dir: dirname
@type dir: str
"""
if os.path.isdir(dir):
self.currentWorkingDirectory = dir
self._setWorkingDirectoryInPrefsDB(dir)
else:
self.currentWorkingDirectory = getDefaultWorkingDirectory()
return
def _setWorkingDirectoryInPrefsDB(self, workdir = None):
"""
Set workdir as current working diretcory in prefDB
@param workdir: dirname
@type workdir: str
"""
if not workdir:
return
workdir = str(workdir)
if os.path.isdir(workdir):
workdir = os.path.normpath(workdir)
env.prefs[workingDirectory_prefs_key] = workdir # Change pref in prefs db.
else:
msg = "[" + workdir + "] is not a directory. Working directory was not changed."
env.history.message( redmsg(msg))
return
def loadFavorite(self):
"""
Load a favorite file
"""
# If the file already exists in the favorites folder then the user is
# given the option of overwriting it or renaming it
env.history.message(greenmsg("Load Favorite File:"))
formats = \
"Favorite (*.txt);;"\
"All Files (*.*)"
directory = self.currentWorkingDirectory
if directory == '':
directory= getDefaultWorkingDirectory()
fname = QFileDialog.getOpenFileName(self,
"Choose a file to load",
directory,
formats)
if not fname:
env.history.message("User cancelled loading file.")
return
else:
dir, fil = os.path.split(str(fname))
self.setCurrentWorkingDirectory(dir)
canLoadFile=loadFavoriteFile(fname)
if canLoadFile == 1:
#get just the name of the file for loading into the combobox
favName = os.path.basename(str(fname))
name = favName[0:len(favName)-4]
indexOfDuplicateItem = self.favoritesComboBox.findText(name)
#duplicate exists in combobox
if indexOfDuplicateItem != -1:
ret = QMessageBox.warning( self, "Warning!",
"The favorite file \"" + name +
"\"already exists.\n"
"Do you want to overwrite the existing file?",
"&Overwrite", "&Rename", "&Cancel",
0, # Enter == button 0
1 # button 1
)
if ret == 0:
self.favoritesComboBox.removeItem(indexOfDuplicateItem)
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
ok2, text = writeProteinDisplayStyleSettingsToFavoritesFile(name)
msg = "Overwrote favorite [%s]." % (text)
env.history.message(msg)
elif ret == 1:
# add new item to favorites folder as well as combobox
self.addFavorite()
else:
#reset the display setting values to factory default
factoryIndex = self.favoritesComboBox.findText(
'Factory default settings')
self.favoritesComboBox.setCurrentIndex(factoryIndex)
env.prefs.restore_defaults(proteinDisplayStylePrefsList)
env.history.message("Cancelled overwriting favorite file.")
return
else:
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
msg = "Loaded favorite [%s]." % (name)
env.history.message(msg)
self.updateProteinDisplayStyleWidgets()
return
def _addWhatsThisText( self ):
"""
Add what's this text for this PM
"""
from ne1_ui.WhatsThisText_for_PropertyManagers import WhatsThis_EditDnaDisplayStyle_PropertyManager
WhatsThis_EditDnaDisplayStyle_PropertyManager(self)
def _addToolTipText(self):
"""
Add tool tip text to all widgets.
"""
from ne1_ui.ToolTipText_for_PropertyManagers import ToolTip_EditProteinDisplayStyle_PropertyManager
ToolTip_EditProteinDisplayStyle_PropertyManager(self)
class DnaGeneratorPropertyManager( PM_Dialog, DebugMenuMixin ):
"""
The DnaGeneratorPropertyManager class provides a Property Manager
for the "Build > Atoms" command.
@ivar title: The title that appears in the property manager header.
@type title: str
@ivar pmName: The name of this property manager. This is used to set
the name of the PM_Dialog object via setObjectName().
@type name: str
@ivar iconPath: The relative path to the PNG file that contains a
22 x 22 icon image that appears in the PM header.
@type iconPath: str
@ivar validSymbols: Miscellaneous symbols that may appear in the sequence
(but are ignored). The hyphen '-' is a special case
that must be dealt with individually; it is not
included because it can confuse regular expressions.
@type validSymbols: QString
"""
title = "DNA"
pmName = title
iconPath = "ui/actions/Tools/Build Structures/DNA.png"
validSymbols = QString(' <>~!@#%&_+`=$*()[]{}|^\'"\\.;:,/?')
# The following class variables guarantee the UI's menu items
# are synchronized with their action code. The arrays should
# not be changed, unless an item is removed or inserted.
# Changes should be made via only the _action... variables.
# e.g., Change _action_Complement from "Complement"
# to "Complement Sequences". The menu item will
# change and its related code will need no update.
_action_Complement = "Complement"
_action_Reverse = "Reverse"
_action_RemoveUnrecognized = 'Remove unrecognized letters'
_action_ConvertUnrecognized = 'Convert unrecognized letters to "N"'
_actionChoices = [ "Action",
"---",
_action_Complement,
_action_Reverse,
_action_RemoveUnrecognized,
_action_ConvertUnrecognized ]
_modeltype_PAM3 = "PAM3"
_modeltype_PAM5 = "PAM5"
_modeltype_Atomistic = "Atomistic" # deprecated
_modelChoices = [ _modeltype_PAM3,
_modeltype_PAM5 ]
def __init__( self ):
"""
Constructor for the DNA Generator property manager.
"""
PM_Dialog.__init__( self, self.pmName, self.iconPath, self.title )
DebugMenuMixin._init1( self )
msg = "Edit the DNA parameters and select <b>Preview</b> to \
preview the structure. Click <b>Done</b> to insert it into \
the model."
# This causes the "Message" box to be displayed as well.
# setAsDefault=True causes this message to be reset whenever
# this PM is (re)displayed via show(). Mark 2007-06-01.
self.MessageGroupBox.insertHtmlMessage( msg, setAsDefault = True )
def _addGroupBoxes( self ):
"""
Add the DNA Property Manager group boxes.
"""
self._pmGroupBox1 = PM_GroupBox( self, title = "Strand Sequence" )
self._loadGroupBox1( self._pmGroupBox1 )
self._pmGroupBox2 = PM_GroupBox( self, title = "DNA Parameters" )
self._loadGroupBox2( self._pmGroupBox2 )
self._pmGroupBox3 = PM_GroupBox( self, title = "Endpoints" )
self._loadGroupBox3( self._pmGroupBox3 )
def _loadGroupBox1(self, pmGroupBox):
"""
Load widgets in group box 1.
"""
# Duplex Length
self.duplexLengthSpinBox = \
PM_DoubleSpinBox( pmGroupBox,
label = "Duplex Length: ",
value = 0,
setAsDefault = False,
minimum = 0,
maximum = 34000,
singleStep = self.getDuplexRise("B-DNA"),
decimals = 3,
suffix = ' Angstroms')
self.connect( self.duplexLengthSpinBox,
SIGNAL("valueChanged(double)"),
self.duplexLengthChanged )
# Strand Length
self.strandLengthSpinBox = \
PM_SpinBox( pmGroupBox,
label = "Strand Length :",
value = 0,
setAsDefault = False,
minimum = 0,
maximum = 10000,
suffix = ' bases' )
self.connect( self.strandLengthSpinBox,
SIGNAL("valueChanged(int)"),
self.strandLengthChanged )
# New Base choices
newBaseChoices = []
for theBase in basesDict.keys():
newBaseChoices = newBaseChoices \
+ [ theBase + ' (' \
+ basesDict[theBase]['Name'] + ')' ]
try:
defaultBaseChoice = basesDict.keys().index('N')
except:
defaultBaseChoice = 0
# Strand Sequence
self.sequenceTextEdit = \
PM_TextEdit( pmGroupBox,
label = "",
spanWidth = True )
self.sequenceTextEdit.setCursorWidth(2)
self.sequenceTextEdit.setWordWrapMode( QTextOption.WrapAnywhere )
self.connect( self.sequenceTextEdit,
SIGNAL("textChanged()"),
self.sequenceChanged )
self.connect( self.sequenceTextEdit,
SIGNAL("cursorPositionChanged()"),
self.cursorPosChanged )
# Actions
self.actionsComboBox = \
PM_ComboBox( pmGroupBox,
label = '',
choices = self._actionChoices,
index = 0,
setAsDefault = True,
spanWidth = True )
# If SIGNAL("activate(const QString&)") is used, we get a TypeError.
# This is a bug that needs Bruce. Using currentIndexChanged(int) as
# a workaround, but there is still a bug when the "Reverse" action
# is selected. Mark 2007-08-15
self.connect( self.actionsComboBox,
SIGNAL("currentIndexChanged(int)"),
self.actionsComboBoxChanged )
def _loadGroupBox2( self, pmGroupBox ):
"""
Load widgets in group box 2.
"""
self.modelComboBox = \
PM_ComboBox( pmGroupBox,
label = "Model :",
choices = self._modelChoices,
setAsDefault = True)
self.conformationComboBox = \
PM_ComboBox( pmGroupBox,
label = "Conformation :",
choices = ["B-DNA"],
setAsDefault = True)
self.connect( self.conformationComboBox,
SIGNAL("currentIndexChanged(int)"),
self.conformationComboBoxChanged )
self.basesPerTurnComboBox= \
PM_ComboBox( pmGroupBox,
label = "Bases Per Turn :",
choices = ["10.0", "10.5", "10.67"],
setAsDefault = True)
# I may decide to reintroduce "base-pair chunks" at a later time.
# Please talk to me if you have a strong feeling about including
# this. Mark 2007-08-19.
createChoices = ["Strand chunks", \
"Single chunk" ]
#@ "Base-pair chunks"]
self.createComboBox = \
PM_ComboBox( pmGroupBox,
label = "Create :",
choices = createChoices,
index = 0,
setAsDefault = True,
spanWidth = False )
def _loadGroupBox3(self, pmGroupBox):
"""
Load widgets in group box 3.
"""
self._endPoint1GroupBox = PM_GroupBox( pmGroupBox, title = "Endpoint1" )
self._endPoint2GroupBox = PM_GroupBox( pmGroupBox, title = "Endpoint2" )
# Point 1
self.x1SpinBox = \
PM_DoubleSpinBox( self._endPoint1GroupBox,
label = \
"ui/actions/Properties Manager/X_Coordinate.png",
value = 0,
setAsDefault = True,
minimum = -100.0,
maximum = 100.0,
decimals = 3,
suffix = ' Angstroms')
self.y1SpinBox = \
PM_DoubleSpinBox( self._endPoint1GroupBox,
label = \
"ui/actions/Properties Manager/Y_Coordinate.png",
value = 0,
setAsDefault = True,
minimum = -100.0,
maximum = 100.0,
decimals = 3,
suffix = ' Angstroms')
self.z1SpinBox = \
PM_DoubleSpinBox( self._endPoint1GroupBox,
label = \
"ui/actions/Properties Manager/Z_Coordinate.png",
value = 0,
setAsDefault = True,
minimum = -100.0,
maximum = 100.0,
decimals = 3,
suffix = ' Angstroms')
# Point 2
self.x2SpinBox = \
PM_DoubleSpinBox( self._endPoint2GroupBox,
label = \
"ui/actions/Properties Manager/X_Coordinate.png",
value = 10.0,
setAsDefault = True,
minimum = -100.0,
maximum = 100.0,
decimals = 3,
suffix = ' Angstroms')
self.y2SpinBox = \
PM_DoubleSpinBox( self._endPoint2GroupBox,
label = \
"ui/actions/Properties Manager/Y_Coordinate.png",
value = 0,
setAsDefault = True,
minimum = -100.0,
maximum = 100.0,
decimals = 3,
suffix = ' Angstroms')
self.z2SpinBox = \
PM_DoubleSpinBox( self._endPoint2GroupBox,
label = \
"ui/actions/Properties Manager/Z_Coordinate.png",
value = 0,
setAsDefault = True,
minimum = -100.0,
maximum = 100.0,
decimals = 3,
suffix = ' Angstroms')
def _addWhatsThisText( self ):
"""
What's This text for some of the widgets in the
DNA Property Manager.
@note: Many PM widgets are still missing their "What's This" text.
"""
self.conformationComboBox.setWhatsThis("""<b>Conformation</b>
<p>There are three DNA geometries, A-DNA, B-DNA,
and Z-DNA. Only B-DNA and Z-DNA are currently supported.</p>""")
self.sequenceTextEdit.setWhatsThis("""<b>Strand Sequence</b>
<p>Type in the strand sequence you want to generate here (5' => 3')<br>
<br>
Recognized base letters:<br>
<br>
A = Adenosine<br>
C = Cytosine<br>
G = Guanosine<br>
T = Thymidine<br>
N = aNy base<br>
X = Unassigned<br>
<br>
Other base letters currently recognized:<br>
<br>
B = C,G, or T<br>
D = A,G, or T<br>
H = A,C, or T<br>
V = A,C, or G<br>
R = A or G (puRine)<br>
Y = C or T (pYrimidine)<br>
K = G or T (Keto)<br>
M = A or C (aMino)<br>
S = G or C (Strong -3H bonds)<br>
W = A or T (Weak - 2H bonds)<br>
</p>""")
self.actionsComboBox.setWhatsThis("""<b>Action</b>
<p>Select an action to perform on the sequence.</p>""")
def conformationComboBoxChanged( self, inIndex ):
"""
Slot for the Conformation combobox. It is called whenever the
Conformation choice is changed.
@param inIndex: The new index.
@type inIndex: int
"""
self.basesPerTurnComboBox.clear()
conformation = self.conformationComboBox.currentText()
if conformation == "B-DNA":
self.basesPerTurnComboBox.insertItem(0, "10.0")
self.basesPerTurnComboBox.insertItem(1, "10.5")
self.basesPerTurnComboBox.insertItem(2, "10.67")
#10.5 is the default value for Bases per turn.
#So set the current index to 1
self.basesPerTurnComboBox.setCurrentIndex(1)
elif conformation == "Z-DNA":
self.basesPerTurnComboBox.insertItem(0, "12.0")
elif inIndex == -1:
# Caused by clear(). This is tolerable for now. Mark 2007-05-24.
conformation = "B-DNA" # Workaround for "Restore Defaults".
pass
else:
msg = redmsg("conformationComboBoxChanged(): \
Error - unknown DNA conformation. Index = "+ inIndex)
env.history.message(msg)
self.duplexLengthSpinBox.setSingleStep(
self.getDuplexRise(conformation) )
def modelComboBoxChanged( self, inIndex ):
"""
Slot for the Model combobox. It is called whenever the
Model choice is changed.
@param inIndex: The new index.
@type inIndex: int
"""
conformation = self._modelChoices[ inIndex ]
self.disconnect( self.conformationComboBox,
SIGNAL("currentIndexChanged(int)"),
self.conformationComboBoxChanged )
self.conformationComboBox.clear() # Generates signal!
if conformation == self._modeltype_PAM3:
self.conformationComboBox.addItem("B-DNA")
elif conformation == self._modeltype_PAM5:
self.conformationComboBox.addItem("B-DNA")
elif conformation == self._modeltype_Atomistic:
self.conformationComboBox.addItem("B-DNA")
self.conformationComboBox.addItem("Z-DNA")
elif inIndex == -1:
# Caused by clear(). This is tolerable for now. Mark 2007-05-24.
pass
else:
msg = "Error - unknown model representation. Index = " + inIndex
env.history.message(redmsg(msg))
self.connect( self.conformationComboBox,
SIGNAL("currentIndexChanged(int)"),
self.conformationComboBoxChanged)
# GroupBox3 slots (and other methods) supporting the Strand Sequence groupbox.
def getDuplexRise( self, inConformation ):
"""
Return the 'rise' between base pairs of the
specified DNA type (conformation).
@param inConformation: The current conformation.
@type inConformation: int
"""
return dnaDict[str(inConformation)]['DuplexRise']
def synchronizeLengths( self ):
"""
Guarantees the values of the duplex length and strand length
spinboxes agree with the strand sequence (textedit).
"""
self.updateStrandLength()
self.updateDuplexLength()
return
# Added :jbirac 20070613:
def duplexLengthChanged( self, inDuplexLength ):
"""
Slot for the duplex length spinbox, called whenever the value of the
Duplex Length spinbox changes.
@param inDuplexLength: The duplex length.
@type inDuplexLength: float
"""
conformation = self.conformationComboBox.currentText()
duplexRise = self.getDuplexRise( conformation )
newStrandLength = inDuplexLength / duplexRise + 0.5
newStrandLength = int( newStrandLength )
self.strandLengthChanged( newStrandLength )
def updateDuplexLength( self ): # Added :jbirac 20070615:
"""
Update the Duplex Length spinbox; always the length of the
strand sequence multiplied by the 'rise' of the duplex. This
method is called by slots of other controls (i.e., this itself
is not a slot.)
"""
conformation = self.conformationComboBox.currentText()
newDuplexLength = self.getDuplexRise( conformation ) \
* self.getSequenceLength()
self.disconnect( self.duplexLengthSpinBox,
SIGNAL("valueChanged(double)"),
self.duplexLengthChanged)
self.duplexLengthSpinBox.setValue( newDuplexLength )
self.connect( self.duplexLengthSpinBox,
SIGNAL("valueChanged(double)"),
self.duplexLengthChanged)
# Renamed from length_changed :jbirac 20070613:
def strandLengthChanged( self, inStrandLength ):
"""
Slot for the Strand Length spin box, called whenever the value of the
Strand Length spin box changes.
@param inStrandLength: The number of bases in the strand sequence.
@type inStrandLength: int
"""
theSequence = self.getPlainSequence()
sequenceLen = len( theSequence )
lengthChange = inStrandLength - self.getSequenceLength()
# Preserve the cursor's position/selection
cursor = self.sequenceTextEdit.textCursor()
#cursorPosition = cursor.position()
selectionStart = cursor.selectionStart()
selectionEnd = cursor.selectionEnd()
if inStrandLength < 0:
return # Should never happen.
if lengthChange < 0:
# If length is less than the previous length,
# simply truncate the current sequence.
theSequence.chop( -lengthChange )
elif lengthChange > 0:
# If length has increased, add the correct number of base
# letters to the current strand sequence.
numNewBases = lengthChange
# Get current base selected in combobox.
chosenBase = 'X' # Unassigned.
basesToAdd = chosenBase * numNewBases
theSequence.append( basesToAdd )
else:
env.history.message(
orangemsg( "strandLengthChanged(): Length has not changed." ))
self.setSequence( theSequence )
return
# Renamed from updateLength :jbirac 20070613:
def updateStrandLength( self ):
"""
Update the Strand Length spinbox; always the length of the strand
sequence.
"""
self.disconnect( self.strandLengthSpinBox,
SIGNAL("valueChanged(int)"),
self.strandLengthChanged )
self.strandLengthSpinBox.setValue( self.getSequenceLength() )
self.connect( self.strandLengthSpinBox,
SIGNAL("valueChanged(int)"),
self.strandLengthChanged )
return
def sequenceChanged( self ):
"""
Slot for the Strand Sequence textedit widget.
Assumes the sequence changed directly by user's keystroke in the
textedit. Other methods...
"""
cursorPosition = self.getCursorPosition()
theSequence = self.getPlainSequence()
# Disconnect while we edit the sequence.
self.disconnect( self.sequenceTextEdit,
SIGNAL("textChanged()"),
self.sequenceChanged )
# How has the text changed?
if theSequence.length() == 0: # There is no sequence.
self.updateStrandLength()
self.updateDuplexLength()
else:
# Insert the sequence; it will be "stylized" by setSequence().
self.setSequence( theSequence )
# Reconnect to respond when the sequence is changed.
self.connect( self.sequenceTextEdit,
SIGNAL("textChanged()"),
self.sequenceChanged )
self.synchronizeLengths()
return
def getPlainSequence( self, inOmitSymbols = False ):
"""
Returns a plain text QString (without HTML stylization)
of the current sequence. All characters are preserved (unless
specified explicitly), including valid base letters, punctuation
symbols, whitespace and invalid letters.
@param inOmitSymbols: Omits characters listed in self.validSymbols.
@type inOmitSymbols: bool
@return: The current DNA sequence in the PM.
@rtype: QString
"""
outSequence = self.sequenceTextEdit.toPlainText()
if inOmitSymbols:
# This may look like a sloppy piece of code, but Qt's QRegExp
# class makes it pretty tricky to remove all punctuation.
theString = '[<>' \
+ str( QRegExp.escape(self.validSymbols) ) \
+ ']|-'
outSequence.remove(QRegExp( theString ))
return outSequence
def stylizeSequence( self, inSequence ):
"""
Converts a plain text string of a sequence (including optional
symbols) to an HTML rich text string.
@param inSequence: A DNA sequence.
@type inSequence: QString
@return: The sequence.
@rtype: QString
"""
outSequence = str(inSequence)
# Verify that all characters (bases) in the sequence are "valid".
invalidSequence = False
basePosition = 0
sequencePosition = 0
invalidStartTag = "<b><font color=black>"
invalidEndTag = "</b>"
previousChar = chr(1) # Null character; may be revised.
# Some characters must be substituted to preserve
# whitespace and tags in HTML code.
substituteDict = { ' ':' ', '<':'<', '>':'>' }
while basePosition < len(outSequence):
theSeqChar = outSequence[basePosition]
if ( theSeqChar in basesDict
or theSeqChar in self.validSymbols ):
# Close any preceding invalid sequence segment.
if invalidSequence == True:
outSequence = outSequence[:basePosition] \
+ invalidEndTag \
+ outSequence[basePosition:]
basePosition += len(invalidEndTag)
invalidSequence = False
# Color the valid characters.
if theSeqChar != previousChar:
# We only need to insert 'color' tags in places where
# the adjacent characters are different.
if theSeqChar in basesDict:
theTag = '<font color=' \
+ basesDict[ theSeqChar ]['Color'] \
+ '>'
elif not previousChar in self.validSymbols:
# The character is a 'valid' symbol to be greyed
# out. Only one 'color' tag is needed for a
# group of adjacent symbols.
theTag = '<font color=dimgrey>'
else:
theTag = ''
outSequence = outSequence[:basePosition] \
+ theTag + outSequence[basePosition:]
basePosition += len(theTag)
# Any <space> character must be substituted with an
# ASCII code tag because the HTML engine will collapse
# whitespace to a single <space> character; whitespace
# is truncated from the end of HTML by default.
# Also, many symbol characters must be substituted
# because they confuse the HTML syntax.
#if str( outSequence[basePosition] ) in substituteDict:
if outSequence[basePosition] in substituteDict:
#theTag = substituteDict[theSeqChar]
theTag = substituteDict[ outSequence[basePosition] ]
outSequence = outSequence[:basePosition] \
+ theTag \
+ outSequence[basePosition + 1:]
basePosition += len(theTag) - 1
else:
# The sequence character is invalid (but permissible).
# Tags (e.g., <b> and </b>) must be inserted at both the
# beginning and end of a segment of invalid characters.
if invalidSequence == False:
outSequence = outSequence[:basePosition] \
+ invalidStartTag \
+ outSequence[basePosition:]
basePosition += len(invalidStartTag)
invalidSequence = True
basePosition += 1
previousChar = theSeqChar
#basePosition += 1
# Specify that theSequence is definitely HTML format, because
# Qt can get confused between HTML and Plain Text.
outSequence = "<html>" + outSequence
outSequence += "</html>"
return outSequence
def setSequence( self,
inSequence,
inStylize = True,
inRestoreCursor = True ):
"""
Replace the current strand sequence with the new sequence text.
@param inSequence: The new sequence.
@type inSequence: QString
@param inStylize: If True, inSequence will be converted from a plain
text string (including optional symbols) to an HTML
rich text string.
@type inStylize: bool
@param inRestoreCursor: Not implemented yet.
@type inRestoreCursor: bool
@attention: Signals/slots must be managed before calling this method.
The textChanged() signal will be sent to any connected widgets.
"""
cursor = self.sequenceTextEdit.textCursor()
selectionStart = cursor.selectionStart()
selectionEnd = cursor.selectionEnd()
if inStylize:
inSequence = self.stylizeSequence( inSequence )
self.sequenceTextEdit.insertHtml( inSequence )
if inRestoreCursor:
cursor.setPosition( min(selectionStart, self.getSequenceLength()),
QTextCursor.MoveAnchor )
cursor.setPosition( min(selectionEnd, self.getSequenceLength()),
QTextCursor.KeepAnchor )
self.sequenceTextEdit.setTextCursor( cursor )
return
def getSequenceLength( self ):
"""
Returns the number of characters in
the strand sequence textedit widget.
"""
theSequence = self.getPlainSequence( inOmitSymbols = True )
outLength = theSequence.length()
return outLength
def getCursorPosition( self ):
"""
Returns the cursor position in the
strand sequence textedit widget.
"""
cursor = self.sequenceTextEdit.textCursor()
return cursor.position()
def cursorPosChanged( self ):
"""
Slot called when the cursor position changes.
"""
cursor = self.sequenceTextEdit.textCursor()
if 0:
env.history.message( greenmsg( "cursorPosChanged: Selection ("
+ str(cursor.selectionStart())
+ " thru "
+ str(cursor.selectionEnd())+')' ) )
return
def actionsComboBoxChanged( self, inIndex ):
"""
Slot for the Actions combobox. It is called whenever the
Action choice is changed.
@param inIndex: The index of the selected action choice.
@type inIndex: int
"""
if inIndex == 0: # Very important.
return
actionName = str(self.actionsComboBox.currentText())
self.actionsComboBox.setCurrentIndex( 0 ) # Generates signal!
self.invokeAction( actionName )
return
def invokeAction( self, inActionName ):
"""
Applies an action on the current sequence displayed in the PM.
@param inActionName: The action name.
@type inActionName: str
@return: The sequence after the action has been applied.
@rtype: str
"""
sequence, allKnown = self._getSequence()
outResult = ""
if inActionName == self._action_Complement:
outResult = getComplementSequence(sequence)
elif inActionName == self._action_Reverse:
outResult = getReverseSequence(sequence)
elif inActionName == self._action_ConvertUnrecognized:
outResult = replaceUnrecognized(sequence, replaceBase = 'N')
self.setSequence( outResult )
elif inActionName == self._action_RemoveUnrecognized:
outResult = replaceUnrecognized(sequence, replaceBase = '')
self.setSequence( outResult )
return
class DnaDisplayStyle_PropertyManager(Command_PropertyManager):
"""
The DnaDisplayStyle_PropertyManager class provides a Property Manager
for the B{Display Style} command on the flyout toolbar in the
Build > Dna mode.
@ivar title: The title that appears in the property manager header.
@type title: str
@ivar pmName: The name of this property manager. This is used to set
the name of the PM_Dialog object via setObjectName().
@type name: str
@ivar iconPath: The relative path to the PNG file that contains a
22 x 22 icon image that appears in the PM header.
@type iconPath: str
"""
title = "Edit DNA Display Style"
pmName = title
iconPath = "ui/actions/Command Toolbar/BuildDna/EditDnaDisplayStyle.png"
def __init__(self, command):
"""
Constructor for the property manager.
"""
self.currentWorkingDirectory = env.prefs[workingDirectory_prefs_key]
_superclass.__init__(self, command)
self.showTopRowButtons( PM_DONE_BUTTON | \
PM_WHATS_THIS_BUTTON)
msg = "Modify the DNA display settings below."
self.updateMessage(msg)
def connect_or_disconnect_signals(self, isConnect):
"""
Connect or disconnect widget signals sent to their slot methods.
This can be overridden in subclasses. By default it does nothing.
@param isConnect: If True the widget will send the signals to the slot
method.
@type isConnect: boolean
"""
if isConnect:
change_connect = self.win.connect
else:
change_connect = self.win.disconnect
# Favorite buttons signal-slot connections.
change_connect(self.applyFavoriteButton, SIGNAL("clicked()"),
self.applyFavorite)
change_connect(self.addFavoriteButton, SIGNAL("clicked()"),
self.addFavorite)
change_connect(self.deleteFavoriteButton, SIGNAL("clicked()"),
self.deleteFavorite)
change_connect(self.saveFavoriteButton, SIGNAL("clicked()"),
self.saveFavorite)
change_connect(self.loadFavoriteButton, SIGNAL("clicked()"),
self.loadFavorite)
# Current display settings groupbox.
change_connect(self.dnaRenditionComboBox,
SIGNAL("currentIndexChanged(int)"),
self.change_dnaRendition)
# Axis options.
change_connect(self.axisShapeComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleAxisShape)
change_connect(self.axisScaleDoubleSpinBox,
SIGNAL("valueChanged(double)"),
self.win.userPrefs.change_dnaStyleAxisScale)
change_connect(self.axisColorComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleAxisColor)
change_connect(self.axisEndingStyleComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleAxisEndingStyle)
# Strands options.
change_connect(self.strandsShapeComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleStrandsShape)
change_connect(self.strandsScaleDoubleSpinBox,
SIGNAL("valueChanged(double)"),
self.win.userPrefs.change_dnaStyleStrandsScale)
change_connect(self.strandsColorComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleStrandsColor)
change_connect(self.strandsArrowsComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleStrandsArrows)
# Structs options.
change_connect(self.strutsShapeComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleStrutsShape)
change_connect(self.strutsScaleDoubleSpinBox,
SIGNAL("valueChanged(double)"),
self.win.userPrefs.change_dnaStyleStrutsScale)
change_connect(self.strutsColorComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleStrutsColor)
# Nucleotides options.
change_connect(self.nucleotidesShapeComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleBasesShape)
change_connect(self.nucleotidesScaleDoubleSpinBox,
SIGNAL("valueChanged(double)"),
self.win.userPrefs.change_dnaStyleBasesScale)
change_connect(self.nucleotidesColorComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleBasesColor)
connect_checkbox_with_boolean_pref(
self.dnaStyleBasesDisplayLettersCheckBox,
dnaStyleBasesDisplayLetters_prefs_key)
# Dna Strand labels option.
change_connect(self.standLabelColorComboBox,
SIGNAL("currentIndexChanged(int)"),
self.change_dnaStrandLabelsDisplay)
def show(self):
"""
Shows the Property Manager. Extends superclass method
"""
_superclass.show(self)
#@REVIEW: Is it safe to do the follwoing before calling superclass.show()?
#-- Ninad 2008-10-02
# Force the Global Display Style to "DNA Cylinder" so the user
# can see the display style setting effects on any DNA in the current
# model. The current global display style will be restored when leaving
# this command (via self.close()).
self.originalDisplayStyle = self.o.displayMode
# TODO: rename that public attr of GLPane (widely used)
# from displayMode to displayStyle. [bruce 080910 comment]
self.o.setGlobalDisplayStyle(diDNACYLINDER)
# Update all PM widgets, .
# note: It is important to update the widgets by blocking the
# 'signals'. If done in the reverse order, it will generate signals
#when updating the PM widgets (via updateDnaDisplayStyleWidgets()),
#causing unneccessary repaints of the model view.
self.updateDnaDisplayStyleWidgets(blockSignals=True)
def close(self):
"""
Closes the Property Manager. Extends superclass method.
"""
_superclass.close(self)
# Restore the original global display style.
self.o.setGlobalDisplayStyle(self.originalDisplayStyle)
def _addGroupBoxes(self):
"""
Add the Property Manager group boxes.
"""
self._pmGroupBox1 = PM_GroupBox(self, title="Favorites")
self._loadGroupBox1(self._pmGroupBox1)
self._pmGroupBox2 = PM_GroupBox(self, title="Current Display Settings")
self._loadGroupBox2(self._pmGroupBox2)
def _loadGroupBox1(self, pmGroupBox):
"""
Load widgets in group box.
"""
# Other info
# Not only loads the factory default settings but also all the favorite
# files stored in the ~/Nanorex/Favorites/DnaDisplayStyle directory
favoriteChoices = ['Factory default settings']
#look for all the favorite files in the favorite folder and add them to
# the list
from platform_dependent.PlatformDependent import find_or_make_Nanorex_subdir
_dir = find_or_make_Nanorex_subdir('Favorites/DnaDisplayStyle')
for file in os.listdir(_dir):
fullname = os.path.join(_dir, file)
if os.path.isfile(fullname):
if fnmatch.fnmatch(file, "*.txt"):
# leave the extension out
favoriteChoices.append(file[0:len(file) - 4])
self.favoritesComboBox = \
PM_ComboBox( pmGroupBox,
choices = favoriteChoices,
spanWidth = True)
self.favoritesComboBox.setWhatsThis("""<b> List of Favorites </b>
<p>
Creates a list of favorite DNA display styles. Once favorite
styles have been added to the list using the Add Favorite button,
the list will display the chosen favorites.
To change the current favorite, select a current favorite from
the list, and push the Apply Favorite button.""")
# PM_ToolButtonRow ===============
# Button list to create a toolbutton row.
# Format:
# - QToolButton, buttonId, buttonText,
# - iconPath,
# - tooltip, shortcut, column
BUTTON_LIST = [
( "QToolButton", 1, "APPLY_FAVORITE",
"ui/actions/Properties Manager/ApplyFavorite.png",
"Apply Favorite", "", 0),
( "QToolButton", 2, "ADD_FAVORITE",
"ui/actions/Properties Manager/AddFavorite.png",
"Add Favorite", "", 1),
( "QToolButton", 3, "DELETE_FAVORITE",
"ui/actions/Properties Manager/DeleteFavorite.png",
"Delete Favorite", "", 2),
( "QToolButton", 4, "SAVE_FAVORITE",
"ui/actions/Properties Manager/SaveFavorite.png",
"Save Favorite", "", 3),
( "QToolButton", 5, "LOAD_FAVORITE",
"ui/actions/Properties Manager/LoadFavorite.png",
"Load Favorite", \
"", 4)
]
self.favsButtonGroup = \
PM_ToolButtonRow( pmGroupBox,
title = "",
buttonList = BUTTON_LIST,
spanWidth = True,
isAutoRaise = False,
isCheckable = False,
setAsDefault = True,
)
self.favsButtonGroup.buttonGroup.setExclusive(False)
self.applyFavoriteButton = self.favsButtonGroup.getButtonById(1)
self.addFavoriteButton = self.favsButtonGroup.getButtonById(2)
self.deleteFavoriteButton = self.favsButtonGroup.getButtonById(3)
self.saveFavoriteButton = self.favsButtonGroup.getButtonById(4)
self.loadFavoriteButton = self.favsButtonGroup.getButtonById(5)
def _loadGroupBox2(self, pmGroupBox):
"""
Load widgets in group box.
"""
dnaRenditionChoices = [
'3D (default)', '2D with base letters', '2D ball and stick',
'2D ladder'
]
self.dnaRenditionComboBox = \
PM_ComboBox( pmGroupBox,
label = "Rendition:",
choices = dnaRenditionChoices,
setAsDefault = True)
dnaComponentChoices = ['Axis', 'Strands', 'Struts', 'Nucleotides']
self.dnaComponentComboBox = \
PM_ComboBox( pmGroupBox,
label = "Component:",
choices = dnaComponentChoices,
setAsDefault = True)
self._loadAxisGroupBox()
self._loadStrandsGroupBox()
self._loadStrutsGroupBox()
self._loadNucleotidesGroupBox()
widgetList = [
self.axisGroupBox, self.strandsGroupBox, self.strutsGroupBox,
self.nucleotidesGroupBox
]
self.dnaComponentStackedWidget = \
PM_StackedWidget( pmGroupBox,
self.dnaComponentComboBox,
widgetList )
standLabelColorChoices = [
'Hide', 'Show (in strand color)', 'Black', 'White',
'Custom color...'
]
self.standLabelColorComboBox = \
PM_ComboBox( pmGroupBox,
label = "Strand labels:",
choices = standLabelColorChoices,
setAsDefault = True)
# This disables "Component" widgets if rendition style is 2D.
self.change_dnaRendition(env.prefs[dnaRendition_prefs_key])
def _loadAxisGroupBox(self):
"""
Load the Axis group box.
"""
axisGroupBox = PM_GroupBox(None)
self.axisGroupBox = axisGroupBox
axisShapeChoices = ['None', 'Wide tube', 'Narrow tube']
self.axisShapeComboBox = \
PM_ComboBox( axisGroupBox ,
label = "Shape:",
choices = axisShapeChoices,
setAsDefault = True)
self.axisScaleDoubleSpinBox = \
PM_DoubleSpinBox( axisGroupBox,
label = "Scale:",
value = 1.00,
setAsDefault = True,
minimum = 0.1,
maximum = 2.0,
decimals = 2,
singleStep = 0.1 )
axisColorChoices = [
'Same as chunk', 'Base order', 'Base order (discrete)',
'Base type', 'Strand order'
]
self.axisColorComboBox = \
PM_ComboBox( axisGroupBox ,
label = "Color:",
choices = axisColorChoices,
setAsDefault = True)
endingTypeChoices = [
'Flat', 'Taper start', 'Taper end', 'Taper both', 'Spherical'
]
self.axisEndingStyleComboBox = \
PM_ComboBox( axisGroupBox ,
label = "Ending style:",
choices = endingTypeChoices,
setAsDefault = True)
def _loadStrandsGroupBox(self):
"""
Load the Strands group box.
"""
strandsGroupBox = PM_GroupBox(None)
self.strandsGroupBox = strandsGroupBox
strandsShapeChoices = ['None', 'Cylinders', 'Tube']
self.strandsShapeComboBox = \
PM_ComboBox( strandsGroupBox ,
label = "Shape:",
choices = strandsShapeChoices,
setAsDefault = True)
self.strandsScaleDoubleSpinBox = \
PM_DoubleSpinBox( strandsGroupBox,
label = "Scale:",
value = 1.00,
setAsDefault = True,
minimum = 0.1,
maximum = 5.0,
decimals = 2,
singleStep = 0.1 )
strandsColorChoices = ['Same as chunk', 'Base order', 'Strand order']
self.strandsColorComboBox = \
PM_ComboBox( strandsGroupBox ,
label = "Color:",
choices = strandsColorChoices,
setAsDefault = True)
strandsArrowsChoices = ['None', '5\'', '3\'', '5\' and 3\'']
self.strandsArrowsComboBox = \
PM_ComboBox( strandsGroupBox ,
label = "Arrows:",
choices = strandsArrowsChoices,
setAsDefault = True)
def _loadStrutsGroupBox(self):
"""
Load the Struts group box.
"""
strutsGroupBox = PM_GroupBox(None)
self.strutsGroupBox = strutsGroupBox
strutsShapeChoices = [
'None', 'Base-axis-base cylinders', 'Straight cylinders'
]
self.strutsShapeComboBox = \
PM_ComboBox( strutsGroupBox ,
label = "Shape:",
choices = strutsShapeChoices,
setAsDefault = True)
self.strutsScaleDoubleSpinBox = \
PM_DoubleSpinBox( strutsGroupBox,
label = "Scale:",
value = 1.00,
setAsDefault = True,
minimum = 0.1,
maximum = 3.0,
decimals = 2,
singleStep = 0.1 )
strutsColorChoices = [
'Same as strand', 'Base order', 'Strand order', 'Base type'
]
self.strutsColorComboBox = \
PM_ComboBox( strutsGroupBox ,
label = "Color:",
choices = strutsColorChoices,
setAsDefault = True)
def _loadNucleotidesGroupBox(self):
"""
Load the Nucleotides group box.
"""
nucleotidesGroupBox = PM_GroupBox(None)
self.nucleotidesGroupBox = nucleotidesGroupBox
nucleotidesShapeChoices = ['None', 'Sugar spheres', 'Base cartoons']
self.nucleotidesShapeComboBox = \
PM_ComboBox( nucleotidesGroupBox ,
label = "Shape:",
choices = nucleotidesShapeChoices,
setAsDefault = True)
self.nucleotidesScaleDoubleSpinBox = \
PM_DoubleSpinBox( nucleotidesGroupBox,
label = "Scale:",
value = 1.00,
setAsDefault = True,
minimum = 0.1,
maximum = 3.0,
decimals = 2,
singleStep = 0.1 )
nucleotidesColorChoices = [
'Same as strand', 'Base order', 'Strand order', 'Base type'
]
self.nucleotidesColorComboBox = \
PM_ComboBox( nucleotidesGroupBox ,
label = "Color:",
choices = nucleotidesColorChoices,
setAsDefault = True)
self.dnaStyleBasesDisplayLettersCheckBox = \
PM_CheckBox(nucleotidesGroupBox ,
text = 'Display base letters',
widgetColumn = 1
)
def updateDnaDisplayStyleWidgets(self, blockSignals=False):
"""
Updates all the DNA Display style widgets based on the current pref keys
values.
@param blockSignals: If its set to True, the set* methods of the
the widgets (currently only PM_ Spinboxes and
ComboBoxes) won't emit a signal.
@type blockSignals: bool
@see: self.show() where this method is called.
@see: PM_Spinbox.setValue()
@see: PM_ComboBox.setCurrentIndex()
@note: This should be called each time the PM is displayed (see show()).
"""
self.dnaRenditionComboBox.setCurrentIndex(
env.prefs[dnaRendition_prefs_key], blockSignals=blockSignals)
self.axisShapeComboBox.setCurrentIndex(
env.prefs[dnaStyleAxisShape_prefs_key], blockSignals=blockSignals)
self.axisScaleDoubleSpinBox.setValue(
env.prefs[dnaStyleAxisScale_prefs_key], blockSignals=blockSignals)
self.axisColorComboBox.setCurrentIndex(
env.prefs[dnaStyleAxisColor_prefs_key], blockSignals=blockSignals)
self.axisEndingStyleComboBox.setCurrentIndex(
env.prefs[dnaStyleAxisEndingStyle_prefs_key],
blockSignals=blockSignals)
self.strandsShapeComboBox.setCurrentIndex(
env.prefs[dnaStyleStrandsShape_prefs_key],
blockSignals=blockSignals)
self.strandsScaleDoubleSpinBox.setValue(
env.prefs[dnaStyleStrandsScale_prefs_key],
blockSignals=blockSignals)
self.strandsColorComboBox.setCurrentIndex(
env.prefs[dnaStyleStrandsColor_prefs_key],
blockSignals=blockSignals)
self.strandsArrowsComboBox.setCurrentIndex(
env.prefs[dnaStyleStrandsArrows_prefs_key],
blockSignals=blockSignals)
self.strutsShapeComboBox.setCurrentIndex(
env.prefs[dnaStyleStrutsShape_prefs_key],
blockSignals=blockSignals)
self.strutsScaleDoubleSpinBox.setValue(
env.prefs[dnaStyleStrutsScale_prefs_key],
blockSignals=blockSignals)
self.strutsColorComboBox.setCurrentIndex(
env.prefs[dnaStyleStrutsColor_prefs_key],
blockSignals=blockSignals)
self.nucleotidesShapeComboBox.setCurrentIndex(
env.prefs[dnaStyleBasesShape_prefs_key], blockSignals=blockSignals)
self.nucleotidesScaleDoubleSpinBox.setValue(
env.prefs[dnaStyleBasesScale_prefs_key], blockSignals=blockSignals)
self.nucleotidesColorComboBox.setCurrentIndex(
env.prefs[dnaStyleBasesColor_prefs_key], blockSignals=blockSignals)
# DNA Strand label combobox.
if env.prefs[dnaStrandLabelsEnabled_prefs_key]:
_dnaStrandColorItem = env.prefs[
dnaStrandLabelsColorMode_prefs_key] + 1
else:
_dnaStrandColorItem = 0
self.standLabelColorComboBox.setCurrentIndex(_dnaStrandColorItem,
blockSignals=blockSignals)
def change_dnaStrandLabelsDisplay(self, mode):
"""
Changes DNA Strand labels display (and color) mode.
@param mode: The display mode:
- 0 = hide all labels
- 1 = show (same color as chunk)
- 2 = show (black)
- 3 = show (white)
- 4 = show (custom color...)
@type mode: int
"""
if mode == 4:
self.win.userPrefs.change_dnaStrandLabelsColor()
if mode == 0:
#@ Fix this at the same time I (we) remove the DNA display style
# prefs options from the Preferences dialog. --Mark 2008-05-13
self.win.userPrefs.toggle_dnaDisplayStrandLabelsGroupBox(False)
else:
self.win.userPrefs.toggle_dnaDisplayStrandLabelsGroupBox(True)
self.win.userPrefs.change_dnaStrandLabelsColorMode(mode - 1)
def applyFavorite(self):
"""
Apply the DNA display style settings stored in the current favorite
(selected in the combobox) to the current DNA display style settings.
"""
# Rules and other info:
# The user has to press the button related to this method when he loads
# a previously saved favorite file
current_favorite = self.favoritesComboBox.currentText()
if current_favorite == 'Factory default settings':
env.prefs.restore_defaults(dnaDisplayStylePrefsList)
else:
favfilepath = getFavoritePathFromBasename(current_favorite)
loadFavoriteFile(favfilepath)
self.updateDnaDisplayStyleWidgets()
return
def addFavorite(self):
"""
Adds a new favorite to the user's list of favorites.
"""
# Rules and other info:
# - The new favorite is defined by the current DNA display style
# settings.
# - The user is prompted to type in a name for the new
# favorite.
# - The DNA display style settings are written to a file in a special
# directory on the disk
# (i.e. $HOME/Nanorex/Favorites/DnaDisplayStyle/$FAV_NAME.fav).
# - The name of the new favorite is added to the list of favorites in
# the combobox, which becomes the current option.
# Existence of a favorite with the same name is checked in the above
# mentioned location and if a duplicate exists, then the user can either
# overwrite and provide a new name.
# Prompt user for a favorite name to add.
from widgets.simple_dialogs import grab_text_line_using_dialog
ok1, name = \
grab_text_line_using_dialog(
title = "Add new favorite",
label = "favorite name:",
iconPath = "ui/actions/Properties Manager/AddFavorite.png",
default = "" )
if ok1:
# check for duplicate files in the
# $HOME/Nanorex/Favorites/DnaDisplayStyle/ directory
fname = getFavoritePathFromBasename(name)
if os.path.exists(fname):
#favorite file already exists!
_ext = ".txt"
ret = QMessageBox.warning(
self,
"Warning!",
"The favorite file \"" + name + _ext +
"\"already exists.\n"
"Do you want to overwrite the existing file?",
"&Overwrite",
"&Cancel",
"",
0, # Enter == button 0
1) # Escape == button 1
if ret == 0:
#overwrite favorite file
ok2, text = writeDnaDisplayStyleSettingsToFavoritesFile(
name)
indexOfDuplicateItem = self.favoritesComboBox.findText(
name)
self.favoritesComboBox.removeItem(indexOfDuplicateItem)
print "Add Favorite: removed duplicate favorite item."
else:
env.history.message(
"Add Favorite: cancelled overwriting favorite item.")
return
else:
ok2, text = writeDnaDisplayStyleSettingsToFavoritesFile(name)
else:
# User cancelled.
return
if ok2:
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
msg = "New favorite [%s] added." % (text)
else:
msg = "Can't add favorite [%s]: %s" % (name, text
) # text is reason why not
env.history.message(msg)
return
def deleteFavorite(self):
"""
Deletes the current favorite from the user's personal list of favorites
(and from disk, only in the favorites folder though).
@note: Cannot delete "Factory default settings".
"""
currentIndex = self.favoritesComboBox.currentIndex()
currentText = self.favoritesComboBox.currentText()
if currentIndex == 0:
msg = "Cannot delete '%s'." % currentText
else:
self.favoritesComboBox.removeItem(currentIndex)
# delete file from the disk
deleteFile = getFavoritePathFromBasename(currentText)
os.remove(deleteFile)
msg = "Deleted favorite named [%s].\n" \
"and the favorite file [%s.txt]." \
% (currentText, currentText)
env.history.message(msg)
return
def saveFavorite(self):
"""
Writes the current favorite (selected in the combobox) to a file, any
where in the disk that
can be given to another NE1 user (i.e. as an email attachment).
"""
cmd = greenmsg("Save Favorite File: ")
env.history.message(greenmsg("Save Favorite File:"))
current_favorite = self.favoritesComboBox.currentText()
favfilepath = getFavoritePathFromBasename(current_favorite)
#Check to see if favfilepath exists first
if not os.path.exists(favfilepath):
msg = "%s does not exist" % favfilepath
env.history.message(cmd + msg)
return
formats = \
"Favorite (*.txt);;"\
"All Files (*.*)"
directory = self.currentWorkingDirectory
saveLocation = directory + "/" + current_favorite + ".txt"
fn = QFileDialog.getSaveFileName(
self,
"Save Favorite As", # caption
saveLocation, #where to save
formats, # file format options
QString("Favorite (*.txt)") # selectedFilter
)
if not fn:
env.history.message(cmd + "Cancelled")
else:
dir, fil = os.path.split(str(fn))
self.setCurrentWorkingDirectory(dir)
saveFavoriteFile(str(fn), favfilepath)
return
def setCurrentWorkingDirectory(self, dir=None):
if os.path.isdir(dir):
self.currentWorkingDirectory = dir
self._setWorkingDirectoryInPrefsDB(dir)
else:
self.currentWorkingDirectory = getDefaultWorkingDirectory()
def _setWorkingDirectoryInPrefsDB(self, workdir=None):
"""
[private method]
Set the working directory in the user preferences database.
@param workdir: The fullpath directory to write to the user pref db.
If I{workdir} is None (default), there is no change.
@type workdir: string
"""
if not workdir:
return
workdir = str(workdir)
if os.path.isdir(workdir):
workdir = os.path.normpath(workdir)
env.prefs[
workingDirectory_prefs_key] = workdir # Change pref in prefs db.
else:
msg = "[" + workdir + "] is not a directory. Working directory was not changed."
env.history.message(redmsg(msg))
return
def loadFavorite(self):
"""
Prompts the user to choose a "favorite file" (i.e. *.txt) from disk to
be added to the personal favorites list.
"""
# If the file already exists in the favorites folder then the user is
# given the option of overwriting it or renaming it
env.history.message(greenmsg("Load Favorite File:"))
formats = \
"Favorite (*.txt);;"\
"All Files (*.*)"
directory = self.currentWorkingDirectory
if directory == '':
directory = getDefaultWorkingDirectory()
fname = QFileDialog.getOpenFileName(self, "Choose a file to load",
directory, formats)
if not fname:
env.history.message("User cancelled loading file.")
return
else:
dir, fil = os.path.split(str(fname))
self.setCurrentWorkingDirectory(dir)
canLoadFile = loadFavoriteFile(fname)
if canLoadFile == 1:
#get just the name of the file for loading into the combobox
favName = os.path.basename(str(fname))
name = favName[0:len(favName) - 4]
indexOfDuplicateItem = self.favoritesComboBox.findText(name)
#duplicate exists in combobox
if indexOfDuplicateItem != -1:
ret = QMessageBox.warning(
self,
"Warning!",
"The favorite file \"" + name + "\"already exists.\n"
"Do you want to overwrite the existing file?",
"&Overwrite",
"&Rename",
"&Cancel",
0, # Enter == button 0
1 # button 1
)
if ret == 0:
self.favoritesComboBox.removeItem(indexOfDuplicateItem)
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
ok2, text = writeDnaDisplayStyleSettingsToFavoritesFile(
name)
msg = "Overwrote favorite [%s]." % (text)
env.history.message(msg)
elif ret == 1:
# add new item to favorites folder as well as combobox
self.addFavorite()
else:
#reset the display setting values to factory default
factoryIndex = self.favoritesComboBox.findText(
'Factory default settings')
self.favoritesComboBox.setCurrentIndex(factoryIndex)
env.prefs.restore_defaults(dnaDisplayStylePrefsList)
env.history.message(
"Cancelled overwriting favorite file.")
return
else:
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
msg = "Loaded favorite [%s]." % (name)
env.history.message(msg)
self.updateDnaDisplayStyleWidgets()
return
def change_dnaRendition(self, rendition):
"""
Sets the DNA rendition to 3D or one of the optional 2D styles.
@param rendition: The rendition mode, where:
- 0 = 3D (default)
- 1 = 2D with base letters
- 2 = 2D ball and stick
- 3 = 2D ladder
@type rendition: int
"""
if rendition == 0:
_enabled_flag = True
else:
_enabled_flag = False
self.dnaComponentComboBox.setEnabled(_enabled_flag)
self.dnaComponentStackedWidget.setEnabled(_enabled_flag)
self.standLabelColorComboBox.setEnabled(_enabled_flag)
env.prefs[dnaRendition_prefs_key] = rendition
self.o.gl_update() # Force redraw
return
def _addWhatsThisText(self):
"""
What's This text for widgets in the DNA Property Manager.
"""
from ne1_ui.WhatsThisText_for_PropertyManagers import WhatsThis_EditDnaDisplayStyle_PropertyManager
WhatsThis_EditDnaDisplayStyle_PropertyManager(self)
def _addToolTipText(self):
"""
Tool Tip text for widgets in the DNA Property Manager.
"""
from ne1_ui.ToolTipText_for_PropertyManagers import ToolTip_EditDnaDisplayStyle_PropertyManager
ToolTip_EditDnaDisplayStyle_PropertyManager(self)
class DnaDisplayStyle_PropertyManager( Command_PropertyManager):
"""
The DnaDisplayStyle_PropertyManager class provides a Property Manager
for the B{Display Style} command on the flyout toolbar in the
Build > Dna mode.
@ivar title: The title that appears in the property manager header.
@type title: str
@ivar pmName: The name of this property manager. This is used to set
the name of the PM_Dialog object via setObjectName().
@type name: str
@ivar iconPath: The relative path to the PNG file that contains a
22 x 22 icon image that appears in the PM header.
@type iconPath: str
"""
title = "Edit DNA Display Style"
pmName = title
iconPath = "ui/actions/Command Toolbar/BuildDna/EditDnaDisplayStyle.png"
def __init__( self, command ):
"""
Constructor for the property manager.
"""
self.currentWorkingDirectory = env.prefs[workingDirectory_prefs_key]
_superclass.__init__(self, command)
self.showTopRowButtons( PM_DONE_BUTTON | \
PM_WHATS_THIS_BUTTON)
msg = "Modify the DNA display settings below."
self.updateMessage(msg)
def connect_or_disconnect_signals(self, isConnect):
"""
Connect or disconnect widget signals sent to their slot methods.
This can be overridden in subclasses. By default it does nothing.
@param isConnect: If True the widget will send the signals to the slot
method.
@type isConnect: boolean
"""
if isConnect:
change_connect = self.win.connect
else:
change_connect = self.win.disconnect
# Favorite buttons signal-slot connections.
change_connect( self.applyFavoriteButton,
SIGNAL("clicked()"),
self.applyFavorite)
change_connect( self.addFavoriteButton,
SIGNAL("clicked()"),
self.addFavorite)
change_connect( self.deleteFavoriteButton,
SIGNAL("clicked()"),
self.deleteFavorite)
change_connect( self.saveFavoriteButton,
SIGNAL("clicked()"),
self.saveFavorite)
change_connect( self.loadFavoriteButton,
SIGNAL("clicked()"),
self.loadFavorite)
# Current display settings groupbox.
change_connect( self.dnaRenditionComboBox,
SIGNAL("currentIndexChanged(int)"),
self.change_dnaRendition )
# Axis options.
change_connect( self.axisShapeComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleAxisShape )
change_connect( self.axisScaleDoubleSpinBox,
SIGNAL("valueChanged(double)"),
self.win.userPrefs.change_dnaStyleAxisScale )
change_connect( self.axisColorComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleAxisColor )
change_connect( self.axisEndingStyleComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleAxisEndingStyle )
# Strands options.
change_connect( self.strandsShapeComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleStrandsShape )
change_connect( self.strandsScaleDoubleSpinBox,
SIGNAL("valueChanged(double)"),
self.win.userPrefs.change_dnaStyleStrandsScale )
change_connect( self.strandsColorComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleStrandsColor )
change_connect( self.strandsArrowsComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleStrandsArrows )
# Structs options.
change_connect( self.strutsShapeComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleStrutsShape )
change_connect( self.strutsScaleDoubleSpinBox,
SIGNAL("valueChanged(double)"),
self.win.userPrefs.change_dnaStyleStrutsScale )
change_connect( self.strutsColorComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleStrutsColor )
# Nucleotides options.
change_connect( self.nucleotidesShapeComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleBasesShape )
change_connect( self.nucleotidesScaleDoubleSpinBox,
SIGNAL("valueChanged(double)"),
self.win.userPrefs.change_dnaStyleBasesScale )
change_connect( self.nucleotidesColorComboBox,
SIGNAL("currentIndexChanged(int)"),
self.win.userPrefs.change_dnaStyleBasesColor )
connect_checkbox_with_boolean_pref(
self.dnaStyleBasesDisplayLettersCheckBox,
dnaStyleBasesDisplayLetters_prefs_key)
# Dna Strand labels option.
change_connect( self.standLabelColorComboBox,
SIGNAL("currentIndexChanged(int)"),
self.change_dnaStrandLabelsDisplay )
def show(self):
"""
Shows the Property Manager. Extends superclass method
"""
_superclass.show(self)
#@REVIEW: Is it safe to do the follwoing before calling superclass.show()?
#-- Ninad 2008-10-02
# Force the Global Display Style to "DNA Cylinder" so the user
# can see the display style setting effects on any DNA in the current
# model. The current global display style will be restored when leaving
# this command (via self.close()).
self.originalDisplayStyle = self.o.displayMode
# TODO: rename that public attr of GLPane (widely used)
# from displayMode to displayStyle. [bruce 080910 comment]
self.o.setGlobalDisplayStyle(diDNACYLINDER)
# Update all PM widgets, .
# note: It is important to update the widgets by blocking the
# 'signals'. If done in the reverse order, it will generate signals
#when updating the PM widgets (via updateDnaDisplayStyleWidgets()),
#causing unneccessary repaints of the model view.
self.updateDnaDisplayStyleWidgets(blockSignals = True)
def close(self):
"""
Closes the Property Manager. Extends superclass method.
"""
_superclass.close(self)
# Restore the original global display style.
self.o.setGlobalDisplayStyle(self.originalDisplayStyle)
def _addGroupBoxes( self ):
"""
Add the Property Manager group boxes.
"""
self._pmGroupBox1 = PM_GroupBox( self,
title = "Favorites")
self._loadGroupBox1( self._pmGroupBox1 )
self._pmGroupBox2 = PM_GroupBox( self,
title = "Current Display Settings")
self._loadGroupBox2( self._pmGroupBox2 )
def _loadGroupBox1(self, pmGroupBox):
"""
Load widgets in group box.
"""
# Other info
# Not only loads the factory default settings but also all the favorite
# files stored in the ~/Nanorex/Favorites/DnaDisplayStyle directory
favoriteChoices = ['Factory default settings']
#look for all the favorite files in the favorite folder and add them to
# the list
from platform_dependent.PlatformDependent import find_or_make_Nanorex_subdir
_dir = find_or_make_Nanorex_subdir('Favorites/DnaDisplayStyle')
for file in os.listdir(_dir):
fullname = os.path.join( _dir, file)
if os.path.isfile(fullname):
if fnmatch.fnmatch( file, "*.txt"):
# leave the extension out
favoriteChoices.append(file[0:len(file)-4])
self.favoritesComboBox = \
PM_ComboBox( pmGroupBox,
choices = favoriteChoices,
spanWidth = True)
self.favoritesComboBox.setWhatsThis(
"""<b> List of Favorites </b>
<p>
Creates a list of favorite DNA display styles. Once favorite
styles have been added to the list using the Add Favorite button,
the list will display the chosen favorites.
To change the current favorite, select a current favorite from
the list, and push the Apply Favorite button.""")
# PM_ToolButtonRow ===============
# Button list to create a toolbutton row.
# Format:
# - QToolButton, buttonId, buttonText,
# - iconPath,
# - tooltip, shortcut, column
BUTTON_LIST = [
( "QToolButton", 1, "APPLY_FAVORITE",
"ui/actions/Properties Manager/ApplyFavorite.png",
"Apply Favorite", "", 0),
( "QToolButton", 2, "ADD_FAVORITE",
"ui/actions/Properties Manager/AddFavorite.png",
"Add Favorite", "", 1),
( "QToolButton", 3, "DELETE_FAVORITE",
"ui/actions/Properties Manager/DeleteFavorite.png",
"Delete Favorite", "", 2),
( "QToolButton", 4, "SAVE_FAVORITE",
"ui/actions/Properties Manager/SaveFavorite.png",
"Save Favorite", "", 3),
( "QToolButton", 5, "LOAD_FAVORITE",
"ui/actions/Properties Manager/LoadFavorite.png",
"Load Favorite", \
"", 4)
]
self.favsButtonGroup = \
PM_ToolButtonRow( pmGroupBox,
title = "",
buttonList = BUTTON_LIST,
spanWidth = True,
isAutoRaise = False,
isCheckable = False,
setAsDefault = True,
)
self.favsButtonGroup.buttonGroup.setExclusive(False)
self.applyFavoriteButton = self.favsButtonGroup.getButtonById(1)
self.addFavoriteButton = self.favsButtonGroup.getButtonById(2)
self.deleteFavoriteButton = self.favsButtonGroup.getButtonById(3)
self.saveFavoriteButton = self.favsButtonGroup.getButtonById(4)
self.loadFavoriteButton = self.favsButtonGroup.getButtonById(5)
def _loadGroupBox2(self, pmGroupBox):
"""
Load widgets in group box.
"""
dnaRenditionChoices = ['3D (default)',
'2D with base letters',
'2D ball and stick',
'2D ladder']
self.dnaRenditionComboBox = \
PM_ComboBox( pmGroupBox,
label = "Rendition:",
choices = dnaRenditionChoices,
setAsDefault = True)
dnaComponentChoices = ['Axis',
'Strands',
'Struts',
'Nucleotides']
self.dnaComponentComboBox = \
PM_ComboBox( pmGroupBox,
label = "Component:",
choices = dnaComponentChoices,
setAsDefault = True)
self._loadAxisGroupBox()
self._loadStrandsGroupBox()
self._loadStrutsGroupBox()
self._loadNucleotidesGroupBox()
widgetList = [self.axisGroupBox,
self.strandsGroupBox,
self.strutsGroupBox,
self.nucleotidesGroupBox]
self.dnaComponentStackedWidget = \
PM_StackedWidget( pmGroupBox,
self.dnaComponentComboBox,
widgetList )
standLabelColorChoices = ['Hide',
'Show (in strand color)',
'Black',
'White',
'Custom color...']
self.standLabelColorComboBox = \
PM_ComboBox( pmGroupBox,
label = "Strand labels:",
choices = standLabelColorChoices,
setAsDefault = True)
# This disables "Component" widgets if rendition style is 2D.
self.change_dnaRendition(env.prefs[dnaRendition_prefs_key])
def _loadAxisGroupBox(self):
"""
Load the Axis group box.
"""
axisGroupBox = PM_GroupBox( None )
self.axisGroupBox = axisGroupBox
axisShapeChoices = ['None', 'Wide tube', 'Narrow tube']
self.axisShapeComboBox = \
PM_ComboBox( axisGroupBox ,
label = "Shape:",
choices = axisShapeChoices,
setAsDefault = True)
self.axisScaleDoubleSpinBox = \
PM_DoubleSpinBox( axisGroupBox,
label = "Scale:",
value = 1.00,
setAsDefault = True,
minimum = 0.1,
maximum = 2.0,
decimals = 2,
singleStep = 0.1 )
axisColorChoices = ['Same as chunk',
'Base order',
'Base order (discrete)',
'Base type',
'Strand order']
self.axisColorComboBox = \
PM_ComboBox( axisGroupBox ,
label = "Color:",
choices = axisColorChoices,
setAsDefault = True)
endingTypeChoices = ['Flat',
'Taper start',
'Taper end',
'Taper both',
'Spherical']
self.axisEndingStyleComboBox = \
PM_ComboBox( axisGroupBox ,
label = "Ending style:",
choices = endingTypeChoices,
setAsDefault = True)
def _loadStrandsGroupBox(self):
"""
Load the Strands group box.
"""
strandsGroupBox = PM_GroupBox( None )
self.strandsGroupBox = strandsGroupBox
strandsShapeChoices = ['None', 'Cylinders', 'Tube']
self.strandsShapeComboBox = \
PM_ComboBox( strandsGroupBox ,
label = "Shape:",
choices = strandsShapeChoices,
setAsDefault = True)
self.strandsScaleDoubleSpinBox = \
PM_DoubleSpinBox( strandsGroupBox,
label = "Scale:",
value = 1.00,
setAsDefault = True,
minimum = 0.1,
maximum = 5.0,
decimals = 2,
singleStep = 0.1 )
strandsColorChoices = ['Same as chunk',
'Base order',
'Strand order']
self.strandsColorComboBox = \
PM_ComboBox( strandsGroupBox ,
label = "Color:",
choices = strandsColorChoices,
setAsDefault = True)
strandsArrowsChoices = ['None',
'5\'',
'3\'',
'5\' and 3\'']
self.strandsArrowsComboBox = \
PM_ComboBox( strandsGroupBox ,
label = "Arrows:",
choices = strandsArrowsChoices,
setAsDefault = True)
def _loadStrutsGroupBox(self):
"""
Load the Struts group box.
"""
strutsGroupBox = PM_GroupBox( None )
self.strutsGroupBox = strutsGroupBox
strutsShapeChoices = ['None',
'Base-axis-base cylinders',
'Straight cylinders']
self.strutsShapeComboBox = \
PM_ComboBox( strutsGroupBox ,
label = "Shape:",
choices = strutsShapeChoices,
setAsDefault = True)
self.strutsScaleDoubleSpinBox = \
PM_DoubleSpinBox( strutsGroupBox,
label = "Scale:",
value = 1.00,
setAsDefault = True,
minimum = 0.1,
maximum = 3.0,
decimals = 2,
singleStep = 0.1 )
strutsColorChoices = ['Same as strand',
'Base order',
'Strand order',
'Base type']
self.strutsColorComboBox = \
PM_ComboBox( strutsGroupBox ,
label = "Color:",
choices = strutsColorChoices,
setAsDefault = True)
def _loadNucleotidesGroupBox(self):
"""
Load the Nucleotides group box.
"""
nucleotidesGroupBox = PM_GroupBox( None )
self.nucleotidesGroupBox = nucleotidesGroupBox
nucleotidesShapeChoices = ['None',
'Sugar spheres',
'Base cartoons']
self.nucleotidesShapeComboBox = \
PM_ComboBox( nucleotidesGroupBox ,
label = "Shape:",
choices = nucleotidesShapeChoices,
setAsDefault = True)
self.nucleotidesScaleDoubleSpinBox = \
PM_DoubleSpinBox( nucleotidesGroupBox,
label = "Scale:",
value = 1.00,
setAsDefault = True,
minimum = 0.1,
maximum = 3.0,
decimals = 2,
singleStep = 0.1 )
nucleotidesColorChoices = ['Same as strand',
'Base order',
'Strand order',
'Base type']
self.nucleotidesColorComboBox = \
PM_ComboBox( nucleotidesGroupBox ,
label = "Color:",
choices = nucleotidesColorChoices,
setAsDefault = True)
self.dnaStyleBasesDisplayLettersCheckBox = \
PM_CheckBox(nucleotidesGroupBox ,
text = 'Display base letters',
widgetColumn = 1
)
def updateDnaDisplayStyleWidgets( self , blockSignals = False):
"""
Updates all the DNA Display style widgets based on the current pref keys
values.
@param blockSignals: If its set to True, the set* methods of the
the widgets (currently only PM_ Spinboxes and
ComboBoxes) won't emit a signal.
@type blockSignals: bool
@see: self.show() where this method is called.
@see: PM_Spinbox.setValue()
@see: PM_ComboBox.setCurrentIndex()
@note: This should be called each time the PM is displayed (see show()).
"""
self.dnaRenditionComboBox.setCurrentIndex(
env.prefs[dnaRendition_prefs_key],
blockSignals = blockSignals )
self.axisShapeComboBox.setCurrentIndex(
env.prefs[dnaStyleAxisShape_prefs_key], blockSignals = blockSignals)
self.axisScaleDoubleSpinBox.setValue(
env.prefs[dnaStyleAxisScale_prefs_key], blockSignals = blockSignals)
self.axisColorComboBox.setCurrentIndex(
env.prefs[dnaStyleAxisColor_prefs_key], blockSignals = blockSignals)
self.axisEndingStyleComboBox.setCurrentIndex(
env.prefs[dnaStyleAxisEndingStyle_prefs_key], blockSignals = blockSignals)
self.strandsShapeComboBox.setCurrentIndex(
env.prefs[dnaStyleStrandsShape_prefs_key], blockSignals = blockSignals)
self.strandsScaleDoubleSpinBox.setValue(
env.prefs[dnaStyleStrandsScale_prefs_key], blockSignals = blockSignals)
self.strandsColorComboBox.setCurrentIndex(
env.prefs[dnaStyleStrandsColor_prefs_key], blockSignals = blockSignals)
self.strandsArrowsComboBox.setCurrentIndex(
env.prefs[dnaStyleStrandsArrows_prefs_key], blockSignals = blockSignals)
self.strutsShapeComboBox.setCurrentIndex(
env.prefs[dnaStyleStrutsShape_prefs_key], blockSignals = blockSignals)
self.strutsScaleDoubleSpinBox.setValue(
env.prefs[dnaStyleStrutsScale_prefs_key], blockSignals = blockSignals)
self.strutsColorComboBox.setCurrentIndex(
env.prefs[dnaStyleStrutsColor_prefs_key], blockSignals = blockSignals)
self.nucleotidesShapeComboBox.setCurrentIndex(
env.prefs[dnaStyleBasesShape_prefs_key], blockSignals = blockSignals)
self.nucleotidesScaleDoubleSpinBox.setValue(
env.prefs[dnaStyleBasesScale_prefs_key], blockSignals = blockSignals)
self.nucleotidesColorComboBox.setCurrentIndex(
env.prefs[dnaStyleBasesColor_prefs_key], blockSignals = blockSignals)
# DNA Strand label combobox.
if env.prefs[dnaStrandLabelsEnabled_prefs_key]:
_dnaStrandColorItem = env.prefs[dnaStrandLabelsColorMode_prefs_key] + 1
else:
_dnaStrandColorItem = 0
self.standLabelColorComboBox.setCurrentIndex(
_dnaStrandColorItem, blockSignals = blockSignals)
def change_dnaStrandLabelsDisplay(self, mode):
"""
Changes DNA Strand labels display (and color) mode.
@param mode: The display mode:
- 0 = hide all labels
- 1 = show (same color as chunk)
- 2 = show (black)
- 3 = show (white)
- 4 = show (custom color...)
@type mode: int
"""
if mode == 4:
self.win.userPrefs.change_dnaStrandLabelsColor()
if mode == 0:
#@ Fix this at the same time I (we) remove the DNA display style
# prefs options from the Preferences dialog. --Mark 2008-05-13
self.win.userPrefs.toggle_dnaDisplayStrandLabelsGroupBox(False)
else:
self.win.userPrefs.toggle_dnaDisplayStrandLabelsGroupBox(True)
self.win.userPrefs.change_dnaStrandLabelsColorMode(mode - 1)
def applyFavorite(self):
"""
Apply the DNA display style settings stored in the current favorite
(selected in the combobox) to the current DNA display style settings.
"""
# Rules and other info:
# The user has to press the button related to this method when he loads
# a previously saved favorite file
current_favorite = self.favoritesComboBox.currentText()
if current_favorite == 'Factory default settings':
env.prefs.restore_defaults(dnaDisplayStylePrefsList)
else:
favfilepath = getFavoritePathFromBasename(current_favorite)
loadFavoriteFile(favfilepath)
self.updateDnaDisplayStyleWidgets()
return
def addFavorite(self):
"""
Adds a new favorite to the user's list of favorites.
"""
# Rules and other info:
# - The new favorite is defined by the current DNA display style
# settings.
# - The user is prompted to type in a name for the new
# favorite.
# - The DNA display style settings are written to a file in a special
# directory on the disk
# (i.e. $HOME/Nanorex/Favorites/DnaDisplayStyle/$FAV_NAME.fav).
# - The name of the new favorite is added to the list of favorites in
# the combobox, which becomes the current option.
# Existence of a favorite with the same name is checked in the above
# mentioned location and if a duplicate exists, then the user can either
# overwrite and provide a new name.
# Prompt user for a favorite name to add.
from widgets.simple_dialogs import grab_text_line_using_dialog
ok1, name = \
grab_text_line_using_dialog(
title = "Add new favorite",
label = "favorite name:",
iconPath = "ui/actions/Properties Manager/AddFavorite.png",
default = "" )
if ok1:
# check for duplicate files in the
# $HOME/Nanorex/Favorites/DnaDisplayStyle/ directory
fname = getFavoritePathFromBasename( name )
if os.path.exists(fname):
#favorite file already exists!
_ext= ".txt"
ret = QMessageBox.warning( self, "Warning!",
"The favorite file \"" + name + _ext + "\"already exists.\n"
"Do you want to overwrite the existing file?",
"&Overwrite", "&Cancel", "",
0, # Enter == button 0
1) # Escape == button 1
if ret == 0:
#overwrite favorite file
ok2, text = writeDnaDisplayStyleSettingsToFavoritesFile(name)
indexOfDuplicateItem = self.favoritesComboBox.findText(name)
self.favoritesComboBox.removeItem(indexOfDuplicateItem)
print "Add Favorite: removed duplicate favorite item."
else:
env.history.message("Add Favorite: cancelled overwriting favorite item.")
return
else:
ok2, text = writeDnaDisplayStyleSettingsToFavoritesFile(name)
else:
# User cancelled.
return
if ok2:
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
msg = "New favorite [%s] added." % (text)
else:
msg = "Can't add favorite [%s]: %s" % (name, text) # text is reason why not
env.history.message(msg)
return
def deleteFavorite(self):
"""
Deletes the current favorite from the user's personal list of favorites
(and from disk, only in the favorites folder though).
@note: Cannot delete "Factory default settings".
"""
currentIndex = self.favoritesComboBox.currentIndex()
currentText = self.favoritesComboBox.currentText()
if currentIndex == 0:
msg = "Cannot delete '%s'." % currentText
else:
self.favoritesComboBox.removeItem(currentIndex)
# delete file from the disk
deleteFile= getFavoritePathFromBasename( currentText )
os.remove(deleteFile)
msg = "Deleted favorite named [%s].\n" \
"and the favorite file [%s.txt]." \
% (currentText, currentText)
env.history.message(msg)
return
def saveFavorite(self):
"""
Writes the current favorite (selected in the combobox) to a file, any
where in the disk that
can be given to another NE1 user (i.e. as an email attachment).
"""
cmd = greenmsg("Save Favorite File: ")
env.history.message(greenmsg("Save Favorite File:"))
current_favorite = self.favoritesComboBox.currentText()
favfilepath = getFavoritePathFromBasename(current_favorite)
#Check to see if favfilepath exists first
if not os.path.exists(favfilepath):
msg = "%s does not exist" % favfilepath
env.history.message(cmd + msg)
return
formats = \
"Favorite (*.txt);;"\
"All Files (*.*)"
directory = self.currentWorkingDirectory
saveLocation = directory + "/" + current_favorite + ".txt"
fn = QFileDialog.getSaveFileName(
self,
"Save Favorite As", # caption
saveLocation, #where to save
formats, # file format options
QString("Favorite (*.txt)") # selectedFilter
)
if not fn:
env.history.message(cmd + "Cancelled")
else:
dir, fil = os.path.split(str(fn))
self.setCurrentWorkingDirectory(dir)
saveFavoriteFile(str(fn), favfilepath)
return
def setCurrentWorkingDirectory(self, dir = None):
if os.path.isdir(dir):
self.currentWorkingDirectory = dir
self._setWorkingDirectoryInPrefsDB(dir)
else:
self.currentWorkingDirectory = getDefaultWorkingDirectory()
def _setWorkingDirectoryInPrefsDB(self, workdir = None):
"""
[private method]
Set the working directory in the user preferences database.
@param workdir: The fullpath directory to write to the user pref db.
If I{workdir} is None (default), there is no change.
@type workdir: string
"""
if not workdir:
return
workdir = str(workdir)
if os.path.isdir(workdir):
workdir = os.path.normpath(workdir)
env.prefs[workingDirectory_prefs_key] = workdir # Change pref in prefs db.
else:
msg = "[" + workdir + "] is not a directory. Working directory was not changed."
env.history.message( redmsg(msg))
return
def loadFavorite(self):
"""
Prompts the user to choose a "favorite file" (i.e. *.txt) from disk to
be added to the personal favorites list.
"""
# If the file already exists in the favorites folder then the user is
# given the option of overwriting it or renaming it
env.history.message(greenmsg("Load Favorite File:"))
formats = \
"Favorite (*.txt);;"\
"All Files (*.*)"
directory = self.currentWorkingDirectory
if directory == '':
directory= getDefaultWorkingDirectory()
fname = QFileDialog.getOpenFileName(self,
"Choose a file to load",
directory,
formats)
if not fname:
env.history.message("User cancelled loading file.")
return
else:
dir, fil = os.path.split(str(fname))
self.setCurrentWorkingDirectory(dir)
canLoadFile=loadFavoriteFile(fname)
if canLoadFile == 1:
#get just the name of the file for loading into the combobox
favName = os.path.basename(str(fname))
name = favName[0:len(favName)-4]
indexOfDuplicateItem = self.favoritesComboBox.findText(name)
#duplicate exists in combobox
if indexOfDuplicateItem != -1:
ret = QMessageBox.warning( self, "Warning!",
"The favorite file \"" + name +
"\"already exists.\n"
"Do you want to overwrite the existing file?",
"&Overwrite", "&Rename", "&Cancel",
0, # Enter == button 0
1 # button 1
)
if ret == 0:
self.favoritesComboBox.removeItem(indexOfDuplicateItem)
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
ok2, text = writeDnaDisplayStyleSettingsToFavoritesFile(name)
msg = "Overwrote favorite [%s]." % (text)
env.history.message(msg)
elif ret == 1:
# add new item to favorites folder as well as combobox
self.addFavorite()
else:
#reset the display setting values to factory default
factoryIndex = self.favoritesComboBox.findText(
'Factory default settings')
self.favoritesComboBox.setCurrentIndex(factoryIndex)
env.prefs.restore_defaults(dnaDisplayStylePrefsList)
env.history.message("Cancelled overwriting favorite file.")
return
else:
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
msg = "Loaded favorite [%s]." % (name)
env.history.message(msg)
self.updateDnaDisplayStyleWidgets()
return
def change_dnaRendition(self, rendition):
"""
Sets the DNA rendition to 3D or one of the optional 2D styles.
@param rendition: The rendition mode, where:
- 0 = 3D (default)
- 1 = 2D with base letters
- 2 = 2D ball and stick
- 3 = 2D ladder
@type rendition: int
"""
if rendition == 0:
_enabled_flag = True
else:
_enabled_flag = False
self.dnaComponentComboBox.setEnabled(_enabled_flag)
self.dnaComponentStackedWidget.setEnabled(_enabled_flag)
self.standLabelColorComboBox.setEnabled(_enabled_flag)
env.prefs[dnaRendition_prefs_key] = rendition
self.o.gl_update() # Force redraw
return
def _addWhatsThisText( self ):
"""
What's This text for widgets in the DNA Property Manager.
"""
from ne1_ui.WhatsThisText_for_PropertyManagers import WhatsThis_EditDnaDisplayStyle_PropertyManager
WhatsThis_EditDnaDisplayStyle_PropertyManager(self)
def _addToolTipText(self):
"""
Tool Tip text for widgets in the DNA Property Manager.
"""
from ne1_ui.ToolTipText_for_PropertyManagers import ToolTip_EditDnaDisplayStyle_PropertyManager
ToolTip_EditDnaDisplayStyle_PropertyManager(self)
class ProteinDisplayStyle_PropertyManager(PM_Dialog, DebugMenuMixin):
"""
The ProteinDisplayStyle_PropertyManager class provides a Property Manager
for the B{Display Style} command on the flyout toolbar in the
Build > Protein mode.
@ivar title: The title that appears in the property manager header.
@type title: str
@ivar pmName: The name of this property manager. This is used to set
the name of the PM_Dialog object via setObjectName().
@type name: str
@ivar iconPath: The relative path to the PNG file that contains a
22 x 22 icon image that appears in the PM header.
@type iconPath: str
"""
title = "Edit Protein Display Style"
pmName = title
iconPath = "ui/actions/Edit/EditProteinDisplayStyle.png"
def __init__(self, parentCommand):
"""
Constructor for the property manager.
"""
self.parentMode = parentCommand
self.w = self.parentMode.w
self.win = self.parentMode.w
self.pw = self.parentMode.pw
self.o = self.win.glpane
self.currentWorkingDirectory = env.prefs[workingDirectory_prefs_key]
PM_Dialog.__init__(self, self.pmName, self.iconPath, self.title)
DebugMenuMixin._init1(self)
self.showTopRowButtons( PM_DONE_BUTTON | \
PM_WHATS_THIS_BUTTON)
msg = "Modify the protein display settings below."
self.updateMessage(msg)
def connect_or_disconnect_signals(self, isConnect=True):
if isConnect:
change_connect = self.win.connect
else:
change_connect = self.win.disconnect
# Favorite buttons signal-slot connections.
change_connect(self.applyFavoriteButton, SIGNAL("clicked()"),
self.applyFavorite)
change_connect(self.addFavoriteButton, SIGNAL("clicked()"),
self.addFavorite)
change_connect(self.deleteFavoriteButton, SIGNAL("clicked()"),
self.deleteFavorite)
change_connect(self.saveFavoriteButton, SIGNAL("clicked()"),
self.saveFavorite)
change_connect(self.loadFavoriteButton, SIGNAL("clicked()"),
self.loadFavorite)
#Display group box signal slot connections
change_connect(self.proteinStyleComboBox,
SIGNAL("currentIndexChanged(int)"),
self.changeProteinDisplayStyle)
change_connect(self.smoothingCheckBox, SIGNAL("stateChanged(int)"),
self.smoothProteinDisplay)
change_connect(self.scaleComboBox, SIGNAL("currentIndexChanged(int)"),
self.changeProteinDisplayScale)
change_connect(self.splineDoubleSpinBox,
SIGNAL("valueChanged(double)"),
self.changeProteinSplineValue)
change_connect(self.scaleFactorDoubleSpinBox,
SIGNAL("valueChanged(double)"),
self.changeProteinScaleFactor)
#color groupbox
change_connect(self.proteinComponentComboBox,
SIGNAL("currentIndexChanged(int)"),
self.chooseProteinComponent)
change_connect(self.proteinAuxComponentComboBox,
SIGNAL("currentIndexChanged(int)"),
self.chooseAuxilliaryProteinComponent)
change_connect(self.customColorComboBox, SIGNAL("editingFinished()"),
self.chooseCustomColor)
change_connect(self.auxColorComboBox, SIGNAL("editingFinished()"),
self.chooseAuxilliaryColor)
change_connect(self.discColorCheckBox, SIGNAL("stateChanged(int)"),
self.setDiscreteColors)
change_connect(self.helixColorComboBox, SIGNAL("editingFinished()"),
self.chooseHelixColor)
change_connect(self.strandColorComboBox, SIGNAL("editingFinished()"),
self.chooseStrandColor)
change_connect(self.coilColorComboBox, SIGNAL("editingFinished()"),
self.chooseCoilColor)
#Protein Display methods
def changeProteinDisplayStyle(self, idx):
env.prefs[proteinStyle_prefs_key] = idx
return
def changeProteinDisplayQuality(self, idx):
env.prefs[proteinStyleQuality_prefs_key] = idx
return
def smoothProteinDisplay(self, state):
if state == Qt.Checked:
env.prefs[proteinStyleSmooth_prefs_key] = True
else:
env.prefs[proteinStyleSmooth_prefs_key] = False
return
def changeProteinDisplayScale(self, idx):
env.prefs[proteinStyleScaling_prefs_key] = idx
return
def changeProteinSplineValue(self, val):
env.prefs[proteinStyleQuality_prefs_key] = val
return
def changeProteinScaleFactor(self, val):
env.prefs[proteinStyleScaleFactor_prefs_key] = val
return
def chooseProteinComponent(self, idx):
env.prefs[proteinStyleColors_prefs_key] = idx
return
def chooseAuxilliaryProteinComponent(self, idx):
env.prefs[proteinStyleAuxColors_prefs_key] = idx - 1
return
def chooseCustomColor(self):
color = self.customColorComboBox.getColor()
env.prefs[proteinStyleCustomColor_prefs_key] = color
return
def chooseAuxilliaryColor(self):
color = self.auxColorComboBox.getColor()
env.prefs[proteinStyleAuxCustomColor_prefs_key] = color
return
def chooseHelixColor(self):
color = self.helixColorComboBox.getColor()
env.prefs[proteinStyleHelixColor_prefs_key] = color
return
def chooseStrandColor(self):
color = self.strandColorComboBox.getColor()
env.prefs[proteinStyleStrandColor_prefs_key] = color
return
def chooseCoilColor(self):
color = self.coilColorComboBox.getColor()
env.prefs[proteinStyleCoilColor_prefs_key] = color
return
def setDiscreteColors(self, state):
if state == Qt.Checked:
env.prefs[proteinStyleColorsDiscrete_prefs_key] = True
else:
env.prefs[proteinStyleColorsDiscrete_prefs_key] = False
return
def ok_btn_clicked(self):
"""
Slot for the OK button
"""
self.win.toolsDone()
def cancel_btn_clicked(self):
"""
Slot for the Cancel button.
"""
#TODO: Cancel button needs to be removed. See comment at the top
self.win.toolsDone()
def show(self):
"""
Shows the Property Manager. Overrides PM_Dialog.show.
"""
self.sequenceEditor = self.win.createProteinSequenceEditorIfNeeded()
self.sequenceEditor.hide()
PM_Dialog.show(self)
#Not required for Proteins
# Force the Global Display Style to "DNA Cylinder" so the user
# can see the display style setting effects on any DNA in the current
# model. The current global display style will be restored when leaving
# this command (via self.close()).
#self.originalDisplayStyle = self.o.getGlobalDisplayStyle()
#self.o.setGlobalDisplayStyle(diDNACYLINDER)
# Update all PM widgets, then establish their signal-slot connections.
# note: It is important to update the widgets *first* since doing
# it in the reverse order will generate signals when updating
# the PM widgets (via updateDnaDisplayStyleWidgets()), causing
# unneccessary repaints of the model view.
self.updateProteinDisplayStyleWidgets()
self.connect_or_disconnect_signals(isConnect=True)
def close(self):
"""
Closes the Property Manager. Overrides PM_Dialog.close.
"""
self.connect_or_disconnect_signals(False)
PM_Dialog.close(self)
#Not required for proteins
# Restore the original global display style.
#self.o.setGlobalDisplayStyle(self.originalDisplayStyle)
def _addGroupBoxes(self):
"""
Add the Property Manager group boxes.
"""
self._pmGroupBox1 = PM_GroupBox(self, title="Favorites")
self._loadGroupBox1(self._pmGroupBox1)
self._pmGroupBox2 = PM_GroupBox(self, title="Display")
self._loadGroupBox2(self._pmGroupBox2)
self._pmGroupBox3 = PM_GroupBox(self, title="Color")
self._loadGroupBox3(self._pmGroupBox3)
def _loadGroupBox1(self, pmGroupBox):
"""
Load widgets in group box.
"""
# Other info
# Not only loads the factory default settings but also all the favorite
# files stored in the ~/Nanorex/Favorites/ProteinDisplayStyle directory
favoriteChoices = ['Factory default settings']
#look for all the favorite files in the favorite folder and add them to
# the list
from platform_dependent.PlatformDependent import find_or_make_Nanorex_subdir
_dir = find_or_make_Nanorex_subdir('Favorites/ProteinDisplayStyle')
for file in os.listdir(_dir):
fullname = os.path.join(_dir, file)
if os.path.isfile(fullname):
if fnmatch.fnmatch(file, "*.txt"):
# leave the extension out
favoriteChoices.append(file[0:len(file) - 4])
self.favoritesComboBox = \
PM_ComboBox( pmGroupBox,
choices = favoriteChoices,
spanWidth = True)
self.favoritesComboBox.setWhatsThis("""<b> List of Favorites </b>
<p>
Creates a list of favorite Protein display styles. Once favorite
styles have been added to the list using the Add Favorite button,
the list will display the chosen favorites.
To change the current favorite, select a current favorite from
the list, and push the Apply Favorite button.""")
# PM_ToolButtonRow ===============
# Button list to create a toolbutton row.
# Format:
# - QToolButton, buttonId, buttonText,
# - iconPath,
# - tooltip, shortcut, column
BUTTON_LIST = [
( "QToolButton", 1, "APPLY_FAVORITE","ui/actions/Properties Manager/ApplyPeptideDisplayStyleFavorite.png",
"Apply Favorite", "", 0),
( "QToolButton", 2, "ADD_FAVORITE",
"ui/actions/Properties Manager/AddFavorite.png","Add Favorite", "", 1),
( "QToolButton", 3, "DELETE_FAVORITE", "ui/actions/Properties Manager/DeleteFavorite.png",
"Delete Favorite", "", 2),
( "QToolButton", 4, "SAVE_FAVORITE",
"ui/actions/Properties Manager/SaveFavorite.png",
"Save Favorite", "", 3),
( "QToolButton", 5, "LOAD_FAVORITE",
"ui/actions/Properties Manager/LoadFavorite.png",
"Load Favorite", \
"", 4)
]
self.favsButtonGroup = \
PM_ToolButtonRow( pmGroupBox,
title = "",
buttonList = BUTTON_LIST,
spanWidth = True,
isAutoRaise = False,
isCheckable = False,
setAsDefault = True,
)
self.favsButtonGroup.buttonGroup.setExclusive(False)
self.applyFavoriteButton = self.favsButtonGroup.getButtonById(1)
self.addFavoriteButton = self.favsButtonGroup.getButtonById(2)
self.deleteFavoriteButton = self.favsButtonGroup.getButtonById(3)
self.saveFavoriteButton = self.favsButtonGroup.getButtonById(4)
self.loadFavoriteButton = self.favsButtonGroup.getButtonById(5)
def _loadGroupBox2(self, pmGroupBox):
"""
Load widgets in group box.
"""
proteinStyleChoices = [
'CA trace (wire)', 'CA trace (cylinders)',
'CA trace (ball and stick)', 'Tube', 'Ladder', 'Zigzag',
'Flat ribbon', 'Solid ribbon', 'Cartoons', 'Fancy cartoons',
'Peptide tiles'
]
self.proteinStyleComboBox = \
PM_ComboBox( pmGroupBox,
label = "Style:",
choices = proteinStyleChoices,
setAsDefault = True)
scaleChoices = ['Constant', 'Secondary structure', 'B-factor']
self.scaleComboBox = \
PM_ComboBox( pmGroupBox,
label = "Scaling:",
choices = scaleChoices,
setAsDefault = True)
self.scaleFactorDoubleSpinBox = \
PM_DoubleSpinBox( pmGroupBox,
label = "Scaling factor:",
value = 1.00,
setAsDefault = True,
minimum = 0.1,
maximum = 3.0,
decimals = 1,
singleStep = 0.1 )
self.splineDoubleSpinBox = \
PM_DoubleSpinBox( pmGroupBox,
label = "Resolution:",
value = 4,
setAsDefault = True,
minimum = 2,
maximum = 8,
decimals = 0,
singleStep = 1 )
self.smoothingCheckBox = \
PM_CheckBox( pmGroupBox,
text = "Smoothing",
setAsDefault = True)
def _loadGroupBox3(self, pmGroupBox):
"""
Load widgets in group box.
"""
colorChoices = [
'Chunk', 'Chain', 'Order', 'Hydropathy', 'Polarity', 'Acidity',
'Size', 'Character', 'Number of contacts',
'Secondary structure type', 'Secondary structure order',
'B-factor', 'Occupancy', 'Custom'
]
self.proteinComponentComboBox = \
PM_ComboBox( pmGroupBox,
label = "Color by:",
choices = colorChoices,
setAsDefault = True)
colorList = [
orange, yellow, red, magenta, cyan, blue, white, black, gray
]
colorNames = [
"Orange(default)", "Yellow", "Red", "Magenta", "Cyan", "Blue",
"White", "Black", "Other color..."
]
self.customColorComboBox = \
PM_ColorComboBox(pmGroupBox,
colorList = colorList,
colorNames = colorNames,
label = "Custom:",
color = orange,
setAsDefault = True)
colorChoices1 = [
'Same as main color', 'Chunk', 'Chain', 'Order', 'Hydropathy',
'Polarity', 'Acidity', 'Size', 'Character', 'Number of contacts',
'Secondary structure type', 'Secondary structure order',
'B-factor', 'Occupancy', 'Custom'
]
self.proteinAuxComponentComboBox = \
PM_ComboBox( pmGroupBox,
label = "Aux:",
choices = colorChoices1,
setAsDefault = True)
colorListAux = [
orange, yellow, red, magenta, cyan, blue, white, black, gray
]
colorNamesAux = [
"Orange(default)", "Yellow", "Red", "Magenta", "Cyan", "Blue",
"White", "Black", "Other color..."
]
self.auxColorComboBox = \
PM_ColorComboBox(pmGroupBox,
colorList = colorListAux,
colorNames = colorNamesAux,
label = "Custom aux:",
color = gray,
setAsDefault = True)
self.discColorCheckBox = \
PM_CheckBox( pmGroupBox,
text = "Discretize colors",
setAsDefault = True
)
colorListHelix = [
red, yellow, gray, magenta, cyan, blue, white, black, orange
]
colorNamesHelix = [
"Red(default)", "Yellow", "Gray", "Magenta", "Cyan", "Blue",
"White", "Black", "Other color..."
]
self.helixColorComboBox = \
PM_ColorComboBox(pmGroupBox,
colorList = colorListHelix,
colorNames = colorNamesHelix,
label = "Helix:",
color = red,
setAsDefault = True)
colorListStrand = [
cyan, yellow, gray, magenta, red, blue, white, black, orange
]
colorNamesStrand = [
"Cyan(default)", "Yellow", "Gray", "Magenta", "Red", "Blue",
"White", "Black", "Other color..."
]
self.strandColorComboBox = \
PM_ColorComboBox(pmGroupBox,
colorList = colorListStrand,
colorNames = colorNamesStrand,
label = "Strand:",
color = cyan,
setAsDefault = True)
self.coilColorComboBox = \
PM_ColorComboBox(pmGroupBox,
colorList = colorListAux,
colorNames = colorNamesAux,
label = "Coil:",
color = orange,
setAsDefault = True)
def updateProteinDisplayStyleWidgets(self):
"""
Updates all the Protein Display style widgets based on the current pref keys
values
"""
self.proteinStyleComboBox.setCurrentIndex(
env.prefs[proteinStyle_prefs_key])
self.splineDoubleSpinBox.setValue(
env.prefs[proteinStyleQuality_prefs_key])
if env.prefs[proteinStyleSmooth_prefs_key] == True:
self.smoothingCheckBox.setCheckState(Qt.Checked)
else:
self.smoothingCheckBox.setCheckState(Qt.Unchecked)
self.scaleComboBox.setCurrentIndex(
env.prefs[proteinStyleScaling_prefs_key])
self.scaleFactorDoubleSpinBox.setValue(
env.prefs[proteinStyleScaleFactor_prefs_key])
self.proteinComponentComboBox.setCurrentIndex(
env.prefs[proteinStyleColors_prefs_key])
self.customColorComboBox.setColor(
env.prefs[proteinStyleCustomColor_prefs_key])
self.proteinAuxComponentComboBox.setCurrentIndex(
env.prefs[proteinStyleAuxColors_prefs_key])
self.auxColorComboBox.setColor(
env.prefs[proteinStyleAuxCustomColor_prefs_key])
if env.prefs[proteinStyleColorsDiscrete_prefs_key] == True:
self.discColorCheckBox.setCheckState(Qt.Checked)
else:
self.discColorCheckBox.setCheckState(Qt.Unchecked)
self.helixColorComboBox.setColor(
env.prefs[proteinStyleHelixColor_prefs_key])
self.strandColorComboBox.setColor(
env.prefs[proteinStyleStrandColor_prefs_key])
self.coilColorComboBox.setColor(
env.prefs[proteinStyleCoilColor_prefs_key])
return
def applyFavorite(self):
# Rules and other info:
# The user has to press the button related to this method when he loads
# a previously saved favorite file
current_favorite = self.favoritesComboBox.currentText()
if current_favorite == 'Factory default settings':
env.prefs.restore_defaults(proteinDisplayStylePrefsList)
else:
favfilepath = getFavoritePathFromBasename(current_favorite)
loadFavoriteFile(favfilepath)
self.updateProteinDisplayStyleWidgets()
return
def addFavorite(self):
# Rules and other info:
# - The new favorite is defined by the current Protein display style
# settings.
# - The user is prompted to type in a name for the new
# favorite.
# - The DNA display style settings are written to a file in a special
# directory on the disk
# (i.e. $HOME/Nanorex/Favorites/ProteinDisplayStyle/$FAV_NAME.txt).
# - The name of the new favorite is added to the list of favorites in
# the combobox, which becomes the current option.
# Existence of a favorite with the same name is checked in the above
# mentioned location and if a duplicate exists, then the user can either
# overwrite and provide a new name.
# Prompt user for a favorite name to add.
from widgets.simple_dialogs import grab_text_line_using_dialog
ok1, name = \
grab_text_line_using_dialog(
title = "Add new favorite",
label = "favorite name:",
iconPath = "ui/actions/Properties Manager/AddFavorite.png",
default = "" )
if ok1:
# check for duplicate files in the
# $HOME/Nanorex/Favorites/DnaDisplayStyle/ directory
fname = getFavoritePathFromBasename(name)
if os.path.exists(fname):
#favorite file already exists!
_ext = ".txt"
ret = QMessageBox.warning(
self,
"Warning!",
"The favorite file \"" + name + _ext +
"\"already exists.\n"
"Do you want to overwrite the existing file?",
"&Overwrite",
"&Cancel",
"",
0, # Enter == button 0
1) # Escape == button 1
if ret == 0:
#overwrite favorite file
ok2, text = writeProteinDisplayStyleSettingsToFavoritesFile(
name)
indexOfDuplicateItem = self.favoritesComboBox.findText(
name)
self.favoritesComboBox.removeItem(indexOfDuplicateItem)
print "Add Favorite: removed duplicate favorite item."
else:
env.history.message(
"Add Favorite: cancelled overwriting favorite item.")
return
else:
ok2, text = writeProteinDisplayStyleSettingsToFavoritesFile(
name)
else:
# User cancelled.
return
if ok2:
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
msg = "New favorite [%s] added." % (text)
else:
msg = "Can't add favorite [%s]: %s" % (name, text
) # text is reason why not
env.history.message(msg)
return
def deleteFavorite(self):
currentIndex = self.favoritesComboBox.currentIndex()
currentText = self.favoritesComboBox.currentText()
if currentIndex == 0:
msg = "Cannot delete '%s'." % currentText
else:
self.favoritesComboBox.removeItem(currentIndex)
# delete file from the disk
deleteFile = getFavoritePathFromBasename(currentText)
os.remove(deleteFile)
msg = "Deleted favorite named [%s].\n" \
"and the favorite file [%s.txt]." \
% (currentText, currentText)
env.history.message(msg)
return
def saveFavorite(self):
cmd = greenmsg("Save Favorite File: ")
env.history.message(greenmsg("Save Favorite File:"))
current_favorite = self.favoritesComboBox.currentText()
favfilepath = getFavoritePathFromBasename(current_favorite)
formats = \
"Favorite (*.txt);;"\
"All Files (*.*)"
directory = self.currentWorkingDirectory
saveLocation = directory + "/" + current_favorite + ".txt"
fn = QFileDialog.getSaveFileName(
self,
"Save Favorite As", # caption
favfilepath, #where to save
formats, # file format options
QString("Favorite (*.txt)") # selectedFilter
)
if not fn:
env.history.message(cmd + "Cancelled")
else:
dir, fil = os.path.split(str(fn))
self.setCurrentWorkingDirectory(dir)
saveFavoriteFile(str(fn), favfilepath)
return
def setCurrentWorkingDirectory(self, dir=None):
if os.path.isdir(dir):
self.currentWorkingDirectory = dir
self._setWorkingDirectoryInPrefsDB(dir)
else:
self.currentWorkingDirectory = getDefaultWorkingDirectory()
def _setWorkingDirectoryInPrefsDB(self, workdir=None):
if not workdir:
return
workdir = str(workdir)
if os.path.isdir(workdir):
workdir = os.path.normpath(workdir)
env.prefs[
workingDirectory_prefs_key] = workdir # Change pref in prefs db.
else:
msg = "[" + workdir + "] is not a directory. Working directory was not changed."
env.history.message(redmsg(msg))
return
def loadFavorite(self):
# If the file already exists in the favorites folder then the user is
# given the option of overwriting it or renaming it
env.history.message(greenmsg("Load Favorite File:"))
formats = \
"Favorite (*.txt);;"\
"All Files (*.*)"
directory = self.currentWorkingDirectory
if directory == '':
directory = getDefaultWorkingDirectory()
fname = QFileDialog.getOpenFileName(self, "Choose a file to load",
directory, formats)
if not fname:
env.history.message("User cancelled loading file.")
return
else:
dir, fil = os.path.split(str(fname))
self.setCurrentWorkingDirectory(dir)
canLoadFile = loadFavoriteFile(fname)
if canLoadFile == 1:
#get just the name of the file for loading into the combobox
favName = os.path.basename(str(fname))
name = favName[0:len(favName) - 4]
indexOfDuplicateItem = self.favoritesComboBox.findText(name)
#duplicate exists in combobox
if indexOfDuplicateItem != -1:
ret = QMessageBox.warning(
self,
"Warning!",
"The favorite file \"" + name + "\"already exists.\n"
"Do you want to overwrite the existing file?",
"&Overwrite",
"&Rename",
"&Cancel",
0, # Enter == button 0
1 # button 1
)
if ret == 0:
self.favoritesComboBox.removeItem(indexOfDuplicateItem)
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
ok2, text = writeProteinDisplayStyleSettingsToFavoritesFile(
name)
msg = "Overwrote favorite [%s]." % (text)
env.history.message(msg)
elif ret == 1:
# add new item to favorites folder as well as combobox
self.addFavorite()
else:
#reset the display setting values to factory default
factoryIndex = self.favoritesComboBox.findText(
'Factory default settings')
self.favoritesComboBox.setCurrentIndex(factoryIndex)
env.prefs.restore_defaults(
proteinDisplayStylePrefsList)
env.history.message(
"Cancelled overwriting favorite file.")
return
else:
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
msg = "Loaded favorite [%s]." % (name)
env.history.message(msg)
self.updateProteinDisplayStyleWidgets()
return
def _addWhatsThisText(self):
from ne1_ui.WhatsThisText_for_PropertyManagers import WhatsThis_EditDnaDisplayStyle_PropertyManager
WhatsThis_EditDnaDisplayStyle_PropertyManager(self)
def _addToolTipText(self):
from ne1_ui.ToolTipText_for_PropertyManagers import ToolTip_EditProteinDisplayStyle_PropertyManager
ToolTip_EditProteinDisplayStyle_PropertyManager(self)
class LightingScheme_PropertyManager(PM_Dialog, DebugMenuMixin):
"""
The LightingScheme_PropertyManager class provides a Property Manager
for changing light properties as well as material properties.
@ivar title: The title that appears in the property manager header.
@type title: str
@ivar pmName: The name of this property manager. This is used to set
the name of the PM_Dialog object via setObjectName().
@type name: str
@ivar iconPath: The relative path to the PNG file that contains a
22 x 22 icon image that appears in the PM header.
@type iconPath: str
"""
title = "Lighting Scheme"
pmName = title
iconPath = "ui/actions/View/LightingScheme.png"
def __init__(self, parentCommand):
"""
Constructor for the property manager.
"""
self.parentMode = parentCommand
self.w = self.parentMode.w
self.win = self.parentMode.w
self.pw = self.parentMode.pw
self.o = self.win.glpane
PM_Dialog.__init__(self, self.pmName, self.iconPath, self.title)
DebugMenuMixin._init1(self)
self.showTopRowButtons( PM_DONE_BUTTON | \
PM_WHATS_THIS_BUTTON)
msg = "Edit the lighting scheme for NE1. Includes turning lights on and off, "\
"changing light colors, changing the position of lights as well as,"\
"changing the ambient, diffuse, and specular properites."
self.updateMessage(msg)
def connect_or_disconnect_signals(self, isConnect):
"""
Connect or disconnect widget signals sent to their slot methods.
This can be overridden in subclasses. By default it does nothing.
@param isConnect: If True the widget will send the signals to the slot
method.
@type isConnect: boolean
"""
if isConnect:
change_connect = self.win.connect
else:
change_connect = self.win.disconnect
# Favorite buttons signal-slot connections.
change_connect(self.applyFavoriteButton, SIGNAL("clicked()"),
self.applyFavorite)
change_connect(self.addFavoriteButton, SIGNAL("clicked()"),
self.addFavorite)
change_connect(self.deleteFavoriteButton, SIGNAL("clicked()"),
self.deleteFavorite)
change_connect(self.saveFavoriteButton, SIGNAL("clicked()"),
self.saveFavorite)
change_connect(self.loadFavoriteButton, SIGNAL("clicked()"),
self.loadFavorite)
# Directional Lighting Properties
change_connect(self.ambientDoubleSpinBox,
SIGNAL("valueChanged(double)"), self.change_lighting)
change_connect(self.lightColorComboBox, SIGNAL("editingFinished()"),
self.changeLightColor)
change_connect(self.enableLightCheckBox, SIGNAL("toggled(bool)"),
self.toggle_light)
change_connect(self.lightComboBox, SIGNAL("activated(int)"),
self.change_active_light)
change_connect(self.diffuseDoubleSpinBox,
SIGNAL("valueChanged(double)"), self.change_lighting)
change_connect(self.specularDoubleSpinBox,
SIGNAL("valueChanged(double)"), self.change_lighting)
change_connect(self.xDoubleSpinBox, SIGNAL("editingFinished()"),
self.save_lighting)
change_connect(self.yDoubleSpinBox, SIGNAL("editingFinished()"),
self.save_lighting)
change_connect(self.zDoubleSpinBox, SIGNAL("editingFinished()"),
self.save_lighting)
# Material Specular Properties
change_connect(self.brightnessDoubleSpinBox,
SIGNAL("valueChanged(double)"),
self.change_material_brightness)
change_connect(self.finishDoubleSpinBox,
SIGNAL("valueChanged(double)"),
self.change_material_finish)
change_connect(self.enableMaterialPropertiesComboBox,
SIGNAL("toggled(bool)"),
self.toggle_material_specularity)
change_connect(self.shininessDoubleSpinBox,
SIGNAL("valueChanged(double)"),
self.change_material_shininess)
self._setup_material_group()
return
def _updatePage_Lighting(self, lights=None): #mark 051124
"""
Setup widgets to initial (default or defined) values on the Lighting page.
"""
if not lights:
self.lights = self.original_lights = self.win.glpane.getLighting()
else:
self.lights = lights
light_num = self.lightComboBox.currentIndex()
# Move lc_prefs_keys upstairs. Mark.
lc_prefs_keys = [
light1Color_prefs_key, light2Color_prefs_key, light3Color_prefs_key
]
self.current_light_key = lc_prefs_keys[
light_num] # Get prefs key for current light color.
self.lightColorComboBox.setColor(env.prefs[self.current_light_key])
self.light_color = env.prefs[self.current_light_key]
# These sliders generate signals whenever their 'setValue()' slot is called (below).
# This creates problems (bugs) for us, so we disconnect them temporarily.
self.disconnect(self.ambientDoubleSpinBox,
SIGNAL("valueChanged(double)"), self.change_lighting)
self.disconnect(self.diffuseDoubleSpinBox,
SIGNAL("valueChanged(double)"), self.change_lighting)
self.disconnect(self.specularDoubleSpinBox,
SIGNAL("valueChanged(double)"), self.change_lighting)
# self.lights[light_num][0] contains 'color' attribute.
# We already have it (self.light_color) from the prefs key (above).
a = self.lights[light_num][1] # ambient intensity
d = self.lights[light_num][2] # diffuse intensity
s = self.lights[light_num][3] # specular intensity
g = self.lights[light_num][4] # xpos
h = self.lights[light_num][5] # ypos
k = self.lights[light_num][6] # zpos
self.ambientDoubleSpinBox.setValue(a) # generates signal
self.diffuseDoubleSpinBox.setValue(d) # generates signal
self.specularDoubleSpinBox.setValue(s) # generates signal
self.xDoubleSpinBox.setValue(g) # generates signal
self.yDoubleSpinBox.setValue(h) # generates signal
self.zDoubleSpinBox.setValue(k) # generates signal
self.enableLightCheckBox.setChecked(self.lights[light_num][7])
# Reconnect the slots to the light sliders.
self.connect(self.ambientDoubleSpinBox, SIGNAL("valueChanged(double)"),
self.change_lighting)
self.connect(self.diffuseDoubleSpinBox, SIGNAL("valueChanged(double)"),
self.change_lighting)
self.connect(self.specularDoubleSpinBox,
SIGNAL("valueChanged(double)"), self.change_lighting)
self.update_light_combobox_items()
self.save_lighting()
self._setup_material_group()
return
def _setup_material_group(self, reset=False):
"""
Setup Material Specularity widgets to initial (default or defined) values on the Lighting page.
If reset = False, widgets are reset from the prefs db.
If reset = True, widgets are reset from their previous values.
"""
if reset:
self.material_specularity = self.original_material_specularity
self.whiteness = self.original_whiteness
self.shininess = self.original_shininess
self.brightness = self.original_brightness
else:
self.material_specularity = self.original_material_specularity = \
env.prefs[material_specular_highlights_prefs_key]
self.whiteness = self.original_whiteness = \
env.prefs[material_specular_finish_prefs_key]
self.shininess = self.original_shininess = \
env.prefs[material_specular_shininess_prefs_key]
self.brightness = self.original_brightness= \
env.prefs[material_specular_brightness_prefs_key]
# Enable/disable material specularity properites.
self.enableMaterialPropertiesComboBox.setChecked(
self.material_specularity)
# For whiteness, the stored range is 0.0 (Plastic) to 1.0 (Metal).
self.finishDoubleSpinBox.setValue(self.whiteness) # generates signal
# For shininess, the range is 15 (low) to 60 (high). Mark. 051129.
self.shininessDoubleSpinBox.setValue(
self.shininess) # generates signal
# For brightness, the range is 0.0 (low) to 1.0 (high). Mark. 051203.
self.brightnessDoubleSpinBox.setValue(
self.brightness) # generates signal
return
def toggle_material_specularity(self, val):
"""
This is the slot for the Material Specularity Enabled checkbox.
"""
env.prefs[material_specular_highlights_prefs_key] = val
def change_material_finish(self, finish):
"""
This is the slot for the Material Finish spin box.
'finish' is between 0.0 and 1.0.
Saves finish parameter to pref db.
"""
# For whiteness, the stored range is 0.0 (Metal) to 1.0 (Plastic).
env.prefs[material_specular_finish_prefs_key] = finish
def change_material_shininess(self, shininess):
"""
This is the slot for the Material Shininess spin box.
'shininess' is between 15 (low) and 60 (high).
"""
env.prefs[material_specular_shininess_prefs_key] = shininess
def change_material_brightness(self, brightness):
"""
This is the slot for the Material Brightness sping box.
'brightness' is between 0.0 (low) and 1.0 (high).
"""
env.prefs[material_specular_brightness_prefs_key] = brightness
def toggle_light(self, on):
"""
Slot for light 'On' checkbox.
It updates the current item in the light combobox with '(On)' or
'(Off)' label.
"""
if on:
txt = "%d (On)" % (self.lightComboBox.currentIndex() + 1)
else:
txt = "%d (Off)" % (self.lightComboBox.currentIndex() + 1)
self.lightComboBox.setItemText(self.lightComboBox.currentIndex(), txt)
self.save_lighting()
def change_lighting(self, specularityValueJunk=None):
"""
Updates win.glpane lighting using the current lighting parameters from
the light checkboxes and sliders. This is also the slot for the light
spin boxes.
@param specularityValueJunk: This value from the spin box is not used
We are interested in valueChanged signal
only
@type specularityValueJunk = int or None
"""
light_num = self.lightComboBox.currentIndex()
light1, light2, light3 = self.win.glpane.getLighting()
a = self.ambientDoubleSpinBox.value()
d = self.diffuseDoubleSpinBox.value()
s = self.specularDoubleSpinBox.value()
g = self.xDoubleSpinBox.value()
h = self.yDoubleSpinBox.value()
k = self.zDoubleSpinBox.value()
new_light = [ self.light_color, a, d, s, g, h, k,\
self.enableLightCheckBox.isChecked()]
# This is a kludge. I'm certain there is a more elegant way. Mark 051204.
if light_num == 0:
self.win.glpane.setLighting([new_light, light2, light3])
elif light_num == 1:
self.win.glpane.setLighting([light1, new_light, light3])
elif light_num == 2:
self.win.glpane.setLighting([light1, light2, new_light])
else:
print "Unsupported light # ", light_num, ". No lighting change made."
def change_active_light(self, currentIndexJunk=None):
"""
Slot for the Light number combobox. This changes the current light.
@param currentIndexJunk: This index value from the combobox is not used
We are interested in 'activated' signal only
@type currentIndexJunk = int or None
"""
self._updatePage_Lighting()
def reset_lighting(self):
"""
Slot for Reset button.
"""
# This has issues.
# I intend to remove the Reset button for A7. Confirm with Bruce. Mark 051204.
self._setup_material_group(reset=True)
self._updatePage_Lighting(self.original_lights)
self.win.glpane.saveLighting()
def save_lighting(self):
"""
Saves lighting parameters (but not material specularity parameters)
to pref db. This is also the slot for light sliders (only when
released).
"""
self.change_lighting()
self.win.glpane.saveLighting()
def restore_default_lighting(self):
"""
Slot for Restore Defaults button.
"""
self.win.glpane.restoreDefaultLighting()
# Restore defaults for the Material Specularity properties
env.prefs.restore_defaults([
material_specular_highlights_prefs_key,
material_specular_shininess_prefs_key,
material_specular_finish_prefs_key,
material_specular_brightness_prefs_key, #bruce 051203 bugfix
])
self._updatePage_Lighting()
self.save_lighting()
def ok_btn_clicked(self):
"""
Slot for the OK button
"""
self.win.toolsDone()
def cancel_btn_clicked(self):
"""
Slot for the Cancel button.
"""
#TODO: Cancel button needs to be removed. See comment at the top
self.win.toolsDone()
def show(self):
"""
Shows the Property Manager. Overrides PM_Dialog.show.
"""
PM_Dialog.show(self)
self.connect_or_disconnect_signals(isConnect=True)
self._updateAllWidgets()
def close(self):
"""
Closes the Property Manager. Overrides PM_Dialog.close.
"""
self.connect_or_disconnect_signals(False)
PM_Dialog.close(self)
def _addGroupBoxes(self):
"""
Add the Property Manager group boxes.
"""
self._pmGroupBox1 = PM_GroupBox(self, title="Favorites")
self._loadGroupBox1(self._pmGroupBox1)
self._pmGroupBox2 = PM_GroupBox(self, title="Directional Lights")
self._loadGroupBox2(self._pmGroupBox2)
self._pmGroupBox3 = PM_GroupBox(self, title="Material Properties")
self._loadGroupBox3(self._pmGroupBox3)
def _loadGroupBox1(self, pmGroupBox):
"""
Load widgets in group box.
"""
favoriteChoices = ['Factory default settings']
#look for all the favorite files in the favorite folder and add them to
# the list
from platform_dependent.PlatformDependent import find_or_make_Nanorex_subdir
_dir = find_or_make_Nanorex_subdir('Favorites/LightingScheme')
for file in os.listdir(_dir):
fullname = os.path.join(_dir, file)
if os.path.isfile(fullname):
if fnmatch.fnmatch(file, "*.txt"):
# leave the extension out
favoriteChoices.append(file[0:len(file) - 4])
self.favoritesComboBox = \
PM_ComboBox( pmGroupBox,
choices = favoriteChoices,
spanWidth = True)
# PM_ToolButtonRow ===============
# Button list to create a toolbutton row.
# Format:
# - QToolButton, buttonId, buttonText,
# - iconPath,
# - tooltip, shortcut, column
BUTTON_LIST = [
( "QToolButton", 1, "APPLY_FAVORITE",
"ui/actions/Properties Manager/ApplyLightingSchemeFavorite.png",
"Apply Favorite", "", 0),
( "QToolButton", 2, "ADD_FAVORITE",
"ui/actions/Properties Manager/AddFavorite.png",
"Add Favorite", "", 1),
( "QToolButton", 3, "DELETE_FAVORITE",
"ui/actions/Properties Manager/DeleteFavorite.png",
"Delete Favorite", "", 2),
( "QToolButton", 4, "SAVE_FAVORITE",
"ui/actions/Properties Manager/SaveFavorite.png",
"Save Favorite", "", 3),
( "QToolButton", 5, "LOAD_FAVORITE",
"ui/actions/Properties Manager/LoadFavorite.png",
"Load Favorite", \
"", 4)
]
self.favsButtonGroup = \
PM_ToolButtonRow( pmGroupBox,
title = "",
buttonList = BUTTON_LIST,
spanWidth = True,
isAutoRaise = False,
isCheckable = False,
setAsDefault = True,
)
self.favsButtonGroup.buttonGroup.setExclusive(False)
self.applyFavoriteButton = self.favsButtonGroup.getButtonById(1)
self.addFavoriteButton = self.favsButtonGroup.getButtonById(2)
self.deleteFavoriteButton = self.favsButtonGroup.getButtonById(3)
self.saveFavoriteButton = self.favsButtonGroup.getButtonById(4)
self.loadFavoriteButton = self.favsButtonGroup.getButtonById(5)
def _loadGroupBox2(self, pmGroupBox):
"""
Load widgets in group box.
"""
self.lightComboBox = \
PM_ComboBox( pmGroupBox,
choices = ["1", "2", "3"],
label = "Light:")
self.enableLightCheckBox = \
PM_CheckBox( pmGroupBox, text = "On" )
self.lightColorComboBox = \
PM_ColorComboBox(pmGroupBox)
self.ambientDoubleSpinBox = \
PM_DoubleSpinBox(pmGroupBox,
maximum = 1.0,
minimum = 0.0,
decimals = 2,
singleStep = .1,
label = "Ambient:")
self.diffuseDoubleSpinBox = \
PM_DoubleSpinBox(pmGroupBox,
maximum = 1.0,
minimum = 0.0,
decimals = 2,
singleStep = .1,
label = "Diffuse:")
self.specularDoubleSpinBox = \
PM_DoubleSpinBox(pmGroupBox,
maximum = 1.0,
minimum = 0.0,
decimals = 2,
singleStep = .1,
label = "Specular:")
self.positionGroupBox = \
PM_GroupBox( pmGroupBox,
title = "Position:")
self.xDoubleSpinBox = \
PM_DoubleSpinBox(self.positionGroupBox,
maximum = 1000,
minimum = -1000,
decimals = 1,
singleStep = 10,
label = "X:")
self.yDoubleSpinBox = \
PM_DoubleSpinBox(self.positionGroupBox,
maximum = 1000,
minimum = -1000,
decimals = 1,
singleStep = 10,
label = "Y:")
self.zDoubleSpinBox = \
PM_DoubleSpinBox(self.positionGroupBox,
maximum = 1000,
minimum = -1000,
decimals = 1,
singleStep = 10,
label = "Z:")
return
def _loadGroupBox3(self, pmGroupBox):
"""
Load widgets in group box.
"""
self.enableMaterialPropertiesComboBox = \
PM_CheckBox( pmGroupBox, text = "On")
self.finishDoubleSpinBox = \
PM_DoubleSpinBox(pmGroupBox,
maximum = 1.0,
minimum = 0.0,
decimals = 2,
singleStep = .1,
label = "Finish:")
self.shininessDoubleSpinBox = \
PM_DoubleSpinBox(pmGroupBox,
maximum = 60,
minimum = 15,
decimals = 2,
label = "Shininess:")
self.brightnessDoubleSpinBox = \
PM_DoubleSpinBox(pmGroupBox,
maximum = 1.0,
minimum = 0.0,
decimals = 2,
singleStep = .1,
label = "Brightness:")
return
def _updateAllWidgets(self):
"""
Update all the PM widgets. This is typically called after applying
a favorite.
"""
self._updatePage_Lighting()
return
def update_light_combobox_items(self):
"""
Updates all light combobox items with '(On)' or '(Off)' label.
"""
for i in range(3):
if self.lights[i][7]:
txt = "%d (On)" % (i + 1)
else:
txt = "%d (Off)" % (i + 1)
self.lightComboBox.setItemText(i, txt)
return
def changeLightColor(self):
"""
Slot method for the ColorComboBox
"""
color = self.lightColorComboBox.getColor()
env.prefs[self.current_light_key] = color
self.light_color = env.prefs[self.current_light_key]
self.save_lighting()
return
def applyFavorite(self):
"""
Apply the lighting scheme settings stored in the current favorite
(selected in the combobox) to the current lighting scheme settings.
"""
# Rules and other info:
# The user has to press the button related to this method when he loads
# a previously saved favorite file
current_favorite = self.favoritesComboBox.currentText()
if current_favorite == 'Factory default settings':
#env.prefs.restore_defaults(lightingSchemePrefsList)
self.restore_default_lighting()
else:
favfilepath = getFavoritePathFromBasename(current_favorite)
loadFavoriteFile(favfilepath)
self._updateAllWidgets()
self.win.glpane.gl_update()
return
def addFavorite(self):
"""
Adds a new favorite to the user's list of favorites.
"""
# Rules and other info:
# - The new favorite is defined by the current lighting scheme
# settings.
# - The user is prompted to type in a name for the new
# favorite.
# - The lighting scheme settings are written to a file in a special
# directory on the disk
# (i.e. $HOME/Nanorex/Favorites/LightingScheme/$FAV_NAME.txt).
# - The name of the new favorite is added to the list of favorites in
# the combobox, which becomes the current option.
# Existence of a favorite with the same name is checked in the above
# mentioned location and if a duplicate exists, then the user can either
# overwrite and provide a new name.
# Prompt user for a favorite name to add.
from widgets.simple_dialogs import grab_text_line_using_dialog
ok1, name = \
grab_text_line_using_dialog(
title = "Add new favorite",
label = "favorite name:",
iconPath = "ui/actions/Properties Manager/AddFavorite.png",
default = "" )
if ok1:
# check for duplicate files in the
# $HOME/Nanorex/Favorites/LightingScheme/ directory
fname = getFavoritePathFromBasename(name)
if os.path.exists(fname):
#favorite file already exists!
_ext = ".txt"
ret = QMessageBox.warning(
self,
"Warning!",
"The favorite file \"" + name + _ext +
"\"already exists.\n"
"Do you want to overwrite the existing file?",
"&Overwrite",
"&Cancel",
"",
0, # Enter == button 0
1) # Escape == button 1
if ret == 0:
#overwrite favorite file
ok2, text = writeLightingSchemeToFavoritesFile(name)
indexOfDuplicateItem = self.favoritesComboBox.findText(
name)
self.favoritesComboBox.removeItem(indexOfDuplicateItem)
print "Add Favorite: removed duplicate favorite item."
else:
env.history.message(
"Add Favorite: cancelled overwriting favorite item.")
return
else:
ok2, text = writeLightingSchemeToFavoritesFile(name)
else:
# User cancelled.
return
if ok2:
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
msg = "New favorite [%s] added." % (text)
else:
msg = "Can't add favorite [%s]: %s" % (name, text
) # text is reason why not
env.history.message(msg)
return
def deleteFavorite(self):
"""
Deletes the current favorite from the user's personal list of favorites
(and from disk, only in the favorites folder though).
@note: Cannot delete "Factory default settings".
"""
currentIndex = self.favoritesComboBox.currentIndex()
currentText = self.favoritesComboBox.currentText()
if currentIndex == 0:
msg = "Cannot delete '%s'." % currentText
else:
self.favoritesComboBox.removeItem(currentIndex)
# delete file from the disk
deleteFile = getFavoritePathFromBasename(currentText)
os.remove(deleteFile)
msg = "Deleted favorite named [%s].\n" \
"and the favorite file [%s.txt]." \
% (currentText, currentText)
env.history.message(msg)
return
def saveFavorite(self):
"""
Writes the current favorite (selected in the combobox) to a file, any
where in the disk that
can be given to another NE1 user (i.e. as an email attachment).
"""
cmd = greenmsg("Save Favorite File: ")
env.history.message(greenmsg("Save Favorite File:"))
current_favorite = self.favoritesComboBox.currentText()
favfilepath = getFavoritePathFromBasename(current_favorite)
formats = \
"Favorite (*.txt);;"\
"All Files (*.*)"
fn = QFileDialog.getSaveFileName(
self,
"Save Favorite As", # caption
favfilepath, #where to save
formats, # file format options
QString("Favorite (*.txt)") # selectedFilter
)
if not fn:
env.history.message(cmd + "Cancelled")
else:
saveFavoriteFile(str(fn), favfilepath)
return
def loadFavorite(self):
"""
Prompts the user to choose a "favorite file" (i.e. *.txt) from disk to
be added to the personal favorites list.
"""
# If the file already exists in the favorites folder then the user is
# given the option of overwriting it or renaming it
env.history.message(greenmsg("Load Favorite File:"))
formats = \
"Favorite (*.txt);;"\
"All Files (*.*)"
directory = getDefaultWorkingDirectory()
fname = QFileDialog.getOpenFileName(self, "Choose a file to load",
directory, formats)
if not fname:
env.history.message("User cancelled loading file.")
return
else:
canLoadFile = loadFavoriteFile(fname)
if canLoadFile == 1:
#get just the name of the file for loading into the combobox
favName = os.path.basename(str(fname))
name = favName[0:len(favName) - 4]
indexOfDuplicateItem = self.favoritesComboBox.findText(name)
#duplicate exists in combobox
if indexOfDuplicateItem != -1:
ret = QMessageBox.warning(
self,
"Warning!",
"The favorite file \"" + name + "\"already exists.\n"
"Do you want to overwrite the existing file?",
"&Overwrite",
"&Rename",
"&Cancel",
0, # Enter == button 0
1 # button 1
)
if ret == 0:
self.favoritesComboBox.removeItem(indexOfDuplicateItem)
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
ok2, text = writeLightingSchemeToFavoritesFile(name)
msg = "Overwrote favorite [%s]." % (text)
env.history.message(msg)
elif ret == 1:
# add new item to favorites folder as well as combobox
self.addFavorite()
else:
#reset the display setting values to factory default
factoryIndex = self.favoritesComboBox.findText(
'Factory default settings')
self.favoritesComboBox.setCurrentIndex(factoryIndex)
env.prefs.restore_defaults(lightingSchemePrefsList)
self.win.glpane.gl_update()
env.history.message(
"Cancelled overwriting favorite file.")
return
else:
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
msg = "Loaded favorite [%s]." % (name)
env.history.message(msg)
self.win.glpane.gl_update()
return
#def _addWhatsThisText( self ):
#"""
#What's This text for widgets in the Lighting Scheme Property Manager.
#"""
#from ne1_ui.WhatsThisText_for_PropertyManagers import WhatsThis_LightingScheme_PropertyManager
#WhatsThis_LightingScheme_PropertyManager(self)
def _addToolTipText(self):
"""
Tool Tip text for widgets in the Lighting Scheme Property Manager.
"""
#modify this for lighting schemes
from ne1_ui.ToolTipText_for_PropertyManagers import ToolTip_LightingScheme_PropertyManager
ToolTip_LightingScheme_PropertyManager(self)
class LightingScheme_PropertyManager( PM_Dialog, DebugMenuMixin ):
"""
The LightingScheme_PropertyManager class provides a Property Manager
for changing light properties as well as material properties.
@ivar title: The title that appears in the property manager header.
@type title: str
@ivar pmName: The name of this property manager. This is used to set
the name of the PM_Dialog object via setObjectName().
@type name: str
@ivar iconPath: The relative path to the PNG file that contains a
22 x 22 icon image that appears in the PM header.
@type iconPath: str
"""
title = "Lighting Scheme"
pmName = title
iconPath = "ui/actions/View/LightingScheme.png"
def __init__( self, parentCommand ):
"""
Constructor for the property manager.
"""
self.parentMode = parentCommand
self.w = self.parentMode.w
self.win = self.parentMode.w
self.pw = self.parentMode.pw
self.o = self.win.glpane
PM_Dialog.__init__(self, self.pmName, self.iconPath, self.title)
DebugMenuMixin._init1( self )
self.showTopRowButtons( PM_DONE_BUTTON | \
PM_WHATS_THIS_BUTTON)
msg = "Edit the lighting scheme for NE1. Includes turning lights on and off, "\
"changing light colors, changing the position of lights as well as,"\
"changing the ambient, diffuse, and specular properites."
self.updateMessage(msg)
def connect_or_disconnect_signals(self, isConnect):
"""
Connect or disconnect widget signals sent to their slot methods.
This can be overridden in subclasses. By default it does nothing.
@param isConnect: If True the widget will send the signals to the slot
method.
@type isConnect: boolean
"""
if isConnect:
change_connect = self.win.connect
else:
change_connect = self.win.disconnect
# Favorite buttons signal-slot connections.
change_connect( self.applyFavoriteButton,
SIGNAL("clicked()"),
self.applyFavorite)
change_connect( self.addFavoriteButton,
SIGNAL("clicked()"),
self.addFavorite)
change_connect( self.deleteFavoriteButton,
SIGNAL("clicked()"),
self.deleteFavorite)
change_connect( self.saveFavoriteButton,
SIGNAL("clicked()"),
self.saveFavorite)
change_connect( self.loadFavoriteButton,
SIGNAL("clicked()"),
self.loadFavorite)
# Directional Lighting Properties
change_connect(self.ambientDoubleSpinBox, SIGNAL("valueChanged(double)"), self.change_lighting)
change_connect(self.lightColorComboBox, SIGNAL("editingFinished()"), self.changeLightColor)
change_connect(self.enableLightCheckBox, SIGNAL("toggled(bool)"), self.toggle_light)
change_connect(self.lightComboBox, SIGNAL("activated(int)"), self.change_active_light)
change_connect(self.diffuseDoubleSpinBox, SIGNAL("valueChanged(double)"), self.change_lighting)
change_connect(self.specularDoubleSpinBox, SIGNAL("valueChanged(double)"), self.change_lighting)
change_connect(self.xDoubleSpinBox, SIGNAL("editingFinished()"), self.save_lighting)
change_connect(self.yDoubleSpinBox, SIGNAL("editingFinished()"), self.save_lighting)
change_connect(self.zDoubleSpinBox, SIGNAL("editingFinished()"), self.save_lighting)
# Material Specular Properties
change_connect(self.brightnessDoubleSpinBox, SIGNAL("valueChanged(double)"), self.change_material_brightness)
change_connect(self.finishDoubleSpinBox, SIGNAL("valueChanged(double)"), self.change_material_finish)
change_connect(self.enableMaterialPropertiesComboBox, SIGNAL("toggled(bool)"), self.toggle_material_specularity)
change_connect(self.shininessDoubleSpinBox, SIGNAL("valueChanged(double)"), self.change_material_shininess)
self._setup_material_group()
return
def _updatePage_Lighting(self, lights = None): #mark 051124
"""
Setup widgets to initial (default or defined) values on the Lighting page.
"""
if not lights:
self.lights = self.original_lights = self.win.glpane.getLighting()
else:
self.lights = lights
light_num = self.lightComboBox.currentIndex()
# Move lc_prefs_keys upstairs. Mark.
lc_prefs_keys = [light1Color_prefs_key, light2Color_prefs_key, light3Color_prefs_key]
self.current_light_key = lc_prefs_keys[light_num] # Get prefs key for current light color.
self.lightColorComboBox.setColor(env.prefs[self.current_light_key])
self.light_color = env.prefs[self.current_light_key]
# These sliders generate signals whenever their 'setValue()' slot is called (below).
# This creates problems (bugs) for us, so we disconnect them temporarily.
self.disconnect(self.ambientDoubleSpinBox, SIGNAL("valueChanged(double)"), self.change_lighting)
self.disconnect(self.diffuseDoubleSpinBox, SIGNAL("valueChanged(double)"), self.change_lighting)
self.disconnect(self.specularDoubleSpinBox, SIGNAL("valueChanged(double)"), self.change_lighting)
# self.lights[light_num][0] contains 'color' attribute.
# We already have it (self.light_color) from the prefs key (above).
a = self.lights[light_num][1] # ambient intensity
d = self.lights[light_num][2] # diffuse intensity
s = self.lights[light_num][3] # specular intensity
g = self.lights[light_num][4] # xpos
h = self.lights[light_num][5] # ypos
k = self.lights[light_num][6] # zpos
self.ambientDoubleSpinBox.setValue(a)# generates signal
self.diffuseDoubleSpinBox.setValue(d) # generates signal
self.specularDoubleSpinBox.setValue(s) # generates signal
self.xDoubleSpinBox.setValue(g) # generates signal
self.yDoubleSpinBox.setValue(h) # generates signal
self.zDoubleSpinBox.setValue(k) # generates signal
self.enableLightCheckBox.setChecked(self.lights[light_num][7])
# Reconnect the slots to the light sliders.
self.connect(self.ambientDoubleSpinBox, SIGNAL("valueChanged(double)"), self.change_lighting)
self.connect(self.diffuseDoubleSpinBox, SIGNAL("valueChanged(double)"), self.change_lighting)
self.connect(self.specularDoubleSpinBox, SIGNAL("valueChanged(double)"), self.change_lighting)
self.update_light_combobox_items()
self.save_lighting()
self._setup_material_group()
return
def _setup_material_group(self, reset = False):
"""
Setup Material Specularity widgets to initial (default or defined) values on the Lighting page.
If reset = False, widgets are reset from the prefs db.
If reset = True, widgets are reset from their previous values.
"""
if reset:
self.material_specularity = self.original_material_specularity
self.whiteness = self.original_whiteness
self.shininess = self.original_shininess
self.brightness = self.original_brightness
else:
self.material_specularity = self.original_material_specularity = \
env.prefs[material_specular_highlights_prefs_key]
self.whiteness = self.original_whiteness = \
env.prefs[material_specular_finish_prefs_key]
self.shininess = self.original_shininess = \
env.prefs[material_specular_shininess_prefs_key]
self.brightness = self.original_brightness= \
env.prefs[material_specular_brightness_prefs_key]
# Enable/disable material specularity properites.
self.enableMaterialPropertiesComboBox.setChecked(self.material_specularity)
# For whiteness, the stored range is 0.0 (Plastic) to 1.0 (Metal).
self.finishDoubleSpinBox.setValue(self.whiteness) # generates signal
# For shininess, the range is 15 (low) to 60 (high). Mark. 051129.
self.shininessDoubleSpinBox.setValue(self.shininess) # generates signal
# For brightness, the range is 0.0 (low) to 1.0 (high). Mark. 051203.
self.brightnessDoubleSpinBox.setValue(self.brightness) # generates signal
return
def toggle_material_specularity(self, val):
"""
This is the slot for the Material Specularity Enabled checkbox.
"""
env.prefs[material_specular_highlights_prefs_key] = val
def change_material_finish(self, finish):
"""
This is the slot for the Material Finish spin box.
'finish' is between 0.0 and 1.0.
Saves finish parameter to pref db.
"""
# For whiteness, the stored range is 0.0 (Metal) to 1.0 (Plastic).
env.prefs[material_specular_finish_prefs_key] = finish
def change_material_shininess(self, shininess):
"""
This is the slot for the Material Shininess spin box.
'shininess' is between 15 (low) and 60 (high).
"""
env.prefs[material_specular_shininess_prefs_key] = shininess
def change_material_brightness(self, brightness):
"""
This is the slot for the Material Brightness sping box.
'brightness' is between 0.0 (low) and 1.0 (high).
"""
env.prefs[material_specular_brightness_prefs_key] = brightness
def toggle_light(self, on):
"""
Slot for light 'On' checkbox.
It updates the current item in the light combobox with '(On)' or
'(Off)' label.
"""
if on:
txt = "%d (On)" % (self.lightComboBox.currentIndex()+1)
else:
txt = "%d (Off)" % (self.lightComboBox.currentIndex()+1)
self.lightComboBox.setItemText(self.lightComboBox.currentIndex(),txt)
self.save_lighting()
def change_lighting(self, specularityValueJunk = None):
"""
Updates win.glpane lighting using the current lighting parameters from
the light checkboxes and sliders. This is also the slot for the light
spin boxes.
@param specularityValueJunk: This value from the spin box is not used
We are interested in valueChanged signal
only
@type specularityValueJunk = int or None
"""
light_num = self.lightComboBox.currentIndex()
light1, light2, light3 = self.win.glpane.getLighting()
a = self.ambientDoubleSpinBox.value()
d = self.diffuseDoubleSpinBox.value()
s = self.specularDoubleSpinBox.value()
g = self.xDoubleSpinBox.value()
h = self.yDoubleSpinBox.value()
k = self.zDoubleSpinBox.value()
new_light = [ self.light_color, a, d, s, g, h, k,\
self.enableLightCheckBox.isChecked()]
# This is a kludge. I'm certain there is a more elegant way. Mark 051204.
if light_num == 0:
self.win.glpane.setLighting([new_light, light2, light3])
elif light_num == 1:
self.win.glpane.setLighting([light1, new_light, light3])
elif light_num == 2:
self.win.glpane.setLighting([light1, light2, new_light])
else:
print "Unsupported light # ", light_num,". No lighting change made."
def change_active_light(self, currentIndexJunk = None):
"""
Slot for the Light number combobox. This changes the current light.
@param currentIndexJunk: This index value from the combobox is not used
We are interested in 'activated' signal only
@type currentIndexJunk = int or None
"""
self._updatePage_Lighting()
def reset_lighting(self):
"""
Slot for Reset button.
"""
# This has issues.
# I intend to remove the Reset button for A7. Confirm with Bruce. Mark 051204.
self._setup_material_group(reset = True)
self._updatePage_Lighting(self.original_lights)
self.win.glpane.saveLighting()
def save_lighting(self):
"""
Saves lighting parameters (but not material specularity parameters)
to pref db. This is also the slot for light sliders (only when
released).
"""
self.change_lighting()
self.win.glpane.saveLighting()
def restore_default_lighting(self):
"""
Slot for Restore Defaults button.
"""
self.win.glpane.restoreDefaultLighting()
# Restore defaults for the Material Specularity properties
env.prefs.restore_defaults([
material_specular_highlights_prefs_key,
material_specular_shininess_prefs_key,
material_specular_finish_prefs_key,
material_specular_brightness_prefs_key, #bruce 051203 bugfix
])
self._updatePage_Lighting()
self.save_lighting()
def ok_btn_clicked(self):
"""
Slot for the OK button
"""
self.win.toolsDone()
def cancel_btn_clicked(self):
"""
Slot for the Cancel button.
"""
#TODO: Cancel button needs to be removed. See comment at the top
self.win.toolsDone()
def show(self):
"""
Shows the Property Manager. Overrides PM_Dialog.show.
"""
PM_Dialog.show(self)
self.connect_or_disconnect_signals(isConnect = True)
self._updateAllWidgets()
def close(self):
"""
Closes the Property Manager. Overrides PM_Dialog.close.
"""
self.connect_or_disconnect_signals(False)
PM_Dialog.close(self)
def _addGroupBoxes( self ):
"""
Add the Property Manager group boxes.
"""
self._pmGroupBox1 = PM_GroupBox( self,
title = "Favorites")
self._loadGroupBox1( self._pmGroupBox1 )
self._pmGroupBox2 = PM_GroupBox( self,
title = "Directional Lights")
self._loadGroupBox2( self._pmGroupBox2 )
self._pmGroupBox3 = PM_GroupBox( self,
title = "Material Properties")
self._loadGroupBox3( self._pmGroupBox3 )
def _loadGroupBox1(self, pmGroupBox):
"""
Load widgets in group box.
"""
favoriteChoices = ['Factory default settings']
#look for all the favorite files in the favorite folder and add them to
# the list
from platform_dependent.PlatformDependent import find_or_make_Nanorex_subdir
_dir = find_or_make_Nanorex_subdir('Favorites/LightingScheme')
for file in os.listdir(_dir):
fullname = os.path.join( _dir, file)
if os.path.isfile(fullname):
if fnmatch.fnmatch( file, "*.txt"):
# leave the extension out
favoriteChoices.append(file[0:len(file)-4])
self.favoritesComboBox = \
PM_ComboBox( pmGroupBox,
choices = favoriteChoices,
spanWidth = True)
# PM_ToolButtonRow ===============
# Button list to create a toolbutton row.
# Format:
# - QToolButton, buttonId, buttonText,
# - iconPath,
# - tooltip, shortcut, column
BUTTON_LIST = [
( "QToolButton", 1, "APPLY_FAVORITE",
"ui/actions/Properties Manager/ApplyLightingSchemeFavorite.png",
"Apply Favorite", "", 0),
( "QToolButton", 2, "ADD_FAVORITE",
"ui/actions/Properties Manager/AddFavorite.png",
"Add Favorite", "", 1),
( "QToolButton", 3, "DELETE_FAVORITE",
"ui/actions/Properties Manager/DeleteFavorite.png",
"Delete Favorite", "", 2),
( "QToolButton", 4, "SAVE_FAVORITE",
"ui/actions/Properties Manager/SaveFavorite.png",
"Save Favorite", "", 3),
( "QToolButton", 5, "LOAD_FAVORITE",
"ui/actions/Properties Manager/LoadFavorite.png",
"Load Favorite", \
"", 4)
]
self.favsButtonGroup = \
PM_ToolButtonRow( pmGroupBox,
title = "",
buttonList = BUTTON_LIST,
spanWidth = True,
isAutoRaise = False,
isCheckable = False,
setAsDefault = True,
)
self.favsButtonGroup.buttonGroup.setExclusive(False)
self.applyFavoriteButton = self.favsButtonGroup.getButtonById(1)
self.addFavoriteButton = self.favsButtonGroup.getButtonById(2)
self.deleteFavoriteButton = self.favsButtonGroup.getButtonById(3)
self.saveFavoriteButton = self.favsButtonGroup.getButtonById(4)
self.loadFavoriteButton = self.favsButtonGroup.getButtonById(5)
def _loadGroupBox2(self, pmGroupBox):
"""
Load widgets in group box.
"""
self.lightComboBox = \
PM_ComboBox( pmGroupBox,
choices = ["1", "2", "3"],
label = "Light:")
self.enableLightCheckBox = \
PM_CheckBox( pmGroupBox, text = "On" )
self.lightColorComboBox = \
PM_ColorComboBox(pmGroupBox)
self.ambientDoubleSpinBox = \
PM_DoubleSpinBox(pmGroupBox,
maximum = 1.0,
minimum = 0.0,
decimals = 2,
singleStep = .1,
label = "Ambient:")
self.diffuseDoubleSpinBox = \
PM_DoubleSpinBox(pmGroupBox,
maximum = 1.0,
minimum = 0.0,
decimals = 2,
singleStep = .1,
label = "Diffuse:")
self.specularDoubleSpinBox = \
PM_DoubleSpinBox(pmGroupBox,
maximum = 1.0,
minimum = 0.0,
decimals = 2,
singleStep = .1,
label = "Specular:")
self.positionGroupBox = \
PM_GroupBox( pmGroupBox,
title = "Position:")
self.xDoubleSpinBox = \
PM_DoubleSpinBox(self.positionGroupBox,
maximum = 1000,
minimum = -1000,
decimals = 1,
singleStep = 10,
label = "X:")
self.yDoubleSpinBox = \
PM_DoubleSpinBox(self.positionGroupBox,
maximum = 1000,
minimum = -1000,
decimals = 1,
singleStep = 10,
label = "Y:")
self.zDoubleSpinBox = \
PM_DoubleSpinBox(self.positionGroupBox,
maximum = 1000,
minimum = -1000,
decimals = 1,
singleStep = 10,
label = "Z:")
return
def _loadGroupBox3(self, pmGroupBox):
"""
Load widgets in group box.
"""
self.enableMaterialPropertiesComboBox = \
PM_CheckBox( pmGroupBox, text = "On")
self.finishDoubleSpinBox = \
PM_DoubleSpinBox(pmGroupBox,
maximum = 1.0,
minimum = 0.0,
decimals = 2,
singleStep = .1,
label = "Finish:")
self.shininessDoubleSpinBox = \
PM_DoubleSpinBox(pmGroupBox,
maximum = 60,
minimum = 15,
decimals = 2,
label = "Shininess:")
self.brightnessDoubleSpinBox = \
PM_DoubleSpinBox(pmGroupBox,
maximum = 1.0,
minimum = 0.0,
decimals = 2,
singleStep = .1,
label = "Brightness:")
return
def _updateAllWidgets(self):
"""
Update all the PM widgets. This is typically called after applying
a favorite.
"""
self._updatePage_Lighting()
return
def update_light_combobox_items(self):
"""
Updates all light combobox items with '(On)' or '(Off)' label.
"""
for i in range(3):
if self.lights[i][7]:
txt = "%d (On)" % (i+1)
else:
txt = "%d (Off)" % (i+1)
self.lightComboBox.setItemText(i, txt)
return
def changeLightColor(self):
"""
Slot method for the ColorComboBox
"""
color = self.lightColorComboBox.getColor()
env.prefs[self.current_light_key] = color
self.light_color = env.prefs[self.current_light_key]
self.save_lighting()
return
def applyFavorite(self):
"""
Apply the lighting scheme settings stored in the current favorite
(selected in the combobox) to the current lighting scheme settings.
"""
# Rules and other info:
# The user has to press the button related to this method when he loads
# a previously saved favorite file
current_favorite = self.favoritesComboBox.currentText()
if current_favorite == 'Factory default settings':
#env.prefs.restore_defaults(lightingSchemePrefsList)
self.restore_default_lighting()
else:
favfilepath = getFavoritePathFromBasename(current_favorite)
loadFavoriteFile(favfilepath)
self._updateAllWidgets()
self.win.glpane.gl_update()
return
def addFavorite(self):
"""
Adds a new favorite to the user's list of favorites.
"""
# Rules and other info:
# - The new favorite is defined by the current lighting scheme
# settings.
# - The user is prompted to type in a name for the new
# favorite.
# - The lighting scheme settings are written to a file in a special
# directory on the disk
# (i.e. $HOME/Nanorex/Favorites/LightingScheme/$FAV_NAME.txt).
# - The name of the new favorite is added to the list of favorites in
# the combobox, which becomes the current option.
# Existence of a favorite with the same name is checked in the above
# mentioned location and if a duplicate exists, then the user can either
# overwrite and provide a new name.
# Prompt user for a favorite name to add.
from widgets.simple_dialogs import grab_text_line_using_dialog
ok1, name = \
grab_text_line_using_dialog(
title = "Add new favorite",
label = "favorite name:",
iconPath = "ui/actions/Properties Manager/AddFavorite.png",
default = "" )
if ok1:
# check for duplicate files in the
# $HOME/Nanorex/Favorites/LightingScheme/ directory
fname = getFavoritePathFromBasename( name )
if os.path.exists(fname):
#favorite file already exists!
_ext= ".txt"
ret = QMessageBox.warning( self, "Warning!",
"The favorite file \"" + name + _ext + "\"already exists.\n"
"Do you want to overwrite the existing file?",
"&Overwrite", "&Cancel", "",
0, # Enter == button 0
1) # Escape == button 1
if ret == 0:
#overwrite favorite file
ok2, text = writeLightingSchemeToFavoritesFile(name)
indexOfDuplicateItem = self.favoritesComboBox.findText(name)
self.favoritesComboBox.removeItem(indexOfDuplicateItem)
print "Add Favorite: removed duplicate favorite item."
else:
env.history.message("Add Favorite: cancelled overwriting favorite item.")
return
else:
ok2, text = writeLightingSchemeToFavoritesFile(name)
else:
# User cancelled.
return
if ok2:
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
msg = "New favorite [%s] added." % (text)
else:
msg = "Can't add favorite [%s]: %s" % (name, text) # text is reason why not
env.history.message(msg)
return
def deleteFavorite(self):
"""
Deletes the current favorite from the user's personal list of favorites
(and from disk, only in the favorites folder though).
@note: Cannot delete "Factory default settings".
"""
currentIndex = self.favoritesComboBox.currentIndex()
currentText = self.favoritesComboBox.currentText()
if currentIndex == 0:
msg = "Cannot delete '%s'." % currentText
else:
self.favoritesComboBox.removeItem(currentIndex)
# delete file from the disk
deleteFile= getFavoritePathFromBasename( currentText )
os.remove(deleteFile)
msg = "Deleted favorite named [%s].\n" \
"and the favorite file [%s.txt]." \
% (currentText, currentText)
env.history.message(msg)
return
def saveFavorite(self):
"""
Writes the current favorite (selected in the combobox) to a file, any
where in the disk that
can be given to another NE1 user (i.e. as an email attachment).
"""
cmd = greenmsg("Save Favorite File: ")
env.history.message(greenmsg("Save Favorite File:"))
current_favorite = self.favoritesComboBox.currentText()
favfilepath = getFavoritePathFromBasename(current_favorite)
formats = \
"Favorite (*.txt);;"\
"All Files (*.*)"
fn = QFileDialog.getSaveFileName(
self,
"Save Favorite As", # caption
favfilepath, #where to save
formats, # file format options
QString("Favorite (*.txt)") # selectedFilter
)
if not fn:
env.history.message(cmd + "Cancelled")
else:
saveFavoriteFile(str(fn), favfilepath)
return
def loadFavorite(self):
"""
Prompts the user to choose a "favorite file" (i.e. *.txt) from disk to
be added to the personal favorites list.
"""
# If the file already exists in the favorites folder then the user is
# given the option of overwriting it or renaming it
env.history.message(greenmsg("Load Favorite File:"))
formats = \
"Favorite (*.txt);;"\
"All Files (*.*)"
directory= getDefaultWorkingDirectory()
fname = QFileDialog.getOpenFileName(self,
"Choose a file to load",
directory,
formats)
if not fname:
env.history.message("User cancelled loading file.")
return
else:
canLoadFile=loadFavoriteFile(fname)
if canLoadFile == 1:
#get just the name of the file for loading into the combobox
favName = os.path.basename(str(fname))
name = favName[0:len(favName)-4]
indexOfDuplicateItem = self.favoritesComboBox.findText(name)
#duplicate exists in combobox
if indexOfDuplicateItem != -1:
ret = QMessageBox.warning( self, "Warning!",
"The favorite file \"" + name +
"\"already exists.\n"
"Do you want to overwrite the existing file?",
"&Overwrite", "&Rename", "&Cancel",
0, # Enter == button 0
1 # button 1
)
if ret == 0:
self.favoritesComboBox.removeItem(indexOfDuplicateItem)
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
ok2, text = writeLightingSchemeToFavoritesFile(name)
msg = "Overwrote favorite [%s]." % (text)
env.history.message(msg)
elif ret == 1:
# add new item to favorites folder as well as combobox
self.addFavorite()
else:
#reset the display setting values to factory default
factoryIndex = self.favoritesComboBox.findText(
'Factory default settings')
self.favoritesComboBox.setCurrentIndex(factoryIndex)
env.prefs.restore_defaults(lightingSchemePrefsList)
self.win.glpane.gl_update()
env.history.message("Cancelled overwriting favorite file.")
return
else:
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
msg = "Loaded favorite [%s]." % (name)
env.history.message(msg)
self.win.glpane.gl_update()
return
#def _addWhatsThisText( self ):
#"""
#What's This text for widgets in the Lighting Scheme Property Manager.
#"""
#from ne1_ui.WhatsThisText_for_PropertyManagers import WhatsThis_LightingScheme_PropertyManager
#WhatsThis_LightingScheme_PropertyManager(self)
def _addToolTipText(self):
"""
Tool Tip text for widgets in the Lighting Scheme Property Manager.
"""
#modify this for lighting schemes
from ne1_ui.ToolTipText_for_PropertyManagers import ToolTip_LightingScheme_PropertyManager
ToolTip_LightingScheme_PropertyManager(self)
class ProteinDisplayStyle_PropertyManager(PM_Dialog, DebugMenuMixin):
"""
The ProteinDisplayStyle_PropertyManager class provides a Property Manager
for the B{Display Style} command on the flyout toolbar in the
Build > Protein mode.
@ivar title: The title that appears in the property manager header.
@type title: str
@ivar pmName: The name of this property manager. This is used to set
the name of the PM_Dialog object via setObjectName().
@type name: str
@ivar iconPath: The relative path to the PNG file that contains a
22 x 22 icon image that appears in the PM header.
@type iconPath: str
"""
title = "Edit Protein Display Style"
pmName = title
iconPath = "ui/actions/Edit/EditProteinDisplayStyle.png"
def __init__(self, parentCommand):
"""
Constructor for the property manager.
"""
self.parentMode = parentCommand
self.w = self.parentMode.w
self.win = self.parentMode.w
self.pw = self.parentMode.pw
self.o = self.win.glpane
self.currentWorkingDirectory = env.prefs[workingDirectory_prefs_key]
PM_Dialog.__init__(self, self.pmName, self.iconPath, self.title)
DebugMenuMixin._init1(self)
self.showTopRowButtons(PM_DONE_BUTTON | PM_WHATS_THIS_BUTTON)
msg = "Modify the protein display settings below."
self.updateMessage(msg)
def connect_or_disconnect_signals(self, isConnect=True):
if isConnect:
change_connect = self.win.connect
else:
change_connect = self.win.disconnect
# Favorite buttons signal-slot connections.
change_connect(self.applyFavoriteButton, SIGNAL("clicked()"), self.applyFavorite)
change_connect(self.addFavoriteButton, SIGNAL("clicked()"), self.addFavorite)
change_connect(self.deleteFavoriteButton, SIGNAL("clicked()"), self.deleteFavorite)
change_connect(self.saveFavoriteButton, SIGNAL("clicked()"), self.saveFavorite)
change_connect(self.loadFavoriteButton, SIGNAL("clicked()"), self.loadFavorite)
# Display group box signal slot connections
change_connect(self.proteinStyleComboBox, SIGNAL("currentIndexChanged(int)"), self.changeProteinDisplayStyle)
change_connect(self.smoothingCheckBox, SIGNAL("stateChanged(int)"), self.smoothProteinDisplay)
change_connect(self.scaleComboBox, SIGNAL("currentIndexChanged(int)"), self.changeProteinDisplayScale)
change_connect(self.splineDoubleSpinBox, SIGNAL("valueChanged(double)"), self.changeProteinSplineValue)
change_connect(self.scaleFactorDoubleSpinBox, SIGNAL("valueChanged(double)"), self.changeProteinScaleFactor)
# color groupbox
change_connect(self.proteinComponentComboBox, SIGNAL("currentIndexChanged(int)"), self.chooseProteinComponent)
change_connect(
self.proteinAuxComponentComboBox, SIGNAL("currentIndexChanged(int)"), self.chooseAuxilliaryProteinComponent
)
change_connect(self.customColorComboBox, SIGNAL("editingFinished()"), self.chooseCustomColor)
change_connect(self.auxColorComboBox, SIGNAL("editingFinished()"), self.chooseAuxilliaryColor)
change_connect(self.discColorCheckBox, SIGNAL("stateChanged(int)"), self.setDiscreteColors)
change_connect(self.helixColorComboBox, SIGNAL("editingFinished()"), self.chooseHelixColor)
change_connect(self.strandColorComboBox, SIGNAL("editingFinished()"), self.chooseStrandColor)
change_connect(self.coilColorComboBox, SIGNAL("editingFinished()"), self.chooseCoilColor)
# Protein Display methods
def changeProteinDisplayStyle(self, idx):
env.prefs[proteinStyle_prefs_key] = idx
return
def changeProteinDisplayQuality(self, idx):
env.prefs[proteinStyleQuality_prefs_key] = idx
return
def smoothProteinDisplay(self, state):
if state == Qt.Checked:
env.prefs[proteinStyleSmooth_prefs_key] = True
else:
env.prefs[proteinStyleSmooth_prefs_key] = False
return
def changeProteinDisplayScale(self, idx):
env.prefs[proteinStyleScaling_prefs_key] = idx
return
def changeProteinSplineValue(self, val):
env.prefs[proteinStyleQuality_prefs_key] = val
return
def changeProteinScaleFactor(self, val):
env.prefs[proteinStyleScaleFactor_prefs_key] = val
return
def chooseProteinComponent(self, idx):
env.prefs[proteinStyleColors_prefs_key] = idx
return
def chooseAuxilliaryProteinComponent(self, idx):
env.prefs[proteinStyleAuxColors_prefs_key] = idx - 1
return
def chooseCustomColor(self):
color = self.customColorComboBox.getColor()
env.prefs[proteinStyleCustomColor_prefs_key] = color
return
def chooseAuxilliaryColor(self):
color = self.auxColorComboBox.getColor()
env.prefs[proteinStyleAuxCustomColor_prefs_key] = color
return
def chooseHelixColor(self):
color = self.helixColorComboBox.getColor()
env.prefs[proteinStyleHelixColor_prefs_key] = color
return
def chooseStrandColor(self):
color = self.strandColorComboBox.getColor()
env.prefs[proteinStyleStrandColor_prefs_key] = color
return
def chooseCoilColor(self):
color = self.coilColorComboBox.getColor()
env.prefs[proteinStyleCoilColor_prefs_key] = color
return
def setDiscreteColors(self, state):
if state == Qt.Checked:
env.prefs[proteinStyleColorsDiscrete_prefs_key] = True
else:
env.prefs[proteinStyleColorsDiscrete_prefs_key] = False
return
def ok_btn_clicked(self):
"""
Slot for the OK button
"""
self.win.toolsDone()
def cancel_btn_clicked(self):
"""
Slot for the Cancel button.
"""
# TODO: Cancel button needs to be removed. See comment at the top
self.win.toolsDone()
def show(self):
"""
Shows the Property Manager. Overrides PM_Dialog.show.
"""
self.sequenceEditor = self.win.createProteinSequenceEditorIfNeeded()
self.sequenceEditor.hide()
PM_Dialog.show(self)
# Not required for Proteins
# Force the Global Display Style to "DNA Cylinder" so the user
# can see the display style setting effects on any DNA in the current
# model. The current global display style will be restored when leaving
# this command (via self.close()).
# self.originalDisplayStyle = self.o.getGlobalDisplayStyle()
# self.o.setGlobalDisplayStyle(diDNACYLINDER)
# Update all PM widgets, then establish their signal-slot connections.
# note: It is important to update the widgets *first* since doing
# it in the reverse order will generate signals when updating
# the PM widgets (via updateDnaDisplayStyleWidgets()), causing
# unneccessary repaints of the model view.
self.updateProteinDisplayStyleWidgets()
self.connect_or_disconnect_signals(isConnect=True)
def close(self):
"""
Closes the Property Manager. Overrides PM_Dialog.close.
"""
self.connect_or_disconnect_signals(False)
PM_Dialog.close(self)
# Not required for proteins
# Restore the original global display style.
# self.o.setGlobalDisplayStyle(self.originalDisplayStyle)
def _addGroupBoxes(self):
"""
Add the Property Manager group boxes.
"""
self._pmGroupBox1 = PM_GroupBox(self, title="Favorites")
self._loadGroupBox1(self._pmGroupBox1)
self._pmGroupBox2 = PM_GroupBox(self, title="Display")
self._loadGroupBox2(self._pmGroupBox2)
self._pmGroupBox3 = PM_GroupBox(self, title="Color")
self._loadGroupBox3(self._pmGroupBox3)
def _loadGroupBox1(self, pmGroupBox):
"""
Load widgets in group box.
"""
# Other info
# Not only loads the factory default settings but also all the favorite
# files stored in the ~/Nanorex/Favorites/ProteinDisplayStyle directory
favoriteChoices = ["Factory default settings"]
# look for all the favorite files in the favorite folder and add them to
# the list
from platform_dependent.PlatformDependent import find_or_make_Nanorex_subdir
_dir = find_or_make_Nanorex_subdir("Favorites/ProteinDisplayStyle")
for file in os.listdir(_dir):
fullname = os.path.join(_dir, file)
if os.path.isfile(fullname):
if fnmatch.fnmatch(file, "*.txt"):
# leave the extension out
favoriteChoices.append(file[0 : len(file) - 4])
self.favoritesComboBox = PM_ComboBox(pmGroupBox, choices=favoriteChoices, spanWidth=True)
self.favoritesComboBox.setWhatsThis(
"""<b> List of Favorites </b>
<p>
Creates a list of favorite Protein display styles. Once favorite
styles have been added to the list using the Add Favorite button,
the list will display the chosen favorites.
To change the current favorite, select a current favorite from
the list, and push the Apply Favorite button."""
)
# PM_ToolButtonRow ===============
# Button list to create a toolbutton row.
# Format:
# - QToolButton, buttonId, buttonText,
# - iconPath,
# - tooltip, shortcut, column
BUTTON_LIST = [
(
"QToolButton",
1,
"APPLY_FAVORITE",
"ui/actions/Properties Manager/ApplyPeptideDisplayStyleFavorite.png",
"Apply Favorite",
"",
0,
),
("QToolButton", 2, "ADD_FAVORITE", "ui/actions/Properties Manager/AddFavorite.png", "Add Favorite", "", 1),
(
"QToolButton",
3,
"DELETE_FAVORITE",
"ui/actions/Properties Manager/DeleteFavorite.png",
"Delete Favorite",
"",
2,
),
(
"QToolButton",
4,
"SAVE_FAVORITE",
"ui/actions/Properties Manager/SaveFavorite.png",
"Save Favorite",
"",
3,
),
(
"QToolButton",
5,
"LOAD_FAVORITE",
"ui/actions/Properties Manager/LoadFavorite.png",
"Load Favorite",
"",
4,
),
]
self.favsButtonGroup = PM_ToolButtonRow(
pmGroupBox,
title="",
buttonList=BUTTON_LIST,
spanWidth=True,
isAutoRaise=False,
isCheckable=False,
setAsDefault=True,
)
self.favsButtonGroup.buttonGroup.setExclusive(False)
self.applyFavoriteButton = self.favsButtonGroup.getButtonById(1)
self.addFavoriteButton = self.favsButtonGroup.getButtonById(2)
self.deleteFavoriteButton = self.favsButtonGroup.getButtonById(3)
self.saveFavoriteButton = self.favsButtonGroup.getButtonById(4)
self.loadFavoriteButton = self.favsButtonGroup.getButtonById(5)
def _loadGroupBox2(self, pmGroupBox):
"""
Load widgets in group box.
"""
proteinStyleChoices = [
"CA trace (wire)",
"CA trace (cylinders)",
"CA trace (ball and stick)",
"Tube",
"Ladder",
"Zigzag",
"Flat ribbon",
"Solid ribbon",
"Cartoons",
"Fancy cartoons",
"Peptide tiles",
]
self.proteinStyleComboBox = PM_ComboBox(
pmGroupBox, label="Style:", choices=proteinStyleChoices, setAsDefault=True
)
scaleChoices = ["Constant", "Secondary structure", "B-factor"]
self.scaleComboBox = PM_ComboBox(pmGroupBox, label="Scaling:", choices=scaleChoices, setAsDefault=True)
self.scaleFactorDoubleSpinBox = PM_DoubleSpinBox(
pmGroupBox,
label="Scaling factor:",
value=1.00,
setAsDefault=True,
minimum=0.1,
maximum=3.0,
decimals=1,
singleStep=0.1,
)
self.splineDoubleSpinBox = PM_DoubleSpinBox(
pmGroupBox, label="Resolution:", value=4, setAsDefault=True, minimum=2, maximum=8, decimals=0, singleStep=1
)
self.smoothingCheckBox = PM_CheckBox(pmGroupBox, text="Smoothing", setAsDefault=True)
def _loadGroupBox3(self, pmGroupBox):
"""
Load widgets in group box.
"""
colorChoices = [
"Chunk",
"Chain",
"Order",
"Hydropathy",
"Polarity",
"Acidity",
"Size",
"Character",
"Number of contacts",
"Secondary structure type",
"Secondary structure order",
"B-factor",
"Occupancy",
"Custom",
]
self.proteinComponentComboBox = PM_ComboBox(
pmGroupBox, label="Color by:", choices=colorChoices, setAsDefault=True
)
colorList = [orange, yellow, red, magenta, cyan, blue, white, black, gray]
colorNames = ["Orange(default)", "Yellow", "Red", "Magenta", "Cyan", "Blue", "White", "Black", "Other color..."]
self.customColorComboBox = PM_ColorComboBox(
pmGroupBox, colorList=colorList, colorNames=colorNames, label="Custom:", color=orange, setAsDefault=True
)
colorChoices1 = [
"Same as main color",
"Chunk",
"Chain",
"Order",
"Hydropathy",
"Polarity",
"Acidity",
"Size",
"Character",
"Number of contacts",
"Secondary structure type",
"Secondary structure order",
"B-factor",
"Occupancy",
"Custom",
]
self.proteinAuxComponentComboBox = PM_ComboBox(
pmGroupBox, label="Aux:", choices=colorChoices1, setAsDefault=True
)
colorListAux = [orange, yellow, red, magenta, cyan, blue, white, black, gray]
colorNamesAux = [
"Orange(default)",
"Yellow",
"Red",
"Magenta",
"Cyan",
"Blue",
"White",
"Black",
"Other color...",
]
self.auxColorComboBox = PM_ColorComboBox(
pmGroupBox,
colorList=colorListAux,
colorNames=colorNamesAux,
label="Custom aux:",
color=gray,
setAsDefault=True,
)
self.discColorCheckBox = PM_CheckBox(pmGroupBox, text="Discretize colors", setAsDefault=True)
colorListHelix = [red, yellow, gray, magenta, cyan, blue, white, black, orange]
colorNamesHelix = [
"Red(default)",
"Yellow",
"Gray",
"Magenta",
"Cyan",
"Blue",
"White",
"Black",
"Other color...",
]
self.helixColorComboBox = PM_ColorComboBox(
pmGroupBox,
colorList=colorListHelix,
colorNames=colorNamesHelix,
label="Helix:",
color=red,
setAsDefault=True,
)
colorListStrand = [cyan, yellow, gray, magenta, red, blue, white, black, orange]
colorNamesStrand = [
"Cyan(default)",
"Yellow",
"Gray",
"Magenta",
"Red",
"Blue",
"White",
"Black",
"Other color...",
]
self.strandColorComboBox = PM_ColorComboBox(
pmGroupBox,
colorList=colorListStrand,
colorNames=colorNamesStrand,
label="Strand:",
color=cyan,
setAsDefault=True,
)
self.coilColorComboBox = PM_ColorComboBox(
pmGroupBox, colorList=colorListAux, colorNames=colorNamesAux, label="Coil:", color=orange, setAsDefault=True
)
def updateProteinDisplayStyleWidgets(self):
"""
Updates all the Protein Display style widgets based on the current pref keys
values
"""
self.proteinStyleComboBox.setCurrentIndex(env.prefs[proteinStyle_prefs_key])
self.splineDoubleSpinBox.setValue(env.prefs[proteinStyleQuality_prefs_key])
if env.prefs[proteinStyleSmooth_prefs_key] == True:
self.smoothingCheckBox.setCheckState(Qt.Checked)
else:
self.smoothingCheckBox.setCheckState(Qt.Unchecked)
self.scaleComboBox.setCurrentIndex(env.prefs[proteinStyleScaling_prefs_key])
self.scaleFactorDoubleSpinBox.setValue(env.prefs[proteinStyleScaleFactor_prefs_key])
self.proteinComponentComboBox.setCurrentIndex(env.prefs[proteinStyleColors_prefs_key])
self.customColorComboBox.setColor(env.prefs[proteinStyleCustomColor_prefs_key])
self.proteinAuxComponentComboBox.setCurrentIndex(env.prefs[proteinStyleAuxColors_prefs_key])
self.auxColorComboBox.setColor(env.prefs[proteinStyleAuxCustomColor_prefs_key])
if env.prefs[proteinStyleColorsDiscrete_prefs_key] == True:
self.discColorCheckBox.setCheckState(Qt.Checked)
else:
self.discColorCheckBox.setCheckState(Qt.Unchecked)
self.helixColorComboBox.setColor(env.prefs[proteinStyleHelixColor_prefs_key])
self.strandColorComboBox.setColor(env.prefs[proteinStyleStrandColor_prefs_key])
self.coilColorComboBox.setColor(env.prefs[proteinStyleCoilColor_prefs_key])
return
def applyFavorite(self):
# Rules and other info:
# The user has to press the button related to this method when he loads
# a previously saved favorite file
current_favorite = self.favoritesComboBox.currentText()
if current_favorite == "Factory default settings":
env.prefs.restore_defaults(proteinDisplayStylePrefsList)
else:
favfilepath = getFavoritePathFromBasename(current_favorite)
loadFavoriteFile(favfilepath)
self.updateProteinDisplayStyleWidgets()
return
def addFavorite(self):
# Rules and other info:
# - The new favorite is defined by the current Protein display style
# settings.
# - The user is prompted to type in a name for the new
# favorite.
# - The DNA display style settings are written to a file in a special
# directory on the disk
# (i.e. $HOME/Nanorex/Favorites/ProteinDisplayStyle/$FAV_NAME.txt).
# - The name of the new favorite is added to the list of favorites in
# the combobox, which becomes the current option.
# Existence of a favorite with the same name is checked in the above
# mentioned location and if a duplicate exists, then the user can either
# overwrite and provide a new name.
# Prompt user for a favorite name to add.
from widgets.simple_dialogs import grab_text_line_using_dialog
ok1, name = grab_text_line_using_dialog(
title="Add new favorite",
label="favorite name:",
iconPath="ui/actions/Properties Manager/AddFavorite.png",
default="",
)
if ok1:
# check for duplicate files in the
# $HOME/Nanorex/Favorites/DnaDisplayStyle/ directory
fname = getFavoritePathFromBasename(name)
if os.path.exists(fname):
# favorite file already exists!
_ext = ".txt"
ret = QMessageBox.warning(
self,
"Warning!",
'The favorite file "' + name + _ext + '"already exists.\n'
"Do you want to overwrite the existing file?",
"&Overwrite",
"&Cancel",
"",
0, # Enter == button 0
1,
) # Escape == button 1
if ret == 0:
# overwrite favorite file
ok2, text = writeProteinDisplayStyleSettingsToFavoritesFile(name)
indexOfDuplicateItem = self.favoritesComboBox.findText(name)
self.favoritesComboBox.removeItem(indexOfDuplicateItem)
print "Add Favorite: removed duplicate favorite item."
else:
env.history.message("Add Favorite: cancelled overwriting favorite item.")
return
else:
ok2, text = writeProteinDisplayStyleSettingsToFavoritesFile(name)
else:
# User cancelled.
return
if ok2:
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
msg = "New favorite [%s] added." % (text)
else:
msg = "Can't add favorite [%s]: %s" % (name, text) # text is reason why not
env.history.message(msg)
return
def deleteFavorite(self):
currentIndex = self.favoritesComboBox.currentIndex()
currentText = self.favoritesComboBox.currentText()
if currentIndex == 0:
msg = "Cannot delete '%s'." % currentText
else:
self.favoritesComboBox.removeItem(currentIndex)
# delete file from the disk
deleteFile = getFavoritePathFromBasename(currentText)
os.remove(deleteFile)
msg = "Deleted favorite named [%s].\n" "and the favorite file [%s.txt]." % (currentText, currentText)
env.history.message(msg)
return
def saveFavorite(self):
cmd = greenmsg("Save Favorite File: ")
env.history.message(greenmsg("Save Favorite File:"))
current_favorite = self.favoritesComboBox.currentText()
favfilepath = getFavoritePathFromBasename(current_favorite)
formats = "Favorite (*.txt);;" "All Files (*.*)"
directory = self.currentWorkingDirectory
saveLocation = directory + "/" + current_favorite + ".txt"
fn = QFileDialog.getSaveFileName(
self,
"Save Favorite As", # caption
favfilepath, # where to save
formats, # file format options
QString("Favorite (*.txt)"), # selectedFilter
)
if not fn:
env.history.message(cmd + "Cancelled")
else:
dir, fil = os.path.split(str(fn))
self.setCurrentWorkingDirectory(dir)
saveFavoriteFile(str(fn), favfilepath)
return
def setCurrentWorkingDirectory(self, dir=None):
if os.path.isdir(dir):
self.currentWorkingDirectory = dir
self._setWorkingDirectoryInPrefsDB(dir)
else:
self.currentWorkingDirectory = getDefaultWorkingDirectory()
def _setWorkingDirectoryInPrefsDB(self, workdir=None):
if not workdir:
return
workdir = str(workdir)
if os.path.isdir(workdir):
workdir = os.path.normpath(workdir)
env.prefs[workingDirectory_prefs_key] = workdir # Change pref in prefs db.
else:
msg = "[" + workdir + "] is not a directory. Working directory was not changed."
env.history.message(redmsg(msg))
return
def loadFavorite(self):
# If the file already exists in the favorites folder then the user is
# given the option of overwriting it or renaming it
env.history.message(greenmsg("Load Favorite File:"))
formats = "Favorite (*.txt);;" "All Files (*.*)"
directory = self.currentWorkingDirectory
if directory == "":
directory = getDefaultWorkingDirectory()
fname = QFileDialog.getOpenFileName(self, "Choose a file to load", directory, formats)
if not fname:
env.history.message("User cancelled loading file.")
return
else:
dir, fil = os.path.split(str(fname))
self.setCurrentWorkingDirectory(dir)
canLoadFile = loadFavoriteFile(fname)
if canLoadFile == 1:
# get just the name of the file for loading into the combobox
favName = os.path.basename(str(fname))
name = favName[0 : len(favName) - 4]
indexOfDuplicateItem = self.favoritesComboBox.findText(name)
# duplicate exists in combobox
if indexOfDuplicateItem != -1:
ret = QMessageBox.warning(
self,
"Warning!",
'The favorite file "' + name + '"already exists.\n'
"Do you want to overwrite the existing file?",
"&Overwrite",
"&Rename",
"&Cancel",
0, # Enter == button 0
1, # button 1
)
if ret == 0:
self.favoritesComboBox.removeItem(indexOfDuplicateItem)
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
ok2, text = writeProteinDisplayStyleSettingsToFavoritesFile(name)
msg = "Overwrote favorite [%s]." % (text)
env.history.message(msg)
elif ret == 1:
# add new item to favorites folder as well as combobox
self.addFavorite()
else:
# reset the display setting values to factory default
factoryIndex = self.favoritesComboBox.findText("Factory default settings")
self.favoritesComboBox.setCurrentIndex(factoryIndex)
env.prefs.restore_defaults(proteinDisplayStylePrefsList)
env.history.message("Cancelled overwriting favorite file.")
return
else:
self.favoritesComboBox.addItem(name)
_lastItem = self.favoritesComboBox.count()
self.favoritesComboBox.setCurrentIndex(_lastItem - 1)
msg = "Loaded favorite [%s]." % (name)
env.history.message(msg)
self.updateProteinDisplayStyleWidgets()
return
def _addWhatsThisText(self):
from ne1_ui.WhatsThisText_for_PropertyManagers import WhatsThis_EditDnaDisplayStyle_PropertyManager
WhatsThis_EditDnaDisplayStyle_PropertyManager(self)
def _addToolTipText(self):
from ne1_ui.ToolTipText_for_PropertyManagers import ToolTip_EditProteinDisplayStyle_PropertyManager
ToolTip_EditProteinDisplayStyle_PropertyManager(self)