# Copyright 2008 Nanorex, Inc. See LICENSE file for details.
"""
ProteinSequenceEditor.py
@copyright: 2008 Nanorex, Inc. See LICENSE file for details.
@version: $Id$
@author: Urmi
History:
Urmi copied this from DnaSequenceEditor.py and modified it to suit the
requirements of a protein sequence editor.
"""
import foundation.env as env
import os
import re
import string
from PyQt4.Qt import SIGNAL
from PyQt4.Qt import QTextCursor
from PyQt4.Qt import QString
from PyQt4.Qt import QFileDialog
from PyQt4.Qt import QMessageBox
from PyQt4.Qt import QRegExp
from PyQt4.Qt import QTextDocument
from PyQt4.Qt import QPalette
from PM.PM_Colors import getPalette
from PM.PM_Colors import sequenceEditorNormalColor
from PM.PM_Colors import sequenceEditorChangedColor
from utilities.prefs_constants import workingDirectory_prefs_key
from protein.ProteinSequenceEditor.Ui_ProteinSequenceEditor import Ui_ProteinSequenceEditor
from utilities import debug_flags
from utilities.debug import print_compact_stack
class ProteinSequenceEditor(Ui_ProteinSequenceEditor):
"""
Creates a dockable protein sequence editor.
"""
validSymbols = QString(' <>~!@#%&_+`=$*()[]{}|^\'"\\.;:,/?')
sequenceFileName = None
current_protein = None # The current protein chunk.
_sequence_changed = False # Set to True when the sequence has been changed by the user.
_previousSequence = "" # The previous sequence, just before the user changed it.
def __init__(self, win):
"""
Creates a dockable protein sequence editor
"""
Ui_ProteinSequenceEditor.__init__(self, win)
self.isAlreadyConnected = False
self.isAlreadyDisconnected = False
self._suppress_textChanged_signal = False
self._suppress_cursorPosChanged_signal = False
self.connect_or_disconnect_signals(True)
self.win = win
self.maxSeqLength = 0
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 and self.isAlreadyConnected:
if debug_flags.atom_debug:
print_compact_stack("warning: attempt to connect widgets"\
"in this PM that are already connected." )
return
if not isConnect and self.isAlreadyDisconnected:
if debug_flags.atom_debug:
print_compact_stack("warning: attempt to disconnect widgets"\
"in this PM that are already disconnected.")
return
self.isAlreadyConnected = isConnect
self.isAlreadyDisconnected = not isConnect
if isConnect:
change_connect = self.win.connect
else:
change_connect = self.win.disconnect
change_connect(self.loadSequenceButton,
SIGNAL("clicked()"),
self._open_FASTA_File)
change_connect(self.saveSequenceButton,
SIGNAL("clicked()"),
self._savePeptideSequence)
change_connect( self.sequenceTextEdit,
SIGNAL("textChanged()"),
self._sequenceChanged )
change_connect( self.sequenceTextEdit,
SIGNAL("editingFinished()"),
self._assignPeptideSequence )
change_connect( self.sequenceTextEdit,
SIGNAL("cursorPositionChanged()"),
self._cursorPosChanged)
change_connect( self.findLineEdit,
SIGNAL("textEdited(const QString&)"),
self.findLineEdit_textEdited)
change_connect( self.findNextToolButton,
SIGNAL("clicked()"),
self.findNext)
change_connect( self.findPreviousToolButton,
SIGNAL("clicked()"),
self.findPrevious)
change_connect( self.replacePushButton,
SIGNAL("clicked()"),
self.replace)
return
def update_state(self, bool_enable = True):
"""
Update the state of this widget by enabling or disabling it depending
upon the flag bool_enable.
@param bool_enable: If True , enables the widgets inside the sequence
editor
@type bool_enable: boolean
"""
for widget in self.children():
if hasattr(widget, 'setEnabled'):
if widget.__class__.__name__ != 'QAbstractButton':
widget.setEnabled(bool_enable)
return
def _sequenceChanged( self ):
"""
Slot for the Protein Sequence textedit widget. (private method)
Assumes the sequence changed directly by user's keystroke in the
textedit. Other methods...
"""
if self._suppress_textChanged_signal:
return
self._suppress_textChanged_signal = True
cursorPos = self.getCursorPosition()
theSequence = self.getPlainSequence()
if len(theSequence) == len(self._previousSequence):
# Replace space characters with the same character.
aa = self._previousSequence[cursorPos - 1]
theSequence.replace(" ", aa)
print "The last character was replaced with: ", aa
# Insert the sequence; it will be "stylized" by _setSequence().
self._setSequence(theSequence, inCursorPos = cursorPos)
if False: # Set to True for debugging statements.
if theSequence == self._previousSequence:
print "The sequence did not change (YOU SHOULD NEVER SEE THIS)."
elif len(theSequence) < len(self._previousSequence):
print "Character(s) were deleted from the sequence."
elif len(theSequence) == len(self._previousSequence):
print "A character was replaced. The sequence length is the same."
else:
print "Character(s) where added to the sequence."
pass
# If the sequence in the text edit (field) is different from the current
# sequence, change the sequence field bg color to pink to
# indicate that the sequence is different. If they are the same,
# change the sequence field background (back) to white.
if theSequence != self.current_protein.protein.get_sequence_string():
self._sequence_changed = True
else:
self._sequence_changed = False
self._previousSequence = theSequence
self._updateSequenceBgColor()
#Urmi 20080725: Some time later we need to have a method here which
#would allow us to set the sequence of the protein chunk. We will also
#update the secondary structure sequence or will it be the same as the
#original one?
self._suppress_textChanged_signal = False
return
def _assignPeptideSequence(self):
"""
(private)
Slot for the "editingFinished()" signal generated by the PM_TextEdit
whenever the user presses the Enter key in the sequence text edit field.
Assigns the amino acid sequence in the sequence editor text field to
the current protein.
@attention: this method is not implemented yet. If called, it will
display a messagebox warning the user that this is not implement yet.
"""
if not self.current_protein:
return
sequenceString = self.getPlainSequence()
sequenceString = str(sequenceString)
#assign sequence only if it not the same as the current sequence
seq = self.current_protein.protein.get_sequence_string()
if seq != sequenceString:
#self.current_protein.setSequence(sequenceString)
#self.updateSequence(cursorPos = self.getCursorPosition())
msg = "We are sorry. You cannot change the sequence since "\
"this feature is not yet supported."
QMessageBox.warning(self.win, "Warning!", msg)
self._suppress_textChanged_signal = False
self.updateSequence(self.current_protein)
return
def _updateSequenceBgColor(self):
"""
Updates the sequence field background color
(pink = changed, white = unchanged).
"""
if self._sequence_changed:
bgColor = sequenceEditorChangedColor
else:
bgColor = sequenceEditorNormalColor
palette = getPalette(None,
QPalette.Base,
bgColor)
self.sequenceTextEdit.setPalette(palette)
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 Protein sequence in the PM.
@rtype: QString
"""
outSequence = self.sequenceTextEdit.toPlainText()
outSequence = outSequence.toUpper()
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 clear( self ):
"""
Clears the sequence editor.
"""
self.current_protein = None
self._setSequenceAndStructure("", "")
return
def _setSequenceAndStructure(self,
inSequence,
inStructure,
inCursorPos = -1):
"""
Sets the sequence, structure and ruler fields in the sequence editor.
@param inSequence: The sequence string.
@type inSequence: QString
@param inStructure: The secondary structure string.
@type inStructure: QString
@param inCursorPos: the position in the sequence in which to place the
cursor. If cursorPos is negative, the cursor position
is placed at first residue of the sequence (default).
@type inCursorPos: int
"""
#NOTE: It is important that sequence is set last so that setCursorPos()
#doesn't complain (i.e. the structure and ruler strings must be
#equal to the length of the sequence string before setting the cursor
# position). --Mark 2008-12-20
self._setSecondaryStructure(inStructure)
self._setRuler(len(inSequence))
self._setSequence(inSequence, inCursorPos = inCursorPos)
return
def _setSequence( self,
inSequence,
inStylize = True,
inCursorPos = -1
):
"""
Replace the current amino acid sequence with the new sequence text.
(private method)
Callers outside this class wishing to update the amino acid sequence
field should call updateSequence().
@param inSequence: The sequence string.
@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 inCursorPos: the position in the sequence in which to place the
cursor. If cursorPos is negative, the cursor position
is placed at first residue of the sequence (default).
@type inCursorPos: int
@see: updateSequence()
"""
seq = str(inSequence)
seq = seq.upper()
htmlSequence = self._convertProteinSequenceToColoredSequence(seq)
if inStylize:
htmlSequence = self._fixedPitchSequence(htmlSequence)
self._suppress_textChanged_signal = True
self._suppress_cursorPosChanged_signal = True
self.sequenceTextEdit.setHtml(htmlSequence) # Generates cursorPosChanged signal!
self.setCursorPosition(inCursorPos = inCursorPos)
self._suppress_textChanged_signal = False
self._suppress_cursorPosChanged_signal = False
return
def _getFormattedSequence(self, inSequence):
"""
Create formatted sequence to be used by secondary structure text edit
@param inSequence: The new sequence.
@type inSequence: QString
"""
colorList = ['Red','Blue', 'Green']
secStrucList = ['H','E', '-']
secStrucDict = dict(zip(secStrucList, colorList))
outSequence = ""
for i in range(len(inSequence)):
currentAA = inSequence[i]
color = secStrucDict[currentAA]
outSequence = outSequence + ""
outSequence = outSequence + currentAA + ""
#Now put html tags and make everything bold
fixedPitchSequence = "" + outSequence
fixedPitchSequence += ""
return fixedPitchSequence
def _setSecondaryStructure(self, inStructure):
"""
Set the secondary structure of the protein. (private method)
Callers outside this class wishing to update the secondary structure
field should call updateSequence().
@param inStructure: The structure string.
@type inStructure: QString
@see: updateSequence()
"""
fixedPitchSequence = self._getFormattedSequence(inStructure)
self.secStrucTextEdit.setHtml(fixedPitchSequence)
return
def getRulerText(self, lengthOfSeq):
"""
Return the ruler text given I{lengthOfSeq} (i.e. the length of the
current sequence).
"""
rulerText = ""
i = 0
while i < lengthOfSeq:
if i == 0:
rulerText = "1"
i = i + 1
elif i % 10 == 0 and i % 5 == 0:
rulerText = rulerText + str(i+1)
if len(str(i+1)) == 2:
i = i + 2
continue
elif len(str(i+1)) == 3:
i = i + 3
else:
i = i + 1
continue
elif i % 5 == 0 and i % 10 != 0:
rulerText = rulerText + "*"
i = i + 1
else:
rulerText = rulerText + "-"
i = i + 1
return rulerText
def _setRuler(self, lengthOfSeq):
"""
Set the sequence ruler with a length of I{lengthOfSeq}.
Callers outside this class wishing to update the ruler
should call updateSequence().
@param lengthOfSeq: length of the sequence.
@type lengthOfSeq: int
@note: supports up to 3 digits (i.e. max length of 999).
"""
rulerText = self.getRulerText(lengthOfSeq)
fixedPitchSequence = "" + rulerText
fixedPitchSequence += ""
self.aaRulerTextEdit.setHtml(fixedPitchSequence)
return
def _convertProteinSequenceToColoredSequence(self, inSequence):
"""
Create formatted sequence to be used by the sequence editor
@param inSequence: The new sequence.
@type inSequence: QString
"""
outSequence = ""
colorList = ['Crimson', 'CadetBlue', 'Coral', 'DarkCyan', 'DarkGray',
'DarkGoldenRod', 'DarkOliveGreen', 'BlueViolet', 'Red',
'Chocolate', 'DarkKhaki', 'DarkSalmon', 'DarkSeaGreen',
'FireBrick', 'HotPink', 'LawnGreen', 'IndianRed', 'Indigo',
'LightCoral', 'LightBlue', 'Khaki']
aaList = ['A', 'V', 'X', 'Y', 'W', 'T', 'S', 'P', 'F', 'M', 'K', 'L', 'I'
'H', 'G', 'Q', 'E', 'C', 'R', 'N', 'D' ]
aaDict = dict(zip(aaList, colorList))
for i in range(len(inSequence)):
currentAA = inSequence[i]
try:
color = aaDict[currentAA]
except KeyError:
color = aaDict['X']
outSequence = outSequence + ""
outSequence = outSequence + currentAA + ""
return outSequence
def _colorExtraSequenceCharacters(self, inSequence):
"""
Returns I{inSequence} with html tags that color any extra overhang
characters gray.
@param inSequence: The sequence.
@type inSequence: QString
@return: inSequence with the html tags to color any overhang characters.
@rtype: string
"""
aaLength = self.current_protein.protein.count_amino_acids()
if len(inSequence) <= aaLength:
return inSequence
sequence = inSequence[:aaLength]
overhang = inSequence[aaLength:]
return sequence + "" + overhang + ""
def _fixedPitchSequence(self, sequence):
"""
Make the sequence 'fixed-pitched' i.e. width of all characters
should be constance
@param sequence: The new sequence.
@type sequence: QString
"""
fixedPitchSequence = "" + sequence
fixedPitchSequence += ""
return fixedPitchSequence
def getSequenceLength( self ):
"""
Returns the number of characters in the sequence textedit widget.
"""
theSequence = self.getPlainSequence( inOmitSymbols = True )
outLength = theSequence.length()
return outLength
def updateSequence(self, proteinChunk = None, inCursorPos = -1):
"""
Updates the sequence editor with the sequence of I{proteinChunk}.
@param proteinChunk: the protein chunk. If proteinChunk is None
(default), the sequence editor is cleared.
@type proteinChunk: protein Chunk
@param inCursorPos: the position in the sequence in which to place the
cursor. If cursorPos is negative, the cursor position
is placed at first residue of the sequence (default).
@type inCursorPos: int
"""
if proteinChunk:
assert isinstance(proteinChunk, self.win.assy.Chunk) and \
proteinChunk.isProteinChunk()
self.current_protein = proteinChunk
else:
# Use self.current_protein. Make sure it's not None.
#assert isinstance(self.current_protein, self.win.assy.Chunk) and \
#proteinChunk.isProteinChunk()
self.clear()
return
# We have a protein chunk. Update the editor with its sequence.
sequence = self.current_protein.protein.get_sequence_string()
structure = self.current_protein.protein.get_secondary_structure_string()
self._setSequenceAndStructure(sequence, structure, inCursorPos = inCursorPos)
# Update the bg color to white.
self._sequence_changed = False
self._previousSequence = sequence
self._updateSequenceBgColor()
# Update window title with name of current protein.
titleString = 'Sequence Editor for ' + self.current_protein.name
self.setWindowTitle(titleString)
if not self.isVisible():
#Show the sequence editor if it isn't visible.
#ATTENTION: the sequence editor will (temporarily) close the
#Reports dockwidget (if it is visible). The Reports dockwidget
#is restored when the sequence Editor is closed.
self.show()
return
def setCursorPosition(self, inCursorPos = -1):
"""
Set the cursor position to I{cursorPos} in the sequence textedit widget.
@param inCursorPos: the position in the sequence in which to place the
cursor. If cursorPos is negative, the cursor position
is placed at the beginning of the sequence (default).
@type inCursorPos: int
"""
# Make sure cursorPos is in the valid range.
if inCursorPos < 0:
cursorPos = 0
anchorPos = 1
elif inCursorPos >= self.getSequenceLength():
cursorPos = self.getSequenceLength() - 1
anchorPos = self.getSequenceLength()
else:
cursorPos = inCursorPos
anchorPos = inCursorPos + 1
# Useful print statements for debugging.
if 0:
print "setCursorPosition(): Sequence=", self.getPlainSequence()
print "Final inCursorPos=%d\ncursorPos=%d, anchorPos=%d" % \
(inCursorPos, cursorPos, anchorPos)
self._suppress_cursorPosChanged_signal = True
# Finally, set the cursor position in the sequence.
cursor = self.sequenceTextEdit.textCursor()
cursor.setPosition(anchorPos, QTextCursor.MoveAnchor)
cursor.setPosition(cursorPos, QTextCursor.KeepAnchor)
self.sequenceTextEdit.setTextCursor( cursor )
cursorMate = self.secStrucTextEdit.textCursor()
cursorMate.setPosition(anchorPos, QTextCursor.MoveAnchor)
cursorMate.setPosition(cursorPos, QTextCursor.KeepAnchor)
self.secStrucTextEdit.setTextCursor( cursorMate )
cursorMate2 = self.aaRulerTextEdit.textCursor()
cursorMate2.setPosition(anchorPos, QTextCursor.MoveAnchor)
cursorMate2.setPosition(cursorPos, QTextCursor.KeepAnchor)
self.aaRulerTextEdit.setTextCursor( cursorMate2 )
self._updateToolTip()
self._suppress_cursorPosChanged_signal = False
return
def getCursorPosition( self ):
"""
Returns the cursor position in the sequence textedit widget.
"""
cursor = self.sequenceTextEdit.textCursor()
return cursor.position()
def _cursorPosChanged( self ):
"""
Slot called when the cursor position of the sequence textEdit changes.
When this happens, this method also changes the cursor position
of the 'Mate' text edit. Because of this, both the text edit widgets
in the Sequence Editor scroll 'in sync'.
"""
if self._suppress_cursorPosChanged_signal:
return
cursor = self.sequenceTextEdit.textCursor()
cursorPos = cursor.position()
if 0:
print "_cursorPosChanged(): cursorPos=", cursorPos
self.setCursorPosition(inCursorPos = cursorPos) # sets all three.
# Provide amino acid info as cursor position changes
env.history.statusbar_msg("")
current_command = self.win.commandSequencer.currentCommand
commandSet = ('EDIT_PROTEIN', 'EDIT_RESIDUES')
if current_command.commandName not in commandSet:
return
aa_index = min(cursorPos, self.getSequenceLength() - 1)
if current_command.commandName == 'EDIT_PROTEIN':
current_command.propMgr.setCurrentAminoAcid(aa_index)
if current_command.commandName == 'EDIT_RESIDUES':
current_command.propMgr._sequenceTableCellChanged(aa_index, 0)
current_command.propMgr.sequenceTable.setCurrentCell(aa_index, 3)
self._updateToolTip()
return
def _updateToolTip(self):
"""
Update the tooltip text (and status bar) with the current residue id.
"""
aa_index = self.current_protein.protein.get_current_amino_acid_index()
aa_info = self.current_protein.protein.get_amino_acid_id(aa_index)
aa_id, residue_id = aa_info.strip().split(":")
toolTipText = residue_id
self.sequenceTextEdit.setToolTip(str(toolTipText))
env.history.statusbar_msg(toolTipText)
return
def _display_and_recenter(self, index):
"""
Display and recenter the view on the current amino acid under the cursor
in the text edit
@param index: index of amino acid under cursor in sequence text edit
@type index: int
@note: this method has no callers. It will likely be moved to
EditResidues_PM soon. -Mark 2008-12-20
"""
chunk = self.current_protein
chunk.protein.collapse_all_rotamers()
current_aa = chunk.protein.get_amino_acid_at_index(index)
if current_aa:
if self.win.commandSequencer.currentCommand.commandName == 'EDIT_RESIDUES':
checked = self.win.commandSequencer.currentCommand.propMgr.recenterViewCheckBox.isChecked()
if checked:
ca_atom = current_aa.get_c_alpha_atom()
if ca_atom:
self.win.glpane.pov = -ca_atom.posn()
self.win.glpane.gl_update()
return
def _open_FASTA_File(self):
"""
Open (read) the user specified FASTA sequence file and load it into
the sequence field.
@TODO: It only reads in the first line of the file. Also, it doesn't
handle any special cases. (Once the special cases are clearly
defined, that functionality will be added.
@attention: This is not implemented yet.
"""
#Urmi 20080714: should not this be only fasta file, for both load and save
if self.parentWidget.assy.filename:
odir = os.path.dirname(self.parentWidget.assy.filename)
else:
odir = env.prefs[workingDirectory_prefs_key]
self.sequenceFileName = \
str(QFileDialog.getOpenFileName(
self,
"Load FASTA sequence for " + self.current_protein.name,
odir,
"FASTA file (*.txt);;All Files (*.*);;"))
lines = self.sequenceFileName
try:
lines = open(self.sequenceFileName, "rU").readlines()
except:
print "Exception occurred to open file: ", self.sequenceFileName
return
sequence = lines[0]
sequence = QString(sequence)
sequence = sequence.toUpper()
self._setSequence(sequence)
return
def _write_FASTA_File(self, fileName, sequence):
"""
Writes I{sequence} in FASTA format to I{filename}.
@param fileName: full path of the file.
@type fileName: str
@param sequence: AA sequence to be saved in FASTA format.
@type sequence: str
@attention: The sequence is not written in FASTA format yet.
@TODO: Write sequence in FASTA format.
"""
try:
f = open(fileName, "w")
except:
print "Exception occurred to open file %s to write: " % fileName
return None
f.write(str(sequence))
f.close()
return
def _savePeptideSequence(self):
"""
Save the current sequence (displayed in the sequence field) in FASTA
format in the specified file.
"""
if not self.sequenceFileName:
sdir = env.prefs[workingDirectory_prefs_key]
else:
sdir = self.sequenceFileName
fileName = QFileDialog.getSaveFileName(
self,
"Save Sequence As ...",
sdir,
"FASTA File (*.txt)"
)
if fileName:
fileName = str(fileName)
if fileName[-4] != '.':
fileName += '.txt'
if os.path.exists(fileName):
# ...and if the "Save As" file exists...
# ... confirm overwrite of the existing file.
ret = QMessageBox.warning(
self,
"Save Sequence...",
"The file \"" + fileName + "\" already exists.\n"\
"Do you want to overwrite the existing file or cancel?",
"&Overwrite", "&Cancel", "",
0, # Enter == button 0
1 ) # Escape == button 1
if ret == 1:
# The user cancelled
return
# write the current set of element colors into a file
self._write_FASTA_File(
fileName,
str(self.sequenceTextEdit.toPlainText()))
return
# ==== Methods to support find and replace.
# Should this (find and replace) be in its own class? -- Ninad 2007-11-28
def findNext(self):
"""
Find the next occurence of the search string in the sequence
"""
self._findNextOrPrevious()
return
def findPrevious(self):
"""
Find the previous occurence of the search string in the sequence
"""
self._findNextOrPrevious(findPrevious = True)
return
def _findNextOrPrevious(self, findPrevious = False):
"""
Find the next or previous matching string depending on the
findPrevious flag. It also considers into account various findFlags
user might have set (e.g. case sensitive search)
@param findPrevious: If true, this method will find the previous
occurance of the search string.
@type findPrevious: boolean
"""
findFlags = QTextDocument.FindFlags()
if findPrevious:
findFlags |= QTextDocument.FindBackward
if self.caseSensitiveFindAction.isChecked():
findFlags |= QTextDocument.FindCaseSensitively
if not self.sequenceTextEdit.hasFocus():
self.sequenceTextEdit.setFocus()
searchString = self.findLineEdit.text()
cursor = self.sequenceTextEdit.textCursor()
found = self.sequenceTextEdit.find(searchString, findFlags)
#May be the cursor reached the end of the document, set it at position 0
#to redo the search. This makes sure that the search loops over as
#user executes findNext multiple times.
if not found:
if findPrevious:
sequence_QString = self.sequenceTextEdit.toPlainText()
newCursorStartPosition = sequence_QString.length()
else:
newCursorStartPosition = 0
cursor.setPosition( newCursorStartPosition,
QTextCursor.MoveAnchor)
self.sequenceTextEdit.setTextCursor(cursor)
found = self.sequenceTextEdit.find(searchString, findFlags)
#Display or hide the warning widgets (that say 'sequence not found'
#based on the boolean 'found'
self._toggleWarningWidgets(found)
return
def _toggleWarningWidgets(self, found):
"""
If the given searchString is not found in the sequence string, toggle
the display of the 'sequence not found' warning widgets. Also enable
or disable the 'Replace' button accordingly
@param found: Flag that decides whether to sho or hide warning
@type found: boolean
@see: self.findNext, self.findPrevious
"""
if not found:
self.findLineEdit.setStyleSheet(self._getFindLineEditStyleSheet())
self.phraseNotFoundLabel.show()
self.warningSign.show()
self.replacePushButton.setEnabled(False)
else:
self.findLineEdit.setStyleSheet("")
self.phraseNotFoundLabel.hide()
self.warningSign.hide()
self.replacePushButton.setEnabled(True)
return
def findLineEdit_textEdited(self, searchString):
"""
Slot method called whenever the text in the findLineEdit is edited
*by the user* (and not by the setText calls). This is useful in
dynamically searching the string as it gets typed in the findLineedit.
@param searchString: string that is searched for
@type searchString: str
"""
self.findNext()
#findNext sets the focus inside the sequenceTextEdit. So set it back to
#to the findLineEdit to permit entering more characters.
if not self.findLineEdit.hasFocus():
self.findLineEdit.setFocus()
return
def replace(self):
"""
Find a string matching the searchString given in the findLineEdit and
replace it with the string given in the replaceLineEdit.
"""
searchString = self.findLineEdit.text()
replaceString = self.replaceLineEdit.text()
sequence = self.sequenceTextEdit.toPlainText()
#Its important to set focus on the sequenceTextEdit otherwise,
#cursor.setPosition and setTextCursor won't have any effect
if not self.sequenceTextEdit.hasFocus():
self.sequenceTextEdit.setFocus()
cursor = self.sequenceTextEdit.textCursor()
selectionStart = cursor.selectionStart()
selectionEnd = cursor.selectionEnd()
sequence.replace( selectionStart,
(selectionEnd - selectionStart),
replaceString )
cursor.setPosition((selectionEnd -1), QTextCursor.MoveAnchor)
self.sequenceTextEdit.setTextCursor(cursor)
#Set the sequence in the text edit.
self._setSequence(sequence)
#Find the next occurance of the 'seqrchString' in the sequence.
self.findNext()
return