class PythonShellTask(Task):
"""
A task which provides a simple Python Shell to the user.
"""
# Task Interface
id = "pyface.tasks.contrib.python_shell"
name = "Python Shell"
# The list of bindings for the shell
bindings = List(Dict)
# The list of commands to run on shell startup
commands = List(Str)
# the IPythonShell instance that we are interacting with
pane = Instance(PythonShellPane)
# Task Interface
menu_bar = SMenuBar(
SMenu(
TaskAction(name="Open...", method="open", accelerator="Ctrl+O"),
id="File",
name="&File",
),
SMenu(id="View", name="&View"),
)
def create_central_pane(self):
""" Create a view pane with a Python shell
"""
logger.debug("Creating Python shell pane in central pane")
self.pane = PythonShellPane(bindings=self.bindings,
commands=self.commands)
return self.pane
# PythonShellTask API
def open(self):
""" Shows a dialog to open a file.
"""
logger.debug("PythonShellTask: opening file")
dialog = FileDialog(parent=self.window.control, wildcard="*.py")
if dialog.open() == OK:
self._open_file(dialog.path)
# Private API
def _open_file(self, path):
""" Execute the selected file in the editor's interpreter
"""
logger.debug('PythonShellTask: executing file "%s"' % path)
self.pane.editor.execute_file(path)
def _menu_bar_default(self):
menu_bar = SMenuBar(
SMenu(
SGroup(
group_factory=DockPaneToggleGroup,
id="tests.bogus_task.DockPaneToggleGroup",
),
id="View",
name="&View",
)
)
return menu_bar
class SecondTask(ExampleTask):
""" A simple task for opening a blank editor.
"""
# Task interface -------------------------------------------------------
id = "example.second_task"
name = "Second Multi-Tab Editor"
menu_bar = SMenuBar(
SMenu(
TaskAction(name="New", method="new", accelerator="Ctrl+N"),
id="File",
name="&File",
),
SMenu(
DockPaneToggleGroup(), TaskToggleGroup(), id="View", name="&View"
),
)
tool_bars = [
SToolBar(
TaskAction(
method="new",
tooltip="New file",
image=ImageResource("document_new"),
),
image_size=(32, 32),
)
]
# ------------------------------------------------------------------------
# 'Task' interface.
# ------------------------------------------------------------------------
def _default_layout_default(self):
return TaskLayout(
left=VSplitter(
HSplitter(
PaneItem("steps.pane1"),
PaneItem("steps.pane2"),
PaneItem("steps.pane3"),
),
HSplitter(
PaneItem("steps.pane4"),
PaneItem("steps.pane5"),
PaneItem("steps.pane6"),
),
)
)
def _menu_bar_default(self):
return SMenuBar(
SMenu(
TaskAction(name="New", method="new", accelerator="Ctrl+N"),
id="File",
name="&File",
),
SMenu(
DockPaneToggleGroup(),
TaskToggleGroup(),
id="View",
name="&View",
),
)
class DialogWithSchema(HasTraits):
"""Test dialog with toolbar and menu schemas."""
action_successful = Bool(False)
def test_clicked(self):
self.action_successful = True
menubar = SMenuBar(
SMenu(
SGroup(
ActionSchema(
action_factory=lambda **traits: TestAction,
),
),
name="&Test menu",
),
)
toolbar = SToolBar(
SGroup(
ActionSchema(
action_factory=lambda **traits: TestAction,
),
),
)
traits_view = View(
Item(
label="Click the button on the toolbar or the menu item.\n"
"The 'Action successful' element should turn to True."
),
Item("action_successful", style="readonly"),
menubar=menubar,
toolbar=toolbar,
buttons=[TestAction, "OK"],
)
class ExampleTask(Task):
""" A simple task for opening a blank editor.
"""
# Task interface -------------------------------------------------------
id = "example.example_task"
name = "Multi-Tab Editor"
active_editor = Property(Instance(IEditor),
observe="editor_area.active_editor")
editor_area = Instance(IEditorAreaPane)
menu_bar = SMenuBar(
SMenu(
TaskAction(name="New", method="new", accelerator="Ctrl+N"),
TaskAction(name="Add Task",
method="add_task",
accelerator="Ctrl+A"),
TaskAction(name="Remove Task",
method="remove_task",
accelerator="Ctrl+R"),
id="File",
name="&File",
),
SMenu(DockPaneToggleGroup(),
TaskToggleGroup(),
id="View",
name="&View"),
)
tool_bars = [
SToolBar(
TaskAction(
method="new",
tooltip="New file",
image=ImageResource("document_new"),
),
image_size=(32, 32),
)
]
# ------------------------------------------------------------------------
# 'Task' interface.
# ------------------------------------------------------------------------
def _default_layout_default(self):
return TaskLayout(top=VSplitter(
HSplitter(PaneItem("steps.pane1"), PaneItem("steps.pane2"))))
def create_central_pane(self):
""" Create the central pane: the script editor.
"""
self.editor_area = EditorAreaPane()
return self.editor_area
def create_dock_panes(self):
""" Create the file browser and connect to its double click event.
"""
return [Pane1(), Pane2()]
# ------------------------------------------------------------------------
# 'ExampleTask' interface.
# ------------------------------------------------------------------------
def new(self):
""" Opens a new empty window
"""
editor = Editor()
self.editor_area.add_editor(editor)
self.editor_area.activate_editor(editor)
self.activated()
def add_task(self):
""" Opens a new empty window
"""
task3 = ThirdTask()
self.window.add_task(task3)
self.window.activate_task(task3)
def remove_task(self):
""" Opens a new empty window
"""
task = self.window.tasks[0]
window = self.window
window.remove_task(self)
window.activate_task(task)
# Trait property getter/setters ----------------------------------------
def _get_active_editor(self):
if self.editor_area is not None:
return self.editor_area.active_editor
return None
class PythonEditorTask(Task):
""" A simple task for editing Python code.
"""
# 'Task' traits -----------------------------------------------------------
#: The unique id of the task.
id = "example.python_editor_task"
#: The human-readable name of the task.
name = "Python Editor"
#: The currently active editor in the editor area, if any.
active_editor = Property(
Instance(IEditor), observe="editor_area.active_editor"
)
#: The editor area for this task.
editor_area = Instance(IEditorAreaPane)
#: The menu bar for the task.
menu_bar = SMenuBar(
SMenu(
SGroup(
TaskAction(name="New", method="new", accelerator="Ctrl+N"),
id="new_group",
),
SGroup(
TaskAction(
name="Open...", method="open", accelerator="Ctrl+O"
),
id="open_group",
),
SGroup(
TaskAction(
name="Save",
method="save",
accelerator="Ctrl+S",
enabled_name="active_editor.dirty",
),
TaskAction(
name="Save As...",
method="save_as",
accelerator="Ctrl+Shift+S",
),
id="save_group",
),
SGroup(
TaskAction(
name="Close Editor",
method="close_editor",
accelerator="Ctrl+W",
),
id="close_group",
),
id="File",
name="&File",
),
SMenu(
SGroup(
EditorAction(
name="Undo",
method="undo",
enabled_name="can_undo",
accelerator="Ctrl+Z",
),
EditorAction(
name="Redo",
method="redo",
enabled_name="can_redo",
accelerator="Ctrl+Shift+Z",
),
id="undo_group",
),
SGroup(
EditorAction(
name="Go to Line...",
method="go_to_line",
accelerator="Ctrl+G",
),
id="search_group",
),
id="Edit",
name="&Edit",
),
SMenu(DockPaneToggleGroup(), id="View", name="&View"),
SMenu(
SGroup(
OpenURLAction(
name="Python Documentation",
id="python_docs",
url=PYTHON_DOCS,
),
id="documentation_group",
),
id="Help",
name="&Help",
),
)
#: The tool bars for the task.
tool_bars = [
SToolBar(
TaskAction(
method="new",
tooltip="New file",
image=ImageResource("document_new"),
),
TaskAction(
method="open",
tooltip="Open a file",
image=ImageResource("document_open"),
),
TaskAction(
method="save",
tooltip="Save the current file",
image=ImageResource("document_save"),
enabled_name="active_editor.dirty",
),
image_size=(16, 16),
show_tool_names=False,
)
]
#: The status bar for the window when this task is active.
status_bar = Instance(StatusBarManager, ())
# -------------------------------------------------------------------------
# 'PythonEditorTask' interface.
# -------------------------------------------------------------------------
def create_editor(self, path=""):
""" Create a new editor in the editor pane.
Parameters
----------
path : path or ''
The path to the file to edit, or '' for an empty editor.
"""
if path:
path = os.path.abspath(path)
use_existing = path != ""
self.editor_area.edit(
path, factory=PythonEditor, use_existing=use_existing
)
if path:
self.active_editor.load()
def close_editor(self):
""" Close the active editor, or if no editors, close the Task window.
"""
if self.editor_area.active_editor is not None:
self.editor_area.remove_editor(self.editor_area.active_editor)
else:
self.window.close()
def new(self):
""" Open a new empty window
"""
self.create_editor()
def open(self):
""" Shows a dialog to open a Python file.
"""
dialog = FileDialog(parent=self.window.control, wildcard="*.py")
if dialog.open() == OK:
self.create_editor(dialog.path)
def save(self):
""" Save the current file.
If needed, this code prompts for a path.
Returns
-------
saved : bool
Whether or not the file was saved.
"""
editor = self.active_editor
try:
editor.save()
except IOError:
# If you are trying to save to a file that doesn't exist, open up a
# FileDialog with a 'save as' action.
dialog = FileDialog(
parent=self.window.control, action="save as", wildcard="*.py"
)
if dialog.open() == OK:
editor.save(dialog.path)
else:
return False
return True
# -------------------------------------------------------------------------
# 'Task' interface.
# -------------------------------------------------------------------------
def _default_layout_default(self):
""" The default layout with the browser pane on the left.
"""
return TaskLayout(
left=PaneItem("example.python_browser_pane", width=200)
)
def create_central_pane(self):
""" Create the central pane: the script editor.
"""
self.editor_area = EditorAreaPane()
return self.editor_area
def create_dock_panes(self):
""" Create the file browser and connect to its double click event.
"""
browser = PythonBrowserPane()
def handler(event):
path = event.new
if os.path.isfile(path):
return self.create_editor(path)
browser.observe(handler, "activated")
return [browser]
# -------------------------------------------------------------------------
# Protected interface.
# -------------------------------------------------------------------------
def _prompt_for_save(self):
""" Prompts the user to save if necessary. Returns whether the dialog
was cancelled.
"""
dirty_editors = {
editor.name: editor
for editor in self.editor_area.editors
if editor.dirty and (editor.obj or editor.code)
}
if not dirty_editors:
return True
message = "You have unsaved files. Would you like to save them?"
dialog = ConfirmationDialog(
parent=self.window.control,
message=message,
cancel=True,
default=CANCEL,
title="Save Changes?",
)
result = dialog.open()
if result == CANCEL:
return False
elif result == YES:
for name, editor in dirty_editors.items():
editor.save(editor.path)
return True
# Trait change handlers --------------------------------------------------
@observe("window:closing")
def _prompt_on_close(self, event):
""" Prompt the user to save when exiting.
"""
close = self._prompt_for_save()
window = event.new
window.veto = not close
@observe("active_editor.name")
def _change_title(self, event):
""" Update the window title when the active editor changes.
"""
if self.window.active_task == self:
if self.active_editor is not None:
self.window.title = self.active_editor.name
else:
self.window.title = self.name
@observe("active_editor.[line,column,selection_length]")
def _update_status(self, event):
if self.active_editor is not None:
editor = self.active_editor
if editor.selection_length:
self.status_bar.messages = [
"Ln {}, Col {} ({} selected)".format(
editor.line, editor.column, editor.selection_length
)
]
else:
self.status_bar.messages = [
"Ln {}, Col {}".format(editor.line, editor.column)
]
else:
self.status_bar.messages = []
# Trait property getter/setters ------------------------------------------
@cached_property
def _get_active_editor(self):
if self.editor_area is not None:
return self.editor_area.active_editor
return None
class ExampleTask(Task):
""" A simple task for editing Python code.
"""
# Task interface -------------------------------------------------------
id = "example.example_task"
name = "Multi-Tab Editor"
active_editor = Property(Instance(IEditor),
observe="editor_area.active_editor")
editor_area = Instance(IEditorAreaPane)
menu_bar = SMenuBar(
SMenu(
TaskAction(name="New", method="new", accelerator="Ctrl+N"),
TaskAction(name="Open...", method="open", accelerator="Ctrl+O"),
TaskAction(name="Save", method="save", accelerator="Ctrl+S"),
id="File",
name="&File",
),
SMenu(DockPaneToggleGroup(), id="View", name="&View"),
)
tool_bars = [
SToolBar(
TaskAction(
method="new",
tooltip="New file",
image=ImageResource("document_new"),
),
TaskAction(
method="open",
tooltip="Open a file",
image=ImageResource("document_open"),
),
TaskAction(
method="save",
tooltip="Save the current file",
image=ImageResource("document_save"),
),
image_size=(32, 32),
show_tool_names=False,
)
]
# ------------------------------------------------------------------------
# 'Task' interface.
# ------------------------------------------------------------------------
def _default_layout_default(self):
return TaskLayout(left=PaneItem("example.python_script_browser_pane"))
def activated(self):
""" Overriden to set the window's title.
"""
return
filename = self.active_editor.path if self.active_editor else ""
self.window.title = filename if filename else "Untitled"
def create_central_pane(self):
""" Create the central pane: the script editor.
"""
self.editor_area = EditorAreaPane()
return self.editor_area
def create_dock_panes(self):
""" Create the file browser and connect to its double click event.
"""
browser = PythonScriptBrowserPane()
handler = lambda _: self._open_file(browser.selected_file)
browser.observe(handler, "activated")
return [browser]
# ------------------------------------------------------------------------
# 'ExampleTask' interface.
# ------------------------------------------------------------------------
def new(self):
""" Opens a new empty window
"""
editor = PythonEditor()
self.editor_area.add_editor(editor)
self.editor_area.activate_editor(editor)
self.activated()
def open(self):
""" Shows a dialog to open a file.
"""
dialog = FileDialog(parent=self.window.control, wildcard="*.py")
if dialog.open() == OK:
self._open_file(dialog.path)
def save(self):
""" Attempts to save the current file, prompting for a path if
necessary. Returns whether the file was saved.
"""
editor = self.active_editor
try:
editor.save()
except IOError:
# If you are trying to save to a file that doesn't exist, open up a
# FileDialog with a 'save as' action.
dialog = FileDialog(parent=self.window.control,
action="save as",
wildcard="*.py")
if dialog.open() == OK:
editor.save(dialog.path)
else:
return False
return True
# ------------------------------------------------------------------------
# Protected interface.
# ------------------------------------------------------------------------
def _open_file(self, filename):
""" Opens the file at the specified path in the editor.
"""
editor = PythonEditor(path=filename)
self.editor_area.add_editor(editor)
self.editor_area.activate_editor(editor)
self.activated()
def _prompt_for_save(self):
""" Prompts the user to save if necessary. Returns whether the dialog
was cancelled.
"""
dirty_editors = dict([(editor.name, editor)
for editor in self.editor_area.editors
if editor.dirty])
if not dirty_editors.keys():
return True
message = "You have unsaved files. Would you like to save them?"
dialog = ConfirmationDialog(
parent=self.window.control,
message=message,
cancel=True,
default=CANCEL,
title="Save Changes?",
)
result = dialog.open()
if result == CANCEL:
return False
elif result == YES:
for name, editor in dirty_editors.items():
editor.save(editor.path)
return True
# Trait change handlers ------------------------------------------------
@observe("window:closing")
def _prompt_on_close(self, event):
""" Prompt the user to save when exiting.
"""
close = self._prompt_for_save()
window = event.new
window.veto = not close
# Trait property getter/setters ----------------------------------------
def _get_active_editor(self):
if self.editor_area is not None:
return self.editor_area.active_editor
return None
class ExampleTask(Task):
""" A simple task for opening a blank editor.
"""
# Task interface -------------------------------------------------------
id = "example.example_task"
name = "Multi-Tab Editor"
active_editor = Property(
Instance(IEditor), observe="editor_area.active_editor"
)
editor_area = Instance(IEditorAreaPane)
menu_bar = SMenuBar(
SMenu(
TaskAction(name="New", method="new", accelerator="Ctrl+N"),
id="File",
name="&File",
),
SMenu(DockPaneToggleGroup(), id="View", name="&View"),
)
tool_bars = [
SToolBar(
TaskAction(
method="new",
tooltip="New file",
image=ImageResource("document_new"),
),
image_size=(32, 32),
)
]
# ------------------------------------------------------------------------
# 'Task' interface.
# ------------------------------------------------------------------------
def create_central_pane(self):
""" Create the central pane: the script editor.
"""
self.editor_area = EditorAreaPane()
return self.editor_area
# ------------------------------------------------------------------------
# 'ExampleTask' interface.
# ------------------------------------------------------------------------
def new(self):
""" Opens a new empty window
"""
editor = Editor()
self.editor_area.add_editor(editor)
self.editor_area.activate_editor(editor)
self.activated()
# Trait property getter/setters ----------------------------------------
def _get_active_editor(self):
if self.editor_area is not None:
return self.editor_area.active_editor
return None
class ExampleTask(Task):
""" A simple task for editing Python code.
"""
# Task interface -------------------------------------------------------
id = "example.example_task"
name = "Python Script Editor"
# default_layout = TaskLayout(
# left=PaneItem('example.python_script_browser_pane'))
menu_bar = SMenuBar(
SMenu(
TaskAction(name="Open...", method="open", accelerator="Ctrl+O"),
TaskAction(name="Save", method="save", accelerator="Ctrl+S"),
id="File",
name="&File",
),
SMenu(DockPaneToggleGroup(), id="View", name="&View"),
)
tool_bars = [
SToolBar(
TaskAction(
method="open",
tooltip="Open a file",
image=ImageResource("document_open"),
),
TaskAction(
method="save",
tooltip="Save the current file",
image=ImageResource("document_save"),
),
)
]
# ------------------------------------------------------------------------
# 'Task' interface.
# ------------------------------------------------------------------------
def _default_layout_default(self):
return TaskLayout(left=PaneItem("example.python_script_browser_pane"))
def activated(self):
""" Overriden to set the window's title.
"""
filename = self.window.central_pane.editor.path
self.window.title = filename if filename else "Untitled"
def create_central_pane(self):
""" Create the central pane: the script editor.
"""
return PythonEditorPane()
def create_dock_panes(self):
""" Create the file browser and connect to its double click event.
"""
browser = PythonScriptBrowserPane()
handler = lambda _: self._open_file(browser.selected_file)
browser.observe(handler, "activated")
return [browser]
# ------------------------------------------------------------------------
# 'ExampleTask' interface.
# ------------------------------------------------------------------------
def open(self):
""" Shows a dialog to open a file.
"""
dialog = FileDialog(parent=self.window.control, wildcard="*.py")
if dialog.open() == OK:
self._open_file(dialog.path)
def save(self):
""" Attempts to save the current file, prompting for a path if
necessary. Returns whether the file was saved.
"""
editor = self.window.central_pane.editor
try:
editor.save()
except IOError:
# If you are trying to save to a file that doesn't exist, open up a
# FileDialog with a 'save as' action.
dialog = FileDialog(parent=self.window.control,
action="save as",
wildcard="*.py")
if dialog.open() == OK:
editor.save(dialog.path)
else:
return False
return True
# ------------------------------------------------------------------------
# Protected interface.
# ------------------------------------------------------------------------
def _open_file(self, filename):
""" Opens the file at the specified path in the editor.
"""
if self._prompt_for_save():
self.window.central_pane.editor.path = filename
self.activated()
def _prompt_for_save(self):
""" Prompts the user to save if necessary. Returns whether the dialog
was cancelled.
"""
if self.window.central_pane.editor.dirty:
message = ("The current file has unsaved changes. "
"Do you want to save your changes?")
dialog = ConfirmationDialog(
parent=self.window.control,
message=message,
cancel=True,
default=CANCEL,
title="Save Changes?",
)
result = dialog.open()
if result == CANCEL:
return False
elif result == YES:
if not self.save():
return self._prompt_for_save()
return True
@observe("window:closing")
def _prompt_on_close(self, event):
""" Prompt the user to save when exiting.
"""
window = event.new
if not self._prompt_for_save():
window.veto = True