def get_toolbar_buttons(self):
"""Return toolbar buttons list."""
buttons = []
# Code to add the stop button
if self.stop_button is None:
self.stop_button = create_toolbutton(
self,
text=_("Stop"),
icon=self.stop_icon,
tip=_("Stop the current command"))
self.disable_stop_button()
# set click event handler
self.stop_button.clicked.connect(self.stop_button_click_handler)
if self.stop_button is not None:
buttons.append(self.stop_button)
if self.options_button is None:
options = self.get_options_menu()
if options:
self.options_button = create_toolbutton(
self, text=_('Options'), icon=ima.icon('tooloptions'))
self.options_button.setPopupMode(QToolButton.InstantPopup)
menu = QMenu(self)
add_actions(menu, options)
self.options_button.setMenu(menu)
if self.options_button is not None:
buttons.append(self.options_button)
return buttons
def __init__(self, parent, actions=None, menu=None,
corner_widgets=None, menu_use_tooltips=False):
QTabWidget.__init__(self, parent)
self.setUsesScrollButtons(True)
# To style tabs on Mac
if sys.platform == 'darwin':
self.setObjectName('plugin-tab')
self.corner_widgets = {}
self.menu_use_tooltips = menu_use_tooltips
if menu is None:
self.menu = QMenu(self)
if actions:
add_actions(self.menu, actions)
else:
self.menu = menu
# Corner widgets
if corner_widgets is None:
corner_widgets = {}
corner_widgets.setdefault(Qt.TopLeftCorner, [])
corner_widgets.setdefault(Qt.TopRightCorner, [])
self.browse_button = create_toolbutton(self,
icon=ima.icon('browse_tab'),
tip=_("Browse tabs"))
self.browse_tabs_menu = QMenu(self)
self.browse_button.setMenu(self.browse_tabs_menu)
self.browse_button.setPopupMode(self.browse_button.InstantPopup)
self.browse_tabs_menu.aboutToShow.connect(self.update_browse_tabs_menu)
corner_widgets[Qt.TopLeftCorner] += [self.browse_button]
self.set_corner_widgets(corner_widgets)
def update_menu(self):
self.menu.clear()
items = self.selectedItems()
actions = self.get_actions_from_items(items)
if actions:
actions.append(None)
actions += self.common_actions
add_actions(self.menu, actions)
def setup_menu(self):
"""Setup context menu"""
self.copy_action = create_action(self,
_('Copy'),
shortcut=keybinding('Copy'),
icon=ima.icon('editcopy'),
triggered=self.copy,
context=Qt.WidgetShortcut)
menu = QMenu(self)
add_actions(menu, [
self.copy_action,
])
return menu
def __init__(self, parent):
self.tabwidget = None
self.menu_actions = None
self.dockviewer = None
self.wrap_action = None
self.editors = []
self.filenames = []
if PYQT5:
TRexPluginWidget.__init__(self, parent, main=parent)
else:
TRexPluginWidget.__init__(self, parent)
# Initialize plugin
self.initialize_plugin()
layout = QVBoxLayout()
self.tabwidget = Tabs(self, self.menu_actions)
self.tabwidget.currentChanged.connect(self.refresh_plugin)
self.tabwidget.move_data.connect(self.move_tab)
if sys.platform == 'darwin':
tab_container = QWidget()
tab_container.setObjectName('tab-container')
tab_layout = QHBoxLayout(tab_container)
tab_layout.setContentsMargins(0, 0, 0, 0)
tab_layout.addWidget(self.tabwidget)
layout.addWidget(tab_container)
else:
layout.addWidget(self.tabwidget)
# Menu as corner widget
options_button = create_toolbutton(self,
text=_('Options'),
icon=ima.icon('tooloptions'))
options_button.setPopupMode(QToolButton.InstantPopup)
menu = QMenu(self)
add_actions(menu, self.menu_actions)
options_button.setMenu(menu)
self.tabwidget.setCornerWidget(options_button)
# Find/replace widget
self.find_widget = FindReplace(self)
self.find_widget.hide()
self.register_widget_shortcuts(self.find_widget)
layout.addWidget(self.find_widget)
self.setLayout(layout)
def contextMenuEvent(self, event):
menu = QMenu(self)
actions = [
self.pageAction(QWebEnginePage.Back),
self.pageAction(QWebEnginePage.Forward), None,
self.pageAction(QWebEnginePage.SelectAll),
self.pageAction(QWebEnginePage.Copy), None, self.zoom_in_action,
self.zoom_out_action
]
if DEV and not WEBENGINE:
settings = self.page().settings()
settings.setAttribute(QWebEngineSettings.DeveloperExtrasEnabled,
True)
actions += [None, self.pageAction(QWebEnginePage.InspectElement)]
add_actions(menu, actions)
menu.popup(event.globalPos())
event.accept()
def setup_context_menu(self):
"""Setup shell context menu"""
self.menu = QMenu(self)
self.cut_action = create_action(self,
_("Cut"),
shortcut=keybinding('Cut'),
icon=ima.icon('editcut'),
triggered=self.cut)
self.copy_action = create_action(self,
_("Copy"),
shortcut=keybinding('Copy'),
icon=ima.icon('editcopy'),
triggered=self.copy)
paste_action = create_action(self,
_("Paste"),
shortcut=keybinding('Paste'),
icon=ima.icon('editpaste'),
triggered=self.paste)
save_action = create_action(self,
_("Save history log..."),
icon=ima.icon('filesave'),
tip=_(
"Save current history log (i.e. all "
"inputs and outputs) in a text file"),
triggered=self.save_historylog)
self.delete_action = create_action(self,
_("Delete"),
shortcut=keybinding('Delete'),
icon=ima.icon('editdelete'),
triggered=self.delete)
selectall_action = create_action(self,
_("Select All"),
shortcut=keybinding('SelectAll'),
icon=ima.icon('selectall'),
triggered=self.selectAll)
add_actions(
self.menu,
(self.cut_action, self.copy_action, paste_action,
self.delete_action, None, selectall_action, None, save_action))
def contextMenuEvent(self, event):
index_clicked = self.indexAt(event.pos())
actions = []
self.popup_menu = QMenu(self)
clear_all_breakpoints_action = create_action(
self,
_("Clear breakpoints in all files"),
triggered=lambda: self.clear_all_breakpoints.emit())
actions.append(clear_all_breakpoints_action)
if self.model.breakpoints:
filename = self.model.breakpoints[index_clicked.row()][0]
lineno = int(self.model.breakpoints[index_clicked.row()][1])
# QAction.triggered works differently for PySide and PyQt
if not API == 'pyside':
clear_slot = lambda _checked, filename=filename, lineno=lineno: \
self.clear_breakpoint.emit(filename, lineno)
edit_slot = lambda _checked, filename=filename, lineno=lineno: \
(self.edit_goto.emit(filename, lineno, ''),
self.set_or_edit_conditional_breakpoint.emit())
else:
clear_slot = lambda filename=filename, lineno=lineno: \
self.clear_breakpoint.emit(filename, lineno)
edit_slot = lambda filename=filename, lineno=lineno: \
(self.edit_goto.emit(filename, lineno, ''),
self.set_or_edit_conditional_breakpoint.emit())
clear_breakpoint_action = create_action(self,
_("Clear this breakpoint"),
triggered=clear_slot)
actions.insert(0, clear_breakpoint_action)
edit_breakpoint_action = create_action(self,
_("Edit this breakpoint"),
triggered=edit_slot)
actions.append(edit_breakpoint_action)
add_actions(self.popup_menu, actions)
self.popup_menu.popup(event.globalPos())
event.accept()
def setup_menu_actions(self):
"""Setup and update the menu actions."""
self.recent_project_menu.clear()
self.recent_projects_actions = []
if self.recent_projects:
for project in self.recent_projects:
if self.is_valid_project(project):
name = project.replace(get_home_dir(), '~')
action = create_action(self,
name,
icon=ima.icon('project'),
triggered=lambda v, path=project:
self.open_project(path=path))
self.recent_projects_actions.append(action)
else:
self.recent_projects.remove(project)
self.recent_projects_actions += [
None, self.clear_recent_projects_action
]
else:
self.recent_projects_actions = [self.clear_recent_projects_action]
add_actions(self.recent_project_menu, self.recent_projects_actions)
self.update_project_actions()
def get_options_menu(self):
ExternalShellBase.get_options_menu(self)
self.interact_action = create_action(self, _("Interact"))
self.interact_action.setCheckable(True)
self.debug_action = create_action(self, _("Debug"))
self.debug_action.setCheckable(True)
self.args_action = create_action(self,
_("Arguments..."),
triggered=self.get_arguments)
self.post_mortem_action = create_action(self, _("Post Mortem Debug"))
self.post_mortem_action.setCheckable(True)
run_settings_menu = QMenu(_("Run settings"), self)
add_actions(run_settings_menu,
(self.interact_action, self.debug_action, self.args_action,
self.post_mortem_action))
self.cwd_button = create_action(
self,
_("Working directory"),
icon=ima.icon('DirOpenIcon'),
tip=_("Set current working directory"),
triggered=self.set_current_working_directory)
self.env_button = create_action(self,
_("Environment variables"),
icon=ima.icon('environ'),
triggered=self.show_env)
self.syspath_button = create_action(self,
_("Show sys.path contents"),
icon=ima.icon('syspath'),
triggered=self.show_syspath)
actions = [
run_settings_menu, self.show_time_action, None, self.cwd_button,
self.env_button, self.syspath_button
]
if self.menu_actions is not None:
actions += [None] + self.menu_actions
return actions
def __init__(self, parent):
QTableView.__init__(self, parent)
self._model = None
# Setting up actions
self.date_dayfirst_action = create_action(self,
"dayfirst",
triggered=ft_partial(
self.parse_to_type,
atype="date",
dayfirst=True))
self.date_monthfirst_action = create_action(self,
"monthfirst",
triggered=ft_partial(
self.parse_to_type,
atype="date",
dayfirst=False))
self.perc_action = create_action(self,
"perc",
triggered=ft_partial(
self.parse_to_type, atype="perc"))
self.acc_action = create_action(self,
"account",
triggered=ft_partial(
self.parse_to_type,
atype="account"))
self.str_action = create_action(self,
"unicode",
triggered=ft_partial(
self.parse_to_type,
atype="unicode"))
self.int_action = create_action(self,
"int",
triggered=ft_partial(
self.parse_to_type, atype="int"))
self.float_action = create_action(self,
"float",
triggered=ft_partial(
self.parse_to_type,
atype="float"))
# Setting up menus
self.date_menu = QMenu()
self.date_menu.setTitle("Date")
add_actions(self.date_menu,
(self.date_dayfirst_action, self.date_monthfirst_action))
self.parse_menu = QMenu(self)
self.parse_menu.addMenu(self.date_menu)
add_actions(self.parse_menu, (self.perc_action, self.acc_action))
self.parse_menu.setTitle("String to")
self.opt_menu = QMenu(self)
self.opt_menu.addMenu(self.parse_menu)
add_actions(self.opt_menu,
(self.str_action, self.int_action, self.float_action))
def update_menu(self):
"""Update context menu"""
self.menu.clear()
add_actions(self.menu, self.create_context_menu_actions())
def __init__(self, parent=None, name_filters=['*.py', '*.pyw'],
show_all=False, show_cd_only=None, show_icontext=True):
QWidget.__init__(self, parent)
# Widgets
self.treewidget = ExplorerTreeWidget(self, show_cd_only=show_cd_only)
button_previous = QToolButton(self)
button_next = QToolButton(self)
button_parent = QToolButton(self)
self.button_menu = QToolButton(self)
menu = QMenu(self)
self.action_widgets = [button_previous, button_next, button_parent,
self.button_menu]
# Actions
icontext_action = create_action(self, _("Show icons and text"),
toggled=self.toggle_icontext)
previous_action = create_action(self, text=_("Previous"),
icon=ima.icon('ArrowBack'),
triggered=self.treewidget.go_to_previous_directory)
next_action = create_action(self, text=_("Next"),
icon=ima.icon('ArrowForward'),
triggered=self.treewidget.go_to_next_directory)
parent_action = create_action(self, text=_("Parent"),
icon=ima.icon('ArrowUp'),
triggered=self.treewidget.go_to_parent_directory)
options_action = create_action(self, text='', tip=_('Options'))
# Setup widgets
self.treewidget.setup(name_filters=name_filters, show_all=show_all)
self.treewidget.chdir(getcwd())
self.treewidget.common_actions += [None, icontext_action]
button_previous.setDefaultAction(previous_action)
previous_action.setEnabled(False)
button_next.setDefaultAction(next_action)
next_action.setEnabled(False)
button_parent.setDefaultAction(parent_action)
self.button_menu.setIcon(ima.icon('tooloptions'))
self.button_menu.setPopupMode(QToolButton.InstantPopup)
self.button_menu.setMenu(menu)
add_actions(menu, self.treewidget.common_actions)
options_action.setMenu(menu)
self.toggle_icontext(show_icontext)
icontext_action.setChecked(show_icontext)
for widget in self.action_widgets:
widget.setAutoRaise(True)
widget.setIconSize(QSize(16, 16))
# Layouts
blayout = QHBoxLayout()
blayout.addWidget(button_previous)
blayout.addWidget(button_next)
blayout.addWidget(button_parent)
blayout.addStretch()
blayout.addWidget(self.button_menu)
layout = QVBoxLayout()
layout.addLayout(blayout)
layout.addWidget(self.treewidget)
self.setLayout(layout)
# Signals and slots
self.treewidget.set_previous_enabled.connect(
previous_action.setEnabled)
self.treewidget.set_next_enabled.connect(next_action.setEnabled)
def __init__(self, parent):
if PYQT5:
TRexPluginWidget.__init__(self, parent, main=parent)
else:
TRexPluginWidget.__init__(self, parent)
self.internal_shell = None
# Initialize plugin
self.initialize_plugin()
self.no_doc_string = _("No documentation available")
self._last_console_cb = None
self._last_editor_cb = None
self.plain_text = PlainText(self)
self.rich_text = RichText(self)
color_scheme = self.get_color_scheme()
self.set_plain_text_font(self.get_plugin_font(), color_scheme)
self.plain_text.editor.toggle_wrap_mode(self.get_option('wrap'))
# Add entries to read-only editor context-menu
self.wrap_action = create_action(self,
_("Wrap lines"),
toggled=self.toggle_wrap_mode)
self.wrap_action.setChecked(self.get_option('wrap'))
self.plain_text.editor.readonly_menu.addSeparator()
add_actions(self.plain_text.editor.readonly_menu, (self.wrap_action, ))
self.set_rich_text_font(self.get_plugin_font('rich_text'))
self.shell = None
# locked = disable link with Console
self.locked = False
self._last_texts = [None, None]
self._last_editor_doc = None
# Object name
layout_edit = QHBoxLayout()
layout_edit.setContentsMargins(0, 0, 0, 0)
txt = _("Source")
if sys.platform == 'darwin':
source_label = QLabel(" " + txt)
else:
source_label = QLabel(txt)
layout_edit.addWidget(source_label)
self.source_combo = QComboBox(self)
self.source_combo.addItems([_("Console"), _("Editor")])
self.source_combo.currentIndexChanged.connect(self.source_changed)
if (not programs.is_module_installed('rope')
and not programs.is_module_installed('jedi', '>=0.8.1')):
self.source_combo.hide()
source_label.hide()
layout_edit.addWidget(self.source_combo)
layout_edit.addSpacing(10)
layout_edit.addWidget(QLabel(_("Object")))
self.combo = ObjectComboBox(self)
layout_edit.addWidget(self.combo)
self.object_edit = QLineEdit(self)
self.object_edit.setReadOnly(True)
layout_edit.addWidget(self.object_edit)
self.combo.setMaxCount(self.get_option('max_history_entries'))
self.combo.addItems(self.load_history())
self.combo.setItemText(0, '')
self.combo.valid.connect(lambda valid: self.force_refresh())
# Plain text docstring option
self.docstring = True
self.rich_help = self.get_option('rich_mode', True)
self.plain_text_action = create_action(self,
_("Plain Text"),
toggled=self.toggle_plain_text)
# Source code option
self.show_source_action = create_action(
self, _("Show Source"), toggled=self.toggle_show_source)
# Rich text option
self.rich_text_action = create_action(self,
_("Rich Text"),
toggled=self.toggle_rich_text)
# Add the help actions to an exclusive QActionGroup
help_actions = QActionGroup(self)
help_actions.setExclusive(True)
help_actions.addAction(self.plain_text_action)
help_actions.addAction(self.rich_text_action)
# Automatic import option
self.auto_import_action = create_action(
self, _("Automatic import"), toggled=self.toggle_auto_import)
auto_import_state = self.get_option('automatic_import')
self.auto_import_action.setChecked(auto_import_state)
# Lock checkbox
self.locked_button = create_toolbutton(self,
triggered=self.toggle_locked)
layout_edit.addWidget(self.locked_button)
self._update_lock_icon()
# Option menu
options_button = create_toolbutton(self,
text=_('Options'),
icon=ima.icon('tooloptions'))
options_button.setPopupMode(QToolButton.InstantPopup)
menu = QMenu(self)
add_actions(menu, [
self.rich_text_action, self.plain_text_action,
self.show_source_action, None, self.auto_import_action
])
options_button.setMenu(menu)
layout_edit.addWidget(options_button)
if self.rich_help:
self.switch_to_rich_text()
else:
self.switch_to_plain_text()
self.plain_text_action.setChecked(not self.rich_help)
self.rich_text_action.setChecked(self.rich_help)
self.source_changed()
# Main layout
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addLayout(layout_edit)
layout.addWidget(self.plain_text)
layout.addWidget(self.rich_text)
self.setLayout(layout)
# Add worker thread for handling rich text rendering
self._sphinx_thread = SphinxThread(
html_text_no_doc=warning(self.no_doc_string))
self._sphinx_thread.html_ready.connect(
self._on_sphinx_thread_html_ready)
self._sphinx_thread.error_msg.connect(self._on_sphinx_thread_error_msg)
# Handle internal and external links
view = self.rich_text.webview
if not WEBENGINE:
view.page().setLinkDelegationPolicy(
QWebEnginePage.DelegateAllLinks)
view.linkClicked.connect(self.handle_link_clicks)
self._starting_up = True
def setup(self,
check_all=None,
exclude_private=None,
exclude_uppercase=None,
exclude_capitalized=None,
exclude_unsupported=None,
excluded_names=None,
minmax=None,
dataframe_format=None,
autorefresh=None):
"""
Setup the namespace browser with provided settings.
Args:
dataframe_format (string): default floating-point format for
DataFrame editor
"""
assert self.shellwidget is not None
self.check_all = check_all
self.exclude_private = exclude_private
self.exclude_uppercase = exclude_uppercase
self.exclude_capitalized = exclude_capitalized
self.exclude_unsupported = exclude_unsupported
self.excluded_names = excluded_names
self.minmax = minmax
self.autorefresh = autorefresh
self.dataframe_format = dataframe_format
if self.editor is not None:
self.editor.setup_menu(minmax)
self.editor.set_dataframe_format(dataframe_format)
self.exclude_private_action.setChecked(exclude_private)
self.exclude_uppercase_action.setChecked(exclude_uppercase)
self.exclude_capitalized_action.setChecked(exclude_capitalized)
self.exclude_unsupported_action.setChecked(exclude_unsupported)
if self.auto_refresh_button is not None:
self.auto_refresh_button.setChecked(autorefresh)
self.refresh_table()
return
self.editor = RemoteCollectionsEditorTableView(
self,
None,
minmax=minmax,
dataframe_format=dataframe_format,
get_value_func=self.get_value,
set_value_func=self.set_value,
new_value_func=self.set_value,
remove_values_func=self.remove_values,
copy_value_func=self.copy_value,
is_list_func=self.is_list,
get_len_func=self.get_len,
is_array_func=self.is_array,
is_image_func=self.is_image,
is_dict_func=self.is_dict,
is_data_frame_func=self.is_data_frame,
is_series_func=self.is_series,
get_array_shape_func=self.get_array_shape,
get_array_ndim_func=self.get_array_ndim,
plot_func=self.plot,
imshow_func=self.imshow,
show_image_func=self.show_image)
self.editor.sig_option_changed.connect(self.sig_option_changed.emit)
self.editor.sig_files_dropped.connect(self.import_data)
# Setup layout
layout = QVBoxLayout()
blayout = QHBoxLayout()
toolbar = self.setup_toolbar(exclude_private, exclude_uppercase,
exclude_capitalized, exclude_unsupported,
autorefresh)
for widget in toolbar:
blayout.addWidget(widget)
# Options menu
options_button = create_toolbutton(self,
text=_('Options'),
icon=ima.icon('tooloptions'))
options_button.setPopupMode(QToolButton.InstantPopup)
menu = QMenu(self)
editor = self.editor
actions = [
self.exclude_private_action, self.exclude_uppercase_action,
self.exclude_capitalized_action, self.exclude_unsupported_action,
None
]
if is_module_installed('numpy'):
actions.append(editor.minmax_action)
add_actions(menu, actions)
options_button.setMenu(menu)
blayout.addStretch()
blayout.addWidget(options_button)
layout.addLayout(blayout)
layout.addWidget(self.editor)
self.setLayout(layout)
layout.setContentsMargins(0, 0, 0, 0)
self.sig_option_changed.connect(self.option_changed)
