def toggle_codecompletion(self, checked):
     """Toggle automatic code completion"""
     if self.tabwidget is None:
         return
     for shell in self.shells:
         shell.shell.set_codecompletion_auto(checked)
     CONF.set(self.ID, 'codecompletion/auto', checked)

 def toggle_codecompletion_enter(self, checked):
     """Toggle Enter key for code completion"""
     if self.tabwidget is None:
         return
     for shell in self.shells:
         shell.shell.set_codecompletion_enter(checked)
     CONF.set(self.ID, 'autocompletion/enter-key', checked)

 def open_interpreter_at_startup(self):
     """Open an interpreter at startup, IPython if module is available"""
     if CONF.get(self.ID, 'open_ipython_at_startup') \
        and programs.is_module_installed("IPython"):
         self.open_ipython()
     if CONF.get(self.ID, 'open_python_at_startup'):
         self.open_interpreter()

 def toggle_wrap_mode(self, checked):
     """Toggle wrap mode"""
     if self.tabwidget is None:
         return
     for shell in self.shells:
         shell.shell.toggle_wrap_mode(checked)
     CONF.set(self.ID, 'wrap', checked)

 def option_changed(self, option, value):
     """
     Change a plugin option in configuration file
     Use a SIGNAL to call it, e.g.:
     self.emit(SIGNAL('option_changed'), 'show_all', checked)
     """
     CONF.set(self.ID, option, value)

    def run(self, session):
        from spyderlib import spyder
        from spyderlib.config import CONF

        cs.exit_if_not_exists(session)
        app = spyder.initialize()

        # This should come from our command line parser, however, Spyder does
        # not provide a way to get the argument parser but only the parsed
        # arguments.
        opts = {'working_directory': cs.path(),
                'debug': False,
                'profile': False,
                'multithreaded': False,
                'light': False,
                'new_instance': True}

        # The python executable is set explicitly here, because Spyder tends
        # not to pick up the one used in a virtualenv. This should be set in a
        # profile in order to not mess with the user's settings.
        CONF.set('console', 'pythonexecutable', sys.executable)

        main = spyder.MainWindow(Bunch(opts))
        main.setup()
        main.show()
        main.open_file(cs.path(session))

        app.exec_()

    def __init__(self, parent):
        PluginWidget.__init__(self, parent)

        # Read-only editor
        self.editor = QsciEditor(self)
        self.editor.setup_editor(linenumbers=False, language='py',
                                 code_folding=True)
        self.connect(self.editor, SIGNAL("focus_changed()"),
                     lambda: self.emit(SIGNAL("focus_changed()")))
        self.editor.setReadOnly(True)
        self.editor.set_font( get_font(self.ID) )
        self.editor.toggle_wrap_mode( CONF.get(self.ID, 'wrap') )
        
        # Add entries to read-only editor context-menu
        font_action = create_action(self, translate("Editor", "&Font..."), None,
                                    'font.png',
                                    translate("Editor", "Set font style"),
                                    triggered=self.change_font)
        wrap_action = create_action(self, translate("Editor", "Wrap lines"),
                                    toggled=self.toggle_wrap_mode)
        wrap_action.setChecked( CONF.get(self.ID, 'wrap') )
        self.editor.readonly_menu.addSeparator()
        add_actions(self.editor.readonly_menu, (font_action, wrap_action))
        
        # Find/replace widget
        self.find_widget = FindReplace(self)
        self.find_widget.set_editor(self.editor)
        self.find_widget.hide()

 def toggle_calltips(self, checked):
     """Toggle calltips"""
     if self.tabwidget is None:
         return
     for shell in self.shells:
         shell.shell.set_calltips(checked)
     CONF.set(self.ID, 'calltips', checked)

 def toggle_wrap_mode(self, checked):
     """Toggle wrap mode"""
     if self.tabwidget is None:
         return
     for editor in self.editors:
         editor.toggle_wrap_mode(checked)
     CONF.set(self.ID, 'wrap', checked)

    def show_banner(self):
        """Banner for IPython widgets with pylab message"""
        from IPython.core.usage import default_gui_banner
        banner = default_gui_banner
        
        pylab_o = CONF.get('ipython_console', 'pylab', True)
        autoload_pylab_o = CONF.get('ipython_console', 'pylab/autoload', True)
        mpl_installed = programs.is_module_installed('matplotlib')
        if mpl_installed and (pylab_o and autoload_pylab_o):
            backend_o = CONF.get('ipython_console', 'pylab/backend', 0)
            backends = {0: 'module://IPython.zmq.pylab.backend_inline',
                        1: 'Qt4Agg', 2: 'Qt4Agg', 3: 'MacOSX', 4: 'GTKAgg',
                        5: 'WXAgg', 6: 'TKAgg'}
            pylab_013_message = """
Welcome to pylab, a matplotlib-based Python environment [backend: %s].
For more information, type 'help(pylab)'.\n""" % backends[backend_o]
            pylab_1_message = """
Populating the interactive namespace from numpy and matplotlib"""
            if programs.is_module_installed('IPython', '>=1.0'):
                banner = banner + pylab_1_message
            else:
                banner = banner + pylab_013_message
        
        sympy_o = CONF.get('ipython_console', 'symbolic_math', True)
        if sympy_o:
            lines = """
These commands were executed:
>>> from __future__ import division
>>> from sympy import *
>>> x, y, z, t = symbols('x y z t')
>>> k, m, n = symbols('k m n', integer=True)
>>> f, g, h = symbols('f g h', cls=Function)
"""
            banner = banner + lines
        return banner

 def __init__(self, parent):
     PydocBrowser.__init__(self, parent)
     SpyderPluginMixin.__init__(self, parent)
     
     self.set_zoom_factor(CONF.get(self.ID, 'zoom_factor'))
     self.url_combo.setMaxCount(CONF.get(self.ID, 'max_history_entries'))
     self.url_combo.addItems( self.load_history() )

 def toggle_codecompletion(self, checked):
     """Toggle code completion"""
     if self.tabwidget is None:
         return
     for shell in self.shells:
         shell.shell.set_codecompletion(checked)
     CONF.set(self.ID, 'autocompletion/enabled', checked)

    def long_banner(self):
        """Banner for IPython widgets with pylab message"""
        from IPython.core.usage import default_gui_banner
        banner = default_gui_banner
        
        pylab_o = CONF.get('ipython_console', 'pylab', True)
        autoload_pylab_o = CONF.get('ipython_console', 'pylab/autoload', True)
        mpl_installed = programs.is_module_installed('matplotlib')
        if mpl_installed and (pylab_o and autoload_pylab_o):
            pylab_message = ("\nPopulating the interactive namespace from "
                             "numpy and matplotlib")
            banner = banner + pylab_message
        
        sympy_o = CONF.get('ipython_console', 'symbolic_math', True)
        if sympy_o:
            lines = """
These commands were executed:
>>> from __future__ import division
>>> from sympy import *
>>> x, y, z, t = symbols('x y z t')
>>> k, m, n = symbols('k m n', integer=True)
>>> f, g, h = symbols('f g h', cls=Function)
"""
            banner = banner + lines
        return banner

 def set_option(self, option, value):
     """
     Set a plugin option in configuration file
     Use a SIGNAL to call it, e.g.:
     plugin.sig_option_changed.emit('show_all', checked)
     """
     CONF.set(self.CONF_SECTION, str(option), value)

 def change_exteditor(self):
     """Change external editor path"""
     path, valid = QInputDialog.getText(self, self.tr('External editor'),
                       self.tr('External editor executable path:'),
                       QLineEdit.Normal,
                       CONF.get(self.ID, 'external_editor/path'))
     if valid:
         CONF.set(self.ID, 'external_editor/path', unicode(path))

 def save_config(self):
     """Save configuration: opened projects & tree widget state"""
     data = self.get_project_config()
     cPickle.dump(data, file(self.DATAPATH, 'w'))
     CONF.set(self.ID, 'expanded_state',
              self.treewidget.get_expanded_state())
     CONF.set(self.ID, 'scrollbar_position',
              self.treewidget.get_scrollbar_position())

 def change_history_depth(self):
     "Change history max entries"""
     depth, valid = QInputDialog.getInteger(self, self.tr('History'),
                                    self.tr('Maximum entries'),
                                    CONF.get(self.ID, 'max_entries'),
                                    10, 10000)
     if valid:
         CONF.set(self.ID, 'max_entries', depth)

 def setup(self):
     """Configure QTextEdit"""
     # Calltips
     self.calltip_size = CONF.get('shell_appearance', 'calltips/size')
     self.calltip_font = get_font('shell_appearance', 'calltips')
     # Completion
     self.completion_size = CONF.get('shell_appearance', 'completion/size')
     self.completion_font = get_font('shell_appearance', 'completion')

 def change_max_line_count(self):
     "Change maximum line count"""
     mlc, valid = QInputDialog.getInteger(self, self.tr('Buffer'),
                                        self.tr('Maximum line count'),
                                        CONF.get(self.ID, 'max_line_count'),
                                        10, 1000000)
     if valid:
         self.shell.setMaximumBlockCount(mlc)
         CONF.set(self.ID, 'max_line_count', mlc)

 def setup(self):
     """Configure QPlainTextEdit"""
     # Calltips
     self.calltip_size = CONF.get('shell_appearance', 'calltips/size')
     self.calltip_font = get_font('shell_appearance', 'calltips')
     # Completion
     size = CONF.get('shell_appearance', 'completion/size')
     font = get_font('shell_appearance', 'completion')
     self.completion_widget.setup_appearance(size, font)