title: PyQt - How to turn on/off spellchecking
body: <p>I'm using the following as a basis for my editor's spellchecker. I want to make an auto-spellcheck button, which when pressed will make the spellchecker work, and when not pressed, the spellchecker should not highlight or suggest anything. You know the one similar to LibreOffice/OpenOffice auto-spelcheck toolbar button?</p>
  
  <p>I can make the button work, no problem. My problem is what should I do with the highlighter? If the highlighter class is created when the button is pressed, what do I do when the button is not pressed? Killing/destroying the highlighter class doesn't work. </p>
  
  <p>I found how to turn the context menu off:</p>
  
  <pre><code>if self.actionSpellCheck.isChecked(): #This is my auto-spellchecking button
      popup_menu.exec_(event.globalPos())
  </code></pre>
  
  <p>OK, I got it, to turn off highlighting I just need to set the highlighter dictionary to None:</p>
  
  <pre><code>self.highlighter.setDict(None)
  </code></pre>
  
  <p>and to turn it on again, just set the dictionary back to the highlighter:</p>
  
  <pre><code>self.highlighter.setDict(self.dict)
  </code></pre>
  
  <p>Thank you.</p>
  
  <p>Here's the original code below to which I added a toolbar with a button:</p>
  
  <pre><code>__license__ = 'MIT'
  __copyright__ = '2009, John Schember '
  __docformat__ = 'restructuredtext en'
  
  import re
  import sys
  
  import enchant
  
  from PyQt4.Qt import QAction
  from PyQt4.Qt import QApplication
  from PyQt4.Qt import QEvent
  from PyQt4.Qt import QMenu
  from PyQt4.Qt import QMouseEvent
  from PyQt4.Qt import QPlainTextEdit
  from PyQt4.Qt import QSyntaxHighlighter
  from PyQt4.Qt import QTextCharFormat
  from PyQt4.Qt import QTextCursor
  from PyQt4.Qt import Qt
  from PyQt4.QtCore import pyqtSignal
  
  class SpellTextEdit(QPlainTextEdit):
  
      def __init__(self, *args):
          QPlainTextEdit.__init__(self, *args)
  
          # Default dictionary based on the current locale.
          self.dict = enchant.Dict("ru_RU")
          self.highlighter = Highlighter(self.document())
          self.highlighter.setDict(self.dict)
  
      def mousePressEvent(self, event):
          if event.button() == Qt.RightButton:
              # Rewrite the mouse event to a left button event so the cursor is
              # moved to the location of the pointer.
              event = QMouseEvent(QEvent.MouseButtonPress, event.pos(),
                  Qt.LeftButton, Qt.LeftButton, Qt.NoModifier)
          QPlainTextEdit.mousePressEvent(self, event)
  
      def contextMenuEvent(self, event):
          popup_menu = self.createStandardContextMenu()
  
          # Select the word under the cursor.
          cursor = self.textCursor()
          cursor.select(QTextCursor.WordUnderCursor)
          self.setTextCursor(cursor)
  
          # Check if the selected word is misspelled and offer spelling
          # suggestions if it is.
          if self.textCursor().hasSelection():
              text = unicode(self.textCursor().selectedText())
              if not self.dict.check(text):
                  spell_menu = QMenu('Spelling Suggestions')
                  for word in self.dict.suggest(text):
                      action = SpellAction(word, spell_menu)
                      action.correct.connect(self.correctWord)
                      spell_menu.addAction(action)
                  # Only add the spelling suggests to the menu if there are
                  # suggestions.
                  if len(spell_menu.actions()) != 0:
                      popup_menu.insertSeparator(popup_menu.actions()[0])
                      popup_menu.insertMenu(popup_menu.actions()[0], spell_menu)
  
          popup_menu.exec_(event.globalPos())
  
      def correctWord(self, word):
          '''
          Replaces the selected text with word.
          '''
          cursor = self.textCursor()
          cursor.beginEditBlock()
  
          cursor.removeSelectedText()
          cursor.insertText(word)
  
          cursor.endEditBlock()
  
  
  class Highlighter(QSyntaxHighlighter):
  
      WORDS = u'(?iu)[\w\']+'
  
      def __init__(self, *args):
          QSyntaxHighlighter.__init__(self, *args)
  
          self.dict = None
  
      def setDict(self, dict):
          self.dict = dict
  
      def highlightBlock(self, text):
          if not self.dict:
              return
  
          text = unicode(text)
  
          format = QTextCharFormat()
          format.setUnderlineColor(Qt.red)
          format.setUnderlineStyle(QTextCharFormat.SpellCheckUnderline)
  
          for word_object in re.finditer(self.WORDS, text):
              if not self.dict.check(word_object.group()):
                  self.setFormat(word_object.start(),
                      word_object.end() - word_object.start(), format)
  
  
  class SpellAction(QAction):
  
      '''
      A special QAction that returns the text in a signal.
      '''
  
      correct = pyqtSignal(unicode)
  
      def __init__(self, *args):
          QAction.__init__(self, *args)
  
          self.triggered.connect(lambda x: self.correct.emit(
              unicode(self.text())))
  
  
  def main(args=sys.argv):
      app = QApplication(args)
  
      spellEdit = SpellTextEdit()
      spellEdit.show()
  
      return app.exec_()
  
  if __name__ == '__main__':
      sys.exit(main())
  </code></pre>