code
stringlengths 9
189k
| meta_data.file_name
stringclasses 538
values | meta_data.module
stringclasses 202
values | meta_data.contains_class
bool 2
classes | meta_data.contains_function
bool 2
classes | meta_data.file_imports
sequencelengths 0
97
| meta_data.start_line
int64 -1
6.71k
| meta_data.end_line
int64 -1
6.74k
|
|---|---|---|---|---|---|---|---|
class SpyderPreferencesTab(BaseConfigTab):
"""
Widget that represents a tab on a preference page.
All calls to :class:`SpyderConfigPage` attributes are resolved
via delegation.
"""
# Name of the tab to display on the configuration page.
TITLE = None
def __init__(self, parent: SpyderConfigPage):
super().__init__(parent)
self.parent = parent
if self.TITLE is None or not isinstance(self.TITLE, str):
raise ValueError("TITLE must be a str")
def apply_settings(self) -> OptionSet:
"""
Hook called to manually apply settings that cannot be automatically
applied.
Reimplement this if the configuration tab has complex widgets that
cannot be created with any of the `self.create_*` calls.
"""
return set({})
def is_valid(self) -> bool:
"""
Return True if the tab contents are valid.
This method can be overriden to perform complex checks.
"""
return True
def __getattr__(self, attr):
this_class_dir = dir(self)
if attr not in this_class_dir:
return getattr(self.parent, attr)
else:
return super().__getattr__(attr)
def setLayout(self, layout):
"""Remove default margins by default."""
layout.setContentsMargins(0, 0, 0, 0)
super().setLayout(layout) | preferences.py | spyder.spyder.api | false | true | [
"import types",
"from typing import Set",
"from spyder.config.manager import CONF",
"from spyder.config.types import ConfigurationKey",
"from spyder.api.utils import PrefixedTuple",
"from spyder.plugins.preferences.widgets.config_widgets import ("
] | 28 | 74 |
class PluginConfigPage(SpyderConfigPage):
"""
Widget to expose the options a plugin offers for configuration as
an entry in Spyder's Preferences dialog.
"""
# TODO: Temporal attribute to handle which appy_settings method to use
# the one of the conf page or the one in the plugin, while the config
# dialog system is updated.
APPLY_CONF_PAGE_SETTINGS = False
def __init__(self, plugin, parent):
self.plugin = plugin
self.main = parent.main
if hasattr(plugin, 'CONF_SECTION'):
self.CONF_SECTION = plugin.CONF_SECTION
if hasattr(plugin, 'get_font'):
self.get_font = plugin.get_font
if not self.APPLY_CONF_PAGE_SETTINGS:
self._patch_apply_settings(plugin)
SpyderConfigPage.__init__(self, parent)
def _wrap_apply_settings(self, func):
"""
Wrap apply_settings call to ensure that a user-defined custom call
is called alongside the Spyder Plugin API configuration propagation
call.
"""
def wrapper(self, options):
opts = self.previous_apply_settings() or set({})
opts |= options
self.aggregate_sections_partials(opts)
func(opts)
return types.MethodType(wrapper, self) | preferences.py | spyder.spyder.api | false | true | [
"import types",
"from typing import Set",
"from spyder.config.manager import CONF",
"from spyder.config.types import ConfigurationKey",
"from spyder.api.utils import PrefixedTuple",
"from spyder.plugins.preferences.widgets.config_widgets import ("
] | 77 | 114 |
def _patch_apply_settings(self, plugin):
self.previous_apply_settings = self.apply_settings
try:
# New API
self.apply_settings = self._wrap_apply_settings(plugin.apply_conf)
self.get_option = plugin.get_conf
self.set_option = plugin.set_conf
self.remove_option = plugin.remove_conf
except AttributeError:
# Old API
self.apply_settings = self._wrap_apply_settings(
plugin.apply_plugin_settings)
self.get_option = plugin.get_option
self.set_option = plugin.set_option
self.remove_option = plugin.remove_option
def aggregate_sections_partials(self, opts):
"""Aggregate options by sections in order to notify observers."""
to_update = {}
for opt in opts:
if isinstance(opt, tuple):
# This is necessary to filter tuple options that do not
# belong to a section.
if len(opt) == 2 and opt[0] is None:
opt = opt[1]
section = self.CONF_SECTION
if opt in self.cross_section_options:
section = self.cross_section_options[opt]
section_options = to_update.get(section, [])
section_options.append(opt)
to_update[section] = section_options | preferences.py | spyder.spyder.api | false | true | [
"import types",
"from typing import Set",
"from spyder.config.manager import CONF",
"from spyder.config.types import ConfigurationKey",
"from spyder.api.utils import PrefixedTuple",
"from spyder.plugins.preferences.widgets.config_widgets import ("
] | 116 | 147 |
for section in to_update:
section_prefix = PrefixedTuple()
# Notify section observers
CONF.notify_observers(section, '__section',
recursive_notification=False)
for opt in to_update[section]:
if isinstance(opt, tuple):
opt = opt[:-1]
section_prefix.add_path(opt)
# Notify prefixed observers
for prefix in section_prefix:
try:
CONF.notify_observers(section, prefix,
recursive_notification=False)
except Exception:
# Prevent unexpected failures on tests
pass
def get_name(self):
"""
Return plugin name to use in preferences page title, and
message boxes.
Normally you do not have to reimplement it, as soon as the
plugin name in preferences page will be the same as the plugin
title.
"""
try:
# New API
name = self.plugin.get_name()
except AttributeError:
# Old API
name = self.plugin.get_plugin_title()
return name
def get_icon(self):
"""
Return plugin icon to use in preferences page. | preferences.py | spyder.spyder.api | false | true | [
"import types",
"from typing import Set",
"from spyder.config.manager import CONF",
"from spyder.config.types import ConfigurationKey",
"from spyder.api.utils import PrefixedTuple",
"from spyder.plugins.preferences.widgets.config_widgets import ("
] | 149 | 187 |
return name
def get_icon(self):
"""
Return plugin icon to use in preferences page.
Normally you do not have to reimplement it, as soon as the
plugin icon in preferences page will be the same as the plugin
icon.
"""
try:
# New API
icon = self.plugin.get_icon()
except AttributeError:
# Old API
icon = self.plugin.get_plugin_icon()
return icon
def setup_page(self):
"""
Setup configuration page widget
You should implement this method and set the layout of the
preferences page.
layout = QVBoxLayout()
layout.addWidget(...)
...
self.setLayout(layout)
"""
raise NotImplementedError
def apply_settings(self) -> OptionSet:
"""
Hook called to manually apply settings that cannot be automatically
applied.
Reimplement this if the configuration page has complex widgets that
cannot be created with any of the `self.create_*` calls.
This call should return a set containing the configuration options that
changed.
"""
return set({}) | preferences.py | spyder.spyder.api | false | true | [
"import types",
"from typing import Set",
"from spyder.config.manager import CONF",
"from spyder.config.types import ConfigurationKey",
"from spyder.api.utils import PrefixedTuple",
"from spyder.plugins.preferences.widgets.config_widgets import ("
] | 183 | 227 |
# -*- coding: utf-8 -*-
#
# Copyright © Spyder Project Contributors
# Licensed under the terms of the MIT License
# (see spyder/__init__.py for details)
"""
This module contains the code editor API.
"""
from spyder.plugins.editor.api.editorextension import EditorExtension
from spyder.plugins.editor.api.panel import Panel | editor.py | spyder.spyder.api | false | false | [
"from spyder.plugins.editor.api.editorextension import EditorExtension",
"from spyder.plugins.editor.api.panel import Panel"
] | 1 | 12 |
# -*- coding: utf-8 -*-
#
# Copyright (c) 2009- Spyder Project Contributors
#
# Distributed under the terms of the MIT License
# (see spyder/__init__.py for details)
"""
API utilities.
"""
def get_class_values(cls):
"""
Get the attribute values for the class enumerations used in our API.
Idea from: https://stackoverflow.com/a/17249228/438386
"""
return [v for (k, v) in cls.__dict__.items() if k[:1] != '_']
class PrefixNode:
"""Utility class used to represent a prefixed string tuple."""
def __init__(self, path=None):
self.children = {}
self.path = path
def __iter__(self):
prefix = [((self.path,), self)]
while prefix != []:
current_prefix, node = prefix.pop(0)
prefix += [(current_prefix + (c,), node.children[c])
for c in node.children]
yield current_prefix
def add_path(self, path):
prefix, *rest = path
if prefix not in self.children:
self.children[prefix] = PrefixNode(prefix)
if len(rest) > 0:
child = self.children[prefix]
child.add_path(rest)
class PrefixedTuple(PrefixNode):
"""Utility class to store and iterate over prefixed string tuples."""
def __iter__(self):
for key in self.children:
child = self.children[key]
for prefix in child:
yield prefix | utils.py | spyder.spyder.api | true | true | [] | 1 | 54 |
class classproperty(property):
"""
Decorator to declare class constants as properties that require additional
computation.
Taken from: https://stackoverflow.com/a/7864317/438386
"""
def __get__(self, cls, owner):
return classmethod(self.fget).__get__(None, owner)() | utils.py | spyder.spyder.api | false | true | [] | 57 | 66 |
# -*- coding: utf-8 -*-
#
# Copyright © Spyder Project Contributors
# Licensed under the terms of the MIT License
# (see spyder/__init__.py for details)
"""
This module contains API exceptions.
"""
class SpyderAPIError(Exception):
pass | exceptions.py | spyder.spyder.api | false | false | [] | 1 | 13 |
# -*- coding: utf-8 -*-
#
# Copyright © Spyder Project Contributors
# Licensed under the terms of the MIT License
# (see spyder/__init__.py for details)
"""
This module contains the internationalization API.
"""
from spyder.config.base import get_translation, _ | translations.py | spyder.spyder.api | false | false | [
"from spyder.config.base import get_translation, _"
] | 1 | 11 |
class PluginMainWidgetWidgets:
CornerWidget = 'corner_widget'
MainToolbar = 'main_toolbar_widget'
OptionsToolButton = 'options_button_widget'
Spinner = 'spinner_widget' | main_widget.py | spyder.spyder.api.widgets | true | false | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 51 | 55 |
class PluginMainWidgetActions:
ClosePane = 'close_pane'
DockPane = 'dock_pane'
UndockPane = 'undock_pane'
LockUnlockPosition = 'lock_unlock_position' | main_widget.py | spyder.spyder.api.widgets | true | false | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 58 | 62 |
class PluginMainWidget(QWidget, SpyderWidgetMixin, SpyderToolbarMixin):
"""
Spyder plugin main widget class.
This class handles both a dockwidget pane and a floating window widget
(undocked pane).
Notes
-----
All Spyder dockable plugins define a main widget that must subclass this.
This widget is a subclass of QMainWindow that consists of a single,
central widget and a set of toolbars that are stacked above or below
that widget.
The toolbars are not moveable nor floatable and must occupy the entire
horizontal space available for the plugin. This mean that toolbars must be
stacked vertically and cannot be placed horizontally next to each other.
"""
# ---- Attributes
# -------------------------------------------------------------------------
ENABLE_SPINNER = False
"""
This attribute enables/disables showing a spinner on the top right to the
left of the corner menu widget (Hamburguer menu).
Plugins that provide actions that take time should make this `True` and
use accordingly with the `start_spinner`/`stop_spinner` methods.
The Find in files plugin is an example of a core plugin that uses it. | main_widget.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 65 | 95 |
The Find in files plugin is an example of a core plugin that uses it.
Parameters
----------
ENABLE_SPINNER: bool
If `True` an extra space will be added to the toolbar (even if the
spinner is not moving) to avoid items jumping to the left/right when
the spinner appears. If `False` no extra space will be added. Default
is False.
"""
CONTEXT_NAME = None
"""
This optional attribute defines the context name under which actions,
toolbars, toolbuttons and menus should be registered on the
Spyder global registry.
If actions, toolbars, toolbuttons or menus belong to the global scope of
the plugin, then this attribute should have a `None` value.
"""
MARGIN_TOP = 0
"""
Use this attribute to adjust the widget's top margin in pixels.
"""
# ---- Signals
# -------------------------------------------------------------------------
sig_free_memory_requested = Signal()
"""
This signal can be emitted to request the main application to garbage
collect deleted objects.
"""
sig_quit_requested = Signal()
"""
This signal can be emitted to request the main application to quit.
"""
sig_restart_requested = Signal()
"""
This signal can be emitted to request the main application to restart.
""" | main_widget.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 95 | 137 |
sig_restart_requested = Signal()
"""
This signal can be emitted to request the main application to restart.
"""
sig_redirect_stdio_requested = Signal(bool)
"""
This signal can be emitted to request the main application to redirect
standard output/error when using Open/Save/Browse dialogs within widgets.
Parameters
----------
enable: bool
Enable/Disable standard input/output redirection.
"""
sig_exception_occurred = Signal(dict)
"""
This signal can be emitted to report an exception handled by this widget.
Parameters
----------
# --- Optional overridable methods
error_data: dict
The dictionary containing error data. The expected keys are:
>>> error_data= {
"text": str,
"is_traceback": bool,
"repo": str,
"title": str,
"label": str,
"steps": str,
}
Notes
-----
The `is_traceback` key indicates if `text` contains plain text or a
Python error traceback.
The `title` and `repo` keys indicate how the error data should
customize the report dialog and Github error submission.
The `label` and `steps` keys allow customizing the content of the
error dialog.
"""
sig_toggle_view_changed = Signal(bool)
"""
This signal is emitted to inform the visibility of a dockable plugin
has changed. | main_widget.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 134 | 183 |
sig_toggle_view_changed = Signal(bool)
"""
This signal is emitted to inform the visibility of a dockable plugin
has changed.
This is triggered by checking/unchecking the entry for a pane in the
`View > Panes` menu.
Parameters
----------
visible: bool
New visibility of the dockwidget.
"""
sig_update_ancestor_requested = Signal()
"""
This signal is emitted to inform the main window that a child widget
needs its ancestor to be updated.
"""
sig_unmaximize_plugin_requested = Signal((), (object,))
"""
This signal is emitted to inform the main window that it needs to
unmaximize the currently maximized plugin, if any.
Parameters
----------
plugin_instance: SpyderDockablePlugin
Unmaximize plugin only if it is not `plugin_instance`.
"""
sig_focus_status_changed = Signal(bool)
"""
This signal is emitted to inform the focus status of the widget.
Parameters
----------
status: bool
True if the widget is focused. False otherwise.
"""
def __init__(self, name, plugin, parent=None):
if PYQT5:
super().__init__(parent=parent, class_parent=plugin)
else:
QWidget.__init__(self, parent)
SpyderWidgetMixin.__init__(self, class_parent=plugin) | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 180 | 226 |
# Attributes
# --------------------------------------------------------------------
self._is_tab = False
self._name = name
self._plugin = plugin
self._parent = parent
self._default_margins = None
self.is_visible = None
self.dock_action = None
self.undock_action = None
self.close_action = None
self._toolbars_already_rendered = False
self._is_maximized = False
# Attribute used to access the action, toolbar, toolbutton and menu
# registries
self.PLUGIN_NAME = name
# We create our toggle action instead of using the one that comes with
# dockwidget because it was not possible to raise and focus the plugin
self.toggle_view_action = None
self._toolbars = OrderedDict()
self._auxiliary_toolbars = OrderedDict()
# Widgets
# --------------------------------------------------------------------
self.windowwidget = None
self.dockwidget = None
self._icon = QIcon()
self._spinner = None
if self.ENABLE_SPINNER:
self._spinner = create_waitspinner(size=16, parent=self)
self._corner_widget = MainCornerWidget(
parent=self,
name=PluginMainWidgetWidgets.CornerWidget,
)
self._corner_widget.ID = 'main_corner' | main_widget.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 228 | 266 |
self._corner_widget = MainCornerWidget(
parent=self,
name=PluginMainWidgetWidgets.CornerWidget,
)
self._corner_widget.ID = 'main_corner'
self._main_toolbar = MainWidgetToolbar(
parent=self,
title=_("Main widget toolbar"),
)
self._main_toolbar.ID = 'main_toolbar'
TOOLBAR_REGISTRY.register_reference(
self._main_toolbar, self._main_toolbar.ID,
self.PLUGIN_NAME, self.CONTEXT_NAME)
self._corner_toolbar = MainWidgetToolbar(
parent=self,
title=_("Main widget corner toolbar"),
)
self._corner_toolbar.ID = 'corner_toolbar',
TOOLBAR_REGISTRY.register_reference(
self._corner_toolbar, self._corner_toolbar.ID,
self.PLUGIN_NAME, self.CONTEXT_NAME)
self._corner_toolbar.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Expanding)
self._options_menu = self._create_menu(
PluginMainWidgetMenus.Options,
title=_('Options menu'),
MenuClass=PluginMainWidgetOptionsMenu
) | main_widget.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 262 | 295 |
self._options_menu = self._create_menu(
PluginMainWidgetMenus.Options,
title=_('Options menu'),
MenuClass=PluginMainWidgetOptionsMenu
)
# Margins
# --------------------------------------------------------------------
# These margins are necessary to give some space between the widgets
# inside this one and the window separator and borders.
self._margin_right = AppStyle.MarginSize
self._margin_bottom = AppStyle.MarginSize
if not self.get_conf('vertical_tabs', section='main'):
self._margin_left = AppStyle.MarginSize
else:
self._margin_left = 0
# Layout
# --------------------------------------------------------------------
self._main_layout = QVBoxLayout()
self._toolbars_layout = QVBoxLayout()
self._main_toolbar_layout = QHBoxLayout()
self._toolbars_layout.setContentsMargins(
self._margin_left, 0, self._margin_right, 0)
self._toolbars_layout.setSpacing(0)
self._main_toolbar_layout.setContentsMargins(0, 0, 0, 0)
self._main_toolbar_layout.setSpacing(0)
self._main_layout.setContentsMargins(0, 0, 0, 0)
self._main_layout.setSpacing(0) | main_widget.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 291 | 320 |
# Add inititals layouts
self._main_toolbar_layout.addWidget(self._main_toolbar, stretch=10000)
self._main_toolbar_layout.addWidget(self._corner_toolbar, stretch=1)
self._toolbars_layout.addLayout(self._main_toolbar_layout)
self._main_layout.addLayout(self._toolbars_layout, stretch=1)
# ---- Private Methods
# -------------------------------------------------------------------------
def _setup(self):
"""
Setup default actions, create options menu, and connect signals.
"""
# Tabs
children = self.findChildren(Tabs)
if children:
for child in children:
self._is_tab = True
# For widgets that use tabs, we add the corner widget using
# the setCornerWidget method.
child.setCornerWidget(self._corner_widget)
self._corner_widget.setStyleSheet(str(PANES_TABBAR_STYLESHEET))
break
self._options_button = self.create_toolbutton(
PluginMainWidgetWidgets.OptionsToolButton,
text=_('Options'),
icon=self.create_icon('tooloptions'),
)
if self.ENABLE_SPINNER:
self.add_corner_widget(
PluginMainWidgetWidgets.Spinner,
self._spinner,
)
self.add_corner_widget(
PluginMainWidgetWidgets.OptionsToolButton,
self._options_button,
) | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 322 | 360 |
self.add_corner_widget(
PluginMainWidgetWidgets.OptionsToolButton,
self._options_button,
)
# Widget setup
# --------------------------------------------------------------------
self._main_toolbar.setVisible(not self._is_tab)
self._corner_toolbar.setVisible(not self._is_tab)
self._options_button.setPopupMode(QToolButton.InstantPopup) | main_widget.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 357 | 366 |
# Create default widget actions
self.dock_action = self.create_action(
name=PluginMainWidgetActions.DockPane,
text=_("Dock"),
tip=_("Dock the pane"),
icon=self.create_icon('dock'),
triggered=self.close_window,
)
self.lock_unlock_action = self.create_action(
name=PluginMainWidgetActions.LockUnlockPosition,
text=_("Unlock position"),
tip=_("Unlock to move pane to another position"),
icon=self.create_icon('drag_dock_widget'),
triggered=self.lock_unlock_position,
)
self.undock_action = self.create_action(
name=PluginMainWidgetActions.UndockPane,
text=_("Undock"),
tip=_("Undock the pane"),
icon=self.create_icon('undock'),
triggered=self.create_window,
)
self.close_action = self.create_action(
name=PluginMainWidgetActions.ClosePane,
text=_("Close"),
tip=_("Close the pane"),
icon=self.create_icon('close_pane'),
triggered=self.close_dock,
)
# We use this instead of the QDockWidget.toggleViewAction
self.toggle_view_action = self.create_action(
name='switch to ' + self._name,
text=self.get_title(),
toggled=lambda checked: self.toggle_view(checked),
context=Qt.WidgetWithChildrenShortcut, | main_widget.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 368 | 402 |
name='switch to ' + self._name,
text=self.get_title(),
toggled=lambda checked: self.toggle_view(checked),
context=Qt.WidgetWithChildrenShortcut,
shortcut_context='_',
) | main_widget.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 399 | 404 |
for item in [self.lock_unlock_action, self.undock_action,
self.close_action, self.dock_action]:
self.add_item_to_menu(
item,
self._options_menu,
section=OptionsMenuSections.Bottom,
)
self._options_button.setMenu(self._options_menu)
self._options_menu.aboutToShow.connect(self._update_actions)
# For widgets that do not use tabs, we add the corner widget to the
# corner toolbar
if not self._is_tab:
self.add_item_to_toolbar(
self._corner_widget,
toolbar=self._corner_toolbar,
section="corner",
)
self._corner_widget.setStyleSheet(str(PANES_TOOLBAR_STYLESHEET))
# Update title
self.setWindowTitle(self.get_title())
def _update_actions(self):
"""
Refresh Options menu.
"""
show_dock_actions = self.windowwidget is None
self.undock_action.setVisible(show_dock_actions)
self.close_action.setVisible(show_dock_actions)
self.lock_unlock_action.setVisible(show_dock_actions)
self.dock_action.setVisible(not show_dock_actions)
# Widget setup
self.update_actions()
@Slot(bool)
def _on_top_level_change(self, top_level):
"""
Actions to perform when a plugin is undocked to be moved.
"""
self.undock_action.setDisabled(top_level) | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 406 | 448 |
# Change the cursor shape when dragging
if top_level:
QApplication.setOverrideCursor(Qt.ClosedHandCursor)
else:
QApplication.restoreOverrideCursor()
@Slot(bool)
def _on_title_bar_shown(self, visible):
"""
Actions to perform when the title bar is shown/hidden.
"""
if visible:
self.lock_unlock_action.setText(_('Lock position'))
self.lock_unlock_action.setIcon(self.create_icon('lock_open'))
for method_name in ['setToolTip', 'setStatusTip']:
method = getattr(self.lock_unlock_action, method_name)
method(_("Lock pane to the current position"))
else:
self.lock_unlock_action.setText(_('Unlock position'))
self.lock_unlock_action.setIcon(
self.create_icon('drag_dock_widget'))
for method_name in ['setToolTip', 'setStatusTip']:
method = getattr(self.lock_unlock_action, method_name)
method(_("Unlock to move pane to another position")) | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 450 | 473 |
# ---- Public Qt overriden methods
# -------------------------------------------------------------------------
def setLayout(self, layout):
"""
Set layout of the main widget of this plugin.
"""
self._main_layout.addLayout(layout, stretch=1000000)
super().setLayout(self._main_layout)
layout.setContentsMargins(
self._margin_left, self.MARGIN_TOP, self._margin_right,
self._margin_bottom
)
layout.setSpacing(0)
def closeEvent(self, event):
self.on_close()
super().closeEvent(event)
def focusInEvent(self, event: QFocusEvent) -> None:
self.sig_focus_status_changed.emit(True)
self.on_focus_in()
return super().focusInEvent(event)
def focusOutEvent(self, event: QFocusEvent) -> None:
self.sig_focus_status_changed.emit(False)
self.on_focus_out()
return super().focusOutEvent(event)
# ---- Public methods to use
# -------------------------------------------------------------------------
def get_plugin(self):
"""
Return the parent plugin.
"""
return self._plugin
def get_action(self, name, context: Optional[str] = None,
plugin: Optional[str] = None):
"""
Return action by name.
"""
plugin = self.PLUGIN_NAME if plugin is None else plugin
context = self.CONTEXT_NAME if context is None else context | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 475 | 517 |
return ACTION_REGISTRY.get_reference(name, plugin, context)
def add_corner_widget(self, widget_id, widget, before=None):
"""
Add widget to corner, that is to the left of the last added widget.
Parameters
----------
widget_id: str
Unique name of the widget.
widget: QWidget
Any QWidget to add in the corner widget.
before: QWidget
Insert the widget before this widget.
Notes
-----
By default widgets are added to the left of the last corner widget.
The central widget provides an options menu button and a spinner so any
additional widgets will be placed to the left of the spinner,
if visible.
"""
self._corner_widget.add_widget(widget_id, widget)
def get_corner_widget(self, name):
"""
Return the a widget inside the corner widget by name.
Parameters
----------
name: str
Unique name of the widget.
"""
return self._corner_widget.get_widget(name)
def start_spinner(self):
"""
Start default status spinner.
"""
if self.ENABLE_SPINNER:
self._spinner.start()
def stop_spinner(self):
"""
Stop default status spinner.
"""
if self.ENABLE_SPINNER:
self._spinner.stop() | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 519 | 567 |
def stop_spinner(self):
"""
Stop default status spinner.
"""
if self.ENABLE_SPINNER:
self._spinner.stop()
def create_toolbar(self, toolbar_id):
"""
Create and add an auxiliary toolbar to the top of the plugin.
Parameters
----------
toolbar_id: str
Unique toolbar string identifier.
Returns
-------
SpyderPluginToolbar
The auxiliary toolbar that was created and added to the plugin
interface.
"""
toolbar = MainWidgetToolbar(parent=self)
toolbar.ID = toolbar_id
TOOLBAR_REGISTRY.register_reference(
toolbar, toolbar_id, self.PLUGIN_NAME, self.CONTEXT_NAME)
self._auxiliary_toolbars[toolbar_id] = toolbar
self._toolbars_layout.addWidget(toolbar)
return toolbar
def get_options_menu(self):
"""
Return the main options menu of the widget.
"""
return self._options_menu
def get_options_menu_button(self):
"""
Return the main options menu button of the widget.
"""
return self._options_button
def get_main_toolbar(self):
"""
Return the main toolbar of the plugin.
Returns
-------
QToolBar
The main toolbar of the widget that contains the options button.
"""
return self._main_toolbar | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 562 | 616 |
Returns
-------
QToolBar
The main toolbar of the widget that contains the options button.
"""
return self._main_toolbar
def get_auxiliary_toolbars(self):
"""
Return the auxiliary toolbars of the plugin.
Returns
-------
OrderedDict
A dictionary of wirh toolbar IDs as keys and auxiliary toolbars as
values.
"""
return self._auxiliary_toolbars
def set_icon_size(self, icon_size):
"""
Set the icon size of the plugin's toolbars.
Parameters
----------
iconsize: int
An integer corresponding to the size in pixels to which the icons
of the plugin's toolbars need to be set.
"""
self._icon_size = icon_size
self._main_toolbar.set_icon_size(QSize(icon_size, icon_size))
def show_status_message(self, message, timeout):
"""
Show a status message in the Spyder widget.
"""
status_bar = self.statusBar()
if status_bar.isVisible():
status_bar.showMessage(message, timeout)
def get_focus_widget(self):
"""
Get the widget to give focus to.
Returns
-------
QWidget
QWidget to give focus to.
Notes
-----
This is applied when the plugin's dockwidget is raised to the top.
"""
return self | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 578 | 631 |
Notes
-----
This is applied when the plugin's dockwidget is raised to the top.
"""
return self
def update_margins(self, margin=None):
"""
Update central widget margins.
"""
layout = self.layout()
if self._default_margins is None:
self._default_margins = layout.getContentsMargins()
if margin is not None:
layout.setContentsMargins(margin, margin, margin, margin)
else:
layout.setContentsMargins(*self._default_margins)
def update_title(self):
"""
Update title of dockwidget or plugin window.
"""
if self.dockwidget is not None:
widget = self.dockwidget
elif self.windowwidget is not None:
widget = self.undocked_window
else:
return
widget.setWindowTitle(self.get_title())
def set_name(self, name):
"""
Set widget name (plugin.NAME).
"""
self._name = name
def get_name(self):
"""
Return widget name (plugin.NAME).
"""
return self._name
def set_icon(self, icon):
"""
Set widget icon.
"""
self._icon = icon
def get_icon(self):
"""
Return widget icon.
"""
return self._icon
def render_toolbars(self):
"""
Render all the toolbars of the widget. | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 72 | 130 |
def get_icon(self):
"""
Return widget icon.
"""
return self._icon
def render_toolbars(self):
"""
Render all the toolbars of the widget.
Notes
-----
This action can only be performed once.
"""
# if not self._toolbars_already_rendered:
self._main_toolbar._render()
self._corner_toolbar._render()
for __, toolbar in self._auxiliary_toolbars.items():
toolbar._render()
# self._toolbars_already_rendered = True
# ---- SpyderDockwidget handling
# -------------------------------------------------------------------------
@Slot()
def create_window(self):
"""
Create a QMainWindow instance containing this widget.
"""
logger.debug("Undocking plugin")
# Widgets
self.windowwidget = window = SpyderWindowWidget(self)
# If the close corner button is used
self.windowwidget.sig_closed.connect(self.close_window)
# Wigdet setup
window.setAttribute(Qt.WA_DeleteOnClose)
window.setCentralWidget(self)
window.setWindowIcon(self.get_icon())
window.setWindowTitle(self.get_title())
window.resize(self.size()) | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 710 | 752 |
# Restore window geometry
geometry = self.get_conf('window_geometry', default='')
if geometry:
try:
window.restoreGeometry(
QByteArray().fromHex(str(geometry).encode('utf-8'))
)
# Move to the primary screen if the window is not placed in a
# visible location.
window.move_to_primary_screen()
except Exception:
pass
# Dock widget setup
if self.dockwidget:
self.dockwidget.setFloating(False)
self.dockwidget.setVisible(False)
self.set_ancestor(window)
self._update_actions()
window.show()
@Slot()
def close_window(self, save_undocked=False):
"""
Close QMainWindow instance that contains this widget.
Parameters
----------
save_undocked : bool, optional
True if the undocked state needs to be saved. The default is False.
Returns
-------
None.
"""
logger.debug("Docking plugin back to the main window")
if self.windowwidget is not None:
# Save window geometry to restore it when undocking the plugin
# again.
geometry = self.windowwidget.saveGeometry()
self.set_conf('window_geometry', qbytearray_to_str(geometry)) | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 754 | 797 |
# Save undocking state if requested
if save_undocked:
self.set_conf('undocked_on_window_close', True)
# Fixes spyder-ide/spyder#10704
self.__unsafe_window = self.windowwidget
self.__unsafe_window.deleteLater()
self.windowwidget.close()
self.windowwidget = None
# These actions can appear disabled when 'Dock' action is pressed
self.undock_action.setDisabled(False)
self.close_action.setDisabled(False)
if self.dockwidget is not None:
self.sig_update_ancestor_requested.emit()
self.get_plugin().switch_to_plugin()
self.dockwidget.setWidget(self)
self.dockwidget.setVisible(True)
self.dockwidget.raise_()
self._update_actions()
else:
# Reset undocked state
self.set_conf('undocked_on_window_close', False)
def change_visibility(self, enable, force_focus=None):
"""Dock widget visibility has changed."""
if self.dockwidget is None:
return
if enable:
# Avoid double trigger of visibility change
self.dockwidget.blockSignals(True)
self.dockwidget.raise_()
self.dockwidget.blockSignals(False)
raise_and_focus = getattr(self, 'RAISE_AND_FOCUS', None) | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 799 | 835 |
raise_and_focus = getattr(self, 'RAISE_AND_FOCUS', None)
if force_focus is None:
if raise_and_focus and enable:
focus_widget = self.get_focus_widget()
if focus_widget:
focus_widget.setFocus()
elif force_focus is True:
focus_widget = self.get_focus_widget()
if focus_widget:
focus_widget.setFocus()
elif force_focus is False:
pass
self.is_visible = enable
# TODO: Pending on plugin migration that uses this
# if getattr(self, 'DISABLE_ACTIONS_WHEN_HIDDEN', None):
# for __, action in self.get_actions().items():
# action.setEnabled(is_visible)
def toggle_view(self, checked):
"""
Toggle dockwidget's visibility when its entry is selected in
the menu `View > Panes`.
Parameters
----------
checked: bool
Is the entry in `View > Panes` checked or not?
Notes
-----
If you need to attach some functionality when this changes, use
sig_toggle_view_changed. For an example, please see
`spyder/plugins/ipythonconsole/plugin.py`
"""
if not self.dockwidget:
return
# Dock plugin if it's undocked before hiding it.
if self.windowwidget is not None:
self.close_window(save_undocked=True) | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 835 | 877 |
# Dock plugin if it's undocked before hiding it.
if self.windowwidget is not None:
self.close_window(save_undocked=True)
if checked:
self.dockwidget.show()
self.dockwidget.raise_()
self.is_visible = True
else:
self.dockwidget.hide()
self.is_visible = False
# Update toggle view status, if needed, without emitting signals.
if self.toggle_view_action.isChecked() != checked:
self.blockSignals(True)
self.toggle_view_action.setChecked(checked)
self.blockSignals(False)
self.sig_toggle_view_changed.emit(checked)
def create_dockwidget(self, mainwindow):
"""
Add to parent QMainWindow as a dock widget.
"""
# Creating dock widget
title = self.get_title()
self.dockwidget = dock = SpyderDockWidget(title, mainwindow)
# Setup
dock.setObjectName(self.__class__.__name__ + '_dw')
dock.setWidget(self)
# Signals
dock.visibilityChanged.connect(self.change_visibility)
dock.topLevelChanged.connect(self._on_top_level_change)
dock.sig_title_bar_shown.connect(self._on_title_bar_shown)
return (dock, dock.LOCATION)
@Slot()
def close_dock(self):
"""
Close the dockwidget.
"""
self.toggle_view(False) | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 875 | 919 |
return (dock, dock.LOCATION)
@Slot()
def close_dock(self):
"""
Close the dockwidget.
"""
self.toggle_view(False)
def lock_unlock_position(self):
"""
Show/hide title bar to move/lock position.
"""
if isinstance(self.dockwidget.titleBarWidget(), DockTitleBar):
self.dockwidget.remove_title_bar()
else:
self.dockwidget.set_title_bar()
def get_maximized_state(self):
"""Get dockwidget's maximized state."""
return self._is_maximized
def set_maximized_state(self, state):
"""
Set internal attribute that holds dockwidget's maximized state.
Parameters
----------
state: bool
True if the plugin is maximized, False otherwise.
"""
self._is_maximized = state
# This is necessary for old API plugins interacting with new ones.
self._plugin._ismaximized = state
# --- API: methods to define or override
# ------------------------------------------------------------------------
def get_title(self):
"""
Return the title that will be displayed on dockwidget or window title.
"""
raise NotImplementedError('PluginMainWidget must define `get_title`!')
def set_ancestor(self, ancestor):
"""
Needed to update the ancestor/parent of child widgets when undocking.
"""
pass | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 912 | 960 |
def set_ancestor(self, ancestor):
"""
Needed to update the ancestor/parent of child widgets when undocking.
"""
pass
def setup(self):
"""
Create widget actions, add to menu and other setup requirements.
"""
raise NotImplementedError(
f'{type(self)} must define a `setup` method!')
def update_actions(self):
"""
Update the state of exposed actions.
Exposed actions are actions created by the self.create_action method.
"""
raise NotImplementedError(
'A PluginMainWidget subclass must define an `update_actions` '
f'method! Hint: {type(self)} should implement `update_actions`')
def on_close(self):
"""
Perform actions before the widget is closed.
This method **must** only operate on local attributes.
"""
pass
def on_focus_in(self):
"""Perform actions when the widget receives focus."""
pass
def on_focus_out(self):
"""Perform actions when the widget loses focus."""
pass | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 956 | 993 |
def run_test():
# Third party imports
from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow
# Local imports
from spyder.utils.qthelpers import qapplication
app = qapplication()
main = QMainWindow()
widget = PluginMainWidget('test', main)
widget.get_title = lambda x=None: 'Test title'
widget._setup()
layout = QHBoxLayout()
layout.addWidget(QTableWidget())
widget.setLayout(layout)
widget.start_spinner()
dock, location = widget.create_dockwidget(main)
main.addDockWidget(location, dock)
main.setStyleSheet(str(APP_STYLESHEET))
main.show()
app.exec_() | main_widget.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 996 | 1,016 |
# -*- coding: utf-8 -*-
#
# Copyright © Spyder Project Contributors
# Licensed under the terms of the MIT License
# (see spyder/__init__.py for details)
"""
Main plugin widget.
SpyderDockablePlugin plugins must provide a WIDGET_CLASS attribute that is a
subclass of PluginMainWidget.
"""
# Standard library imports
from collections import OrderedDict
import logging
from typing import Optional
# Third party imports
from qtpy import PYQT5
from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot
from qtpy.QtGui import QFocusEvent, QIcon
from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,
QToolButton, QVBoxLayout, QWidget) | main_widget.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 1 | 24 |
# Local imports
from spyder.api.translations import _
from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,
SpyderWindowWidget)
from spyder.api.widgets.menus import (
PluginMainWidgetOptionsMenu,
OptionsMenuSections,
PluginMainWidgetMenus
)
from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin
from spyder.api.widgets.toolbars import MainWidgetToolbar
from spyder.py3compat import qbytearray_to_str
from spyder.utils.qthelpers import create_waitspinner
from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY
from spyder.utils.stylesheet import (
AppStyle, APP_STYLESHEET, PANES_TABBAR_STYLESHEET,
PANES_TOOLBAR_STYLESHEET)
from spyder.widgets.dock import DockTitleBar, SpyderDockWidget
from spyder.widgets.tabs import Tabs
# Logging
logger = logging.getLogger(__name__)
# Code for: class PluginMainWidgetWidgets:
# Code for: class PluginMainWidgetActions:
# Code for: class PluginMainWidget(QWidget, SpyderWidgetMixin, SpyderToolbarMixin):
# Code for: def run_test():
if __name__ == '__main__':
run_test() | main_widget.py | spyder.spyder.api.widgets | true | true | [
"from collections import OrderedDict",
"import logging",
"from typing import Optional",
"from qtpy import PYQT5",
"from qtpy.QtCore import QByteArray, QSize, Qt, Signal, Slot",
"from qtpy.QtGui import QFocusEvent, QIcon",
"from qtpy.QtWidgets import (QApplication, QHBoxLayout, QSizePolicy,",
"from spyder.api.translations import _",
"from spyder.api.widgets.auxiliary_widgets import (MainCornerWidget,",
"from spyder.api.widgets.menus import (",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin",
"from spyder.api.widgets.toolbars import MainWidgetToolbar",
"from spyder.py3compat import qbytearray_to_str",
"from spyder.utils.qthelpers import create_waitspinner",
"from spyder.utils.registries import ACTION_REGISTRY, TOOLBAR_REGISTRY",
"from spyder.utils.stylesheet import (",
"from spyder.widgets.dock import DockTitleBar, SpyderDockWidget",
"from spyder.widgets.tabs import Tabs",
"from qtpy.QtWidgets import QHBoxLayout, QTableWidget, QMainWindow",
"from spyder.utils.qthelpers import qapplication"
] | 26 | 64 |
# -*- coding: utf-8 -*-
#
# Copyright © Spyder Project Contributors
#
# Licensed under the terms of the MIT License
# (see spyder/__init__.py for details)
"""Status bar widgets."""
# Third party imports
from qtpy import PYQT5
from qtpy.QtCore import Qt, QSize, QTimer, Signal
from qtpy.QtGui import QIcon
from qtpy.QtWidgets import QHBoxLayout, QLabel, QWidget
# Local imports
from spyder.api.exceptions import SpyderAPIError
from spyder.api.widgets.mixins import SpyderWidgetMixin
from spyder.utils.palette import QStylePalette
from spyder.utils.qthelpers import create_waitspinner | status.py | spyder.spyder.api.widgets | false | false | [
"from qtpy import PYQT5",
"from qtpy.QtCore import Qt, QSize, QTimer, Signal",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import QHBoxLayout, QLabel, QWidget",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.mixins import SpyderWidgetMixin",
"from spyder.utils.palette import QStylePalette",
"from spyder.utils.qthelpers import create_waitspinner"
] | 1 | 20 |
class StatusBarWidget(QWidget, SpyderWidgetMixin):
"""
Base class for status bar widgets.
These widgets consist by default of an icon, a label and a spinner,
which are organized from left to right on that order.
You can also add any other QWidget to this layout by setting the
CUSTOM_WIDGET_CLASS class attribute. It'll be put between the label
and the spinner.
"""
ID = None
"""
Unique string widget identifier.
"""
CUSTOM_WIDGET_CLASS = None
"""
Custom widget class to add to the default layout.
"""
sig_clicked = Signal()
"""
This signal is emmitted when the widget is clicked.
"""
def __init__(self, parent=None, show_icon=True, show_label=True,
show_spinner=False):
"""
Base class for status bar widgets.
These are composed of the following widgets, which are arranged
in a QHBoxLayout from left to right:
* Icon
* Label
* Custom QWidget
* Spinner
Parameters
----------
show_icon: bool
Show an icon in the widget.
show_label: bool
Show a label in the widget.
show_spinner: bool
Show a spinner. | status.py | spyder.spyder.api.widgets | false | false | [
"from qtpy import PYQT5",
"from qtpy.QtCore import Qt, QSize, QTimer, Signal",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import QHBoxLayout, QLabel, QWidget",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.mixins import SpyderWidgetMixin",
"from spyder.utils.palette import QStylePalette",
"from spyder.utils.qthelpers import create_waitspinner"
] | 23 | 70 |
Notes
-----
1. To use an icon, you need to redefine the ``get_icon`` method.
2. To use a label, you need to call ``set_value``.
"""
if PYQT5:
super().__init__(parent, class_parent=parent)
else:
QWidget.__init__(self, parent)
SpyderWidgetMixin.__init__(self, class_parent=parent)
self._parent = parent
self.show_icon = show_icon
self.show_label = show_label
self.show_spinner = show_spinner
self.value = None
self.label_icon = None
self.label_value = None
self.spinner = None
self.custom_widget = None
self.set_layout()
self.setStyleSheet(self._stylesheet())
def set_layout(self):
"""Set layout for default widgets."""
# Icon
if self.show_icon:
self._icon = self.get_icon()
self._pixmap = None
self._icon_size = QSize(16, 16) # Should this be adjustable?
self.label_icon = QLabel(self)
self.set_icon()
# Label
if self.show_label:
self.label_value = QLabel(self)
self.set_value('')
self.label_value.setAlignment(Qt.AlignRight | Qt.AlignVCenter) | status.py | spyder.spyder.api.widgets | false | true | [
"from qtpy import PYQT5",
"from qtpy.QtCore import Qt, QSize, QTimer, Signal",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import QHBoxLayout, QLabel, QWidget",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.mixins import SpyderWidgetMixin",
"from spyder.utils.palette import QStylePalette",
"from spyder.utils.qthelpers import create_waitspinner"
] | 72 | 112 |
# Label
if self.show_label:
self.label_value = QLabel(self)
self.set_value('')
self.label_value.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
# Custom widget
if self.CUSTOM_WIDGET_CLASS:
if not issubclass(self.CUSTOM_WIDGET_CLASS, QWidget):
raise SpyderAPIError(
'Any custom status widget must subclass QWidget!'
)
self.custom_widget = self.CUSTOM_WIDGET_CLASS(self._parent)
# Spinner
if self.show_spinner:
self.spinner = create_waitspinner(size=14, parent=self)
self.spinner.hide()
# Layout setup
layout = QHBoxLayout(self)
layout.setSpacing(0) # Reduce space between icon and label
if self.show_icon:
layout.addWidget(self.label_icon)
if self.show_label:
layout.addWidget(self.label_value)
if self.custom_widget:
layout.addWidget(self.custom_widget)
if self.show_spinner:
layout.addWidget(self.spinner)
layout.addSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
layout.setAlignment(Qt.AlignVCenter)
# Setup
self.update_tooltip() | status.py | spyder.spyder.api.widgets | false | false | [
"from qtpy import PYQT5",
"from qtpy.QtCore import Qt, QSize, QTimer, Signal",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import QHBoxLayout, QLabel, QWidget",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.mixins import SpyderWidgetMixin",
"from spyder.utils.palette import QStylePalette",
"from spyder.utils.qthelpers import create_waitspinner"
] | 108 | 144 |
layout.addSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
layout.setAlignment(Qt.AlignVCenter)
# Setup
self.update_tooltip()
# ---- Status bar widget API
def set_icon(self):
"""Set the icon for the status bar widget."""
if self.label_icon:
icon = self._icon
self.label_icon.setVisible(icon is not None)
if icon is not None and isinstance(icon, QIcon):
self._pixmap = icon.pixmap(self._icon_size)
self.label_icon.setPixmap(self._pixmap)
def set_value(self, value):
"""Set formatted text value."""
if self.label_value:
self.value = value
self.label_value.setText(value)
def update_tooltip(self):
"""Update tooltip for widget."""
tooltip = self.get_tooltip()
if tooltip:
if self.label_value:
self.label_value.setToolTip(tooltip)
if self.label_icon:
self.label_icon.setToolTip(tooltip)
self.setToolTip(tooltip)
def mouseReleaseEvent(self, event):
"""Override Qt method to allow for click signal."""
super(StatusBarWidget, self).mousePressEvent(event)
self.sig_clicked.emit()
# ---- API to be defined by user
def get_tooltip(self):
"""Return the widget tooltip text."""
return ''
def get_icon(self):
"""Return the widget tooltip text."""
return None | status.py | spyder.spyder.api.widgets | false | true | [
"from qtpy import PYQT5",
"from qtpy.QtCore import Qt, QSize, QTimer, Signal",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import QHBoxLayout, QLabel, QWidget",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.mixins import SpyderWidgetMixin",
"from spyder.utils.palette import QStylePalette",
"from spyder.utils.qthelpers import create_waitspinner"
] | 139 | 184 |
def get_icon(self):
"""Return the widget tooltip text."""
return None
def _stylesheet(self):
stylesheet = ("QToolTip {{background-color: {background_color};"
"color: {color};"
"border: none}}").format(
background_color=QStylePalette.COLOR_ACCENT_2,
color=QStylePalette.COLOR_TEXT_1
)
return stylesheet | status.py | spyder.spyder.api.widgets | false | true | [
"from qtpy import PYQT5",
"from qtpy.QtCore import Qt, QSize, QTimer, Signal",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import QHBoxLayout, QLabel, QWidget",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.mixins import SpyderWidgetMixin",
"from spyder.utils.palette import QStylePalette",
"from spyder.utils.qthelpers import create_waitspinner"
] | 182 | 193 |
class BaseTimerStatus(StatusBarWidget):
"""
Base class for status bar widgets that update based on timers.
"""
def __init__(self, parent=None):
"""Base class for status bar widgets that update based on timers."""
self.timer = None # Needs to come before parent call
super().__init__(parent)
self._interval = 2000
# Widget setup
fm = self.label_value.fontMetrics()
self.label_value.setMinimumWidth(fm.width('000%'))
# Setup
self.timer = QTimer(self)
self.timer.timeout.connect(self.update_status)
self.timer.start(self._interval)
def closeEvent(self, event):
self.timer.stop()
super().closeEvent(event)
# ---- Qt API
def setVisible(self, value):
"""Override Qt method to stops timers if widget is not visible."""
if self.timer is not None:
if value:
self.timer.start(self._interval)
else:
self.timer.stop()
super(BaseTimerStatus, self).setVisible(value)
# ---- BaseTimerStatus widget API
def update_status(self):
"""Update status label widget, if widget is visible."""
if self.isVisible():
self.label_value.setText(self.get_value())
def set_interval(self, interval):
"""Set timer interval (ms)."""
self._interval = interval
if self.timer is not None:
self.timer.setInterval(interval) | status.py | spyder.spyder.api.widgets | false | true | [
"from qtpy import PYQT5",
"from qtpy.QtCore import Qt, QSize, QTimer, Signal",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import QHBoxLayout, QLabel, QWidget",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.mixins import SpyderWidgetMixin",
"from spyder.utils.palette import QStylePalette",
"from spyder.utils.qthelpers import create_waitspinner"
] | 196 | 240 |
def set_interval(self, interval):
"""Set timer interval (ms)."""
self._interval = interval
if self.timer is not None:
self.timer.setInterval(interval)
# ---- API to be defined by user
def get_value(self):
"""Return formatted text value."""
raise NotImplementedError | status.py | spyder.spyder.api.widgets | false | true | [
"from qtpy import PYQT5",
"from qtpy.QtCore import Qt, QSize, QTimer, Signal",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import QHBoxLayout, QLabel, QWidget",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.mixins import SpyderWidgetMixin",
"from spyder.utils.palette import QStylePalette",
"from spyder.utils.qthelpers import create_waitspinner"
] | 236 | 245 |
# -*- coding: utf-8 -*-
#
# Copyright © Spyder Project Contributors
# Licensed under the terms of the MIT License
# (see spyder/__init__.py for details)
"""
Spyder API auxiliary widgets.
"""
# Third party imports
from qtpy.QtCore import QEvent, QSize, Signal
from qtpy.QtWidgets import QMainWindow, QSizePolicy, QToolBar, QWidget
# Local imports
from spyder.api.exceptions import SpyderAPIError
from spyder.api.widgets.mixins import SpyderMainWindowMixin
from spyder.utils.stylesheet import APP_STYLESHEET | auxiliary_widgets.py | spyder.spyder.api.widgets | false | false | [
"from qtpy.QtCore import QEvent, QSize, Signal",
"from qtpy.QtWidgets import QMainWindow, QSizePolicy, QToolBar, QWidget",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.mixins import SpyderMainWindowMixin",
"from spyder.utils.stylesheet import APP_STYLESHEET"
] | 1 | 18 |
class SpyderWindowWidget(QMainWindow, SpyderMainWindowMixin):
"""MainWindow subclass that contains a SpyderDockablePlugin."""
# ---- Signals
# ------------------------------------------------------------------------
sig_closed = Signal()
"""This signal is emitted when the close event is fired."""
sig_window_state_changed = Signal(object)
"""
This signal is emitted when the window state has changed (for instance,
between maximized and minimized states).
Parameters
----------
window_state: Qt.WindowStates
The window state.
"""
def __init__(self, widget):
super().__init__()
self.widget = widget
# To distinguish these windows from the main Spyder one
self.is_window_widget = True
# Setting interface theme
self.setStyleSheet(str(APP_STYLESHEET))
def closeEvent(self, event):
"""Override Qt method to emit a custom `sig_close` signal."""
super().closeEvent(event)
self.sig_closed.emit()
def changeEvent(self, event):
"""
Override Qt method to emit a custom `sig_windowstate_changed` signal
when there's a change in the window state.
"""
if event.type() == QEvent.WindowStateChange:
self.sig_window_state_changed.emit(self.windowState())
super().changeEvent(event) | auxiliary_widgets.py | spyder.spyder.api.widgets | false | true | [
"from qtpy.QtCore import QEvent, QSize, Signal",
"from qtpy.QtWidgets import QMainWindow, QSizePolicy, QToolBar, QWidget",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.mixins import SpyderMainWindowMixin",
"from spyder.utils.stylesheet import APP_STYLESHEET"
] | 21 | 62 |
class MainCornerWidget(QToolBar):
"""
Corner widget to hold options menu, spinner and additional options.
"""
def __init__(self, parent, name):
super().__init__(parent)
self._icon_size = QSize(16, 16)
self.setIconSize(self._icon_size)
self._widgets = {}
self._actions = []
self.setObjectName(name)
# We add an strut widget here so that there is a spacing
# between the first item of the corner widget and the last
# item of the MainWidgetToolbar.
self._strut = QWidget()
self._strut.setFixedWidth(0)
self._strut.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.addWidget(self._strut)
def add_widget(self, widget_id, widget):
"""
Add a widget to the left of the last widget added to the corner.
"""
if widget_id in self._widgets:
raise SpyderAPIError(
'Wigdet with name "{}" already added. Current names are: {}'
''.format(widget_id, list(self._widgets.keys()))
)
widget.ID = widget_id
self._widgets[widget_id] = widget
self._actions.append(self.addWidget(widget))
def get_widget(self, widget_id):
"""Return a widget by unique id."""
if widget_id in self._widgets:
return self._widgets[widget_id] | auxiliary_widgets.py | spyder.spyder.api.widgets | false | true | [
"from qtpy.QtCore import QEvent, QSize, Signal",
"from qtpy.QtWidgets import QMainWindow, QSizePolicy, QToolBar, QWidget",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.mixins import SpyderMainWindowMixin",
"from spyder.utils.stylesheet import APP_STYLESHEET"
] | 65 | 104 |
# -*- coding: utf-8 -*-
#
# Copyright © Spyder Project Contributors
# Licensed under the terms of the MIT License
# (see spyder/__init__.py for details)
"""
Main container widget.
SpyderPluginV2 plugins must provide a CONTAINER_CLASS attribute that is a
subclass of PluginMainContainer, if they provide additional widgets like
status bar widgets or toolbars.
"""
from qtpy import PYQT5
from qtpy.QtCore import Signal
from qtpy.QtWidgets import QWidget
from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin | main_container.py | spyder.spyder.api.widgets | false | false | [
"from qtpy import PYQT5",
"from qtpy.QtCore import Signal",
"from qtpy.QtWidgets import QWidget",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin"
] | 1 | 19 |
class PluginMainContainer(QWidget, SpyderWidgetMixin, SpyderToolbarMixin):
"""
Spyder plugin main container class.
This class handles a non-dockable widget to be able to contain, parent and
store references to other widgets, like status bar widgets, toolbars,
context menus, etc.
Notes
-----
All Spyder non dockable plugins can define a plugin container that must
subclass this.
"""
CONTEXT_NAME = None
"""
This optional attribute defines the context name under which actions,
toolbars, toolbuttons and menus should be registered on the
Spyder global registry.
If actions, toolbars, toolbuttons or menus belong to the global scope of
the plugin, then this attribute should have a `None` value.
"""
# ---- Signals
# ------------------------------------------------------------------------
sig_free_memory_requested = Signal()
"""
This signal can be emitted to request the main application to garbage
collect deleted objects.
"""
sig_quit_requested = Signal()
"""
This signal can be emitted to request the main application to quit.
"""
sig_restart_requested = Signal()
"""
This signal can be emitted to request the main application to restart.
"""
sig_redirect_stdio_requested = Signal(bool)
"""
This signal can be emitted to request the main application to redirect
standard output/error when using Open/Save/Browse dialogs within widgets. | main_container.py | spyder.spyder.api.widgets | false | false | [
"from qtpy import PYQT5",
"from qtpy.QtCore import Signal",
"from qtpy.QtWidgets import QWidget",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin"
] | 22 | 67 |
Parameters
----------
enable: bool
Enable/Disable standard input/output redirection.
"""
sig_exception_occurred = Signal(dict)
"""
This signal can be emitted to report an exception handled by this widget.
Parameters
----------
error_data: dict
The dictionary containing error data. The expected keys are:
>>> error_data= {
"text": str,
"is_traceback": bool,
"repo": str,
"title": str,
"label": str,
"steps": str,
}
Notes
-----
The `is_traceback` key indicates if `text` contains plain text or a
Python error traceback.
The `title` and `repo` keys indicate how the error data should
customize the report dialog and Github error submission.
The `label` and `steps` keys allow customizing the content of the
error dialog.
"""
sig_unmaximize_plugin_requested = Signal((), (object,))
"""
This signal is emitted to inform the main window that it needs to
unmaximize the currently maximized plugin, if any.
Parameters
----------
plugin_instance: SpyderDockablePlugin
Unmaximize plugin only if it is not `plugin_instance`.
""" | main_container.py | spyder.spyder.api.widgets | false | false | [
"from qtpy import PYQT5",
"from qtpy.QtCore import Signal",
"from qtpy.QtWidgets import QWidget",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin"
] | 69 | 113 |
Parameters
----------
plugin_instance: SpyderDockablePlugin
Unmaximize plugin only if it is not `plugin_instance`.
"""
def __init__(self, name, plugin, parent=None):
if PYQT5:
super().__init__(parent=parent, class_parent=plugin)
else:
QWidget.__init__(self, parent)
SpyderWidgetMixin.__init__(self, class_parent=plugin)
# ---- Attributes
# --------------------------------------------------------------------
self._name = name
self._plugin = plugin
self._parent = parent
# Attribute used to access the action, toolbar, toolbutton and menu
# registries
self.PLUGIN_NAME = name
# Widget setup
# A PluginMainContainer inherits from QWidget so it can be a parent
# for the widgets it contains. Since it is a QWidget it will occupy a
# physical space on the screen and may cast "shadow" on the top left
# of the main window. To prevent this we ensure the widget has zero
# width and zero height.
# See: spyder-ide/spyder#13547
self.setMaximumWidth(0)
self.setMaximumHeight(0)
# ---- Public Qt overridden methods
# -------------------------------------------------------------------------
def closeEvent(self, event):
self.on_close()
super().closeEvent(event) | main_container.py | spyder.spyder.api.widgets | false | true | [
"from qtpy import PYQT5",
"from qtpy.QtCore import Signal",
"from qtpy.QtWidgets import QWidget",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin"
] | 69 | 106 |
# ---- API: methods to define or override
# ------------------------------------------------------------------------
def setup(self):
"""
Create actions, widgets, add to menu and other setup requirements.
"""
raise NotImplementedError(
'A PluginMainContainer subclass must define a `setup` method!')
def update_actions(self):
"""
Update the state of exposed actions.
Exposed actions are actions created by the self.create_action method.
"""
raise NotImplementedError(
'A PluginMainContainer subclass must define a `update_actions` '
'method!')
def on_close(self):
"""
Perform actions before the container is closed.
This method **must** only operate on local attributes.
"""
pass | main_container.py | spyder.spyder.api.widgets | false | true | [
"from qtpy import PYQT5",
"from qtpy.QtCore import Signal",
"from qtpy.QtWidgets import QWidget",
"from spyder.api.widgets.mixins import SpyderToolbarMixin, SpyderWidgetMixin"
] | 148 | 173 |
# -*- coding: utf-8 -*-
#
# Copyright © Spyder Project Contributors
# Licensed under the terms of the MIT License
# (see spyder/__init__.py for details)
"""
Spyder API toolbar widgets.
"""
# Standard library imports
from collections import OrderedDict
import os
import sys
from typing import Union, Optional, Tuple, List, Dict
import uuid
# Third part imports
from qtpy.QtCore import QEvent, QObject, QSize, Qt
from qtpy.QtWidgets import (
QAction, QProxyStyle, QStyle, QToolBar, QToolButton, QWidget)
# Local imports
from spyder.api.exceptions import SpyderAPIError
from spyder.api.translations import _
from spyder.utils.icon_manager import ima
from spyder.utils.qthelpers import SpyderAction
from spyder.utils.stylesheet import (
APP_TOOLBAR_STYLESHEET, PANES_TOOLBAR_STYLESHEET)
# Generic type annotations
ToolbarItem = Union[SpyderAction, QWidget]
ToolbarItemEntry = Tuple[ToolbarItem, Optional[str], Optional[str],
Optional[str]]
# ---- Constants
# ----------------------------------------------------------------------------
class ToolbarLocation:
Top = Qt.TopToolBarArea
Bottom = Qt.BottomToolBarArea
# ---- Event filters
# ---------------------------------------------------------------------------- | toolbars.py | spyder.spyder.api.widgets | true | false | [
"from collections import OrderedDict",
"import os",
"import sys",
"from typing import Union, Optional, Tuple, List, Dict",
"import uuid",
"from qtpy.QtCore import QEvent, QObject, QSize, Qt",
"from qtpy.QtWidgets import (",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.translations import _",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import SpyderAction",
"from spyder.utils.stylesheet import ("
] | 1 | 45 |
class ToolbarLocation:
Top = Qt.TopToolBarArea
Bottom = Qt.BottomToolBarArea
# ---- Event filters
# ----------------------------------------------------------------------------
class ToolTipFilter(QObject):
"""
Filter tool tip events on toolbuttons.
"""
def eventFilter(self, obj, event):
event_type = event.type()
action = obj.defaultAction() if isinstance(obj, QToolButton) else None
if event_type == QEvent.ToolTip and action is not None:
if action.tip is None:
return action.text_beside_icon
return QObject.eventFilter(self, obj, event)
# ---- Styles
# ---------------------------------------------------------------------------- | toolbars.py | spyder.spyder.api.widgets | true | true | [
"from collections import OrderedDict",
"import os",
"import sys",
"from typing import Union, Optional, Tuple, List, Dict",
"import uuid",
"from qtpy.QtCore import QEvent, QObject, QSize, Qt",
"from qtpy.QtWidgets import (",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.translations import _",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import SpyderAction",
"from spyder.utils.stylesheet import ("
] | 39 | 62 |
class ToolbarStyle(QProxyStyle):
# The toolbar type. This can be 'Application' or 'MainWidget'
TYPE = None
def pixelMetric(self, pm, option, widget):
"""
Adjust size of toolbar extension button (in pixels).
From https://stackoverflow.com/a/27042352/438386
"""
# Important: These values need to be updated in case we change the size
# of our toolbar buttons in utils/stylesheet.py. That's because Qt only
# allow to set them in pixels here, not em's.
if pm == QStyle.PM_ToolBarExtensionExtent:
if self.TYPE == 'Application':
if os.name == 'nt':
return 40
elif sys.platform == 'darwin':
return 54
else:
return 57
elif self.TYPE == 'MainWidget':
if os.name == 'nt':
return 36
elif sys.platform == 'darwin':
return 42
else:
return 44
else:
print("Unknown toolbar style type") # spyder: test-skip
return super().pixelMetric(pm, option, widget)
# ---- Toolbars
# ---------------------------------------------------------------------------- | toolbars.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import os",
"import sys",
"from typing import Union, Optional, Tuple, List, Dict",
"import uuid",
"from qtpy.QtCore import QEvent, QObject, QSize, Qt",
"from qtpy.QtWidgets import (",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.translations import _",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import SpyderAction",
"from spyder.utils.stylesheet import ("
] | 63 | 98 |
class SpyderToolbar(QToolBar):
"""
Spyder Toolbar.
This class provides toolbars with some predefined functionality.
"""
def __init__(self, parent, title):
super().__init__(parent=parent)
self._section_items = OrderedDict()
self._item_map = {} # type: Dict[str, ToolbarItem]
self._pending_items = {} # type: Dict[str, List[ToolbarItemEntry]]
self._title = title
self._default_section = "default_section"
self.setWindowTitle(title)
# Set icon for extension button.
# From https://stackoverflow.com/a/55412455/438386
ext_button = self.findChild(QToolButton, "qt_toolbar_ext_button")
ext_button.setIcon(ima.icon('toolbar_ext_button'))
ext_button.setToolTip(_("More"))
def add_item(self, action_or_widget: ToolbarItem,
section: Optional[str] = None, before: Optional[str] = None,
before_section: Optional[str] = None, omit_id: bool = False):
"""
Add action or widget item to given toolbar `section`. | toolbars.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import os",
"import sys",
"from typing import Union, Optional, Tuple, List, Dict",
"import uuid",
"from qtpy.QtCore import QEvent, QObject, QSize, Qt",
"from qtpy.QtWidgets import (",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.translations import _",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import SpyderAction",
"from spyder.utils.stylesheet import ("
] | 99 | 126 |
Parameters
----------
item: SpyderAction or QWidget
The item to add to the `toolbar`.
toolbar_id: str or None
The application toolbar unique string identifier.
section: str or None
The section id in which to insert the `item` on the `toolbar`.
before: str or None
Make the item appear before another given item.
before_section: str or None
Make the item defined section appear before another given section
(must be already defined).
omit_id: bool
If True, then the toolbar will check if the item to add declares an
id, False otherwise. This flag exists only for items added on
Spyder 4 plugins. Default: False
"""
item_id = None
if (isinstance(action_or_widget, SpyderAction) or
hasattr(action_or_widget, 'action_id')):
item_id = action_or_widget.action_id
elif hasattr(action_or_widget, 'ID'):
item_id = action_or_widget.ID
if not omit_id and item_id is None and action_or_widget is not None:
raise SpyderAPIError(
f'Item {action_or_widget} must declare an ID attribute.') | toolbars.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"import os",
"import sys",
"from typing import Union, Optional, Tuple, List, Dict",
"import uuid",
"from qtpy.QtCore import QEvent, QObject, QSize, Qt",
"from qtpy.QtWidgets import (",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.translations import _",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import SpyderAction",
"from spyder.utils.stylesheet import ("
] | 128 | 155 |
if not omit_id and item_id is None and action_or_widget is not None:
raise SpyderAPIError(
f'Item {action_or_widget} must declare an ID attribute.')
if before is not None:
if before not in self._item_map:
before_pending_items = self._pending_items.get(before, [])
before_pending_items.append(
(action_or_widget, section, before, before_section))
self._pending_items[before] = before_pending_items
return
else:
before = self._item_map[before]
if section is None:
section = self._default_section
action_or_widget._section = section
if before is not None:
if section == self._default_section:
action_or_widget._section = before._section
section = before._section
if section not in self._section_items:
self._section_items[section] = [action_or_widget]
else:
if before is not None:
new_actions_or_widgets = []
for act_or_wid in self._section_items[section]:
if act_or_wid == before:
new_actions_or_widgets.append(action_or_widget)
new_actions_or_widgets.append(act_or_wid) | toolbars.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"import os",
"import sys",
"from typing import Union, Optional, Tuple, List, Dict",
"import uuid",
"from qtpy.QtCore import QEvent, QObject, QSize, Qt",
"from qtpy.QtWidgets import (",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.translations import _",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import SpyderAction",
"from spyder.utils.stylesheet import ("
] | 153 | 185 |
self._section_items[section] = new_actions_or_widgets
else:
self._section_items[section].append(action_or_widget)
if (before_section is not None and
before_section in self._section_items):
new_sections_keys = []
for sec in self._section_items.keys():
if sec == before_section:
new_sections_keys.append(section)
if sec != section:
new_sections_keys.append(sec)
self._section_items = OrderedDict(
(section_key, self._section_items[section_key])
for section_key in new_sections_keys)
if item_id is not None:
self._item_map[item_id] = action_or_widget
if item_id in self._pending_items:
item_pending = self._pending_items.pop(item_id)
for item, section, before, before_section in item_pending:
self.add_item(item, section=section, before=before,
before_section=before_section) | toolbars.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"import os",
"import sys",
"from typing import Union, Optional, Tuple, List, Dict",
"import uuid",
"from qtpy.QtCore import QEvent, QObject, QSize, Qt",
"from qtpy.QtWidgets import (",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.translations import _",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import SpyderAction",
"from spyder.utils.stylesheet import ("
] | 187 | 208 |
def remove_item(self, item_id: str):
"""Remove action or widget from toolbar by id."""
item = self._item_map.pop(item_id)
for section in list(self._section_items.keys()):
section_items = self._section_items[section]
if item in section_items:
section_items.remove(item)
if len(section_items) == 0:
self._section_items.pop(section)
self.clear()
self._render()
def _render(self):
"""
Create the toolbar taking into account sections and locations.
This method is called once on widget setup.
"""
sec_items = []
for sec, items in self._section_items.items():
for item in items:
sec_items.append([sec, item])
sep = QAction(self)
sep.setSeparator(True)
sec_items.append((None, sep))
if sec_items:
sec_items.pop()
for (sec, item) in sec_items:
if isinstance(item, QAction):
add_method = super().addAction
else:
add_method = super().addWidget
add_method(item)
if isinstance(item, QAction):
text_beside_icon = getattr(item, 'text_beside_icon', False)
widget = self.widgetForAction(item)
if text_beside_icon:
widget.setToolButtonStyle(Qt.ToolButtonTextBesideIcon) | toolbars.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import os",
"import sys",
"from typing import Union, Optional, Tuple, List, Dict",
"import uuid",
"from qtpy.QtCore import QEvent, QObject, QSize, Qt",
"from qtpy.QtWidgets import (",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.translations import _",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import SpyderAction",
"from spyder.utils.stylesheet import ("
] | 210 | 253 |
if text_beside_icon:
widget.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
if item.isCheckable():
widget.setCheckable(True) | toolbars.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"import os",
"import sys",
"from typing import Union, Optional, Tuple, List, Dict",
"import uuid",
"from qtpy.QtCore import QEvent, QObject, QSize, Qt",
"from qtpy.QtWidgets import (",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.translations import _",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import SpyderAction",
"from spyder.utils.stylesheet import ("
] | 252 | 256 |
class ApplicationToolbar(SpyderToolbar):
"""
Spyder Main application Toolbar.
"""
ID = None
"""
Unique string toolbar identifier.
This is used by Qt to be able to save and restore the state of widgets.
"""
def __init__(self, parent, title):
super().__init__(parent=parent, title=title)
self._style = ToolbarStyle(None)
self._style.TYPE = 'Application'
self._style.setParent(self)
self.setStyle(self._style)
self.setStyleSheet(str(APP_TOOLBAR_STYLESHEET)) | toolbars.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import os",
"import sys",
"from typing import Union, Optional, Tuple, List, Dict",
"import uuid",
"from qtpy.QtCore import QEvent, QObject, QSize, Qt",
"from qtpy.QtWidgets import (",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.translations import _",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import SpyderAction",
"from spyder.utils.stylesheet import ("
] | 259 | 279 |
class MainWidgetToolbar(SpyderToolbar):
"""
Spyder Widget toolbar class.
A toolbar used in Spyder dockable plugins to add internal toolbars
to their interface.
"""
ID = None
"""
Unique string toolbar identifier.
"""
def __init__(self, parent=None, title=None):
super().__init__(parent, title=title or '')
self._icon_size = QSize(16, 16)
# Setup
self.setObjectName("main_widget_toolbar_{}".format(
str(uuid.uuid4())[:8]))
self.setFloatable(False)
self.setMovable(False)
self.setContextMenuPolicy(Qt.PreventContextMenu)
self.setIconSize(self._icon_size)
self._style = ToolbarStyle(None)
self._style.TYPE = 'MainWidget'
self._style.setParent(self)
self.setStyle(self._style)
self.setStyleSheet(str(PANES_TOOLBAR_STYLESHEET))
self._filter = ToolTipFilter()
def set_icon_size(self, icon_size):
self._icon_size = icon_size
self.setIconSize(icon_size)
def _render(self):
"""
Create the toolbar taking into account the sections and locations.
This method is called once on widget setup.
"""
sec_items = []
for sec, items in self._section_items.items():
for item in items:
sec_items.append([sec, item])
sep = QAction(self)
sep.setSeparator(True)
sec_items.append((None, sep)) | toolbars.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"import os",
"import sys",
"from typing import Union, Optional, Tuple, List, Dict",
"import uuid",
"from qtpy.QtCore import QEvent, QObject, QSize, Qt",
"from qtpy.QtWidgets import (",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.translations import _",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import SpyderAction",
"from spyder.utils.stylesheet import ("
] | 282 | 333 |
sep = QAction(self)
sep.setSeparator(True)
sec_items.append((None, sep))
if sec_items:
sec_items.pop()
for (sec, item) in sec_items:
if isinstance(item, QAction):
add_method = super().addAction
else:
add_method = super().addWidget
add_method(item)
if isinstance(item, QAction):
widget = self.widgetForAction(item)
widget.installEventFilter(self._filter)
text_beside_icon = getattr(item, 'text_beside_icon', False)
if text_beside_icon:
widget.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
if item.isCheckable():
widget.setCheckable(True) | toolbars.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"import os",
"import sys",
"from typing import Union, Optional, Tuple, List, Dict",
"import uuid",
"from qtpy.QtCore import QEvent, QObject, QSize, Qt",
"from qtpy.QtWidgets import (",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.translations import _",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import SpyderAction",
"from spyder.utils.stylesheet import ("
] | 233 | 257 |
class SpyderToolButtonMixin:
"""
Provide methods to create, add and get toolbuttons.
"""
def create_toolbutton(self, name, text=None, icon=None,
tip=None, toggled=None, triggered=None,
autoraise=True, text_beside_icon=False,
section=None, option=None):
"""
Create a Spyder toolbutton.
"""
if toggled and not callable(toggled):
toggled = lambda value: None
if toggled is not None:
if section is None and option is not None:
section = self.CONF_SECTION
toolbutton = create_toolbutton(
self,
text=text,
shortcut=None,
icon=icon,
tip=tip,
toggled=toggled,
triggered=triggered,
autoraise=autoraise,
text_beside_icon=text_beside_icon,
section=section,
option=option,
id_=name,
plugin=self.PLUGIN_NAME,
context_name=self.CONTEXT_NAME,
register_toolbutton=True
)
toolbutton.name = name
if toggled:
if section is not None and option is not None:
value = CONF.get(section, option)
toolbutton.setChecked(value)
return toolbutton | mixins.py | spyder.spyder.api.widgets | true | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 36 | 79 |
return toolbutton
def get_toolbutton(self, name: str, context: Optional[str] = None,
plugin: Optional[str] = None) -> QToolButton:
"""
Return toolbutton by name, plugin and context.
Parameters
----------
name: str
Name of the toolbutton to retrieve.
context: Optional[str]
Widget or context identifier under which the toolbutton was stored.
If None, then `CONTEXT_NAME` is used instead
plugin: Optional[str]
Name of the plugin where the toolbutton was defined. If None, then
`PLUGIN_NAME` is used.
Returns
-------
toolbutton: QToolButton
The corresponding toolbutton stored under the given `name`,
`context` and `plugin`.
Raises
------
KeyError
If either of `name`, `context` or `plugin` keys do not exist in the
toolbutton registry.
"""
plugin = self.PLUGIN_NAME if plugin is None else plugin
context = self.CONTEXT_NAME if context is None else context
return TOOLBUTTON_REGISTRY.get_reference(name, plugin, context)
def get_toolbuttons(self, context: Optional[str] = None,
plugin: Optional[str] = None) -> Dict[str, QToolButton]:
"""
Return all toolbuttons defined by a context on a given plugin. | mixins.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 79 | 116 |
Parameters
----------
context: Optional[str]
Widget or context identifier under which the toolbuttons were
stored. If None, then `CONTEXT_NAME` is used instead
plugin: Optional[str]
Name of the plugin where the toolbuttons were defined.
If None, then `PLUGIN_NAME` is used.
Returns
-------
toolbuttons: Dict[str, QToolButton]
A dictionary that maps string keys to their corresponding
toolbuttons.
"""
plugin = self.PLUGIN_NAME if plugin is None else plugin
context = self.CONTEXT_NAME if context is None else context
return TOOLBUTTON_REGISTRY.get_references(plugin, context) | mixins.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 86 | 103 |
class SpyderToolbarMixin:
"""
Provide methods to create, add and get toolbars.
"""
def add_item_to_toolbar(self, action_or_widget, toolbar, section=None,
before=None, before_section=None):
"""
If you provide a `before` action, the action will be placed before this
one, so the section option will be ignored, since the action will now
be placed in the same section as the `before` action.
"""
toolbar.add_item(action_or_widget, section=section, before=before,
before_section=before_section)
def create_stretcher(self, id_=None):
"""
Create a stretcher widget to be used in a Qt toolbar.
"""
stretcher = QWidget(self)
stretcher.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
if id_ is not None:
stretcher.ID = id_
return stretcher
def create_toolbar(self, name: str) -> QToolBar:
"""
Create a Spyder toolbar.
"""
toolbar = QToolBar(self)
TOOLBAR_REGISTRY.register_reference(
toolbar, name, self.PLUGIN_NAME, self.CONTEXT_NAME)
return toolbar
def get_toolbar(self, name: str, context: Optional[str] = None,
plugin: Optional[str] = None) -> QToolBar:
"""
Return toolbar by name, plugin and context. | mixins.py | spyder.spyder.api.widgets | true | true | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 138 | 176 |
def get_toolbar(self, name: str, context: Optional[str] = None,
plugin: Optional[str] = None) -> QToolBar:
"""
Return toolbar by name, plugin and context.
Parameters
----------
name: str
Name of the toolbar to retrieve.
context: Optional[str]
Widget or context identifier under which the toolbar was stored.
If None, then `CONTEXT_NAME` is used instead
plugin: Optional[str]
Name of the plugin where the toolbar was defined. If None, then
`PLUGIN_NAME` is used.
Returns
-------
toolbar: QToolBar
The corresponding toolbar stored under the given `name`, `context`
and `plugin`.
Raises
------
KeyError
If either of `name`, `context` or `plugin` keys do not exist in the
toolbar registry.
"""
plugin = self.PLUGIN_NAME if plugin is None else plugin
context = self.CONTEXT_NAME if context is None else context
return TOOLBAR_REGISTRY.get_reference(name, plugin, context)
def get_toolbars(self, context: Optional[str] = None,
plugin: Optional[str] = None) -> Dict[str, QToolBar]:
"""
Return all toolbars defined by a context on a given plugin. | mixins.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 173 | 208 |
Parameters
----------
context: Optional[str]
Widget or context identifier under which the toolbars were stored.
If None, then `CONTEXT_NAME` is used instead
plugin: Optional[str]
Name of the plugin where the toolbars were defined. If None, then
`PLUGIN_NAME` is used.
Returns
-------
toolbars: Dict[str, QToolBar]
A dictionary that maps string keys to their corresponding toolbars.
"""
plugin = self.PLUGIN_NAME if plugin is None else plugin
context = self.CONTEXT_NAME if context is None else context
return TOOLBAR_REGISTRY.get_references(plugin, context) | mixins.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 86 | 102 |
class SpyderMenuMixin:
"""
Provide methods to create, add and get menus.
This mixin uses a custom menu object that allows for the creation of
sections in a simple way.
"""
def add_item_to_menu(self, action_or_menu, menu, section=None,
before=None):
"""
Add a SpyderAction or a QWidget to the menu.
"""
if not isinstance(menu, SpyderMenu):
raise SpyderAPIError('Menu must be an instance of SpyderMenu!')
menu.add_action(action_or_menu, section=section, before=before)
def _create_menu(
self,
menu_id: str,
title: Optional[str] = None,
icon: Optional[QIcon] = None,
reposition: Optional[bool] = True,
MenuClass=SpyderMenu
) -> SpyderMenu:
"""
Create a SpyderMenu or a subclass of it.
Notes
-----
* This method should only be used directly to generate a menu that is a
subclass of SpyderMenu.
* Refer to the documentation for `create_menu` to learn about its args.
"""
menus = getattr(self, '_menus', None)
if menus is None:
self._menus = OrderedDict()
if menu_id in self._menus:
raise SpyderAPIError(
'Menu name "{}" already in use!'.format(menu_id)
) | mixins.py | spyder.spyder.api.widgets | true | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 229 | 271 |
if menu_id in self._menus:
raise SpyderAPIError(
'Menu name "{}" already in use!'.format(menu_id)
)
menu = MenuClass(
parent=self,
menu_id=menu_id,
title=title,
reposition=reposition
)
if icon is not None:
menu.menuAction().setIconVisibleInMenu(True)
menu.setIcon(icon)
MENU_REGISTRY.register_reference(
menu, menu_id, self.PLUGIN_NAME, self.CONTEXT_NAME
)
self._menus[menu_id] = menu
return menu
def create_menu(
self,
menu_id: str,
title: Optional[str] = None,
icon: Optional[QIcon] = None,
reposition: Optional[bool] = True,
) -> SpyderMenu:
"""
Create a menu for Spyder.
Parameters
----------
menu_id: str
Unique str identifier for the menu.
title: str or None
Localized text string for the menu.
icon: QIcon or None
Icon to use for the menu.
reposition: bool, optional (default True)
Whether to vertically reposition the menu due to it's padding.
Returns
-------
SpyderMenu
The created menu.
"""
return self._create_menu(
menu_id=menu_id,
title=title,
icon=icon,
reposition=reposition
) | mixins.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 268 | 322 |
def get_menu(
self,
name: str,
context: Optional[str] = None,
plugin: Optional[str] = None
) -> SpyderMenu:
"""
Return a menu by name, plugin and context.
Parameters
----------
name: str
Name of the menu to retrieve.
context: Optional[str]
Widget or context identifier under which the menu was stored.
If None, then `CONTEXT_NAME` is used instead
plugin: Optional[str]
Name of the plugin where the menu was defined. If None, then
`PLUGIN_NAME` is used.
Returns
-------
menu: SpyderMenu
The corresponding menu stored under the given `name`, `context`
and `plugin`.
Raises
------
KeyError
If either of `name`, `context` or `plugin` keys do not exist in the
menu registry.
"""
plugin = self.PLUGIN_NAME if plugin is None else plugin
context = self.CONTEXT_NAME if context is None else context
return MENU_REGISTRY.get_reference(name, plugin, context)
def get_menus(self, context: Optional[str] = None,
plugin: Optional[str] = None) -> Dict[str, SpyderMenu]:
"""
Return all menus defined by a context on a given plugin. | mixins.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 324 | 363 |
Parameters
----------
context: Optional[str]
Widget or context identifier under which the menus were stored.
If None, then `CONTEXT_NAME` is used instead
plugin: Optional[str]
Name of the plugin where the menus were defined. If None, then
`PLUGIN_NAME` is used.
Returns
-------
menus: Dict[str, SpyderMenu]
A dictionary that maps string keys to their corresponding menus.
"""
plugin = self.PLUGIN_NAME if plugin is None else plugin
context = self.CONTEXT_NAME if context is None else context
return MENU_REGISTRY.get_references(plugin, context) | mixins.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 86 | 102 |
class SpyderActionMixin:
"""
Provide methods to create, add and get actions in a unified way.
This mixin uses a custom action object.
"""
def _update_action_state(self, action_name, value):
"""
This allows to update the state of a togglable action without emitting
signals.
This is useful when the global application configuration changes and
we need to propagate the current state of an action based on those
changes
"""
self.blockSignals(True)
try:
self.get_action(action_name).setChecked(value)
except SpyderAPIError:
pass
self.blockSignals(False) | mixins.py | spyder.spyder.api.widgets | true | true | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 384 | 405 |
# Comment: The word `context` is used for two different concepts.
# On one side it refers to a Qt widget shortcut context and on the
# other it refers to a section of the configuration (or the widget
# name where it is applied).
def create_action(self, name, text, icon=None, icon_text='', tip=None,
toggled=None, triggered=None, shortcut_context=None,
context=Qt.WidgetWithChildrenShortcut, initial=None,
register_shortcut=False, section=None, option=None,
parent=None, register_action=True, overwrite=False,
context_name=None, menurole=None):
"""
name: str
unique identifiable name for the action
text: str
Localized text for the action
icon: QIcon,
Icon for the action when applied to menu or toolbutton.
icon_text: str
Icon for text in toolbars. If True, this will also disable
the tooltip on this toolbutton if part of a toolbar.
tip: str
Tooltip to define for action on menu or toolbar.
toggled: Optional[Union[Callable, bool]]
If True, then the action modifies the configuration option on the
section specified. Otherwise, it should be a callable to use
when toggling this action. If None, then the action does not
behave like a checkbox.
triggered: callable | mixins.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 407 | 434 |
when toggling this action. If None, then the action does not
behave like a checkbox.
triggered: callable
The callable to use when triggering this action.
shortcut_context: str
Set the `str` context of the shortcut.
context: Qt.ShortcutContext
Set the context for the shortcut.
initial: object
Sets the initial state of a togglable action. This does not emit
the toggled signal.
section: Optional[str]
Name of the configuration section whose option is going to be
modified. If None, and `option` is not None, then it defaults to
the class `CONF_SECTION` attribute.
option: ConfigurationKey
Name of the configuration option whose value is reflected and
affected by the action.
register_shortcut: bool, optional
If True, main window will expose the shortcut in Preferences.
The default value is `False`.
parent: QWidget (None)
Define the parent of the widget. Use `self` if not provided.
register_action: bool, optional
If True, the action will be registered and searchable.
The default value is `True`.
overwrite: bool, optional
If True, in case of action overwriting no warning will be shown.
The default value is `False`
context_name: Optional[str] | mixins.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 432 | 461 |
overwrite: bool, optional
If True, in case of action overwriting no warning will be shown.
The default value is `False`
context_name: Optional[str]
Name of the context that holds the action in case of registration.
The combination of `name` and `context_name` is unique so trying
to register an action with the same `name` and `context_name` will
cause a warning unless `overwrite` is set to `True`.
menurole: QAction.MenuRole, optional
Menu role for the action (it only has effect on macOS). | mixins.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 458 | 467 |
Notes
-----
There is no need to set shortcuts right now. We only create actions
with this (and similar methods) and these are then exposed as possible
shortcuts on plugin registration in the main window with the
register_shortcut argument.
If icon_text is True, this will also disable the tooltip.
If a shortcut is found in the default config then it is assigned,
otherwise it's left blank for the user to define one for it.
"""
if triggered is None and toggled is None:
raise SpyderAPIError(
'Action must provide the toggled or triggered parameters!'
)
if parent is None:
parent = self
if toggled and not callable(toggled):
toggled = lambda value: None
if toggled is not None:
if section is None and option is not None:
section = self.CONF_SECTION | mixins.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 258 | 283 |
if toggled is not None:
if section is None and option is not None:
section = self.CONF_SECTION
action = create_action(
parent,
text=text,
icon=icon,
tip=tip,
toggled=toggled,
triggered=triggered,
context=context,
section=section,
option=option,
id_=name,
plugin=self.PLUGIN_NAME,
context_name=(
self.CONTEXT_NAME if context_name is None else context_name),
register_action=register_action,
overwrite=overwrite,
menurole=menurole
)
action.name = name
if icon_text:
action.setIconText(icon_text)
action.text_beside_icon = bool(icon_text)
action.shortcut_context = shortcut_context
action.register_shortcut = register_shortcut
action.tip = tip
if initial is not None:
if toggled:
action.setChecked(initial)
elif triggered:
raise SpyderAPIError(
'Initial values can only apply to togglable actions!')
else:
if toggled:
if section is not None and option is not None:
value = CONF.get(section, option)
action.setChecked(value)
return action | mixins.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 51 | 94 |
return action
def get_action(self, name: str, context: Optional[str] = None,
plugin: Optional[str] = None) -> Any:
"""
Return an action by name, context and plugin.
Parameters
----------
name: str
Name of the action to retrieve.
context: Optional[str]
Widget or context identifier under which the action was stored.
If None, then `CONTEXT_NAME` is used instead
plugin: Optional[str]
Name of the plugin where the action was defined. If None, then
`PLUGIN_NAME` is used.
Returns
-------
action: SpyderAction
The corresponding action stored under the given `name`, `context`
and `plugin`.
Raises
------
KeyError
If either of `name`, `context` or `plugin` keys do not exist in the
action registry.
"""
plugin = self.PLUGIN_NAME if plugin is None else plugin
context = self.CONTEXT_NAME if context is None else context
return ACTION_REGISTRY.get_reference(name, plugin, context)
def get_actions(self, context: Optional[str] = None,
plugin: Optional[str] = None) -> dict:
"""
Return all actions defined by a context on a given plugin. | mixins.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 535 | 573 |
def get_actions(self, context: Optional[str] = None,
plugin: Optional[str] = None) -> dict:
"""
Return all actions defined by a context on a given plugin.
Parameters
----------
context: Optional[str]
Widget or context identifier under which the actions were stored.
If None, then `CONTEXT_NAME` is used instead
plugin: Optional[str]
Name of the plugin where the actions were defined. If None, then
`PLUGIN_NAME` is used.
Returns
-------
actions: Dict[str, SpyderAction]
A dictionary that maps string keys to their corresponding actions. | mixins.py | spyder.spyder.api.widgets | false | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 570 | 587 |
Returns
-------
actions: Dict[str, SpyderAction]
A dictionary that maps string keys to their corresponding actions.
Notes
-----
1. Actions should be created once. Creating new actions on menu popup
is *highly* discouraged.
2. Actions can be created directly on a PluginMainWidget or
PluginMainContainer subclass. Child widgets can also create
actions, but they need to subclass SpyderWidgetMixin.
3. PluginMainWidget or PluginMainContainer will collect any actions
defined in subwidgets (if defined) and expose them in the
get_actions method at the plugin level.
4. Any action created this way is now exposed as a possible shortcut
automatically without manual shortcut registration.
If an option is found in the config system then it is assigned,
otherwise it's left with an empty shortcut.
5. There is no need to override this method.
"""
plugin = self.PLUGIN_NAME if plugin is None else plugin
context = self.CONTEXT_NAME if context is None else context
return ACTION_REGISTRY.get_references(plugin, context)
def update_actions(self, options):
"""
Update the state of exposed actions.
Exposed actions are actions created by the `create_action` method.
"""
raise NotImplementedError('') | mixins.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 97 | 128 |
class SpyderWidgetMixin(SpyderActionMixin, SpyderMenuMixin,
SpyderConfigurationObserver, SpyderToolButtonMixin):
"""
Basic functionality for all Spyder widgets and Qt items.
This mixin does not include toolbar handling as that is limited to the
application with the coreui plugin or the PluginMainWidget for dockable
plugins.
This provides a simple management of widget options, as well as Qt helpers
for defining the actions a widget provides.
"""
# Plugin name identifier used to store actions, toolbars, toolbuttons
# and menus
PLUGIN_NAME = None
# Context name used to store actions, toolbars, toolbuttons and menus
CONTEXT_NAME = None
def __init__(self, class_parent=None):
for attr in ['CONF_SECTION', 'PLUGIN_NAME']:
if getattr(self, attr, None) is None:
if hasattr(class_parent, attr):
# Inherit class_parent CONF_SECTION/PLUGIN_NAME value
setattr(self, attr, getattr(class_parent, attr))
super().__init__()
@staticmethod
def create_icon(name):
"""
Create an icon by name using the spyder Icon manager.
"""
return ima.icon(name)
def update_style(self):
"""
Update stylesheet and style of the widget.
This method will be called recursively on all widgets on theme change.
"""
pass | mixins.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 618 | 660 |
def update_style(self):
"""
Update stylesheet and style of the widget.
This method will be called recursively on all widgets on theme change.
"""
pass
def update_translation(self):
"""
Update localization of the widget.
This method will be called recursively on all widgets on language
change.
"""
pass | mixins.py | spyder.spyder.api.widgets | false | true | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 654 | 669 |
class SpyderMainWindowMixin:
"""
Mixin with additional functionality for the QMainWindow's used in Spyder.
"""
def _is_on_visible_screen(self: QMainWindow):
"""Detect if the window is placed on a visible screen."""
x, y = self.geometry().x(), self.geometry().y()
qapp = QApplication.instance()
current_screen = qapp.screenAt(QPoint(x, y))
if current_screen is None:
return False
else:
return True
def move_to_primary_screen(self: QMainWindow):
"""Move the window to the primary screen if necessary."""
if self._is_on_visible_screen():
return
qapp = QApplication.instance()
primary_screen_geometry = qapp.primaryScreen().availableGeometry()
x, y = primary_screen_geometry.x(), primary_screen_geometry.y()
if self.isMaximized():
self.showNormal()
self.move(QPoint(x, y))
# With this we want to maximize only the Spyder main window and not the
# plugin ones, which usually are not maximized.
if not hasattr(self, 'is_window_widget'):
self.showMaximized() | mixins.py | spyder.spyder.api.widgets | true | true | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 672 | 705 |
# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# Copyright (c) 2013-2016 Colin Duquesnoy and others (see pyqode/AUTHORS.rst)
# Copyright (c) 2016- Spyder Project Contributors (see AUTHORS.txt)
#
# Distributed under the terms of the MIT License
# (see NOTICE.txt in the Spyder root directory for details)
# -----------------------------------------------------------------------------
"""
Spyder API Mixins.
"""
# Standard library imports
from collections import OrderedDict
from typing import Any, Optional, Dict
# Third party imports
from qtpy.QtCore import QPoint, Qt
from qtpy.QtGui import QIcon
from qtpy.QtWidgets import (
QApplication, QMainWindow, QSizePolicy, QToolBar, QWidget, QToolButton
)
# Local imports
from spyder.api.config.mixins import SpyderConfigurationObserver
from spyder.api.exceptions import SpyderAPIError
from spyder.api.widgets.menus import SpyderMenu
from spyder.config.manager import CONF
from spyder.utils.icon_manager import ima
from spyder.utils.qthelpers import create_action, create_toolbutton
from spyder.utils.registries import (
ACTION_REGISTRY, MENU_REGISTRY, TOOLBAR_REGISTRY, TOOLBUTTON_REGISTRY)
# Code for: class SpyderToolButtonMixin:
# Code for: class SpyderToolbarMixin:
# Code for: class SpyderMenuMixin:
# Code for: class SpyderActionMixin:
# Code for: class SpyderWidgetMixin(SpyderActionMixin, SpyderMenuMixin,
# Code for: class SpyderMainWindowMixin: | mixins.py | spyder.spyder.api.widgets | true | false | [
"from collections import OrderedDict",
"from typing import Any, Optional, Dict",
"from qtpy.QtCore import QPoint, Qt",
"from qtpy.QtGui import QIcon",
"from qtpy.QtWidgets import (",
"from spyder.api.config.mixins import SpyderConfigurationObserver",
"from spyder.api.exceptions import SpyderAPIError",
"from spyder.api.widgets.menus import SpyderMenu",
"from spyder.config.manager import CONF",
"from spyder.utils.icon_manager import ima",
"from spyder.utils.qthelpers import create_action, create_toolbutton",
"from spyder.utils.registries import ("
] | 1 | 51 |
# -*- coding: utf-8 -*-
#
# Copyright © Spyder Project Contributors
# Licensed under the terms of the MIT License
# (see spyder/__init__.py for details)
"""
Widgets to extend Spyder through its API.
""" | __init__.py | spyder.spyder.api.widgets | false | false | [] | 1 | 9 |
# -*- coding: utf-8 -*-
#
# Copyright © Spyder Project Contributors
# Licensed under the terms of the MIT License
# (see spyder/__init__.py for details)
"""
Spyder API menu widgets.
"""
# Standard library imports
import sys
from typing import Optional, Union, TypeVar
# Third party imports
import qstylizer.style
from qtpy.QtWidgets import QAction, QMenu, QWidget
# Local imports
from spyder.api.config.fonts import SpyderFontType, SpyderFontsMixin
from spyder.utils.qthelpers import add_actions, set_menu_icons, SpyderAction
from spyder.utils.palette import QStylePalette
from spyder.utils.stylesheet import AppStyle, MAC, WIN
# ---- Constants
# -----------------------------------------------------------------------------
MENU_SEPARATOR = None
# Generic type annotations
T = TypeVar('T', bound='SpyderMenu')
class OptionsMenuSections:
Top = 'top_section'
Bottom = 'bottom_section'
class PluginMainWidgetMenus:
Context = 'context_menu'
Options = 'options_menu'
# ---- Widgets
# ----------------------------------------------------------------------------- | menus.py | spyder.spyder.api.widgets | true | false | [
"import sys",
"from typing import Optional, Union, TypeVar",
"import qstylizer.style",
"from qtpy.QtWidgets import QAction, QMenu, QWidget",
"from spyder.api.config.fonts import SpyderFontType, SpyderFontsMixin",
"from spyder.utils.qthelpers import add_actions, set_menu_icons, SpyderAction",
"from spyder.utils.palette import QStylePalette",
"from spyder.utils.stylesheet import AppStyle, MAC, WIN"
] | 1 | 46 |
class SpyderMenu(QMenu, SpyderFontsMixin):
"""
A QMenu subclass to implement additional functionality for Spyder.
"""
MENUS = []
APP_MENU = False
def __init__(
self,
parent: Optional[QWidget] = None,
menu_id: Optional[str] = None,
title: Optional[str] = None,
min_width: Optional[int] = None,
reposition: Optional[bool] = True,
):
"""
Create a menu for Spyder.
Parameters
----------
parent: QWidget or None
The menu's parent
menu_id: str
Unique str identifier for the menu.
title: str or None
Localized text string for the menu.
min_width: int or None
Minimum width for the menu.
reposition: bool, optional (default True)
Whether to vertically reposition the menu due to it's padding.
"""
self._parent = parent
self.menu_id = menu_id
self._title = title
self._reposition = reposition
self._sections = []
self._actions = []
self._actions_map = {}
self._unintroduced_actions = {}
self._after_sections = {}
self._dirty = False
self._is_shown = False
self._is_submenu = False
self._in_app_menu = False
if title is None:
super().__init__(parent)
else:
super().__init__(title, parent)
self.MENUS.append((parent, title, self)) | menus.py | spyder.spyder.api.widgets | false | false | [
"import sys",
"from typing import Optional, Union, TypeVar",
"import qstylizer.style",
"from qtpy.QtWidgets import QAction, QMenu, QWidget",
"from spyder.api.config.fonts import SpyderFontType, SpyderFontsMixin",
"from spyder.utils.qthelpers import add_actions, set_menu_icons, SpyderAction",
"from spyder.utils.palette import QStylePalette",
"from spyder.utils.stylesheet import AppStyle, MAC, WIN"
] | 47 | 98 |
if title is None:
super().__init__(parent)
else:
super().__init__(title, parent)
self.MENUS.append((parent, title, self))
# Set min width
if min_width is not None:
self.setMinimumWidth(min_width)
# Signals
self.aboutToShow.connect(self.render)
# Adjustmens for Mac
if sys.platform == 'darwin':
# Needed to enable the dynamic population of actions in app menus
# in the aboutToShow signal.
# See spyder-ide/spyder#14612
if self.APP_MENU:
self.addAction(QAction(self))
# Necessary to follow Mac's HIG for app menus.
self.aboutToShow.connect(self._set_icons)
# Style
self.css = self._generate_stylesheet()
self.setStyleSheet(self.css.toString())
# ---- Public API
# -------------------------------------------------------------------------
def clear_actions(self):
"""
Remove actions from the menu (including custom references)
Returns
-------
None.
"""
self.clear()
self._sections = []
self._actions = []
self._actions_map = {}
self._unintroduced_actions = {}
self._after_sections = {} | menus.py | spyder.spyder.api.widgets | false | true | [
"import sys",
"from typing import Optional, Union, TypeVar",
"import qstylizer.style",
"from qtpy.QtWidgets import QAction, QMenu, QWidget",
"from spyder.api.config.fonts import SpyderFontType, SpyderFontsMixin",
"from spyder.utils.qthelpers import add_actions, set_menu_icons, SpyderAction",
"from spyder.utils.palette import QStylePalette",
"from spyder.utils.stylesheet import AppStyle, MAC, WIN"
] | 93 | 137 |
def add_action(self: T,
action: Union[SpyderAction, T],
section: Optional[str] = None,
before: Optional[str] = None,
before_section: Optional[str] = None,
check_before: bool = True,
omit_id: bool = False):
"""
Add action to a given menu section. | menus.py | spyder.spyder.api.widgets | false | false | [
"import sys",
"from typing import Optional, Union, TypeVar",
"import qstylizer.style",
"from qtpy.QtWidgets import QAction, QMenu, QWidget",
"from spyder.api.config.fonts import SpyderFontType, SpyderFontsMixin",
"from spyder.utils.qthelpers import add_actions, set_menu_icons, SpyderAction",
"from spyder.utils.palette import QStylePalette",
"from spyder.utils.stylesheet import AppStyle, MAC, WIN"
] | 139 | 147 |
Parameters
----------
action: SpyderAction
The action to add.
section: str or None
The section id in which to insert the `action`.
before: str
Make the action appear before the given action identifier.
before_section: str or None
Make the item section (if provided) appear before another
given section.
check_before: bool
Check if the `before` action is part of the menu. This is
necessary to avoid an infinite recursion when adding
unintroduced actions with this method again.
omit_id: bool
If True, then the menu will check if the item to add declares an
id, False otherwise. This flag exists only for items added on
Spyder 4 plugins. Default: False
"""
item_id = None
if isinstance(action, SpyderAction) or hasattr(action, 'action_id'):
item_id = action.action_id
elif isinstance(action, SpyderMenu) or hasattr(action, 'menu_id'):
item_id = action.menu_id
action._is_submenu = True
if not omit_id and item_id is None and action is not None:
raise AttributeError(f'Item {action} must declare an id.')
if before is None:
self._actions.append((section, action))
else:
new_actions = []
added = False
before_item = self._actions_map.get(before, None) | menus.py | spyder.spyder.api.widgets | false | false | [
"import sys",
"from typing import Optional, Union, TypeVar",
"import qstylizer.style",
"from qtpy.QtWidgets import QAction, QMenu, QWidget",
"from spyder.api.config.fonts import SpyderFontType, SpyderFontsMixin",
"from spyder.utils.qthelpers import add_actions, set_menu_icons, SpyderAction",
"from spyder.utils.palette import QStylePalette",
"from spyder.utils.stylesheet import AppStyle, MAC, WIN"
] | 65 | 100 |
for sec, act in self._actions:
if before_item is not None and act == before_item:
added = True
new_actions.append((section, action))
new_actions.append((sec, act))
# Actions can't be added to the menu if the `before` action is
# not part of it yet. That's why we need to save them in the
# `_unintroduced_actions` dict, so we can add them again when
# the menu is rendered.
if not added and check_before:
before_actions = self._unintroduced_actions.get(before, [])
before_actions.append((section, action))
self._unintroduced_actions[before] = before_actions
self._actions = new_actions
if section not in self._sections:
self._add_section(section, before_section)
# Track state of menu to avoid re-rendering if menu has not changed
self._dirty = True
self._actions_map[item_id] = action
def remove_action(self, item_id: str):
if item_id in self._actions_map:
action = self._actions_map.pop(item_id)
position = None
for i, (_, act) in enumerate(self._actions):
if act == action:
position = i
break
if position is not None:
self._actions.pop(position)
self._dirty = True | menus.py | spyder.spyder.api.widgets | false | true | [
"import sys",
"from typing import Optional, Union, TypeVar",
"import qstylizer.style",
"from qtpy.QtWidgets import QAction, QMenu, QWidget",
"from spyder.api.config.fonts import SpyderFontType, SpyderFontsMixin",
"from spyder.utils.qthelpers import add_actions, set_menu_icons, SpyderAction",
"from spyder.utils.palette import QStylePalette",
"from spyder.utils.stylesheet import AppStyle, MAC, WIN"
] | 186 | 223 |
if position is not None:
self._actions.pop(position)
self._dirty = True
def get_title(self):
"""
Return the title for menu.
"""
return self._title
def get_actions(self):
"""
Return a parsed list of menu actions.
Includes MENU_SEPARATOR taking into account the sections defined.
"""
actions = []
for section in self._sections:
for (sec, action) in self._actions:
if sec == section:
actions.append(action)
actions.append(MENU_SEPARATOR)
return actions
def get_sections(self):
"""
Return a tuple of menu sections.
"""
return tuple(self._sections)
# ---- Private API
# -------------------------------------------------------------------------
def _add_missing_actions(self):
"""
Add actions that were not introduced to the menu because a `before`
action they require is not part of it.
"""
for before, actions in self._unintroduced_actions.items():
for section, action in actions:
self.add_action(
action,
section=section,
before=before,
check_before=False
)
self._unintroduced_actions = {} | menus.py | spyder.spyder.api.widgets | false | true | [
"import sys",
"from typing import Optional, Union, TypeVar",
"import qstylizer.style",
"from qtpy.QtWidgets import QAction, QMenu, QWidget",
"from spyder.api.config.fonts import SpyderFontType, SpyderFontsMixin",
"from spyder.utils.qthelpers import add_actions, set_menu_icons, SpyderAction",
"from spyder.utils.palette import QStylePalette",
"from spyder.utils.stylesheet import AppStyle, MAC, WIN"
] | 221 | 268 |
self._unintroduced_actions = {}
def render(self):
"""
Create the menu prior to showing it. This takes into account sections
and location of menus.
"""
if self._dirty:
self.clear()
self._add_missing_actions()
actions = self.get_actions()
add_actions(self, actions)
self._set_icons()
self._dirty = False
def _add_section(self, section, before_section=None):
"""
Add a new section to the list of sections in this menu.
Parameters
----------
before_section: str or None
Make `section` appear before another one.
"""
inserted_before_other = False | menus.py | spyder.spyder.api.widgets | false | true | [
"import sys",
"from typing import Optional, Union, TypeVar",
"import qstylizer.style",
"from qtpy.QtWidgets import QAction, QMenu, QWidget",
"from spyder.api.config.fonts import SpyderFontType, SpyderFontsMixin",
"from spyder.utils.qthelpers import add_actions, set_menu_icons, SpyderAction",
"from spyder.utils.palette import QStylePalette",
"from spyder.utils.stylesheet import AppStyle, MAC, WIN"
] | 268 | 294 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.