def __init__(self, parent, namespace, message, commands=[]):
InternalShell.__init__(self,
parent=parent,
namespace=namespace,
message=message,
commands=commands,
multithreaded=False)
self.setup()
def __init__(self,
parent=None,
namespace=None,
commands=[],
message=None,
exitfunc=None,
profile=False,
multithreaded=False):
SpyderPluginWidget.__init__(self, parent)
debug_print(" ..internal console: initializing")
self.dialog_manager = DialogManager()
# Shell
light_background = self.get_option('light_background')
self.shell = InternalShell(parent,
namespace,
commands,
message,
self.get_option('max_line_count'),
self.get_plugin_font(),
exitfunc,
profile,
multithreaded,
light_background=light_background)
self.connect(
self.shell, SIGNAL('status(QString)'),
lambda msg: self.emit(SIGNAL('show_message(QString,int)'), msg, 0))
self.connect(self.shell, SIGNAL("go_to_error(QString)"),
self.go_to_error)
self.connect(self.shell, SIGNAL("focus_changed()"),
lambda: self.emit(SIGNAL("focus_changed()")))
# Redirecting some SIGNALs:
self.connect(
self.shell, SIGNAL('redirect_stdio(bool)'),
lambda state: self.emit(SIGNAL('redirect_stdio(bool)'), state))
# Initialize plugin
self.initialize_plugin()
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.set_editor(self.shell)
self.find_widget.hide()
self.register_widget_shortcuts("Editor", self.find_widget)
# Main layout
layout = QVBoxLayout()
layout.addWidget(self.shell)
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Parameters
self.shell.toggle_wrap_mode(self.get_option('wrap'))
# Accepting drops
self.setAcceptDrops(True)
def __init__(self, parent, namespace, message, commands=[]):
InternalShell.__init__(self,
parent=parent,
namespace=namespace,
message=message,
commands=commands,
multithreaded=True)
DockableWidgetMixin.__init__(self, parent)
self.setup()
def __init__(self):
super(Demo, self).__init__()
self.code_editor = CodeEditor(self)
self.code_editor.setup_editor(
language = "python",
font = QFont("Courier New")
)
run_sc = QShortcut(QKeySequence("F5"), self, self.run)
self.shell = InternalShell(self, {"demo":self},
multithreaded = False,
max_line_count = 3000,
font = QFont("Courier new", 10),
message='caonima'
)
self.dict_editor = DictEditorWidget(self, {})
self.dict_editor.editor.set_filter(self.filter_namespace)
self.dict_editor.set_data(self.shell.interpreter.namespace)
vbox = QVBoxLayout()
vbox.addWidget(self.code_editor)
vbox.addWidget(self.shell)
hbox = QHBoxLayout()
hbox.addWidget(self.dict_editor)
hbox.addLayout(vbox)
self.setLayout(hbox)
self.resize(800, 600)
def _constructConsoleWidget(self, central_widget):
"""
"""
font = qg.QFont("Courier new")
font.setPointSize(12)
ns = {'win': self, 'widget': central_widget}
msg = "Try for example: widget.set_text('foobar') or win.close()"
# Note: by default, the internal shell is multithreaded which is safer
# but not compatible with graphical user interface creation.
# For example, if you need to plot data with Matplotlib, you will need
# to pass the option: multithreaded=False
self.console = cons = InternalShell(self, namespace=ns, message=msg)
# Setup the console widget
cons.set_font(font)
cons.set_codecompletion_auto(True)
cons.set_calltips(True)
cons.setup_calltips(size=600, font=font)
cons.setup_completion(size=(300, 100), font=font)
console_dock = qg.QDockWidget("Console", self)
console_dock.setWidget(cons)
# Add the console widget to window as a dockwidget
self.addDockWidget(qc.Qt.BottomDockWidgetArea, console_dock)
def addConsole(root):
font = QFont("Courier new")
font.setPointSize(10)
ns = {
's': root,
}
msg = "self: s"
# Note: by default, the internal shell is multithreaded which is safer
# but not compatible with graphical user interface creation.
# For example, if you need to plot data with Matplotlib, you will need
# to pass the option: multithreaded=False
root.console = cons = InternalShell(root,
namespace=ns,
message=msg,
multithreaded=False)
cons.set_font(font)
cons.set_codecompletion_auto(True)
cons.set_codecompletion_case(False)
cons.set_inspector_enabled(True)
cons.set_calltips(True)
cons.setup_calltips(size=600, font=font)
cons.setup_completion(size=(300, 180), font=font)
console_dock = QDockWidget("Console", root)
console_dock.setWidget(cons)
# Add the console widget to window as a dockwidget
root.addDockWidget(Qt.BottomDockWidgetArea, console_dock)
def __init__(self):
super(Demo, self).__init__()
self.shell = InternalShell(self, {"demo": self},
multithreaded=False,
max_line_count=3000,
font=QFont("Courier new", 10),
message='mid caoni ma')
self.line_edit = QLineEdit()
vbox = QVBoxLayout()
vbox.addWidget(self.line_edit)
vbox.addWidget(self.shell)
self.setLayout(vbox)
def __init__(
self, parent=None, namespace=None, commands=[], message=None, exitfunc=None, profile=False, multithreaded=False
):
if PYQT5:
SpyderPluginWidget.__init__(self, parent, main=parent)
else:
SpyderPluginWidget.__init__(self, parent)
debug_print(" ..internal console: initializing")
self.dialog_manager = DialogManager()
# Shell
light_background = self.get_option("light_background")
self.shell = InternalShell(
parent,
namespace,
commands,
message,
self.get_option("max_line_count"),
self.get_plugin_font(),
exitfunc,
profile,
multithreaded,
light_background=light_background,
)
self.shell.status.connect(lambda msg: self.show_message.emit(msg, 0))
self.shell.go_to_error.connect(self.go_to_error)
self.shell.focus_changed.connect(lambda: self.focus_changed.emit())
# Redirecting some signals:
self.shell.redirect_stdio.connect(lambda state: self.redirect_stdio.emit(state))
# Initialize plugin
self.initialize_plugin()
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.set_editor(self.shell)
self.find_widget.hide()
self.register_widget_shortcuts("Editor", self.find_widget)
# Main layout
layout = QVBoxLayout()
layout.addWidget(self.shell)
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Parameters
self.shell.toggle_wrap_mode(self.get_option("wrap"))
# Accepting drops
self.setAcceptDrops(True)
def __init__(self, parent=None, namespace=None, commands=[], message=None,
exitfunc=None, profile=False, multithreaded=False):
SpyderPluginWidget.__init__(self, parent)
debug_print(" ..internal console: initializing")
self.dialog_manager = DialogManager()
# Shell
light_background = self.get_option('light_background')
self.shell = InternalShell(parent, namespace, commands, message,
self.get_option('max_line_count'),
self.get_plugin_font(), exitfunc, profile,
multithreaded,
light_background=light_background)
self.connect(self.shell, SIGNAL('status(QString)'),
lambda msg:
self.emit(SIGNAL('show_message(QString,int)'), msg, 0))
self.connect(self.shell, SIGNAL("go_to_error(QString)"),
self.go_to_error)
self.connect(self.shell, SIGNAL("focus_changed()"),
lambda: self.emit(SIGNAL("focus_changed()")))
# Redirecting some SIGNALs:
self.connect(self.shell, SIGNAL('redirect_stdio(bool)'),
lambda state: self.emit(SIGNAL('redirect_stdio(bool)'),
state))
# Initialize plugin
self.initialize_plugin()
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.set_editor(self.shell)
self.find_widget.hide()
self.register_widget_shortcuts("Editor", self.find_widget)
# Main layout
layout = QVBoxLayout()
layout.addWidget(self.shell)
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Parameters
self.shell.toggle_wrap_mode(self.get_option('wrap'))
# Accepting drops
self.setAcceptDrops(True)
def _init_python_tab(self):
# Console
ns = {'current': self.provider, 'selections': self.selections}
cmds = """
from __future__ import division
import scipy as sp
import numpy as np
import matplotlib.pyplot as plt
import guiqwt
import guiqwt.pyplot as guiplt
import guidata
import spykeutils
import spykeviewer
plt.ion()
""".split('\n')
self.console = InternalShell(self.consoleDock, namespace=ns,
multithreaded=False, commands=cmds, max_line_count=1000)
self.consoleDock.setWidget(self.console)
self.console.clear_terminal()
# Variable browser
self.browser = NamespaceBrowser(self.variableExplorerDock)
self.browser.set_shellwidget(self.console)
self.browser.setup(check_all=True, exclude_private=True,
exclude_uppercase=False, exclude_capitalized=False,
exclude_unsupported=True, excluded_names=[],
truncate=False, minmax=False, collvalue=False,
remote_editing=False, inplace=False, autorefresh=False)
self.variableExplorerDock.setWidget(self.browser)
# History
self.history = CodeEditor(self.historyDock)
self.history.setup_editor(linenumbers=False, language='py',
scrollflagarea=False)
self.history.setReadOnly(True)
self.history.set_text('\n'.join(self.console.history))
self.history.set_cursor_position('eof')
self.historyDock.setWidget(self.history)
self.console.connect(self.console, SIGNAL("refresh()"),
self._append_python_history)
def addConsole(window, ui_window, **kwargs):
# Create the console widget
font = QtGui.QFont("Courier new")
font.setPointSize(10)
# Note: by default, the internal shell is multithreaded which is safer
# but not compatible with graphical user interface creation.
# For example, if you need to plot data with Matplotlib, you will need
# to pass the option: multithreaded=False
#Internal Shell(self, parent=None, namespace=None, commands=[], message='', max_line_count=300, font=None, debug=False, exitfunc=None, profile=False, multithreaded=True, light_background=True
ui_window.console = cons = InternalShell(window, **kwargs) #debug=True
# Setup the console widget
cons.set_font(font)
cons.set_codecompletion_auto(True)
cons.set_calltips(True)
cons.setup_calltips(size=600, font=font)
cons.setup_completion(size=(300, 180), font=font)
console_dock = QtGui.QDockWidget("Console", window)
console_dock.setWidget(cons)
# Add the console widget to window as a dockwidget
window.addDockWidget(Qt.BottomDockWidgetArea, console_dock)
def __init__(self, parent=None, namespace=None, commands=[], message="",
debug=False, exitfunc=None, profile=False, multithreaded=True):
# Shell
self.shell = InternalShell(parent, namespace, commands, message,
CONF.get(self.ID, 'max_line_count'),
get_font(self.ID),
debug, exitfunc, profile, multithreaded)
self.connect(self.shell, SIGNAL('status(QString)'),
lambda msg:
self.emit(SIGNAL('show_message(QString,int)'), msg, 0))
self.connect(self.shell, SIGNAL("go_to_error(QString)"),
self.go_to_error)
self.connect(self.shell, SIGNAL("focus_changed()"),
lambda: self.emit(SIGNAL("focus_changed()")))
# Redirecting some SIGNALs:
self.connect(self.shell, SIGNAL('redirect_stdio(bool)'),
lambda state: self.emit(SIGNAL('redirect_stdio(bool)'),
state))
SpyderPluginWidget.__init__(self, parent)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.set_editor(self.shell)
self.find_widget.hide()
# Main layout
layout = QVBoxLayout()
layout.addWidget(self.shell)
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Parameters
self.shell.toggle_wrap_mode( CONF.get(self.ID, 'wrap') )
# Accepting drops
self.setAcceptDrops(True)
class Console(SpyderPluginWidget):
"""
Console widget
"""
CONF_SECTION = 'internal_console'
focus_changed = Signal()
redirect_stdio = Signal(bool)
edit_goto = Signal(str, int, str)
def __init__(self, parent=None, namespace=None, commands=[], message=None,
exitfunc=None, profile=False, multithreaded=False):
if PYQT5:
SpyderPluginWidget.__init__(self, parent, main = parent)
else:
SpyderPluginWidget.__init__(self, parent)
debug_print(" ..internal console: initializing")
self.dialog_manager = DialogManager()
# Shell
light_background = self.get_option('light_background')
self.shell = InternalShell(parent, namespace, commands, message,
self.get_option('max_line_count'),
self.get_plugin_font(), exitfunc, profile,
multithreaded,
light_background=light_background)
self.shell.status.connect(lambda msg: self.show_message.emit(msg, 0))
self.shell.go_to_error.connect(self.go_to_error)
self.shell.focus_changed.connect(lambda: self.focus_changed.emit())
# Redirecting some signals:
self.shell.redirect_stdio.connect(lambda state:
self.redirect_stdio.emit(state))
# Initialize plugin
self.initialize_plugin()
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.set_editor(self.shell)
self.find_widget.hide()
self.register_widget_shortcuts("Editor", self.find_widget)
# Main layout
layout = QVBoxLayout()
layout.addWidget(self.shell)
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Parameters
self.shell.toggle_wrap_mode(self.get_option('wrap'))
# Accepting drops
self.setAcceptDrops(True)
#------ Private API --------------------------------------------------------
def set_historylog(self, historylog):
"""Bind historylog instance to this console
Not used anymore since v2.0"""
historylog.add_history(self.shell.history_filename)
self.shell.append_to_history.connect(historylog.append_to_history)
def set_inspector(self, inspector):
"""Bind inspector instance to this console"""
self.shell.inspector = inspector
#------ SpyderPluginWidget API ---------------------------------------------
def get_plugin_title(self):
"""Return widget title"""
return _('Internal console')
def get_focus_widget(self):
"""
Return the widget to give focus to when
this plugin's dockwidget is raised on top-level
"""
return self.shell
def closing_plugin(self, cancelable=False):
"""Perform actions before parent main window is closed"""
self.dialog_manager.close_all()
self.shell.exit_interpreter()
return True
def refresh_plugin(self):
pass
def get_plugin_actions(self):
"""Return a list of actions related to plugin"""
quit_action = create_action(self, _("&Quit"),
icon='exit.png', tip=_("Quit"),
triggered=self.quit)
self.register_shortcut(quit_action, "_", "Quit", "Ctrl+Q")
run_action = create_action(self, _("&Run..."), None,
'run_small.png', _("Run a Python script"),
triggered=self.run_script)
environ_action = create_action(self,
_("Environment variables..."),
icon = 'environ.png',
tip=_("Show and edit environment variables"
" (for current session)"),
triggered=self.show_env)
syspath_action = create_action(self,
_("Show sys.path contents..."),
icon = 'syspath.png',
tip=_("Show (read-only) sys.path"),
triggered=self.show_syspath)
buffer_action = create_action(self,
_("Buffer..."), None,
tip=_("Set maximum line count"),
triggered=self.change_max_line_count)
font_action = create_action(self,
_("&Font..."), None,
'font.png', _("Set shell font style"),
triggered=self.change_font)
exteditor_action = create_action(self,
_("External editor path..."), None, None,
_("Set external editor executable path"),
triggered=self.change_exteditor)
wrap_action = create_action(self,
_("Wrap lines"),
toggled=self.toggle_wrap_mode)
wrap_action.setChecked(self.get_option('wrap'))
calltips_action = create_action(self, _("Display balloon tips"),
toggled=self.toggle_calltips)
calltips_action.setChecked(self.get_option('calltips'))
codecompletion_action = create_action(self,
_("Automatic code completion"),
toggled=self.toggle_codecompletion)
codecompletion_action.setChecked(self.get_option('codecompletion/auto'))
codecompenter_action = create_action(self,
_("Enter key selects completion"),
toggled=self.toggle_codecompletion_enter)
codecompenter_action.setChecked(self.get_option(
'codecompletion/enter_key'))
option_menu = QMenu(_("Internal console settings"), self)
option_menu.setIcon(get_icon('tooloptions.png'))
add_actions(option_menu, (buffer_action, font_action, wrap_action,
calltips_action, codecompletion_action,
codecompenter_action, exteditor_action))
plugin_actions = [None, run_action, environ_action, syspath_action,
option_menu, None, quit_action]
# Add actions to context menu
add_actions(self.shell.menu, plugin_actions)
return plugin_actions
def register_plugin(self):
"""Register plugin in Spyder's main window"""
self.focus_changed.connect(self.main.plugin_focus_changed)
self.main.add_dockwidget(self)
# Connecting the following signal once the dockwidget has been created:
self.shell.traceback_available.connect(self.traceback_available)
def traceback_available(self):
"""Traceback is available in the internal console: showing the
internal console automatically to warn the user"""
if CONF.get('main', 'show_internal_console_if_traceback', False):
self.dockwidget.show()
self.dockwidget.raise_()
#------ Public API ---------------------------------------------------------
@Slot()
def quit(self):
"""Quit mainwindow"""
self.main.close()
@Slot()
def show_env(self):
"""Show environment variables"""
self.dialog_manager.show(EnvDialog())
@Slot()
def show_syspath(self):
"""Show sys.path"""
editor = DictEditor()
editor.setup(sys.path, title="sys.path", readonly=True,
width=600, icon='syspath.png')
self.dialog_manager.show(editor)
@Slot()
def run_script(self, filename=None, silent=False, set_focus=False,
args=None):
"""Run a Python script"""
if filename is None:
self.shell.interpreter.restore_stds()
filename, _selfilter = getopenfilename(self, _("Run Python script"),
getcwd(), _("Python scripts")+" (*.py ; *.pyw ; *.ipy)")
self.shell.interpreter.redirect_stds()
if filename:
os.chdir( osp.dirname(filename) )
filename = osp.basename(filename)
else:
return
debug_print(args)
filename = osp.abspath(filename)
rbs = remove_backslashes
command = "runfile('%s', args='%s')" % (rbs(filename), rbs(args))
if set_focus:
self.shell.setFocus()
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.raise_()
self.shell.write(command+'\n')
self.shell.run_command(command)
def go_to_error(self, text):
"""Go to error if relevant"""
match = get_error_match(to_text_string(text))
if match:
fname, lnb = match.groups()
self.edit_script(fname, int(lnb))
def edit_script(self, filename=None, goto=-1):
"""Edit script"""
# Called from InternalShell
if not hasattr(self, 'main') \
or not hasattr(self.main, 'editor'):
self.shell.external_editor(filename, goto)
return
if filename is not None:
self.edit_goto.emit(osp.abspath(filename), goto, '')
def execute_lines(self, lines):
"""Execute lines and give focus to shell"""
self.shell.execute_lines(to_text_string(lines))
self.shell.setFocus()
@Slot()
def change_font(self):
"""Change console font"""
font, valid = QFontDialog.getFont(self.get_plugin_font(),
self, _("Select a new font"))
if valid:
self.shell.set_font(font)
self.set_plugin_font(font)
@Slot()
def change_max_line_count(self):
"Change maximum line count"""
mlc, valid = QInputDialog.getInteger(self, _('Buffer'),
_('Maximum line count'),
self.get_option('max_line_count'),
0, 1000000)
if valid:
self.shell.setMaximumBlockCount(mlc)
self.set_option('max_line_count', mlc)
@Slot()
def change_exteditor(self):
"""Change external editor path"""
path, valid = QInputDialog.getText(self, _('External editor'),
_('External editor executable path:'),
QLineEdit.Normal,
self.get_option('external_editor/path'))
if valid:
self.set_option('external_editor/path', to_text_string(path))
@Slot(bool)
def toggle_wrap_mode(self, checked):
"""Toggle wrap mode"""
self.shell.toggle_wrap_mode(checked)
self.set_option('wrap', checked)
@Slot(bool)
def toggle_calltips(self, checked):
"""Toggle calltips"""
self.shell.set_calltips(checked)
self.set_option('calltips', checked)
@Slot(bool)
def toggle_codecompletion(self, checked):
"""Toggle automatic code completion"""
self.shell.set_codecompletion_auto(checked)
self.set_option('codecompletion/auto', checked)
@Slot(bool)
def toggle_codecompletion_enter(self, checked):
"""Toggle Enter key for code completion"""
self.shell.set_codecompletion_enter(checked)
self.set_option('codecompletion/enter_key', checked)
#----Drag and drop
def dragEnterEvent(self, event):
"""Reimplement Qt method
Inform Qt about the types of data that the widget accepts"""
source = event.mimeData()
if source.hasUrls():
if mimedata2url(source):
event.acceptProposedAction()
else:
event.ignore()
elif source.hasText():
event.acceptProposedAction()
def dropEvent(self, event):
"""Reimplement Qt method
Unpack dropped data and handle it"""
source = event.mimeData()
if source.hasUrls():
pathlist = mimedata2url(source)
self.shell.drop_pathlist(pathlist)
elif source.hasText():
lines = to_text_string(source.text())
self.shell.set_cursor_position('eof')
self.shell.execute_lines(lines)
event.acceptProposedAction()
def __init__(self, parent, namespace, message, commands=[]):
InternalShell.__init__(self, parent=parent, namespace=namespace,
message=message, commands=commands,
multithreaded=False)
self.setup()
class Console(SpyderPluginWidget):
"""
Console widget
"""
CONF_SECTION = 'internal_console'
focus_changed = Signal()
redirect_stdio = Signal(bool)
edit_goto = Signal(str, int, str)
def __init__(self, parent=None, namespace=None, commands=[], message=None,
exitfunc=None, profile=False, multithreaded=False):
if PYQT5:
SpyderPluginWidget.__init__(self, parent, main = parent)
else:
SpyderPluginWidget.__init__(self, parent)
debug_print(" ..internal console: initializing")
self.dialog_manager = DialogManager()
# Shell
light_background = self.get_option('light_background')
self.shell = InternalShell(parent, namespace, commands, message,
self.get_option('max_line_count'),
self.get_plugin_font(), exitfunc, profile,
multithreaded,
light_background=light_background)
self.shell.status.connect(lambda msg: self.show_message.emit(msg, 0))
self.shell.go_to_error.connect(self.go_to_error)
self.shell.focus_changed.connect(lambda: self.focus_changed.emit())
# Redirecting some signals:
self.shell.redirect_stdio.connect(lambda state:
self.redirect_stdio.emit(state))
# Initialize plugin
self.initialize_plugin()
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.set_editor(self.shell)
self.find_widget.hide()
self.register_widget_shortcuts("Editor", self.find_widget)
# Main layout
layout = QVBoxLayout()
layout.addWidget(self.shell)
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Parameters
self.shell.toggle_wrap_mode(self.get_option('wrap'))
# Accepting drops
self.setAcceptDrops(True)
#------ Private API --------------------------------------------------------
def set_historylog(self, historylog):
"""Bind historylog instance to this console
Not used anymore since v2.0"""
historylog.add_history(self.shell.history_filename)
self.shell.append_to_history.connect(historylog.append_to_history)
def set_help(self, help_plugin):
"""Bind help instance to this console"""
self.shell.help = help_plugin
#------ SpyderPluginWidget API ---------------------------------------------
def get_plugin_title(self):
"""Return widget title"""
return _('Internal console')
def get_focus_widget(self):
"""
Return the widget to give focus to when
this plugin's dockwidget is raised on top-level
"""
return self.shell
def closing_plugin(self, cancelable=False):
"""Perform actions before parent main window is closed"""
self.dialog_manager.close_all()
self.shell.exit_interpreter()
return True
def refresh_plugin(self):
pass
def get_plugin_actions(self):
"""Return a list of actions related to plugin"""
quit_action = create_action(self, _("&Quit"),
icon=ima.icon('exit'),
tip=_("Quit"),
triggered=self.quit)
self.register_shortcut(quit_action, "_", "Quit", "Ctrl+Q")
run_action = create_action(self, _("&Run..."), None,
ima.icon('run_small'),
_("Run a Python script"),
triggered=self.run_script)
environ_action = create_action(self,
_("Environment variables..."),
icon=ima.icon('environ'),
tip=_("Show and edit environment variables"
" (for current session)"),
triggered=self.show_env)
syspath_action = create_action(self,
_("Show sys.path contents..."),
icon=ima.icon('syspath'),
tip=_("Show (read-only) sys.path"),
triggered=self.show_syspath)
buffer_action = create_action(self,
_("Buffer..."), None,
tip=_("Set maximum line count"),
triggered=self.change_max_line_count)
font_action = create_action(self,
_("&Font..."), None,
ima.icon('font'), _("Set shell font style"),
triggered=self.change_font)
exteditor_action = create_action(self,
_("External editor path..."), None, None,
_("Set external editor executable path"),
triggered=self.change_exteditor)
wrap_action = create_action(self,
_("Wrap lines"),
toggled=self.toggle_wrap_mode)
wrap_action.setChecked(self.get_option('wrap'))
calltips_action = create_action(self, _("Display balloon tips"),
toggled=self.toggle_calltips)
calltips_action.setChecked(self.get_option('calltips'))
codecompletion_action = create_action(self,
_("Automatic code completion"),
toggled=self.toggle_codecompletion)
codecompletion_action.setChecked(self.get_option('codecompletion/auto'))
codecompenter_action = create_action(self,
_("Enter key selects completion"),
toggled=self.toggle_codecompletion_enter)
codecompenter_action.setChecked(self.get_option(
'codecompletion/enter_key'))
option_menu = QMenu(_('Internal console settings'), self)
option_menu.setIcon(ima.icon('tooloptions'))
add_actions(option_menu, (buffer_action, font_action, wrap_action,
calltips_action, codecompletion_action,
codecompenter_action, exteditor_action))
plugin_actions = [None, run_action, environ_action, syspath_action,
option_menu, None, quit_action]
# Add actions to context menu
add_actions(self.shell.menu, plugin_actions)
return plugin_actions
def register_plugin(self):
"""Register plugin in Spyder's main window"""
self.focus_changed.connect(self.main.plugin_focus_changed)
self.main.add_dockwidget(self)
# Connecting the following signal once the dockwidget has been created:
self.shell.traceback_available.connect(self.traceback_available)
def traceback_available(self):
"""Traceback is available in the internal console: showing the
internal console automatically to warn the user"""
if CONF.get('main', 'show_internal_console_if_traceback', False):
self.dockwidget.show()
self.dockwidget.raise_()
#------ Public API ---------------------------------------------------------
@Slot()
def quit(self):
"""Quit mainwindow"""
self.main.close()
@Slot()
def show_env(self):
"""Show environment variables"""
self.dialog_manager.show(EnvDialog())
@Slot()
def show_syspath(self):
"""Show sys.path"""
editor = CollectionsEditor()
editor.setup(sys.path, title="sys.path", readonly=True,
width=600, icon=ima.icon('syspath'))
self.dialog_manager.show(editor)
@Slot()
def run_script(self, filename=None, silent=False, set_focus=False,
args=None):
"""Run a Python script"""
if filename is None:
self.shell.interpreter.restore_stds()
filename, _selfilter = getopenfilename(self, _("Run Python script"),
getcwd(), _("Python scripts")+" (*.py ; *.pyw ; *.ipy)")
self.shell.interpreter.redirect_stds()
if filename:
os.chdir( osp.dirname(filename) )
filename = osp.basename(filename)
else:
return
debug_print(args)
filename = osp.abspath(filename)
rbs = remove_backslashes
command = "runfile('%s', args='%s')" % (rbs(filename), rbs(args))
if set_focus:
self.shell.setFocus()
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.raise_()
self.shell.write(command+'\n')
self.shell.run_command(command)
def go_to_error(self, text):
"""Go to error if relevant"""
match = get_error_match(to_text_string(text))
if match:
fname, lnb = match.groups()
self.edit_script(fname, int(lnb))
def edit_script(self, filename=None, goto=-1):
"""Edit script"""
# Called from InternalShell
if not hasattr(self, 'main') \
or not hasattr(self.main, 'editor'):
self.shell.external_editor(filename, goto)
return
if filename is not None:
self.edit_goto.emit(osp.abspath(filename), goto, '')
def execute_lines(self, lines):
"""Execute lines and give focus to shell"""
self.shell.execute_lines(to_text_string(lines))
self.shell.setFocus()
@Slot()
def change_font(self):
"""Change console font"""
font, valid = QFontDialog.getFont(self.get_plugin_font(),
self, _("Select a new font"))
if valid:
self.shell.set_font(font)
self.set_plugin_font(font)
@Slot()
def change_max_line_count(self):
"Change maximum line count"""
mlc, valid = QInputDialog.getInteger(self, _('Buffer'),
_('Maximum line count'),
self.get_option('max_line_count'),
0, 1000000)
if valid:
self.shell.setMaximumBlockCount(mlc)
self.set_option('max_line_count', mlc)
@Slot()
def change_exteditor(self):
"""Change external editor path"""
path, valid = QInputDialog.getText(self, _('External editor'),
_('External editor executable path:'),
QLineEdit.Normal,
self.get_option('external_editor/path'))
if valid:
self.set_option('external_editor/path', to_text_string(path))
@Slot(bool)
def toggle_wrap_mode(self, checked):
"""Toggle wrap mode"""
self.shell.toggle_wrap_mode(checked)
self.set_option('wrap', checked)
@Slot(bool)
def toggle_calltips(self, checked):
"""Toggle calltips"""
self.shell.set_calltips(checked)
self.set_option('calltips', checked)
@Slot(bool)
def toggle_codecompletion(self, checked):
"""Toggle automatic code completion"""
self.shell.set_codecompletion_auto(checked)
self.set_option('codecompletion/auto', checked)
@Slot(bool)
def toggle_codecompletion_enter(self, checked):
"""Toggle Enter key for code completion"""
self.shell.set_codecompletion_enter(checked)
self.set_option('codecompletion/enter_key', checked)
#----Drag and drop
def dragEnterEvent(self, event):
"""Reimplement Qt method
Inform Qt about the types of data that the widget accepts"""
source = event.mimeData()
if source.hasUrls():
if mimedata2url(source):
event.acceptProposedAction()
else:
event.ignore()
elif source.hasText():
event.acceptProposedAction()
def dropEvent(self, event):
"""Reimplement Qt method
Unpack dropped data and handle it"""
source = event.mimeData()
if source.hasUrls():
pathlist = mimedata2url(source)
self.shell.drop_pathlist(pathlist)
elif source.hasText():
lines = to_text_string(source.text())
self.shell.set_cursor_position('eof')
self.shell.execute_lines(lines)
event.acceptProposedAction()
def runPlugin(self):
global ariadne
global CubeLoader
ns = {'ariadne': ariadne, 'CubeLoader': CubeLoader}
msg = "Try for example: ariadne.Neurons or CubeLoader.LoadDataset()"
# Note: by default, the internal shell is multithreaded which is safer
# but not compatible with graphical user interface creation.
# For example, if you need to plot data with Matplotlib, you will need
# to pass the option: multithreaded=False
cons = SpyderShell(ariadne,multithreaded=False, namespace=ns, message=msg)
ariadne.shell = cons
# Create the console widget
font = QtGui.QFont("Courier new")
font.setPointSize(10)
# Setup the console widget
cons.set_font(font)
cons.set_codecompletion_auto(True)
cons.set_calltips(True)
cons.setup_calltips(size=600, font=font)
cons.setup_completion(size=(300, 180), font=font)
ariadne.Console.setWidget(cons)
ariadne.Console.setFloating(0)
ariadne.Console.setVisible(1)
class MainWindow(QMainWindow, Ui_MainWindow):
""" The main window of SpikeViewer
"""
def __init__(self, parent = None):
QMainWindow.__init__(self, parent)
QCoreApplication.setOrganizationName('SpykeUtils')
QCoreApplication.setApplicationName('Spyke Viewer')
self.setupUi(self)
self.dir = os.getcwd()
self.console = None
self.progress = ProgressIndicatorDialog(self)
self.provider_factory = DataProvider
self.selections = []
self.provider = None
self.plugin_paths = []
# Drag and Drop for selections menu
self.menuSelections.setAcceptDrops(True)
self.menuSelections.paintEvent =\
self.on_menuSelections_paint
self.menuSelections.mousePressEvent =\
self.on_menuSelections_mousePressed
self.menuSelections.mouseMoveEvent =\
self.on_menuSelections_mouseMoved
self.menuSelections.dragEnterEvent =\
self.on_menuSelections_dragEnter
self.menuSelections.dragMoveEvent =\
self.on_menuSelections_dragMoved
self.menuSelections.dropEvent =\
self.on_menuSelections_drop
self.seldrag_start_pos = None
self.seldrag_selection = None
self.seldrag_target = None
self.seldrag_target_upper = False
# Docks
self.setCentralWidget(None)
# A lot of docks are only needed for the internal database mode
self.navigationDBDock.setVisible(False)
self.filterDBDock.setVisible(False)
self.spikeSortingDock.setVisible(False)
self.waveformsDock.setVisible(False)
self.spikeTrainDock.setVisible(False)
if not hasattr(self, 'internal_database_mode'):
self.removeDockWidget(self.navigationDBDock)
self.removeDockWidget(self.filterDBDock)
self.removeDockWidget(self.spikeSortingDock)
self.removeDockWidget(self.waveformsDock)
self.removeDockWidget(self.spikeTrainDock)
del self.navigationDBDock
del self.filterDBDock
del self.spikeSortingDock
del self.waveformsDock
del self.spikeTrainDock
self.update_view_menu()
if not hasattr(self, 'internal_database_mode'):
self.restore_state()
self.mode_switch()
def update_view_menu(self):
self.menuBar.clear()
self.menuBar.addMenu(self.menuFile)
self.menuBar.addMenu(self.menuSelections)
self.menuView = self.createPopupMenu()
self.menuView.setTitle('View')
self.menuBar.addMenu(self.menuView)
self.menuBar.addMenu(self.menuHelp)
def restore_state(self):
settings = QSettings()
if not settings.contains('windowGeometry') or\
not settings.contains('windowState'):
self.set_initial_layout()
else:
self.restoreGeometry(settings.value('windowGeometry'))
self.restoreState(settings.value('windowState'))
if not settings.contains('pluginPaths'):
if hasattr(sys, 'frozen'):
module_path = os.path.dirname(sys.executable)
else:
file_path = os.path.abspath(os.path.dirname(__file__))
module_path = os.path.dirname(os.path.dirname(file_path))
plugin_path = os.path.join(module_path, 'plugins')
if os.path.isdir(plugin_path):
self.plugin_paths.append(plugin_path)
else:
paths = settings.value('pluginPaths')
if paths is None:
self.plugin_paths = []
else:
self.plugin_paths = paths
if not settings.contains('selectionPath'):
data_path = QDesktopServices.storageLocation(
QDesktopServices.DataLocation)
self.selection_path = os.path.join(data_path, 'selections')
else:
self.selection_path = settings.value('selectionPath')
if not settings.contains('dataPath'):
data_path = QDesktopServices.storageLocation(
QDesktopServices.DataLocation)
AnalysisPlugin.data_dir = os.path.join(data_path, 'data')
else:
AnalysisPlugin.data_dir = settings.value('dataPath')
if not settings.contains('remoteScript'):
if hasattr(sys, 'frozen'):
path = os.path.dirname(sys.executable)
else:
file_path = os.path.abspath(os.path.dirname(__file__))
path = os.path.dirname(os.path.dirname(file_path))
path = os.path.join(path, 'bin')
self.remote_script = os.path.join(path, 'spykeview_analysis')
else:
self.remote_script = settings.value('remoteScript')
def set_initial_layout(self):
self.setGeometry(self.x(), self.y(), 800, 750)
self.navigationNeoDock.setVisible(True)
self.removeDockWidget(self.filterDock)
self.removeDockWidget(self.analysisDock)
self.addDockWidget(Qt.RightDockWidgetArea, self.filterDock)
self.addDockWidget(Qt.RightDockWidgetArea, self.analysisDock)
self.tabifyDockWidget(self.filterDock, self.analysisDock)
self.filterDock.setVisible(True)
self.analysisDock.setVisible(True)
self.consoleDock.setVisible(False)
self.variableExplorerDock.setVisible(False)
self.historyDock.setVisible(False)
self.tabifyDockWidget(self.consoleDock, self.variableExplorerDock)
self.tabifyDockWidget(self.variableExplorerDock, self.historyDock)
def mode_switch(self):
if self.is_db_mode():
self.switch_to_db_mode()
if self.is_neo_mode():
self.switch_to_neo_mode()
if self.console:
self.console.interpreter.locals['current'] = self.provider
def switch_to_db_mode(self):
raise NotImplementedError()
def switch_to_neo_mode(self):
raise NotImplementedError()
def _init_python_tab(self):
# Console
ns = {'current': self.provider, 'selections': self.selections}
cmds = """
from __future__ import division
import scipy as sp
import numpy as np
import matplotlib.pyplot as plt
import guiqwt
import guiqwt.pyplot as guiplt
import guidata
import spykeutils
import spykeviewer
plt.ion()
""".split('\n')
self.console = InternalShell(self.consoleDock, namespace=ns,
multithreaded=False, commands=cmds, max_line_count=1000)
self.consoleDock.setWidget(self.console)
self.console.clear_terminal()
# Variable browser
self.browser = NamespaceBrowser(self.variableExplorerDock)
self.browser.set_shellwidget(self.console)
self.browser.setup(check_all=True, exclude_private=True,
exclude_uppercase=False, exclude_capitalized=False,
exclude_unsupported=True, excluded_names=[],
truncate=False, minmax=False, collvalue=False,
remote_editing=False, inplace=False, autorefresh=False)
self.variableExplorerDock.setWidget(self.browser)
# History
self.history = CodeEditor(self.historyDock)
self.history.setup_editor(linenumbers=False, language='py',
scrollflagarea=False)
self.history.setReadOnly(True)
self.history.set_text('\n'.join(self.console.history))
self.history.set_cursor_position('eof')
self.historyDock.setWidget(self.history)
self.console.connect(self.console, SIGNAL("refresh()"),
self._append_python_history)
def _append_python_history(self):
self.browser.refresh_table()
self.history.append('\n' + self.console.history[-1])
self.history.set_cursor_position('eof')
def is_neo_mode(self):
return True
def is_db_mode(self):
return False
@pyqtSignature("")
def on_actionExit_triggered(self):
self.close()
def on_menuHelp_triggered(self):
QMessageBox.about(self, 'How to navigate plots',
'Zoom:\tHold right mouse button' +
'\nTranslate:\tHold middle mouse button' +
'\nHome:\tClick middle mouse button' +
'\n\nAxis synchronization does not work with some actions. ' +
'Zoom or translate changed plot to synchronize.')
def on_menuSelections_mousePressed(self, event):
if event.button() == Qt.LeftButton:
action = self.menuSelections.actionAt(event.pos())
if action:
selection = action.data()
if selection:
self.seldrag_start_pos = event.pos()
self.seldrag_selection = selection
else:
self.seldrag_start_pos = None
self.seldrag_selection = None
self.seldrag_target = None
QMenu.mousePressEvent(self.menuSelections, event)
def on_menuSelections_mouseMoved(self, event):
if event.buttons() & Qt.LeftButton and self.seldrag_start_pos:
if ((event.pos() - self.seldrag_start_pos).manhattanLength() >=
QApplication.startDragDistance()):
drag = QDrag(self.menuSelections)
data = QMimeData()
data.setText(self.seldrag_selection.name)
drag.setMimeData(data)
drag.exec_()
self.seldrag_start_pos = None
self.seldrag_selection = None
self.seldrag_target = None
QMenu.mouseMoveEvent(self.menuSelections, event)
def on_menuSelections_paint(self, event):
QMenu.paintEvent(self.menuSelections, event)
if self.seldrag_target:
# Paint line where selection will be dropped
p = QPainter()
color = QPalette().color(self.menuSelections.foregroundRole())
pen = QPen(color, 2, Qt.SolidLine)
p.begin(self.menuSelections)
p.setPen(pen)
rect = self.menuSelections.actionGeometry(self.seldrag_target)
if self.seldrag_target_upper:
p.drawLine(rect.topLeft(), rect.topRight())
else:
p.drawLine(rect.bottomLeft(), rect.bottomRight())
p.end()
def _menuSelections_pos_is_drop_target(self, pos):
""" Return if selection can be dropped at this position and
prepare information needed for drawing and dropping
"""
action = self.menuSelections.actionAt(pos)
if not action or not action.data():
self.seldrag_target = None
return False
self.seldrag_target = action
rect = self.menuSelections.actionGeometry(action)
if pos.y() < rect.top() + rect.height() / 2:
self.seldrag_target_upper = True
else:
self.seldrag_target_upper = False
return True
def on_menuSelections_dragEnter(self, event):
event.setDropAction(Qt.MoveAction)
if self._menuSelections_pos_is_drop_target(event.pos()):
event.accept()
else:
event.ignore()
QMenu.dragEnterEvent(self.menuSelections, event)
def on_menuSelections_dragMoved(self, event):
event.setDropAction(Qt.MoveAction)
if self._menuSelections_pos_is_drop_target(event.pos()):
event.accept()
self.menuSelections.update()
else:
event.ignore()
QMenu.dragMoveEvent(self.menuSelections, event)
def on_menuSelections_drop(self, event):
source = self.seldrag_selection
target = self.seldrag_target.data()
if source != target:
self.selections.remove(source)
target_index = self.selections.index(target)
if not self.seldrag_target_upper:
target_index += 1
self.selections.insert(target_index, source)
self.populate_selection_menu()
QMenu.dropEvent(self.menuSelections, event)
def populate_selection_menu(self):
self.menuSelections.clear()
a = self.menuSelections.addAction('New')
a.triggered.connect(self.on_selection_new)
a = self.menuSelections.addAction('Clear')
a.triggered.connect(self.on_selection_clear)
self.menuSelections.addSeparator()
for i, s in enumerate(self.selections):
m = self.menuSelections.addMenu(s.name)
m.menuAction().setData(s)
a = m.addAction('Load')
self.connect(a, SIGNAL('triggered()'),
lambda sel=s:self.on_selection_load(sel))
a = m.addAction('Save')
self.connect(a, SIGNAL('triggered()'),
lambda sel=s:self.on_selection_save(sel))
a = m.addAction('Rename')
self.connect(a, SIGNAL('triggered()'),
lambda sel=s:self.on_selection_rename(sel))
a = m.addAction('Remove')
self.connect(a, SIGNAL('triggered()'),
lambda sel=s:self.on_selection_remove(sel))
def on_selection_load(self, selection):
self.set_current_selection(selection.data_dict())
def on_selection_save(self, selection):
i = self.selections.index(selection)
self.selections[i] = self.provider_factory(
self.selections[i].name, self)
self.populate_selection_menu()
def on_selection_clear(self):
if QMessageBox.question(self, 'Confirmation',
'Do you really want to remove all selections?',
QMessageBox.Yes | QMessageBox.No) == QMessageBox.No:
return
del self.selections[:]
self.populate_selection_menu()
def on_selection_rename(self, selection):
(name, ok) = QInputDialog.getText(self, 'Edit selection name',
'New name:', QLineEdit.Normal, selection.name)
if ok and name:
selection.name = name
self.populate_selection_menu()
def on_selection_remove(self, selection):
if QMessageBox.question(self, 'Confirmation',
'Do you really want to remove the selection "%s"?' %
selection.name,
QMessageBox.Yes | QMessageBox.No) == QMessageBox.No:
return
self.selections.remove(selection)
self.populate_selection_menu()
def on_selection_new(self):
self.selections.append(self.provider_factory('Selection %d' %
(len(self.selections) + 1), self))
self.populate_selection_menu()
def serialize_selections(self):
sl = list() # Selection list, current selection as first item
sl.append(self.provider_factory('current', self).data_dict())
for s in self.selections:
sl.append(s.data_dict())
return json.dumps(sl, sort_keys=True, indent=2)
def save_selections_to_file(self, filename):
f = open(filename, 'w')
f.write(self.serialize_selections())
f.close()
def load_selections_from_file(self, filename):
try:
f = open(filename, 'r')
p = json.load(f)
# First selection in file is current selection
self.set_current_selection(p[0])
for s in p[1:]:
self.add_selection(s)
f.close()
self.populate_selection_menu()
except Exception, e:
self.progress.done()
QMessageBox.critical(self, 'Error loading selection',
str(e).decode('utf8'))
class Console(SpyderPluginWidget):
"""
Console widget
"""
ID = 'shell'
def __init__(self, parent=None, namespace=None, commands=[], message="",
debug=False, exitfunc=None, profile=False, multithreaded=True):
# Shell
self.shell = InternalShell(parent, namespace, commands, message,
CONF.get(self.ID, 'max_line_count'),
get_font(self.ID),
debug, exitfunc, profile, multithreaded)
self.connect(self.shell, SIGNAL('status(QString)'),
lambda msg:
self.emit(SIGNAL('show_message(QString,int)'), msg, 0))
self.connect(self.shell, SIGNAL("go_to_error(QString)"),
self.go_to_error)
self.connect(self.shell, SIGNAL("focus_changed()"),
lambda: self.emit(SIGNAL("focus_changed()")))
# Redirecting some SIGNALs:
self.connect(self.shell, SIGNAL('redirect_stdio(bool)'),
lambda state: self.emit(SIGNAL('redirect_stdio(bool)'),
state))
SpyderPluginWidget.__init__(self, parent)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.set_editor(self.shell)
self.find_widget.hide()
# Main layout
layout = QVBoxLayout()
layout.addWidget(self.shell)
layout.addWidget(self.find_widget)
self.setLayout(layout)
# Parameters
self.shell.toggle_wrap_mode( CONF.get(self.ID, 'wrap') )
# Accepting drops
self.setAcceptDrops(True)
#------ Private API --------------------------------------------------------
def set_historylog(self, historylog):
"""Bind historylog instance to this console
Not used anymore since v2.0"""
historylog.add_history(self.shell.history_filename)
self.connect(self.shell, SIGNAL('append_to_history(QString,QString)'),
historylog.append_to_history)
def set_inspector(self, inspector):
"""Bind inspector instance to this console"""
self.shell.inspector = inspector
#------ SpyderPluginWidget API ---------------------------------------------
def get_plugin_title(self):
"""Return widget title"""
return self.tr('Internal console')
def get_focus_widget(self):
"""
Return the widget to give focus to when
this plugin's dockwidget is raised on top-level
"""
return self.shell
def closing_plugin(self, cancelable=False):
"""Perform actions before parent main window is closed"""
self.shell.exit_interpreter()
return True
def refresh_plugin(self):
pass
def get_plugin_actions(self):
"""Setup actions"""
quit_action = create_action(self, self.tr("&Quit"), self.tr("Ctrl+Q"),
'exit.png', self.tr("Quit"),
triggered=self.quit)
run_action = create_action(self, self.tr("&Run..."), None,
'run_small.png', self.tr("Run a Python script"),
triggered=self.run_script)
environ_action = create_action(self,
self.tr("Environment variables..."),
icon = 'environ.png',
tip=self.tr("Show and edit environment variables"
" (for current session)"),
triggered=self.show_env)
syspath_action = create_action(self,
self.tr("Show sys.path contents..."),
icon = 'syspath.png',
tip=self.tr("Show (read-only) sys.path"),
triggered=show_syspath)
buffer_action = create_action(self,
self.tr("Buffer..."), None,
tip=self.tr("Set maximum line count"),
triggered=self.change_max_line_count)
font_action = create_action(self,
self.tr("&Font..."), None,
'font.png', self.tr("Set shell font style"),
triggered=self.change_font)
exteditor_action = create_action(self,
self.tr("External editor path..."), None, None,
self.tr("Set external editor executable path"),
triggered=self.change_exteditor)
wrap_action = create_action(self,
self.tr("Wrap lines"),
toggled=self.toggle_wrap_mode)
wrap_action.setChecked( CONF.get(self.ID, 'wrap') )
calltips_action = create_action(self, self.tr("Balloon tips"),
toggled=self.toggle_calltips)
calltips_action.setChecked( CONF.get(self.ID, 'calltips') )
codecompletion_action = create_action(self,
self.tr("Automatic code completion"),
toggled=self.toggle_codecompletion)
codecompletion_action.setChecked( CONF.get(self.ID,
'codecompletion/auto') )
codecompenter_action = create_action(self,
self.tr("Enter key selects completion"),
toggled=self.toggle_codecompletion_enter)
codecompenter_action.setChecked( CONF.get(self.ID,
'codecompletion/enter-key') )
option_menu = QMenu(self.tr("Internal console settings"), self)
option_menu.setIcon(get_icon('tooloptions.png'))
add_actions(option_menu, (buffer_action, font_action, wrap_action,
calltips_action, codecompletion_action,
codecompenter_action, exteditor_action))
menu_actions = [None, run_action, environ_action, syspath_action,
option_menu, None, quit_action]
toolbar_actions = []
# Add actions to context menu
add_actions(self.shell.menu, menu_actions)
return menu_actions, toolbar_actions
#------ Public API ---------------------------------------------------------
def quit(self):
"""Quit mainwindow"""
self.main.close()
def show_env(self):
"""Show environment variables"""
dlg = EnvDialog()
dlg.exec_()
def run_script(self, filename=None, silent=False, set_focus=False,
args=None):
"""Run a Python script"""
if filename is None:
self.shell.interpreter.restore_stds()
filename = QFileDialog.getOpenFileName(self,
self.tr("Run Python script"), os.getcwdu(),
self.tr("Python scripts")+" (*.py ; *.pyw)")
self.shell.interpreter.redirect_stds()
if filename:
filename = unicode(filename)
os.chdir( os.path.dirname(filename) )
filename = os.path.basename(filename)
self.emit(SIGNAL("refresh()"))
else:
return
command = "runfile(%s, args=%s)" % (repr(osp.abspath(filename)),
repr(args))
if set_focus:
self.shell.setFocus()
if self.dockwidget and not self.ismaximized:
self.dockwidget.setVisible(True)
self.dockwidget.raise_()
self.shell.write(command+'\n')
self.shell.run_command(command)
def go_to_error(self, text):
"""Go to error if relevant"""
match = get_error_match(unicode(text))
if match:
fname, lnb = match.groups()
self.edit_script(fname, int(lnb))
def edit_script(self, filename=None, goto=-1):
"""Edit script"""
# Called from InternalShell
if not hasattr(self, 'main') \
or not hasattr(self.main, 'editor'):
self.shell.external_editor(filename, goto)
return
if filename is not None:
self.emit(SIGNAL("edit_goto(QString,int,QString)"),
osp.abspath(filename), goto, '')
def execute_lines(self, lines):
"""Execute lines and give focus to shell"""
self.shell.execute_lines(unicode(lines))
self.shell.setFocus()
def change_font(self):
"""Change console font"""
font, valid = QFontDialog.getFont(get_font(self.ID),
self, self.tr("Select a new font"))
if valid:
self.shell.set_font(font)
set_font(font, self.ID)
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 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 toggle_wrap_mode(self, checked):
"""Toggle wrap mode"""
self.shell.toggle_wrap_mode(checked)
CONF.set(self.ID, 'wrap', checked)
def toggle_calltips(self, checked):
"""Toggle calltips"""
self.shell.set_calltips(checked)
CONF.set(self.ID, 'calltips', checked)
def toggle_codecompletion(self, checked):
"""Toggle automatic code completion"""
self.shell.set_codecompletion_auto(checked)
CONF.set(self.ID, 'codecompletion/auto', checked)
def toggle_codecompletion_enter(self, checked):
"""Toggle Enter key for code completion"""
self.shell.set_codecompletion_enter(checked)
CONF.set(self.ID, 'codecompletion/enter-key', checked)
#----Drag and drop
def dragEnterEvent(self, event):
"""Reimplement Qt method
Inform Qt about the types of data that the widget accepts"""
source = event.mimeData()
if source.hasUrls():
if mimedata2url(source):
event.acceptProposedAction()
else:
event.ignore()
elif source.hasText():
event.acceptProposedAction()
def dropEvent(self, event):
"""Reimplement Qt method
Unpack dropped data and handle it"""
source = event.mimeData()
if source.hasUrls():
pathlist = mimedata2url(source)
self.shell.drop_pathlist(pathlist)
elif source.hasText():
lines = unicode(source.text())
self.shell.set_cursor_position('eof')
self.shell.execute_lines(lines)
event.acceptProposedAction()