def __init__(self, parent, model):
super(AlgorithmMonitorDialog, self).__init__(parent)
self.tree = QTreeWidget(self)
self.tree.setColumnCount(3)
self.tree.setSelectionMode(QTreeWidget.NoSelection)
self.tree.setColumnWidth(0, 220)
self.tree.setHeaderLabels(['Algorithm', 'Progress', ''])
header = self.tree.header()
header.setSectionResizeMode(1, QHeaderView.Stretch)
header.setSectionResizeMode(2, QHeaderView.Fixed)
header.setStretchLastSection(False)
button_layout = QHBoxLayout()
self.close_button = QPushButton('Close')
button_layout.addStretch()
button_layout.addWidget(self.close_button)
layout = QVBoxLayout()
layout.addWidget(self.tree)
layout.addLayout(button_layout)
self.setLayout(layout)
self.setWindowTitle('Mantid - Algorithm progress')
self.setWindowIcon(QIcon(":/MantidPlot_Icon_32offset.png"))
self.resize(500, 300)
self.presenter = AlgorithmProgressDialogPresenter(self, model)
self.presenter.update_gui()
def set_corner_widgets(self, corner_widgets):
"""
Set tabs corner widgets
corner_widgets: dictionary of (corner, widgets)
corner: Qt.TopLeftCorner or Qt.TopRightCorner
widgets: list of widgets (may contains integers to add spacings)
"""
assert isinstance(corner_widgets, dict)
assert all(key in (Qt.TopLeftCorner, Qt.TopRightCorner)
for key in corner_widgets)
self.corner_widgets.update(corner_widgets)
for corner, widgets in list(self.corner_widgets.items()):
cwidget = QWidget()
cwidget.hide()
prev_widget = self.cornerWidget(corner)
if prev_widget:
prev_widget.close()
self.setCornerWidget(cwidget, corner)
clayout = QHBoxLayout()
clayout.setContentsMargins(0, 0, 0, 0)
for widget in widgets:
if isinstance(widget, int):
clayout.addSpacing(widget)
else:
clayout.addWidget(widget)
cwidget.setLayout(clayout)
cwidget.show()
def create_controls(self):
self.btn_start = QPushButton(tr("Start"))
self.btn_stop = QPushButton(tr("Stop"))
self.btn_stop.setEnabled(False)
self.btn_start.clicked.connect(self.start_recording)
self.btn_stop.clicked.connect(self.stop_recording)
self.chk_actions = QCheckBox(tr("Actions"))
self.chk_code = QCheckBox(tr("Code"))
for c in [self.chk_actions, self.chk_code]:
c.setChecked(True)
c.toggled.connect(self.update_filter)
hbox = QHBoxLayout()
for w in [self.btn_start, self.btn_stop]:
hbox.addWidget(w)
hbox2 = QHBoxLayout()
for w in [self.chk_actions, self.chk_code]:
hbox2.addWidget(w)
vbox = QVBoxLayout()
vbox.addLayout(hbox)
vbox.addLayout(hbox2)
wrap = QWidget()
wrap.setLayout(vbox)
height = vbox.sizeHint().height()
wrap.setFixedHeight(height)
self.setWidget(wrap)
def __init__(self, parent, plugin, tabs, data, icon):
QDialog.__init__(self, parent)
# Variables
self.plugins_tabs = []
self.plugins_data = []
self.plugins_instances = []
self.add_plugin(plugin, tabs, data, icon)
self.plugin = None # Last plugin with focus
self.mode = self.FILE_MODE # By default start in this mode
self.initial_cursors = None # {fullpath: QCursor}
self.initial_path = None # Fullpath of initial active editor
self.initial_widget = None # Initial active editor
self.line_number = None # Selected line number in filer
self.is_visible = False # Is the switcher visible?
help_text = _("Press <b>Enter</b> to switch files or <b>Esc</b> to "
"cancel.<br><br>Type to filter filenames.<br><br>"
"Use <b>:number</b> to go to a line, e.g. "
"<b><code>main:42</code></b><br>"
"Use <b>@symbol_text</b> to go to a symbol, e.g. "
"<b><code>@init</code></b>"
"<br><br> Press <b>Ctrl+W</b> to close current tab.<br>")
# Either allow searching for a line number or a symbol but not both
regex = QRegExp("([A-Za-z0-9_]{0,100}@[A-Za-z0-9_]{0,100})|" +
"([A-Za-z0-9_]{0,100}:{0,1}[0-9]{0,100})")
# Widgets
self.edit = FilesFilterLine(self)
self.help = HelperToolButton()
self.list = QListWidget(self)
self.filter = KeyPressFilter()
regex_validator = QRegExpValidator(regex, self.edit)
# Widgets setup
self.setWindowFlags(Qt.Popup | Qt.FramelessWindowHint)
self.setWindowOpacity(0.95)
self.edit.installEventFilter(self.filter)
self.edit.setValidator(regex_validator)
self.help.setToolTip(help_text)
self.list.setItemDelegate(HTMLDelegate(self))
# Layout
edit_layout = QHBoxLayout()
edit_layout.addWidget(self.edit)
edit_layout.addWidget(self.help)
layout = QVBoxLayout()
layout.addLayout(edit_layout)
layout.addWidget(self.list)
self.setLayout(layout)
# Signals
self.rejected.connect(self.restore_initial_state)
self.filter.sig_up_key_pressed.connect(self.previous_row)
self.filter.sig_down_key_pressed.connect(self.next_row)
self.edit.returnPressed.connect(self.accept)
self.edit.textChanged.connect(self.setup)
self.list.itemSelectionChanged.connect(self.item_selection_changed)
self.list.clicked.connect(self.edit.setFocus)
def __init__(self, plugin, id_,
history_filename, config_options,
additional_options, interpreter_versions,
connection_file=None, hostname=None,
menu_actions=None, slave=False,
external_kernel=False, given_name=None):
super(ClientWidget, self).__init__(plugin)
SaveHistoryMixin.__init__(self, history_filename)
# --- Init attrs
self.id_ = id_
self.connection_file = connection_file
self.hostname = hostname
self.menu_actions = menu_actions
self.slave = slave
self.given_name = given_name
# --- Other attrs
self.options_button = None
self.stop_button = None
self.stop_icon = ima.icon('stop')
self.history = []
self.allow_rename = True
self.stderr_dir = None
# --- Widgets
self.shellwidget = ShellWidget(config=config_options,
ipyclient=self,
additional_options=additional_options,
interpreter_versions=interpreter_versions,
external_kernel=external_kernel,
local_kernel=True)
self.infowidget = WebView(self)
self.set_infowidget_font()
self.loading_page = self._create_loading_page()
self._show_loading_page()
# --- Layout
vlayout = QVBoxLayout()
toolbar_buttons = self.get_toolbar_buttons()
hlayout = QHBoxLayout()
for button in toolbar_buttons:
hlayout.addWidget(button)
vlayout.addLayout(hlayout)
vlayout.setContentsMargins(0, 0, 0, 0)
vlayout.addWidget(self.shellwidget)
vlayout.addWidget(self.infowidget)
self.setLayout(vlayout)
# --- Exit function
self.exit_callback = lambda: plugin.close_client(client=self)
# --- Signals
# As soon as some content is printed in the console, stop
# our loading animation
document = self.get_control().document()
document.contentsChange.connect(self._hide_loading_page)
# --- Dialog manager
self.dialog_manager = DialogManager()
def __init__(self, parent, name_filters=[],
show_all=True, show_hscrollbar=True, options_button=None):
QWidget.__init__(self, parent)
self.name_filters = name_filters
self.show_all = show_all
self.show_hscrollbar = show_hscrollbar
self.treewidget = ExplorerTreeWidget(self, self.show_hscrollbar)
self.treewidget.setup(name_filters=self.name_filters,
show_all=self.show_all)
self.treewidget.setup_view()
self.treewidget.hide()
self.emptywidget = ExplorerTreeWidget(self)
if options_button:
btn_layout = QHBoxLayout()
btn_layout.setAlignment(Qt.AlignLeft)
btn_layout.addStretch()
btn_layout.addWidget(options_button, Qt.AlignRight)
layout = create_plugin_layout(btn_layout)
else:
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.emptywidget)
layout.addWidget(self.treewidget)
self.setLayout(layout)
def __init__(self, editor):
Panel.__init__(self, editor)
self._editor = editor
self._editor.sig_cursor_position_changed.connect(
self._handle_cursor_position_change_event
)
# The layout
hbox = QHBoxLayout()
self.class_cb = QComboBox()
self.method_cb = QComboBox()
hbox.addWidget(self.class_cb)
hbox.addWidget(self.method_cb)
hbox.setSpacing(0)
hbox.setContentsMargins(0, 0, 0, 0)
self.setLayout(hbox)
# Internal data
self.folds = None
self.parents = None
self.classes = None
self.funcs = None
# Initial data for the dropdowns.
self.class_cb.addItem("<None>", 0)
self.method_cb.addItem("<None>", 0)
# Attach some events.
self.class_cb.activated.connect(self.combobox_activated)
self.method_cb.activated.connect(self.combobox_activated)
def __init__(self, parent):
QDialog.__init__(self, parent)
self.setWindowTitle("Spyder %s: %s" % (__version__,
_("Dependencies")))
self.setWindowIcon(ima.icon('tooloptions'))
self.setModal(True)
self.treewidget = DependenciesTreeWidget(self)
self.label = QLabel(_("Optional modules are not required to run "
"Spyder but enhance its functions."))
self.label2 = QLabel(_("<b>Note:</b> New dependencies or changed ones "
"will be correctly detected only after Spyder "
"is restarted."))
btn = QPushButton(_("Copy to clipboard"), )
btn.clicked.connect(self.copy_to_clipboard)
bbox = QDialogButtonBox(QDialogButtonBox.Ok)
bbox.accepted.connect(self.accept)
hlayout = QHBoxLayout()
hlayout.addWidget(btn)
hlayout.addStretch()
hlayout.addWidget(bbox)
vlayout = QVBoxLayout()
vlayout.addWidget(self.treewidget)
vlayout.addWidget(self.label)
vlayout.addWidget(self.label2)
vlayout.addLayout(hlayout)
self.setLayout(vlayout)
self.resize(840, 560)
class AlgorithmProgressWidget(QWidget):
"""
Widget consisting of a progress bar and a button.
"""
def __init__(self, parent=None):
super(AlgorithmProgressWidget, self).__init__(parent)
self.progress_bar = None
self.details_button = QPushButton('Details')
self.details_button.clicked.connect(self.show_dialog)
self.layout = QHBoxLayout()
self.layout.addStretch()
self.layout.addWidget(self.details_button)
self.setLayout(self.layout)
self.presenter = AlgorithmProgressPresenter(self)
def show_progress_bar(self):
if self.progress_bar is None:
self.progress_bar = QProgressBar()
self.progress_bar.setAlignment(Qt.AlignHCenter)
self.layout.insertWidget(0, self.progress_bar)
self.layout.removeItem(self.layout.takeAt(1))
def hide_progress_bar(self):
if self.progress_bar is not None:
self.layout.insertStretch(0)
self.layout.removeWidget(self.progress_bar)
self.progress_bar.close()
self.progress_bar = None
def show_dialog(self):
dialog = AlgorithmMonitorDialog(self, self.presenter.model)
dialog.show()
def setup_page(self):
# Widgets
self.table = ShortcutsTable(self)
self.finder = ShortcutFinder(self.table, self.table.set_regex)
self.table.finder = self.finder
self.label_finder = QLabel(_('Search: '))
self.reset_btn = QPushButton(_("Reset to default values"))
# Layout
hlayout = QHBoxLayout()
vlayout = QVBoxLayout()
hlayout.addWidget(self.label_finder)
hlayout.addWidget(self.finder)
vlayout.addWidget(self.table)
vlayout.addLayout(hlayout)
vlayout.addWidget(self.reset_btn)
self.setLayout(vlayout)
self.setTabOrder(self.table, self.finder)
self.setTabOrder(self.finder, self.reset_btn)
# Signals and slots
if PYQT5:
# Qt5 'dataChanged' has 3 parameters
self.table.proxy_model.dataChanged.connect(
lambda i1, i2, roles, opt='': self.has_been_modified(opt))
else:
self.table.proxy_model.dataChanged.connect(
lambda i1, i2, opt='': self.has_been_modified(opt))
self.reset_btn.clicked.connect(self.reset_to_default)
def __init__(self, *args, **kwargs):
super(ClosePackageManagerDialog, self).__init__(*args, **kwargs)
self.label_icon = QLabel()
self.label_about = QLabel('Conda is still busy.\n\n'
'Do you want to cancel the process?')
self.button_ok = QPushButton('Yes')
self.button_cancel = QPushButton('No')
self.buttonbox = QDialogButtonBox(Qt.Horizontal)
# Widget setup
self.buttonbox.addButton(self.button_ok, QDialogButtonBox.ActionRole)
self.buttonbox.addButton(self.button_cancel,
QDialogButtonBox.ActionRole)
# self.label_icon.setPixmap(QPixmap(images.ANACONDA_ICON_64_PATH))
self.setWindowTitle("Cancel Process")
# Layouts
h_layout = QHBoxLayout()
h_layout.addWidget(self.label_icon, 0, Qt.AlignTop)
h_layout.addSpacing(10)
h_layout.addWidget(self.label_about)
main_layout = QVBoxLayout()
main_layout.addLayout(h_layout)
main_layout.addSpacing(20)
main_layout.addWidget(self.buttonbox)
self.setLayout(main_layout)
# Signals
self.button_ok.clicked.connect(self.accept)
self.button_cancel.clicked.connect(self.reject)
def __init__(self, parent=None, show_fullpath=True, fullpath_sorting=True,
show_all_files=True, show_comments=True, options_button=None):
QWidget.__init__(self, parent)
self.treewidget = OutlineExplorerTreeWidget(self,
show_fullpath=show_fullpath,
fullpath_sorting=fullpath_sorting,
show_all_files=show_all_files,
show_comments=show_comments)
self.visibility_action = create_action(self,
_("Show/hide outline explorer"),
icon='outline_explorer_vis.png',
toggled=self.toggle_visibility)
self.visibility_action.setChecked(True)
btn_layout = QHBoxLayout()
for btn in self.setup_buttons():
btn.setAutoRaise(True)
btn.setIconSize(QSize(16, 16))
btn_layout.addWidget(btn)
if options_button:
btn_layout.addStretch()
btn_layout.addWidget(options_button, Qt.AlignRight)
layout = create_plugin_layout(btn_layout, self.treewidget)
self.setLayout(layout)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.catalog_list = CatalogList()
layout = QHBoxLayout()
layout.addWidget(QLabel("Catalog:"))
layout.addWidget(self.catalog_list)
self.setLayout(layout)
def create_combobox(self, text, choices, option, default=NoDefault,
tip=None, restart=False):
"""choices: couples (name, key)"""
label = QLabel(text)
combobox = QComboBox()
if tip is not None:
combobox.setToolTip(tip)
for name, key in choices:
if not (name is None and key is None):
combobox.addItem(name, to_qvariant(key))
# Insert separators
count = 0
for index, item in enumerate(choices):
name, key = item
if name is None and key is None:
combobox.insertSeparator(index + count)
count += 1
self.comboboxes[combobox] = (option, default)
layout = QHBoxLayout()
layout.addWidget(label)
layout.addWidget(combobox)
layout.addStretch(1)
layout.setContentsMargins(0, 0, 0, 0)
widget = QWidget(self)
widget.label = label
widget.combobox = combobox
widget.setLayout(layout)
combobox.restart_required = restart
combobox.label_text = text
return widget
def __init__(self, parent=None, logname=None, level=logging.NOTSET):
QWidget.__init__(self, parent=parent)
# Create Widgets
self.label = QLabel('Minimum displayed log level: ', parent=self)
self.combo = QComboBox(parent=self)
self.text = QPlainTextEdit(parent=self)
self.text.setReadOnly(True)
self.clear_btn = QPushButton("Clear", parent=self)
# Create layout
layout = QVBoxLayout()
level_control = QHBoxLayout()
level_control.addWidget(self.label)
level_control.addWidget(self.combo)
layout.addLayout(level_control)
layout.addWidget(self.text)
layout.addWidget(self.clear_btn)
self.setLayout(layout)
# Allow QCombobox to control log level
for log_level, value in LogLevels.as_dict().items():
self.combo.addItem(log_level, value)
self.combo.currentIndexChanged[str].connect(self.setLevel)
# Allow QPushButton to clear log text
self.clear_btn.clicked.connect(self.clear)
# Create a handler with the default format
self.handler = GuiHandler(level=level, parent=self)
self.logFormat = self.default_format
self.handler.message.connect(self.write)
# Create logger. Either as a root or given logname
self.log = None
self.level = None
self.logName = logname or ''
self.logLevel = level
self.destroyed.connect(functools.partial(logger_destroyed, self.log))
def create_window():
# Create app and widgets
app = QApplication(sys.argv)
win = QMainWindow()
main_area = QWidget()
button_area = QWidget()
scroll_area = QScrollArea()
button = QPushButton("Start Video")
btn_grab = QPushButton("Grab Frame")
# Create layouts
vbox = QVBoxLayout()
hbox = QHBoxLayout()
# Fill Layouts
vbox.addWidget(scroll_area)
vbox.addWidget(button_area)
hbox.addStretch()
hbox.addWidget(button)
hbox.addWidget(btn_grab)
# Assign layouts to widgets
main_area.setLayout(vbox)
button_area.setLayout(hbox)
scroll_area.setLayout(QVBoxLayout())
# Attach some child widgets directly
win.setCentralWidget(main_area)
return app, win, button, btn_grab, scroll_area
def __init__(self, parent=None, show_fullpath=True, fullpath_sorting=True,
show_all_files=True, show_comments=True):
QWidget.__init__(self, parent)
self.treewidget = OutlineExplorerTreeWidget(self,
show_fullpath=show_fullpath,
fullpath_sorting=fullpath_sorting,
show_all_files=show_all_files,
show_comments=show_comments)
self.visibility_action = create_action(self,
_("Show/hide outline explorer"),
icon='outline_explorer_vis.png',
toggled=self.toggle_visibility)
self.visibility_action.setChecked(True)
btn_layout = QHBoxLayout()
btn_layout.setAlignment(Qt.AlignLeft)
for btn in self.setup_buttons():
btn_layout.addWidget(btn)
layout = QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addLayout(btn_layout)
layout.addWidget(self.treewidget)
self.setLayout(layout)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.uid_label = QLabel()
self.open_individually_button = QPushButton('Open individually')
self.open_individually_button.hide()
self.open_individually_button.clicked.connect(self._open_individually)
self.open_overplotted_button = QPushButton('Open over-plotted')
self.open_overplotted_button.hide()
self.open_overplotted_button.clicked.connect(self._open_overplotted)
self.open_overplotted_on_button = QPushButton('Add to tab...')
self.open_overplotted_on_button.hide()
self.open_overplotted_on_button.setEnabled(False)
self.open_overplotted_on_button.clicked.connect(self._open_overplotted_on)
self.copy_uid_button = QPushButton('Copy UID to Clipboard')
self.copy_uid_button.hide()
self.copy_uid_button.clicked.connect(self._copy_uid)
self.streams = QLabel()
self.entries = []
uid_layout = QHBoxLayout()
uid_layout.addWidget(self.uid_label)
uid_layout.addWidget(self.copy_uid_button)
layout = QVBoxLayout()
layout.addWidget(self.open_individually_button)
layout.addWidget(self.open_overplotted_button)
layout.addWidget(self.open_overplotted_on_button)
layout.addLayout(uid_layout)
layout.addWidget(self.streams)
self.setLayout(layout)
self._tab_titles = ()
def setup_and_check(self, data, title=''):
"""
Setup DataFrameEditor:
return False if data is not supported, True otherwise
"""
self.layout = QGridLayout()
self.setLayout(self.layout)
self.setWindowIcon(ima.icon('arredit'))
if title:
title = to_text_string(title) + " - %s" % data.__class__.__name__
else:
title = _("%s editor") % data.__class__.__name__
if isinstance(data, Series):
self.is_series = True
data = data.to_frame()
self.setWindowTitle(title)
self.resize(600, 500)
self.dataModel = DataFrameModel(data, parent=self)
self.dataTable = DataFrameView(self, self.dataModel)
self.layout.addWidget(self.dataTable)
self.setLayout(self.layout)
self.setMinimumSize(400, 300)
# Make the dialog act as a window
self.setWindowFlags(Qt.Window)
btn_layout = QHBoxLayout()
btn = QPushButton(_("Format"))
# disable format button for int type
btn_layout.addWidget(btn)
btn.clicked.connect(self.change_format)
btn = QPushButton(_('Resize'))
btn_layout.addWidget(btn)
btn.clicked.connect(self.resize_to_contents)
bgcolor = QCheckBox(_('Background color'))
bgcolor.setChecked(self.dataModel.bgcolor_enabled)
bgcolor.setEnabled(self.dataModel.bgcolor_enabled)
bgcolor.stateChanged.connect(self.change_bgcolor_enable)
btn_layout.addWidget(bgcolor)
self.bgcolor_global = QCheckBox(_('Column min/max'))
self.bgcolor_global.setChecked(self.dataModel.colum_avg_enabled)
self.bgcolor_global.setEnabled(not self.is_series and
self.dataModel.bgcolor_enabled)
self.bgcolor_global.stateChanged.connect(self.dataModel.colum_avg)
btn_layout.addWidget(self.bgcolor_global)
btn_layout.addStretch()
bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
bbox.accepted.connect(self.accept)
bbox.rejected.connect(self.reject)
btn_layout.addWidget(bbox)
self.layout.addLayout(btn_layout, 2, 0)
return True
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.main = parent
# Widgets
self.pages_widget = QStackedWidget()
self.pages_widget.setMinimumWidth(600)
self.contents_widget = QListWidget()
self.button_reset = QPushButton(_('Reset to defaults'))
bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Apply |
QDialogButtonBox.Cancel)
self.apply_btn = bbox.button(QDialogButtonBox.Apply)
# Widgets setup
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Spyder), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
self.setWindowTitle(_('Preferences'))
self.setWindowIcon(ima.icon('configure'))
self.contents_widget.setMovement(QListView.Static)
self.contents_widget.setSpacing(1)
self.contents_widget.setCurrentRow(0)
self.contents_widget.setMinimumWidth(220)
self.contents_widget.setMinimumHeight(400)
# Layout
hsplitter = QSplitter()
hsplitter.addWidget(self.contents_widget)
hsplitter.addWidget(self.pages_widget)
hsplitter.setStretchFactor(0, 1)
hsplitter.setStretchFactor(1, 2)
btnlayout = QHBoxLayout()
btnlayout.addWidget(self.button_reset)
btnlayout.addStretch(1)
btnlayout.addWidget(bbox)
vlayout = QVBoxLayout()
vlayout.addWidget(hsplitter)
vlayout.addLayout(btnlayout)
self.setLayout(vlayout)
# Signals and slots
if self.main:
self.button_reset.clicked.connect(self.main.reset_spyder)
self.pages_widget.currentChanged.connect(self.current_page_changed)
self.contents_widget.currentRowChanged.connect(
self.pages_widget.setCurrentIndex)
bbox.accepted.connect(self.accept)
bbox.rejected.connect(self.reject)
bbox.clicked.connect(self.button_clicked)
# Ensures that the config is present on spyder first run
CONF.set('main', 'interface_language', load_lang_conf())
def _init_ui(self):
# LINE 1: Data component drop down
self.component_prompt = QLabel("Data Component:")
self.component_prompt.setWordWrap(True)
# Add the data component labels to the drop down, with the ComponentID
# set as the userData:
if self.parent is not None and hasattr(self.parent, 'data_components'):
self.label_data = [(str(cid), cid) for cid in self.parent.data_components]
else:
self.label_data = [(str(cid), cid) for cid in self.data.visible_components]
default_index = 0
self.component_combo = QComboBox()
self.component_combo.setFixedWidth(200)
update_combobox(self.component_combo, self.label_data, default_index=default_index)
self.component_combo.currentIndexChanged.connect(self.update_unit_layout)
# hbl is short for Horizontal Box Layout
hbl1 = QHBoxLayout()
hbl1.addWidget(self.component_prompt)
hbl1.addWidget(self.component_combo)
hbl1.addStretch(1)
# LINE 2: Unit conversion layout
# This layout is filled by CubeVizUnit
self.unit_layout = QHBoxLayout() # this is hbl2
# LINE 3: Message box
self.message_box = QLabel("")
hbl3 = QHBoxLayout()
hbl3.addWidget(self.message_box)
hbl3.addStretch(1)
# Line 4: Buttons
ok_text = "Convert Data" if self.convert_data else "Convert Displayed Units"
ok_function = self.convert_data_units if self.convert_data else self.convert_displayed_units
self.okButton = QPushButton(ok_text)
self.okButton.clicked.connect(ok_function)
self.okButton.setDefault(True)
self.cancelButton = QPushButton("Cancel")
self.cancelButton.clicked.connect(self.cancel)
hbl4 = QHBoxLayout()
hbl4.addStretch(1)
hbl4.addWidget(self.cancelButton)
hbl4.addWidget(self.okButton)
vbl = QVBoxLayout()
vbl.addLayout(hbl1)
vbl.addLayout(self.unit_layout)
vbl.addLayout(hbl3)
vbl.addLayout(hbl4)
self.setLayout(vbl)
self.vbl = vbl
self.update_unit_layout(default_index)
self.show()
def create_controls(self):
"""
Create UI controls.
"""
vbox = QVBoxLayout()
form = QFormLayout()
self.num_angle = QDoubleSpinBox()
self.num_angle.setValue(0.0)
self.num_angle.setMinimum(-360)
self.num_angle.setMaximum(360)
form.addRow(tr("Angle:"), self.num_angle)
vbox.addLayout(form)
self.gbo_preview = QGroupBox(tr("Preview"))
self.gbo_preview.setCheckable(True)
self.gbo_preview.setChecked(False)
gbo_vbox = QVBoxLayout()
self.chk_grid = QCheckBox(tr("Grid"))
self.chk_grid.setChecked(False)
self.num_grid = QSpinBox()
self.num_grid.setValue(4)
self.num_grid.setMinimum(1)
self.num_grid.setEnabled(False)
self.chk_grid.toggled[bool].connect(self.num_grid.setEnabled)
gbo_vbox.addWidget(self.chk_grid)
gbo_vbox.addWidget(self.num_grid)
self.gbo_preview.setLayout(gbo_vbox)
vbox.addWidget(self.gbo_preview)
self.gbo_preview.toggled[bool].connect(self.set_preview)
self.gbo_output = QGroupBox(tr("Output"))
self.opt_new = QRadioButton(tr("New signal"))
self.opt_replace = QRadioButton(tr("In place"))
self.opt_new.setChecked(True)
gbo_vbox2 = QVBoxLayout()
gbo_vbox2.addWidget(self.opt_new)
gbo_vbox2.addWidget(self.opt_replace)
self.gbo_output.setLayout(gbo_vbox2)
vbox.addWidget(self.gbo_output)
self.chk_reshape = QCheckBox(tr("Resize to fit"))
self.chk_reshape.setChecked(False)
vbox.addWidget(self.chk_reshape)
self.btn_ok = QPushButton(tr("&OK"))
self.btn_ok.setDefault(True)
self.btn_ok.clicked.connect(self.accept)
self.btn_cancel = QPushButton(tr("&Cancel"))
self.btn_cancel.clicked.connect(self.reject)
hbox = QHBoxLayout()
hbox.addWidget(self.btn_ok)
hbox.addWidget(self.btn_cancel)
vbox.addLayout(hbox)
vbox.addStretch(1)
self.setLayout(vbox)
def __init__(self, text, title='', font=None, parent=None,
readonly=False, size=(400, 300)):
QDialog.__init__(self, parent)
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Spyder), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
self.text = None
self.btn_save_and_close = None
# Display text as unicode if it comes as bytes, so users see
# its right representation
if is_binary_string(text):
self.is_binary = True
text = to_text_string(text, 'utf8')
else:
self.is_binary = False
self.layout = QVBoxLayout()
self.setLayout(self.layout)
# Text edit
self.edit = QTextEdit(parent)
self.edit.setReadOnly(readonly)
self.edit.textChanged.connect(self.text_changed)
self.edit.setPlainText(text)
if font is None:
font = get_font()
self.edit.setFont(font)
self.layout.addWidget(self.edit)
# Buttons configuration
btn_layout = QHBoxLayout()
btn_layout.addStretch()
if not readonly:
self.btn_save_and_close = QPushButton(_('Save and Close'))
self.btn_save_and_close.setDisabled(True)
self.btn_save_and_close.clicked.connect(self.accept)
btn_layout.addWidget(self.btn_save_and_close)
self.btn_close = QPushButton(_('Close'))
self.btn_close.setAutoDefault(True)
self.btn_close.setDefault(True)
self.btn_close.clicked.connect(self.reject)
btn_layout.addWidget(self.btn_close)
self.layout.addLayout(btn_layout)
# Make the dialog act as a window
self.setWindowFlags(Qt.Window)
self.setWindowIcon(ima.icon('edit'))
self.setWindowTitle(_("Text editor") + \
"%s" % (" - "+str(title) if str(title) else ""))
self.resize(size[0], size[1])
def add_new_row(self, _metadata, row=0):
self.main_window.postprocessing_ui.table.insertRow(row)
_layout = QHBoxLayout()
_widget = QCheckBox()
_widget.setEnabled(True)
_layout.addWidget(_widget)
_layout.addStretch()
_new_widget = QWidget()
_new_widget.setLayout(_layout)
_widget.stateChanged.connect(lambda state=0, row=row:
self.parent.table_select_state_changed(state, row))
self.main_window_postprocessing_ui.table.setCellWidget(row, 0, _new_widget)
_item = QTableWidgetItem(_metadata['name'])
self.main_window_postprocessing_ui.table.setItem(row, 1, _item)
_item = QTableWidgetItem(_metadata['runs'])
self.main_window_postprocessing_ui.table.setItem(row, 2, _item)
if not _metadata['sample_formula']:
_item = QTableWidgetItem(_metadata['sample_formula'])
self.main_window_postprocessing_ui.table.setItem(row, 3, _item)
if not _metadata['mass_density']:
_item = QTableWidgetItem(_metadata['mass_density'])
self.main_window_postprocessing_ui.table.setItem(row, 4, _item)
if not _metadata['radius']:
_item = QTableWidgetItem(_metadata['radius'])
self.main_window_postprocessing_ui.table.setItem(row, 5, _item)
if not _metadata['packing_fraction']:
_item = QTableWidgetItem(_metadata['packing_fraction'])
self.main_window_postprocessing_ui.table.setItem(row, 6, _item)
_widget = QComboBox()
_widget.addItem("cylindrical")
_widget.addItem("spherical")
if _metadata['sample_shape'] == 'spherical':
_widget.setCurrentIndex(1)
self.main_window_postprocessing_ui.table.setCellWidget(row, 7, _widget)
_layout = QHBoxLayout()
_widget = QCheckBox()
if _metadata['do_abs_correction'] == 'go':
_widget.setCheckState(Qt.Checked)
_widget.setStyleSheet("border: 2px; solid-black")
_widget.setEnabled(True)
_layout.addStretch()
_layout.addWidget(_widget)
_layout.addStretch()
_new_widget = QWidget()
_new_widget.setLayout(_layout)
self.main_window_postprocessing_ui.table.setCellWidget(row, 8, _new_widget)
def __init__(self, parent,
search_text = r"# ?TODO|# ?FIXME|# ?XXX",
search_text_regexp=True, search_path=None,
include=[".", ".py"], include_idx=None, include_regexp=True,
exclude=r"\.pyc$|\.orig$|\.hg|\.svn", exclude_idx=None,
exclude_regexp=True,
supported_encodings=("utf-8", "iso-8859-1", "cp1252"),
in_python_path=False, more_options=False):
QWidget.__init__(self, parent)
self.setWindowTitle(_('Find in files'))
self.search_thread = None
self.get_pythonpath_callback = None
self.find_options = FindOptions(self, search_text, search_text_regexp,
search_path,
include, include_idx, include_regexp,
exclude, exclude_idx, exclude_regexp,
supported_encodings, in_python_path,
more_options)
self.find_options.find.connect(self.find)
self.find_options.stop.connect(self.stop_and_reset_thread)
self.result_browser = ResultsBrowser(self)
collapse_btn = create_toolbutton(self)
collapse_btn.setDefaultAction(self.result_browser.collapse_all_action)
expand_btn = create_toolbutton(self)
expand_btn.setDefaultAction(self.result_browser.expand_all_action)
restore_btn = create_toolbutton(self)
restore_btn.setDefaultAction(self.result_browser.restore_action)
# collapse_sel_btn = create_toolbutton(self)
# collapse_sel_btn.setDefaultAction(
# self.result_browser.collapse_selection_action)
# expand_sel_btn = create_toolbutton(self)
# expand_sel_btn.setDefaultAction(
# self.result_browser.expand_selection_action)
btn_layout = QVBoxLayout()
btn_layout.setAlignment(Qt.AlignTop)
for widget in [collapse_btn, expand_btn, restore_btn]:
# collapse_sel_btn, expand_sel_btn]:
btn_layout.addWidget(widget)
hlayout = QHBoxLayout()
hlayout.addWidget(self.result_browser)
hlayout.addLayout(btn_layout)
layout = QVBoxLayout()
left, _x, right, bottom = layout.getContentsMargins()
layout.setContentsMargins(left, 0, right, bottom)
layout.addWidget(self.find_options)
layout.addLayout(hlayout)
self.setLayout(layout)
def __init__(self, parent):
QWidget.__init__(self, parent)
self.status_text = QLabel(self)
self.spinner = QWaitingSpinner(self, centerOnParent=False)
self.spinner.setNumberOfLines(12)
self.spinner.setInnerRadius(2)
layout = QHBoxLayout()
layout.addWidget(self.spinner)
layout.addWidget(self.status_text)
self.setLayout(layout)
def add_button_box(self, stdbtns):
"""Create dialog button box and add it to the dialog layout"""
bbox = QDialogButtonBox(stdbtns)
run_btn = bbox.addButton(_("Run"), QDialogButtonBox.AcceptRole)
run_btn.clicked.connect(self.run_btn_clicked)
bbox.accepted.connect(self.accept)
bbox.rejected.connect(self.reject)
btnlayout = QHBoxLayout()
btnlayout.addStretch(1)
btnlayout.addWidget(bbox)
self.layout().addLayout(btnlayout)
def __init__(self, plugin, name, history_filename, config_options,
additional_options, interpreter_versions,
connection_file=None, hostname=None,
menu_actions=None, slave=False):
super(ClientWidget, self).__init__(plugin)
SaveHistoryMixin.__init__(self)
# --- Init attrs
self.name = name
self.history_filename = get_conf_path(history_filename)
self.connection_file = connection_file
self.hostname = hostname
self.menu_actions = menu_actions
self.slave = slave
# --- Other attrs
self.options_button = None
self.stop_button = None
self.stop_icon = ima.icon('stop')
self.history = []
# --- Widgets
self.shellwidget = ShellWidget(config=config_options,
additional_options=additional_options,
interpreter_versions=interpreter_versions,
local_kernel=True)
self.shellwidget.hide()
self.infowidget = WebView(self)
self.set_infowidget_font()
self.loading_page = self._create_loading_page()
self.infowidget.setHtml(self.loading_page,
QUrl.fromLocalFile(CSS_PATH))
# --- Layout
vlayout = QVBoxLayout()
toolbar_buttons = self.get_toolbar_buttons()
hlayout = QHBoxLayout()
for button in toolbar_buttons:
hlayout.addWidget(button)
vlayout.addLayout(hlayout)
vlayout.setContentsMargins(0, 0, 0, 0)
vlayout.addWidget(self.shellwidget)
vlayout.addWidget(self.infowidget)
self.setLayout(vlayout)
# --- Exit function
self.exit_callback = lambda: plugin.close_client(client=self)
# --- Signals
# As soon as some content is printed in the console, stop
# our loading animation
document = self.get_control().document()
document.contentsChange.connect(self._stop_loading_animation)
class QLabeledSlider(QWidget):
"""
A labeled slider widget
"""
range = None
integer = None
def __init__(self, parent=None):
super(QLabeledSlider, self).__init__(parent)
self._range = range
self._slider = QSlider()
self._slider.setMinimum(0)
self._slider.setMaximum(100)
self._slider.setOrientation(Qt.Horizontal)
self._label = QLabel('')
self._layout = QHBoxLayout()
self._layout.setContentsMargins(2, 2, 2, 2)
self._layout.addWidget(self._slider)
self._layout.addWidget(self._label)
self._slider.valueChanged.connect(self._update_label)
self.setLayout(self._layout)
def _update_label(self, *args):
self._label.setText(str(self.value()))
@property
def valueChanged(self):
return self._slider.valueChanged
def value(self, layer=None, view=None):
value = self._slider.value() / 100. * (self.range[1] - self.range[0]) + self.range[0]
if self.integer:
return int(value)
else:
return(value)
_in_set_value = False
def setValue(self, value):
if self._in_set_value:
return
self._in_set_value = True
value = int(100 * (value - self.range[0]) / (self.range[1] - self.range[0]))
self._slider.setValue(value)
self._in_set_value = False
def __init__(self, parent):
QFrame.__init__(self, parent)
self._webview = WebView(self)
layout = QHBoxLayout()
layout.addWidget(self._webview)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self.setFrameStyle(QFrame.StyledPanel | QFrame.Sunken)
self._webview.linkClicked.connect(self.linkClicked)
class FindReplace(QWidget):
"""Find widget"""
STYLE = {False: "background-color:rgb(255, 175, 90);",
True: "",
None: "",
'regexp_error': "background-color:rgb(255, 80, 80);",
}
TOOLTIP = {False: _("No matches"),
True: _("Search string"),
None: _("Search string"),
'regexp_error': _("Regular expression error")
}
visibility_changed = Signal(bool)
return_shift_pressed = Signal()
return_pressed = Signal()
def __init__(self, parent, enable_replace=False):
QWidget.__init__(self, parent)
self.enable_replace = enable_replace
self.editor = None
self.is_code_editor = None
glayout = QGridLayout()
glayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(glayout)
self.close_button = create_toolbutton(self, triggered=self.hide,
icon=ima.icon('DialogCloseButton'))
glayout.addWidget(self.close_button, 0, 0)
# Find layout
self.search_text = PatternComboBox(self, tip=_("Search string"),
adjust_to_minimum=False)
self.return_shift_pressed.connect(
lambda:
self.find(changed=False, forward=False, rehighlight=False,
multiline_replace_check = False))
self.return_pressed.connect(
lambda:
self.find(changed=False, forward=True, rehighlight=False,
multiline_replace_check = False))
self.search_text.lineEdit().textEdited.connect(
self.text_has_been_edited)
self.number_matches_text = QLabel(self)
self.previous_button = create_toolbutton(self,
triggered=self.find_previous,
icon=ima.icon('ArrowUp'),
tip=_("Find previous"))
self.next_button = create_toolbutton(self,
triggered=self.find_next,
icon=ima.icon('ArrowDown'),
tip=_("Find next"))
self.next_button.clicked.connect(self.update_search_combo)
self.previous_button.clicked.connect(self.update_search_combo)
self.re_button = create_toolbutton(self, icon=ima.icon('regex'),
tip=_("Regular expression"))
self.re_button.setCheckable(True)
self.re_button.toggled.connect(lambda state: self.find())
self.case_button = create_toolbutton(self,
icon=ima.icon(
"format_letter_case"),
tip=_("Case Sensitive"))
self.case_button.setCheckable(True)
self.case_button.toggled.connect(lambda state: self.find())
self.words_button = create_toolbutton(self,
icon=get_icon("whole_words.png"),
tip=_("Whole words"))
self.words_button.setCheckable(True)
self.words_button.toggled.connect(lambda state: self.find())
self.highlight_button = create_toolbutton(self,
icon=get_icon("highlight.png"),
tip=_("Highlight matches"))
self.highlight_button.setCheckable(True)
self.highlight_button.toggled.connect(self.toggle_highlighting)
hlayout = QHBoxLayout()
self.widgets = [self.close_button, self.search_text,
self.number_matches_text, self.previous_button,
self.next_button, self.re_button, self.case_button,
self.words_button, self.highlight_button]
for widget in self.widgets[1:]:
hlayout.addWidget(widget)
glayout.addLayout(hlayout, 0, 1)
# Replace layout
replace_with = QLabel(_("Replace with:"))
self.replace_text = PatternComboBox(self, adjust_to_minimum=False,
tip=_('Replace string'))
self.replace_text.valid.connect(
lambda _: self.replace_find(focus_replace_text=True))
self.replace_button = create_toolbutton(self,
text=_('Replace/find next'),
icon=ima.icon('DialogApplyButton'),
triggered=self.replace_find,
text_beside_icon=True)
self.replace_sel_button = create_toolbutton(self,
text=_('Replace in selection'),
icon=ima.icon('DialogApplyButton'),
triggered=self.replace_find_selection,
text_beside_icon=True)
self.replace_sel_button.clicked.connect(self.update_replace_combo)
self.replace_sel_button.clicked.connect(self.update_search_combo)
self.replace_all_button = create_toolbutton(self,
text=_('Replace all'),
icon=ima.icon('DialogApplyButton'),
triggered=self.replace_find_all,
text_beside_icon=True)
self.replace_all_button.clicked.connect(self.update_replace_combo)
self.replace_all_button.clicked.connect(self.update_search_combo)
self.replace_layout = QHBoxLayout()
widgets = [replace_with, self.replace_text, self.replace_button,
self.replace_sel_button, self.replace_all_button]
for widget in widgets:
self.replace_layout.addWidget(widget)
glayout.addLayout(self.replace_layout, 1, 1)
self.widgets.extend(widgets)
self.replace_widgets = widgets
self.hide_replace()
self.search_text.setTabOrder(self.search_text, self.replace_text)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.shortcuts = self.create_shortcuts(parent)
self.highlight_timer = QTimer(self)
self.highlight_timer.setSingleShot(True)
self.highlight_timer.setInterval(1000)
self.highlight_timer.timeout.connect(self.highlight_matches)
self.search_text.installEventFilter(self)
def eventFilter(self, widget, event):
"""Event filter for search_text widget.
Emits signals when presing Enter and Shift+Enter.
This signals are used for search forward and backward.
Also, a crude hack to get tab working in the Find/Replace boxes.
"""
if event.type() == QEvent.KeyPress:
key = event.key()
shift = event.modifiers() & Qt.ShiftModifier
if key == Qt.Key_Return:
if shift:
self.return_shift_pressed.emit()
else:
self.return_pressed.emit()
if key == Qt.Key_Tab:
if self.search_text.hasFocus():
self.replace_text.set_current_text(
self.search_text.currentText())
self.focusNextChild()
return super(FindReplace, self).eventFilter(widget, event)
def create_shortcuts(self, parent):
"""Create shortcuts for this widget"""
# Configurable
findnext = CONF.config_shortcut(
self.find_next,
context='find_replace',
name='Find next',
parent=parent)
findprev = CONF.config_shortcut(
self.find_previous,
context='find_replace',
name='Find previous',
parent=parent)
togglefind = CONF.config_shortcut(
self.show,
context='find_replace',
name='Find text',
parent=parent)
togglereplace = CONF.config_shortcut(
self.show_replace,
context='find_replace',
name='Replace text',
parent=parent)
hide = CONF.config_shortcut(
self.hide,
context='find_replace',
name='hide find and replace',
parent=self)
return [findnext, findprev, togglefind, togglereplace, hide]
def get_shortcut_data(self):
"""
Returns shortcut data, a list of tuples (shortcut, text, default)
shortcut (QShortcut or QAction instance)
text (string): action/shortcut description
default (string): default key sequence
"""
return [sc.data for sc in self.shortcuts]
def update_search_combo(self):
self.search_text.lineEdit().returnPressed.emit()
def update_replace_combo(self):
self.replace_text.lineEdit().returnPressed.emit()
@Slot(bool)
def toggle_highlighting(self, state):
"""Toggle the 'highlight all results' feature"""
if self.editor is not None:
if state:
self.highlight_matches()
else:
self.clear_matches()
def show(self, hide_replace=True):
"""Overrides Qt Method"""
QWidget.show(self)
self.visibility_changed.emit(True)
self.change_number_matches()
if self.editor is not None:
if hide_replace:
if self.replace_widgets[0].isVisible():
self.hide_replace()
text = self.editor.get_selected_text()
# When selecting several lines, and replace box is activated the
# text won't be replaced for the selection
if hide_replace or len(text.splitlines()) <= 1:
highlighted = True
# If no text is highlighted for search, use whatever word is
# under the cursor
if not text:
highlighted = False
try:
cursor = self.editor.textCursor()
cursor.select(QTextCursor.WordUnderCursor)
text = to_text_string(cursor.selectedText())
except AttributeError:
# We can't do this for all widgets, e.g. WebView's
pass
# Now that text value is sorted out, use it for the search
if text and not self.search_text.currentText() or highlighted:
self.search_text.setEditText(text)
self.search_text.lineEdit().selectAll()
self.refresh()
else:
self.search_text.lineEdit().selectAll()
self.search_text.setFocus()
@Slot()
def hide(self):
"""Overrides Qt Method"""
for widget in self.replace_widgets:
widget.hide()
QWidget.hide(self)
self.visibility_changed.emit(False)
if self.editor is not None:
self.editor.setFocus()
self.clear_matches()
def show_replace(self):
"""Show replace widgets"""
if self.enable_replace:
self.show(hide_replace=False)
for widget in self.replace_widgets:
widget.show()
def hide_replace(self):
"""Hide replace widgets"""
for widget in self.replace_widgets:
widget.hide()
def refresh(self):
"""Refresh widget"""
if self.isHidden():
if self.editor is not None:
self.clear_matches()
return
state = self.editor is not None
for widget in self.widgets:
widget.setEnabled(state)
if state:
self.find()
def set_editor(self, editor, refresh=True):
"""
Set associated editor/web page:
codeeditor.base.TextEditBaseWidget
browser.WebView
"""
self.editor = editor
# Note: This is necessary to test widgets/editor.py
# in Qt builds that don't have web widgets
try:
from qtpy.QtWebEngineWidgets import QWebEngineView
except ImportError:
QWebEngineView = type(None)
self.words_button.setVisible(not isinstance(editor, QWebEngineView))
self.re_button.setVisible(not isinstance(editor, QWebEngineView))
from spyder.plugins.editor.widgets.codeeditor import CodeEditor
self.is_code_editor = isinstance(editor, CodeEditor)
self.highlight_button.setVisible(self.is_code_editor)
if refresh:
self.refresh()
if self.isHidden() and editor is not None:
self.clear_matches()
@Slot()
def find_next(self, set_focus=True):
"""Find next occurrence"""
state = self.find(changed=False, forward=True, rehighlight=False,
multiline_replace_check=False)
if set_focus:
self.editor.setFocus()
self.search_text.add_current_text()
return state
@Slot()
def find_previous(self, set_focus=True):
"""Find previous occurrence"""
state = self.find(changed=False, forward=False, rehighlight=False,
multiline_replace_check=False)
if set_focus:
self.editor.setFocus()
return state
def text_has_been_edited(self, text):
"""Find text has been edited (this slot won't be triggered when
setting the search pattern combo box text programmatically)"""
self.find(changed=True, forward=True, start_highlight_timer=True)
def highlight_matches(self):
"""Highlight found results"""
if self.is_code_editor and self.highlight_button.isChecked():
text = self.search_text.currentText()
case = self.case_button.isChecked()
word = self.words_button.isChecked()
regexp = self.re_button.isChecked()
self.editor.highlight_found_results(text, word=word,
regexp=regexp, case=case)
def clear_matches(self):
"""Clear all highlighted matches"""
if self.is_code_editor:
self.editor.clear_found_results()
def find(self, changed=True, forward=True, rehighlight=True,
start_highlight_timer=False, multiline_replace_check=True):
"""Call the find function"""
# When several lines are selected in the editor and replace box is
# activated, dynamic search is deactivated to prevent changing the
# selection. Otherwise we show matching items.
if multiline_replace_check and self.replace_widgets[0].isVisible():
sel_text = self.editor.get_selected_text()
if len(to_text_string(sel_text).splitlines()) > 1:
return None
text = self.search_text.currentText()
if len(text) == 0:
self.search_text.lineEdit().setStyleSheet("")
if not self.is_code_editor:
# Clears the selection for WebEngine
self.editor.find_text('')
self.change_number_matches()
return None
else:
case = self.case_button.isChecked()
word = self.words_button.isChecked()
regexp = self.re_button.isChecked()
found = self.editor.find_text(text, changed, forward, case=case,
word=word, regexp=regexp)
stylesheet = self.STYLE[found]
tooltip = self.TOOLTIP[found]
if not found and regexp:
error_msg = regexp_error_msg(text)
if error_msg: # special styling for regexp errors
stylesheet = self.STYLE['regexp_error']
tooltip = self.TOOLTIP['regexp_error'] + ': ' + error_msg
self.search_text.lineEdit().setStyleSheet(stylesheet)
self.search_text.setToolTip(tooltip)
if self.is_code_editor and found:
block = self.editor.textCursor().block()
TextHelper(self.editor).unfold_if_colapsed(block)
if rehighlight or not self.editor.found_results:
self.highlight_timer.stop()
if start_highlight_timer:
self.highlight_timer.start()
else:
self.highlight_matches()
else:
self.clear_matches()
number_matches = self.editor.get_number_matches(text, case=case,
regexp=regexp,
word=word)
if hasattr(self.editor, 'get_match_number'):
match_number = self.editor.get_match_number(text, case=case,
regexp=regexp,
word=word)
else:
match_number = 0
self.change_number_matches(current_match=match_number,
total_matches=number_matches)
return found
def __init__(self, parent, enable_replace=False):
QWidget.__init__(self, parent)
self.enable_replace = enable_replace
self.editor = None
self.is_code_editor = None
glayout = QGridLayout()
glayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(glayout)
self.close_button = create_toolbutton(self, triggered=self.hide,
icon=ima.icon('DialogCloseButton'))
glayout.addWidget(self.close_button, 0, 0)
# Find layout
self.search_text = PatternComboBox(self, tip=_("Search string"),
adjust_to_minimum=False)
self.return_shift_pressed.connect(
lambda:
self.find(changed=False, forward=False, rehighlight=False,
multiline_replace_check = False))
self.return_pressed.connect(
lambda:
self.find(changed=False, forward=True, rehighlight=False,
multiline_replace_check = False))
self.search_text.lineEdit().textEdited.connect(
self.text_has_been_edited)
self.number_matches_text = QLabel(self)
self.previous_button = create_toolbutton(self,
triggered=self.find_previous,
icon=ima.icon('ArrowUp'),
tip=_("Find previous"))
self.next_button = create_toolbutton(self,
triggered=self.find_next,
icon=ima.icon('ArrowDown'),
tip=_("Find next"))
self.next_button.clicked.connect(self.update_search_combo)
self.previous_button.clicked.connect(self.update_search_combo)
self.re_button = create_toolbutton(self, icon=ima.icon('regex'),
tip=_("Regular expression"))
self.re_button.setCheckable(True)
self.re_button.toggled.connect(lambda state: self.find())
self.case_button = create_toolbutton(self,
icon=ima.icon(
"format_letter_case"),
tip=_("Case Sensitive"))
self.case_button.setCheckable(True)
self.case_button.toggled.connect(lambda state: self.find())
self.words_button = create_toolbutton(self,
icon=get_icon("whole_words.png"),
tip=_("Whole words"))
self.words_button.setCheckable(True)
self.words_button.toggled.connect(lambda state: self.find())
self.highlight_button = create_toolbutton(self,
icon=get_icon("highlight.png"),
tip=_("Highlight matches"))
self.highlight_button.setCheckable(True)
self.highlight_button.toggled.connect(self.toggle_highlighting)
hlayout = QHBoxLayout()
self.widgets = [self.close_button, self.search_text,
self.number_matches_text, self.previous_button,
self.next_button, self.re_button, self.case_button,
self.words_button, self.highlight_button]
for widget in self.widgets[1:]:
hlayout.addWidget(widget)
glayout.addLayout(hlayout, 0, 1)
# Replace layout
replace_with = QLabel(_("Replace with:"))
self.replace_text = PatternComboBox(self, adjust_to_minimum=False,
tip=_('Replace string'))
self.replace_text.valid.connect(
lambda _: self.replace_find(focus_replace_text=True))
self.replace_button = create_toolbutton(self,
text=_('Replace/find next'),
icon=ima.icon('DialogApplyButton'),
triggered=self.replace_find,
text_beside_icon=True)
self.replace_sel_button = create_toolbutton(self,
text=_('Replace in selection'),
icon=ima.icon('DialogApplyButton'),
triggered=self.replace_find_selection,
text_beside_icon=True)
self.replace_sel_button.clicked.connect(self.update_replace_combo)
self.replace_sel_button.clicked.connect(self.update_search_combo)
self.replace_all_button = create_toolbutton(self,
text=_('Replace all'),
icon=ima.icon('DialogApplyButton'),
triggered=self.replace_find_all,
text_beside_icon=True)
self.replace_all_button.clicked.connect(self.update_replace_combo)
self.replace_all_button.clicked.connect(self.update_search_combo)
self.replace_layout = QHBoxLayout()
widgets = [replace_with, self.replace_text, self.replace_button,
self.replace_sel_button, self.replace_all_button]
for widget in widgets:
self.replace_layout.addWidget(widget)
glayout.addLayout(self.replace_layout, 1, 1)
self.widgets.extend(widgets)
self.replace_widgets = widgets
self.hide_replace()
self.search_text.setTabOrder(self.search_text, self.replace_text)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.shortcuts = self.create_shortcuts(parent)
self.highlight_timer = QTimer(self)
self.highlight_timer.setSingleShot(True)
self.highlight_timer.setInterval(1000)
self.highlight_timer.timeout.connect(self.highlight_matches)
self.search_text.installEventFilter(self)
def setup_page(self):
about_label = QLabel(
_("The following are the default options for "
"running files.These options may be overriden "
"using the <b>Configuration per file</b> entry "
"of the <b>Run</b> menu."))
about_label.setWordWrap(True)
interpreter_group = QGroupBox(_("Console"))
interpreter_bg = QButtonGroup(interpreter_group)
self.current_radio = self.create_radiobutton(
CURRENT_INTERPRETER,
CURRENT_INTERPRETER_OPTION,
True,
button_group=interpreter_bg)
self.dedicated_radio = self.create_radiobutton(
DEDICATED_INTERPRETER,
DEDICATED_INTERPRETER_OPTION,
False,
button_group=interpreter_bg)
self.systerm_radio = self.create_radiobutton(
SYSTERM_INTERPRETER,
SYSTERM_INTERPRETER_OPTION,
False,
button_group=interpreter_bg)
interpreter_layout = QVBoxLayout()
interpreter_group.setLayout(interpreter_layout)
interpreter_layout.addWidget(self.current_radio)
interpreter_layout.addWidget(self.dedicated_radio)
interpreter_layout.addWidget(self.systerm_radio)
general_group = QGroupBox(_("General settings"))
post_mortem = self.create_checkbox(POST_MORTEM, 'post_mortem', False)
clear_variables = self.create_checkbox(CLEAR_ALL_VARIABLES,
'clear_namespace', False)
general_layout = QVBoxLayout()
general_layout.addWidget(clear_variables)
general_layout.addWidget(post_mortem)
general_group.setLayout(general_layout)
wdir_group = QGroupBox(_("Working Directory settings"))
wdir_bg = QButtonGroup(wdir_group)
wdir_label = QLabel(_("Default working directory is:"))
wdir_label.setWordWrap(True)
dirname_radio = self.create_radiobutton(FILE_DIR,
WDIR_USE_SCRIPT_DIR_OPTION,
True,
button_group=wdir_bg)
cwd_radio = self.create_radiobutton(CW_DIR,
WDIR_USE_CWD_DIR_OPTION,
False,
button_group=wdir_bg)
thisdir_radio = self.create_radiobutton(FIXED_DIR,
WDIR_USE_FIXED_DIR_OPTION,
False,
button_group=wdir_bg)
thisdir_bd = self.create_browsedir("", WDIR_FIXED_DIR_OPTION,
getcwd_or_home())
thisdir_radio.toggled.connect(thisdir_bd.setEnabled)
dirname_radio.toggled.connect(thisdir_bd.setDisabled)
cwd_radio.toggled.connect(thisdir_bd.setDisabled)
thisdir_layout = QHBoxLayout()
thisdir_layout.addWidget(thisdir_radio)
thisdir_layout.addWidget(thisdir_bd)
wdir_layout = QVBoxLayout()
wdir_layout.addWidget(wdir_label)
wdir_layout.addWidget(dirname_radio)
wdir_layout.addWidget(cwd_radio)
wdir_layout.addLayout(thisdir_layout)
wdir_group.setLayout(wdir_layout)
external_group = QGroupBox(_("External system terminal"))
interact_after = self.create_checkbox(INTERACT, 'interact', False)
external_layout = QVBoxLayout()
external_layout.addWidget(interact_after)
external_group.setLayout(external_layout)
firstrun_cb = self.create_checkbox(
ALWAYS_OPEN_FIRST_RUN % _("Run Settings dialog"),
ALWAYS_OPEN_FIRST_RUN_OPTION, False)
vlayout = QVBoxLayout()
vlayout.addWidget(about_label)
vlayout.addSpacing(10)
vlayout.addWidget(interpreter_group)
vlayout.addWidget(general_group)
vlayout.addWidget(wdir_group)
vlayout.addWidget(external_group)
vlayout.addWidget(firstrun_cb)
vlayout.addStretch(1)
self.setLayout(vlayout)
def setup(self, check_all=None, exclude_private=None,
exclude_uppercase=None, exclude_capitalized=None,
exclude_unsupported=None, excluded_names=None,
minmax=None, dataframe_format=None):
"""
Setup the namespace browser with provided settings.
Args:
dataframe_format (string): default floating-point format for
DataFrame editor
"""
assert self.shellwidget is not None
self.check_all = check_all
self.exclude_private = exclude_private
self.exclude_uppercase = exclude_uppercase
self.exclude_capitalized = exclude_capitalized
self.exclude_unsupported = exclude_unsupported
self.excluded_names = excluded_names
self.minmax = minmax
self.dataframe_format = dataframe_format
if self.editor is not None:
self.editor.setup_menu(minmax)
self.editor.set_dataframe_format(dataframe_format)
self.exclude_private_action.setChecked(exclude_private)
self.exclude_uppercase_action.setChecked(exclude_uppercase)
self.exclude_capitalized_action.setChecked(exclude_capitalized)
self.exclude_unsupported_action.setChecked(exclude_unsupported)
self.refresh_table()
return
self.editor = RemoteCollectionsEditorTableView(
self,
None,
minmax=minmax,
dataframe_format=dataframe_format,
get_value_func=self.get_value,
set_value_func=self.set_value,
new_value_func=self.set_value,
remove_values_func=self.remove_values,
copy_value_func=self.copy_value,
is_list_func=self.is_list,
get_len_func=self.get_len,
is_array_func=self.is_array,
is_image_func=self.is_image,
is_dict_func=self.is_dict,
is_data_frame_func=self.is_data_frame,
is_series_func=self.is_series,
get_array_shape_func=self.get_array_shape,
get_array_ndim_func=self.get_array_ndim,
plot_func=self.plot, imshow_func=self.imshow,
show_image_func=self.show_image)
self.editor.sig_option_changed.connect(self.sig_option_changed.emit)
self.editor.sig_files_dropped.connect(self.import_data)
self.editor.sig_free_memory.connect(self.sig_free_memory.emit)
# Setup layout
blayout = QHBoxLayout()
toolbar = self.setup_toolbar(exclude_private, exclude_uppercase,
exclude_capitalized, exclude_unsupported)
for widget in toolbar:
blayout.addWidget(widget)
# Options menu
options_button = create_toolbutton(self, text=_('Options'),
icon=ima.icon('tooloptions'))
options_button.setPopupMode(QToolButton.InstantPopup)
menu = QMenu(self)
editor = self.editor
actions = [self.exclude_private_action, self.exclude_uppercase_action,
self.exclude_capitalized_action,
self.exclude_unsupported_action, None]
if is_module_installed('numpy'):
actions.append(editor.minmax_action)
add_actions(menu, actions)
options_button.setMenu(menu)
blayout.addStretch()
blayout.addWidget(options_button)
layout = create_plugin_layout(blayout, self.editor)
self.setLayout(layout)
self.sig_option_changed.connect(self.option_changed)
def __init__(self, parent, opacity, duration, easing_curve):
super(FadingTipBox, self).__init__(parent, opacity, duration,
easing_curve)
self.holder = self.anim # needed for qt to work
self.parent = parent
self.frames = None
self.color_top = QColor.fromRgb(230, 230, 230)
self.color_back = QColor.fromRgb(255, 255, 255)
self.offset_shadow = 0
self.fixed_width = 300
self.key_pressed = None
self.setAttribute(Qt.WA_TranslucentBackground)
self.setWindowFlags(Qt.Dialog | Qt.FramelessWindowHint
| Qt.WindowStaysOnTopHint)
self.setModal(False)
# Widgets
self.button_home = QPushButton("<<")
self.button_close = QPushButton("X")
self.button_previous = QPushButton(" < ")
self.button_end = QPushButton(">>")
self.button_next = QPushButton(" > ")
self.button_run = QPushButton(_('Run code'))
self.button_disable = None
self.button_current = QToolButton()
self.label_image = QLabel()
self.label_title = QLabel()
self.combo_title = QComboBox()
self.label_current = QLabel()
self.label_content = QLabel()
self.label_content.setMinimumWidth(self.fixed_width)
self.label_content.setMaximumWidth(self.fixed_width)
self.label_current.setAlignment(Qt.AlignCenter)
self.label_content.setWordWrap(True)
self.widgets = [
self.label_content, self.label_title, self.label_current,
self.combo_title, self.button_close, self.button_run,
self.button_next, self.button_previous, self.button_end,
self.button_home, self.button_current
]
arrow = get_image_path('hide.png')
self.stylesheet = '''QPushButton {
background-color: rgbs(200,200,200,100%);
color: rgbs(0,0,0,100%);
border-style: outset;
border-width: 1px;
border-radius: 3px;
border-color: rgbs(100,100,100,100%);
padding: 2px;
}
QPushButton:hover {
background-color: rgbs(150, 150, 150, 100%);
}
QPushButton:disabled {
background-color: rgbs(230,230,230,100%);
color: rgbs(200,200,200,100%);
border-color: rgbs(200,200,200,100%);
}
QComboBox {
padding-left: 5px;
background-color: rgbs(230,230,230,100%);
border-width: 0px;
border-radius: 0px;
min-height:20px;
max-height:20px;
}
QComboBox::drop-down {
subcontrol-origin: padding;
subcontrol-position: top left;
border-width: 0px;
}
QComboBox::down-arrow {
image: url(''' + arrow + ''');
}
'''
# Windows fix, slashes should be always in unix-style
self.stylesheet = self.stylesheet.replace('\\', '/')
for widget in self.widgets:
widget.setFocusPolicy(Qt.NoFocus)
widget.setStyleSheet(self.stylesheet)
layout_top = QHBoxLayout()
layout_top.addWidget(self.combo_title)
layout_top.addStretch()
layout_top.addWidget(self.button_close)
layout_top.addSpacerItem(
QSpacerItem(self.offset_shadow, self.offset_shadow))
layout_content = QHBoxLayout()
layout_content.addWidget(self.label_content)
layout_content.addWidget(self.label_image)
layout_content.addSpacerItem(QSpacerItem(5, 5))
layout_run = QHBoxLayout()
layout_run.addStretch()
layout_run.addWidget(self.button_run)
layout_run.addStretch()
layout_run.addSpacerItem(
QSpacerItem(self.offset_shadow, self.offset_shadow))
layout_navigation = QHBoxLayout()
layout_navigation.addWidget(self.button_home)
layout_navigation.addWidget(self.button_previous)
layout_navigation.addStretch()
layout_navigation.addWidget(self.label_current)
layout_navigation.addStretch()
layout_navigation.addWidget(self.button_next)
layout_navigation.addWidget(self.button_end)
layout_navigation.addSpacerItem(
QSpacerItem(self.offset_shadow, self.offset_shadow))
layout = QVBoxLayout()
layout.addLayout(layout_top)
layout.addStretch()
layout.addSpacerItem(QSpacerItem(15, 15))
layout.addLayout(layout_content)
layout.addLayout(layout_run)
layout.addStretch()
layout.addSpacerItem(QSpacerItem(15, 15))
layout.addLayout(layout_navigation)
layout.addSpacerItem(
QSpacerItem(self.offset_shadow, self.offset_shadow))
layout.setSizeConstraint(QLayout.SetFixedSize)
self.setLayout(layout)
self.set_funcs_before_fade_in([self._disable_widgets])
self.set_funcs_after_fade_in([self._enable_widgets])
self.set_funcs_before_fade_out([self._disable_widgets])
self.setContextMenuPolicy(Qt.CustomContextMenu)
def __init__(self, parent):
"""Project creation dialog."""
super(ProjectDialog, self).__init__(parent=parent)
# Variables
current_python_version = '.'.join([to_text_string(sys.version_info[0]),
to_text_string(sys.version_info[1])])
python_versions = ['2.7', '3.4', '3.5']
if current_python_version not in python_versions:
python_versions.append(current_python_version)
python_versions = sorted(python_versions)
self.project_name = None
self.location = get_home_dir()
# Widgets
self.groupbox = QGroupBox()
self.radio_new_dir = QRadioButton(_("New directory"))
self.radio_from_dir = QRadioButton(_("Existing directory"))
self.label_project_name = QLabel(_('Project name'))
self.label_location = QLabel(_('Location'))
self.label_project_type = QLabel(_('Project type'))
self.label_python_version = QLabel(_('Python version'))
self.text_project_name = QLineEdit()
self.text_location = QLineEdit(get_home_dir())
self.combo_project_type = QComboBox()
self.combo_python_version = QComboBox()
self.button_select_location = QToolButton()
self.button_cancel = QPushButton(_('Cancel'))
self.button_create = QPushButton(_('Create'))
self.bbox = QDialogButtonBox(Qt.Horizontal)
self.bbox.addButton(self.button_cancel, QDialogButtonBox.ActionRole)
self.bbox.addButton(self.button_create, QDialogButtonBox.ActionRole)
# Widget setup
self.combo_python_version.addItems(python_versions)
self.radio_new_dir.setChecked(True)
self.text_location.setEnabled(True)
self.text_location.setReadOnly(True)
self.button_select_location.setIcon(get_std_icon('DirOpenIcon'))
self.button_cancel.setDefault(True)
self.button_cancel.setAutoDefault(True)
self.button_create.setEnabled(False)
self.combo_project_type.addItems(self._get_project_types())
self.combo_python_version.setCurrentIndex(
python_versions.index(current_python_version))
self.setWindowTitle(_('Create new project'))
self.setFixedWidth(500)
self.label_python_version.setVisible(False)
self.combo_python_version.setVisible(False)
# Layouts
layout_top = QHBoxLayout()
layout_top.addWidget(self.radio_new_dir)
layout_top.addWidget(self.radio_from_dir)
layout_top.addStretch(1)
self.groupbox.setLayout(layout_top)
layout_grid = QGridLayout()
layout_grid.addWidget(self.label_project_name, 0, 0)
layout_grid.addWidget(self.text_project_name, 0, 1, 1, 2)
layout_grid.addWidget(self.label_location, 1, 0)
layout_grid.addWidget(self.text_location, 1, 1)
layout_grid.addWidget(self.button_select_location, 1, 2)
layout_grid.addWidget(self.label_project_type, 2, 0)
layout_grid.addWidget(self.combo_project_type, 2, 1, 1, 2)
layout_grid.addWidget(self.label_python_version, 3, 0)
layout_grid.addWidget(self.combo_python_version, 3, 1, 1, 2)
layout = QVBoxLayout()
layout.addWidget(self.groupbox)
layout.addSpacing(10)
layout.addLayout(layout_grid)
layout.addStretch()
layout.addSpacing(20)
layout.addWidget(self.bbox)
self.setLayout(layout)
# Signals and slots
self.button_select_location.clicked.connect(self.select_location)
self.button_create.clicked.connect(self.create_project)
self.button_cancel.clicked.connect(self.close)
self.radio_from_dir.clicked.connect(self.update_location)
self.radio_new_dir.clicked.connect(self.update_location)
self.text_project_name.textChanged.connect(self.update_location)
class UiPlotSubWindow(QMainWindow):
"""
Main plotting window.
"""
def __init__(self, *args, **kwargs):
super(UiPlotSubWindow, self).__init__(*args, **kwargs)
self.vertical_layout = QVBoxLayout()
self.horizontal_layout = QHBoxLayout()
self.vertical_layout.setContentsMargins(0, 0, 0, 0)
self.vertical_layout.setSpacing(2)
# X range
self.label_x_range = QLabel()
self.label_x_range.setText("X Range")
self.line_edit_min_x_range = QLineEdit()
self.line_edit_max_x_range = QLineEdit()
self.layout_x_range = QHBoxLayout()
self.layout_x_range.addWidget(self.label_x_range)
self.layout_x_range.addWidget(self.line_edit_min_x_range)
self.layout_x_range.addWidget(self.line_edit_max_x_range)
# Y range
self.label_y_range = QLabel()
self.label_y_range.setText("Y Range")
self.line_edit_min_y_range = QLineEdit()
self.line_edit_max_y_range = QLineEdit()
self.layout_y_range = QHBoxLayout()
self.layout_y_range.addWidget(self.label_y_range)
self.layout_y_range.addWidget(self.line_edit_min_y_range)
self.layout_y_range.addWidget(self.line_edit_max_y_range)
# Reset
self.button_reset = QPushButton()
self.button_reset.setText("Reset")
# Cursor position
self.line_edit_cursor_pos = QLabel()
# self.line_edit_cursor_pos.setReadOnly(True)
self.line_edit_cursor_pos.setText("Pos: 0, 0")
# Line labels
self._linelist_window = None
self._line_labels = []
self.horizontal_layout.addWidget(self.line_edit_cursor_pos)
self.horizontal_layout.addStretch()
# self.horizontal_layout.addLayout(self.layout_x_range)
# self.horizontal_layout.addLayout(self.layout_y_range)
self.horizontal_layout.addWidget(self.button_reset)
self.vertical_layout.addLayout(self.horizontal_layout)
self.main_widget = QWidget(self)
self.main_widget.setLayout(self.vertical_layout)
self.setCentralWidget(self.main_widget)
def setupui(self):
vbl = QVBoxLayout(self)
self.stack = QStackedWidget(self)
vbl.addWidget(self.stack)
rbA = QRadioButton('Antennas', self)
rbP = QRadioButton('Positions', self)
rbA.toggled.connect(_part(self.toggle_button, 0))
rbP.toggled.connect(_part(self.toggle_button, 1))
self.radio_buttons.append(rbA)
self.radio_buttons.append(rbP)
rbA.setChecked(True)
hbl = QHBoxLayout()
hbl.addStretch()
hbl.addWidget(rbA)
hbl.addStretch()
hbl.addWidget(rbP)
hbl.addStretch()
vbl.addItem(hbl)
# ##### Antennas Widget ######
stack1 = QWidget(self.stack)
self.stack.addWidget(stack1)
vbl = QVBoxLayout(stack1)
graph = self.create_graph(stack1, False)
vbl.addWidget(graph)
stats = self.create_statistics(stack1, False)
vbl.addWidget(stats)
if not self.data_prefix.startswith('PM'):
hbl2 = QHBoxLayout()
hbl2.addStretch()
vbl.addItem(hbl2)
pb = QPushButton('Open FFT Data', stack1)
hbl2.addWidget(pb)
hbl2.addStretch()
Window = create_window_from_widget(
FFTData, title=self.bpm+': FFT Data')
util.connect_window(
pb, Window, parent=stack1, prefix=self.prefix,
bpm=self.bpm, data_prefix=self.data_prefix, position=False)
# ##### Position Widget ######
stack2 = QWidget(self.stack)
self.stack.addWidget(stack2)
vbl = QVBoxLayout(stack2)
graph = self.create_graph(stack2, True)
vbl.addWidget(graph)
stats = self.create_statistics(stack2, True)
vbl.addWidget(stats)
if not self.data_prefix.startswith('PM'):
hbl2 = QHBoxLayout()
hbl2.addStretch()
vbl.addItem(hbl2)
pb = QPushButton('Open FFT Data', stack2)
hbl2.addWidget(pb)
hbl2.addStretch()
Window = create_window_from_widget(
FFTData, title=self.bpm+': FFT Data')
util.connect_window(
pb, Window, parent=stack1, prefix=self.prefix,
bpm=self.bpm, data_prefix=self.data_prefix, position=True)
self.setStyleSheet("""
#MultiTurnDataGraph{
min-width:48em;
min-height:24em;
}
QLabel{
min-width:6em; max-width:6em;
min-height:1.5em; max-height:1.5em;
}""")
def __init__(self, parent, search_text, search_text_regexp, search_path,
include, include_idx, include_regexp, exclude, exclude_idx,
exclude_regexp, supported_encodings, in_python_path,
more_options):
QWidget.__init__(self, parent)
if search_path is None:
search_path = getcwd()
if not isinstance(search_text, (list, tuple)):
search_text = [search_text]
if not isinstance(search_path, (list, tuple)):
search_path = [search_path]
if not isinstance(include, (list, tuple)):
include = [include]
if not isinstance(exclude, (list, tuple)):
exclude = [exclude]
self.supported_encodings = supported_encodings
# Layout 1
hlayout1 = QHBoxLayout()
self.search_text = PatternComboBox(self, search_text,
_("Search pattern"))
self.edit_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.edit_regexp.setCheckable(True)
self.edit_regexp.setChecked(search_text_regexp)
self.more_widgets = ()
self.more_options = create_toolbutton(self,
toggled=self.toggle_more_options)
self.more_options.setCheckable(True)
self.more_options.setChecked(more_options)
self.ok_button = create_toolbutton(self,
text=_("Search"),
icon=ima.icon('DialogApplyButton'),
triggered=lambda: self.find.emit(),
tip=_("Start search"),
text_beside_icon=True)
self.ok_button.clicked.connect(self.update_combos)
self.stop_button = create_toolbutton(
self,
text=_("Stop"),
icon=ima.icon('stop'),
triggered=lambda: self.stop.emit(),
tip=_("Stop search"),
text_beside_icon=True)
self.stop_button.setEnabled(False)
for widget in [
self.search_text, self.edit_regexp, self.ok_button,
self.stop_button, self.more_options
]:
hlayout1.addWidget(widget)
# Layout 2
hlayout2 = QHBoxLayout()
self.include_pattern = PatternComboBox(self, include,
_("Included filenames pattern"))
if include_idx is not None and include_idx >= 0 \
and include_idx < self.include_pattern.count():
self.include_pattern.setCurrentIndex(include_idx)
self.include_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.include_regexp.setCheckable(True)
self.include_regexp.setChecked(include_regexp)
include_label = QLabel(_("Include:"))
include_label.setBuddy(self.include_pattern)
self.exclude_pattern = PatternComboBox(self, exclude,
_("Excluded filenames pattern"))
if exclude_idx is not None and exclude_idx >= 0 \
and exclude_idx < self.exclude_pattern.count():
self.exclude_pattern.setCurrentIndex(exclude_idx)
self.exclude_regexp = create_toolbutton(self,
icon=ima.icon('advanced'),
tip=_('Regular expression'))
self.exclude_regexp.setCheckable(True)
self.exclude_regexp.setChecked(exclude_regexp)
exclude_label = QLabel(_("Exclude:"))
exclude_label.setBuddy(self.exclude_pattern)
for widget in [
include_label, self.include_pattern, self.include_regexp,
exclude_label, self.exclude_pattern, self.exclude_regexp
]:
hlayout2.addWidget(widget)
# Layout 3
hlayout3 = QHBoxLayout()
self.python_path = QRadioButton(_("PYTHONPATH"), self)
self.python_path.setChecked(in_python_path)
self.python_path.setToolTip(
_("Search in all directories listed in sys.path which"
" are outside the Python installation directory"))
self.hg_manifest = QRadioButton(_("Hg repository"), self)
self.detect_hg_repository()
self.hg_manifest.setToolTip(
_("Search in current directory hg repository"))
self.custom_dir = QRadioButton(_("Here:"), self)
self.custom_dir.setChecked(not in_python_path)
self.dir_combo = PathComboBox(self)
self.dir_combo.addItems(search_path)
self.dir_combo.setToolTip(_("Search recursively in this directory"))
self.dir_combo.open_dir.connect(self.set_directory)
self.python_path.toggled.connect(self.dir_combo.setDisabled)
self.hg_manifest.toggled.connect(self.dir_combo.setDisabled)
browse = create_toolbutton(self,
icon=ima.icon('DirOpenIcon'),
tip=_('Browse a search directory'),
triggered=self.select_directory)
for widget in [
self.python_path, self.hg_manifest, self.custom_dir,
self.dir_combo, browse
]:
hlayout3.addWidget(widget)
self.search_text.valid.connect(lambda valid: self.find.emit())
vlayout = QVBoxLayout()
vlayout.setContentsMargins(0, 0, 0, 0)
vlayout.addLayout(hlayout1)
vlayout.addLayout(hlayout2)
vlayout.addLayout(hlayout3)
self.more_widgets = (hlayout2, hlayout3)
self.toggle_more_options(more_options)
self.setLayout(vlayout)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
class NapariNotification(QDialog):
"""Notification dialog frame, appears at the bottom right of the canvas.
By default, only the first line of the notification is shown, and the text
is elided. Double-clicking on the text (or clicking the chevron icon) will
expand to show the full notification. The dialog will autmatically
disappear in ``DISMISS_AFTER`` milliseconds, unless hovered or clicked.
Parameters
----------
message : str
The message that will appear in the notification
severity : str or NotificationSeverity, optional
Severity level {'error', 'warning', 'info', 'none'}. Will determine
the icon associated with the message.
by default NotificationSeverity.WARNING.
source : str, optional
A source string for the notifcation (intended to show the module and
or package responsible for the notification), by default None
actions : list of tuple, optional
A sequence of 2-tuples, where each tuple is a string and a callable.
Each tuple will be used to create button in the dialog, where the text
on the button is determine by the first item in the tuple, and a
callback function to call when the button is pressed is the second item
in the tuple. by default ()
"""
MAX_OPACITY = 0.9
FADE_IN_RATE = 220
FADE_OUT_RATE = 120
DISMISS_AFTER = 4000
MIN_WIDTH = 400
def __init__(
self,
message: str,
severity: Union[
str, NotificationSeverity
] = NotificationSeverity.WARNING,
source: Optional[str] = None,
actions: ActionSequence = (),
):
"""[summary]
"""
super().__init__(None)
# FIXME: this does not work with multiple viewers.
# we need a way to detect the viewer in which the error occured.
for wdg in QApplication.topLevelWidgets():
if isinstance(wdg, QMainWindow):
try:
# TODO: making the canvas the parent makes it easier to
# move/resize, but also means that the notification can get
# clipped on the left if the canvas is too small.
canvas = wdg.centralWidget().children()[1].canvas.native
self.setParent(canvas)
canvas.resized.connect(self.move_to_bottom_right)
break
except Exception:
pass
self.setupUi()
self.setAttribute(Qt.WA_DeleteOnClose)
self.setup_buttons(actions)
self.setMouseTracking(True)
self.severity_icon.setText(NotificationSeverity(severity).as_icon())
self.message.setText(message)
if source:
self.source_label.setText(f'Source: {source}')
self.close_button.clicked.connect(self.close)
self.expand_button.clicked.connect(self.toggle_expansion)
self.timer = None
self.opacity = QGraphicsOpacityEffect()
self.setGraphicsEffect(self.opacity)
self.opacity_anim = QPropertyAnimation(self.opacity, b"opacity", self)
self.geom_anim = QPropertyAnimation(self, b"geometry", self)
self.move_to_bottom_right()
def move_to_bottom_right(self, offset=(8, 8)):
"""Position widget at the bottom right edge of the parent."""
if not self.parent():
return
sz = self.parent().size() - self.size() - QSize(*offset)
self.move(QPoint(sz.width(), sz.height()))
def slide_in(self):
"""Run animation that fades in the dialog with a slight slide up."""
geom = self.geometry()
self.geom_anim.setDuration(self.FADE_IN_RATE)
self.geom_anim.setStartValue(geom.translated(0, 20))
self.geom_anim.setEndValue(geom)
self.geom_anim.setEasingCurve(QEasingCurve.OutQuad)
# fade in
self.opacity_anim.setDuration(self.FADE_IN_RATE)
self.opacity_anim.setStartValue(0)
self.opacity_anim.setEndValue(self.MAX_OPACITY)
self.geom_anim.start()
self.opacity_anim.start()
def show(self):
"""Show the message with a fade and slight slide in from the bottom."""
super().show()
self.slide_in()
self.timer = QTimer()
self.timer.setInterval(self.DISMISS_AFTER)
self.timer.setSingleShot(True)
self.timer.timeout.connect(self.close)
self.timer.start()
def mouseMoveEvent(self, event):
"""On hover, stop the self-destruct timer"""
self.timer.stop()
def mouseDoubleClickEvent(self, event):
"""Expand the notification on double click."""
self.toggle_expansion()
def close(self):
"""Fade out then close."""
self.opacity_anim.setDuration(self.FADE_OUT_RATE)
self.opacity_anim.setStartValue(self.MAX_OPACITY)
self.opacity_anim.setEndValue(0)
self.opacity_anim.start()
self.opacity_anim.finished.connect(super().close)
def toggle_expansion(self):
"""Toggle the expanded state of the notification frame."""
self.contract() if self.property('expanded') else self.expand()
self.timer.stop()
def expand(self):
"""Expanded the notification so that the full message is visible."""
curr = self.geometry()
self.geom_anim.setDuration(100)
self.geom_anim.setStartValue(curr)
new_height = self.sizeHint().height()
delta = new_height - curr.height()
self.geom_anim.setEndValue(
QRect(curr.x(), curr.y() - delta, curr.width(), new_height)
)
self.geom_anim.setEasingCurve(QEasingCurve.OutQuad)
self.geom_anim.start()
self.setProperty('expanded', True)
self.style().unpolish(self.expand_button)
self.style().polish(self.expand_button)
def contract(self):
"""Contract notification to a single elided line of the message."""
geom = self.geometry()
self.geom_anim.setDuration(100)
self.geom_anim.setStartValue(geom)
dlt = geom.height() - self.minimumHeight()
self.geom_anim.setEndValue(
QRect(geom.x(), geom.y() + dlt, geom.width(), geom.height() - dlt)
)
self.geom_anim.setEasingCurve(QEasingCurve.OutQuad)
self.geom_anim.start()
self.setProperty('expanded', False)
self.style().unpolish(self.expand_button)
self.style().polish(self.expand_button)
def setupUi(self):
"""Set up the UI during initialization."""
self.setWindowFlags(Qt.SubWindow)
self.setMinimumWidth(self.MIN_WIDTH)
self.setMaximumWidth(self.MIN_WIDTH)
self.setMinimumHeight(40)
self.setSizeGripEnabled(False)
self.setModal(False)
self.verticalLayout = QVBoxLayout(self)
self.verticalLayout.setContentsMargins(2, 2, 2, 2)
self.verticalLayout.setSpacing(0)
self.row1_widget = QWidget(self)
self.row1 = QHBoxLayout(self.row1_widget)
self.row1.setContentsMargins(12, 12, 12, 8)
self.row1.setSpacing(4)
self.severity_icon = QLabel(self.row1_widget)
self.severity_icon.setObjectName("severity_icon")
self.severity_icon.setMinimumWidth(30)
self.severity_icon.setMaximumWidth(30)
self.row1.addWidget(self.severity_icon, alignment=Qt.AlignTop)
self.message = MultilineElidedLabel(self.row1_widget)
self.message.setMinimumWidth(self.MIN_WIDTH - 200)
self.message.setSizePolicy(
QSizePolicy.Expanding, QSizePolicy.Expanding
)
self.row1.addWidget(self.message, alignment=Qt.AlignTop)
self.expand_button = QPushButton(self.row1_widget)
self.expand_button.setObjectName("expand_button")
self.expand_button.setCursor(Qt.PointingHandCursor)
self.expand_button.setMaximumWidth(20)
self.expand_button.setFlat(True)
self.row1.addWidget(self.expand_button, alignment=Qt.AlignTop)
self.close_button = QPushButton(self.row1_widget)
self.close_button.setObjectName("close_button")
self.close_button.setCursor(Qt.PointingHandCursor)
self.close_button.setMaximumWidth(20)
self.close_button.setFlat(True)
self.row1.addWidget(self.close_button, alignment=Qt.AlignTop)
self.verticalLayout.addWidget(self.row1_widget, 1)
self.row2_widget = QWidget(self)
self.row2_widget.hide()
self.row2 = QHBoxLayout(self.row2_widget)
self.source_label = QLabel(self.row2_widget)
self.source_label.setObjectName("source_label")
self.row2.addWidget(self.source_label, alignment=Qt.AlignBottom)
self.row2.addStretch()
self.row2.setContentsMargins(12, 2, 16, 12)
self.row2_widget.setMaximumHeight(34)
self.row2_widget.setStyleSheet(
'QPushButton{'
'padding: 4px 12px 4px 12px; '
'font-size: 11px;'
'min-height: 18px; border-radius: 0;}'
)
self.verticalLayout.addWidget(self.row2_widget, 0)
self.setProperty('expanded', False)
self.resize(self.MIN_WIDTH, 40)
def setup_buttons(self, actions: ActionSequence = ()):
"""Add buttons to the dialog.
Parameters
----------
actions : tuple, optional
A sequence of 2-tuples, where each tuple is a string and a
callable. Each tuple will be used to create button in the dialog,
where the text on the button is determine by the first item in the
tuple, and a callback function to call when the button is pressed
is the second item in the tuple. by default ()
"""
if isinstance(actions, dict):
actions = list(actions.items())
for text, callback in actions:
btn = QPushButton(text)
btn.clicked.connect(callback)
btn.clicked.connect(self.close)
self.row2.addWidget(btn)
if actions:
self.row2_widget.show()
self.setMinimumHeight(
self.row2_widget.maximumHeight() + self.minimumHeight()
)
def sizeHint(self):
"""Return the size required to show the entire message."""
return QSize(
super().sizeHint().width(),
self.row2_widget.height() + self.message.sizeHint().height(),
)
@classmethod
def from_exception(cls, exception: BaseException) -> 'NapariNotification':
"""Create a NapariNotifcation dialog from an exception object."""
# TODO: this method could be used to recognize various exception
# subclasses and populate the dialog accordingly.
msg = getattr(exception, 'message', str(exception))
severity = getattr(exception, 'severity', 'WARNING')
source = None
actions = getattr(exception, 'actions', ())
return cls(msg, severity, source, actions)
def setup_and_check(self,
data,
title='',
readonly=False,
xlabels=None,
ylabels=None):
"""
Setup ArrayEditor:
return False if data is not supported, True otherwise
"""
self.data = data
readonly = readonly or not self.data.flags.writeable
is_record_array = data.dtype.names is not None
is_masked_array = isinstance(data, np.ma.MaskedArray)
if data.ndim > 3:
self.error(
_("Arrays with more than 3 dimensions are not "
"supported"))
return False
if xlabels is not None and len(xlabels) != self.data.shape[1]:
self.error(
_("The 'xlabels' argument length do no match array "
"column number"))
return False
if ylabels is not None and len(ylabels) != self.data.shape[0]:
self.error(
_("The 'ylabels' argument length do no match array row "
"number"))
return False
if not is_record_array:
dtn = data.dtype.name
if dtn == 'object':
# If the array doesn't have shape, we can't display it
if data.shape == ():
self.error(
_("Object arrays without shape are not "
"supported"))
return False
# We don't know what's inside these arrays, so we can't handle
# edits
self.readonly = readonly = True
elif (dtn not in SUPPORTED_FORMATS and not dtn.startswith('str')
and not dtn.startswith('unicode')):
arr = _("%s arrays") % data.dtype.name
self.error(_("%s are currently not supported") % arr)
return False
self.layout = QGridLayout()
self.setLayout(self.layout)
self.setWindowIcon(ima.icon('arredit'))
if title:
title = to_text_string(title) + " - " + _("NumPy array")
else:
title = _("Array editor")
if readonly:
title += ' (' + _('read only') + ')'
self.setWindowTitle(title)
self.resize(600, 500)
# Stack widget
self.stack = QStackedWidget(self)
if is_record_array:
for name in data.dtype.names:
self.stack.addWidget(
ArrayEditorWidget(self, data[name], readonly, xlabels,
ylabels))
elif is_masked_array:
self.stack.addWidget(
ArrayEditorWidget(self, data, readonly, xlabels, ylabels))
self.stack.addWidget(
ArrayEditorWidget(self, data.data, readonly, xlabels, ylabels))
self.stack.addWidget(
ArrayEditorWidget(self, data.mask, readonly, xlabels, ylabels))
elif data.ndim == 3:
pass
else:
self.stack.addWidget(
ArrayEditorWidget(self, data, readonly, xlabels, ylabels))
self.arraywidget = self.stack.currentWidget()
if self.arraywidget:
self.arraywidget.model.dataChanged.connect(
self.save_and_close_enable)
self.stack.currentChanged.connect(self.current_widget_changed)
self.layout.addWidget(self.stack, 1, 0)
# Buttons configuration
btn_layout = QHBoxLayout()
if is_record_array or is_masked_array or data.ndim == 3:
if is_record_array:
btn_layout.addWidget(QLabel(_("Record array fields:")))
names = []
for name in data.dtype.names:
field = data.dtype.fields[name]
text = name
if len(field) >= 3:
title = field[2]
if not is_text_string(title):
title = repr(title)
text += ' - ' + title
names.append(text)
else:
names = [_('Masked data'), _('Data'), _('Mask')]
if data.ndim == 3:
# QSpinBox
self.index_spin = QSpinBox(self, keyboardTracking=False)
self.index_spin.valueChanged.connect(self.change_active_widget)
# QComboBox
names = [str(i) for i in range(3)]
ra_combo = QComboBox(self)
ra_combo.addItems(names)
ra_combo.currentIndexChanged.connect(self.current_dim_changed)
# Adding the widgets to layout
label = QLabel(_("Axis:"))
btn_layout.addWidget(label)
btn_layout.addWidget(ra_combo)
self.shape_label = QLabel()
btn_layout.addWidget(self.shape_label)
label = QLabel(_("Index:"))
btn_layout.addWidget(label)
btn_layout.addWidget(self.index_spin)
self.slicing_label = QLabel()
btn_layout.addWidget(self.slicing_label)
# set the widget to display when launched
self.current_dim_changed(self.last_dim)
else:
ra_combo = QComboBox(self)
ra_combo.currentIndexChanged.connect(
self.stack.setCurrentIndex)
ra_combo.addItems(names)
btn_layout.addWidget(ra_combo)
if is_masked_array:
label = QLabel(
_("<u>Warning</u>: changes are applied separately"))
label.setToolTip(_("For performance reasons, changes applied "\
"to masked array won't be reflected in "\
"array's data (and vice-versa)."))
btn_layout.addWidget(label)
btn_layout.addStretch()
if not readonly:
self.btn_save_and_close = QPushButton(_('Save and Close'))
self.btn_save_and_close.setDisabled(True)
self.btn_save_and_close.clicked.connect(self.accept)
btn_layout.addWidget(self.btn_save_and_close)
self.btn_close = QPushButton(_('Close'))
self.btn_close.setAutoDefault(True)
self.btn_close.setDefault(True)
self.btn_close.clicked.connect(self.reject)
btn_layout.addWidget(self.btn_close)
self.layout.addLayout(btn_layout, 2, 0)
self.setMinimumSize(400, 300)
# Make the dialog act as a window
self.setWindowFlags(Qt.Window)
return True
def __init__(self, parent):
super(FindReplaceDialog, self).__init__(parent)
self.parent = parent
self.setWindowTitle("Find Replace")
self.setFixedSize(400, 200)
main_layout = QVBoxLayout()
find_layout = QHBoxLayout()
replace_layout = QHBoxLayout()
options_layout = QHBoxLayout()
buttons_layout = QHBoxLayout()
find_label = QLabel()
find_label.setText("Find:")
self.find_input = QLineEdit()
find_layout.addWidget(find_label)
find_layout.addWidget(self.find_input)
replace_label = QLabel()
replace_label.setText("Replace:")
self.replace_input = QLineEdit()
replace_layout.addWidget(replace_label)
replace_layout.addWidget(self.replace_input)
self.close_button = QPushButton()
self.close_button.setText("Close")
self.find_button = QPushButton()
self.find_button.setText("Find")
self.replace_button = QPushButton()
self.replace_button.setText("Replace")
self.all_button = QPushButton()
self.all_button.setText("Replace All")
buttons_layout.addWidget(self.close_button)
buttons_layout.addWidget(self.find_button)
buttons_layout.addWidget(self.replace_button)
buttons_layout.addWidget(self.all_button)
self.highlight_result = QCheckBox()
self.highlight_result.setText("highlight results")
options_layout.addWidget(self.highlight_result)
main_layout.addLayout(find_layout)
main_layout.addLayout(replace_layout)
main_layout.addLayout(options_layout)
main_layout.addLayout(buttons_layout)
self.setLayout(main_layout)
self.find_button.clicked.connect(self.find_text)
self.replace_button.clicked.connect(self.replace_text)
self.all_button.clicked.connect(self.replace_all_text)
self.close_button.clicked.connect(self.hide_dialog)
def __init__(self, parent, text,
title=None, icon=None, contents_title=None, varname=None):
QDialog.__init__(self, parent)
# Destroying the C++ object right after closing the dialog box,
# otherwise it may be garbage-collected in another QThread
# (e.g. the editor's analysis thread in Spyder), thus leading to
# a segmentation fault on UNIX or an application crash on Windows
self.setAttribute(Qt.WA_DeleteOnClose)
if title is None:
title = _("Import wizard")
self.setWindowTitle(title)
if icon is None:
self.setWindowIcon(ima.icon('fileimport'))
if contents_title is None:
contents_title = _("Raw text")
if varname is None:
varname = _("variable_name")
self.var_name, self.clip_data = None, None
# Setting GUI
self.tab_widget = QTabWidget(self)
self.text_widget = ContentsWidget(self, text)
self.table_widget = PreviewWidget(self)
self.tab_widget.addTab(self.text_widget, _("text"))
self.tab_widget.setTabText(0, contents_title)
self.tab_widget.addTab(self.table_widget, _("table"))
self.tab_widget.setTabText(1, _("Preview"))
self.tab_widget.setTabEnabled(1, False)
name_layout = QHBoxLayout()
name_label = QLabel(_("Variable Name"))
name_layout.addWidget(name_label)
self.name_edt = QLineEdit()
self.name_edt.setText(varname)
name_layout.addWidget(self.name_edt)
btns_layout = QHBoxLayout()
cancel_btn = QPushButton(_("Cancel"))
btns_layout.addWidget(cancel_btn)
cancel_btn.clicked.connect(self.reject)
h_spacer = QSpacerItem(40, 20,
QSizePolicy.Expanding, QSizePolicy.Minimum)
btns_layout.addItem(h_spacer)
self.back_btn = QPushButton(_("Previous"))
self.back_btn.setEnabled(False)
btns_layout.addWidget(self.back_btn)
self.back_btn.clicked.connect(ft_partial(self._set_step, step=-1))
self.fwd_btn = QPushButton(_("Next"))
if not text:
self.fwd_btn.setEnabled(False)
btns_layout.addWidget(self.fwd_btn)
self.fwd_btn.clicked.connect(ft_partial(self._set_step, step=1))
self.done_btn = QPushButton(_("Done"))
self.done_btn.setEnabled(False)
btns_layout.addWidget(self.done_btn)
self.done_btn.clicked.connect(self.process)
self.text_widget.asDataChanged.connect(self.fwd_btn.setEnabled)
self.text_widget.asDataChanged.connect(self.done_btn.setDisabled)
layout = QVBoxLayout()
layout.addLayout(name_layout)
layout.addWidget(self.tab_widget)
layout.addLayout(btns_layout)
self.setLayout(layout)
def __init__(self,
parent=None,
package=None,
extra_message='',
current_prefix=None):
"""Create new environment dialog if navigator conflicts with deps."""
super(ConflictDialog, self).__init__(parent=parent)
parts = package.split('=')
self.package = parts[0] if '=' in package else package
self.package_version = parts[-1] if '=' in package else ''
self.current_prefix = current_prefix
base_message = ('<b>{0}</b> cannot be installed on this '
'environment.').format(package)
base_message = extra_message or base_message
# Widgets
self.label_info = LabelBase(
base_message + '<br><br>'
'Do you want to install the package in an existing '
'environment or <br>create a new environment?'
''.format(package))
self.label_name = LabelBase('Name:')
self.label_prefix = LabelBase(' ' * 100)
self.label_location = LabelBase('Location:')
self.combo_name = ComboBoxBase()
self.button_ok = ButtonPrimary('Create')
self.button_cancel = ButtonNormal('Cancel')
# Widgets setup
self.align_labels([self.label_name, self.label_location])
self.combo_name.setEditable(True)
self.combo_name.setCompleter(None)
self.combo_name.setValidator(self.get_regex_validator())
self.setMinimumWidth(self.BASE_DIALOG_WIDTH)
self.setWindowTitle("Create new environment for '{}'".format(package))
self.label_prefix.setObjectName('environment-location')
self.combo_name.setObjectName('environment-selection')
# Layouts
grid_layout = QGridLayout()
grid_layout.addWidget(self.label_name, 0, 0)
grid_layout.addWidget(SpacerHorizontal(), 0, 1)
grid_layout.addWidget(self.combo_name, 0, 2)
grid_layout.addWidget(SpacerVertical(), 1, 0)
grid_layout.addWidget(self.label_location, 2, 0)
grid_layout.addWidget(SpacerHorizontal(), 2, 1)
grid_layout.addWidget(self.label_prefix, 2, 2)
layout_buttons = QHBoxLayout()
layout_buttons.addStretch()
layout_buttons.addWidget(self.button_cancel)
layout_buttons.addWidget(SpacerHorizontal())
layout_buttons.addWidget(self.button_ok)
main_layout = QVBoxLayout()
main_layout.addWidget(self.label_info)
main_layout.addWidget(SpacerVertical())
main_layout.addWidget(SpacerVertical())
main_layout.addLayout(grid_layout)
main_layout.addWidget(SpacerVertical())
main_layout.addWidget(SpacerVertical())
main_layout.addLayout(layout_buttons)
self.setLayout(main_layout)
# Signals
self.button_ok.clicked.connect(self.accept)
self.button_cancel.clicked.connect(self.reject)
self.combo_name.setCurrentText(self.package)
self.combo_name.currentTextChanged.connect(self.refresh)
self.button_ok.setDisabled(True)
def __init__(self, parent, text):
QWidget.__init__(self, parent)
self.text_editor = QTextEdit(self)
self.text_editor.setText(text)
self.text_editor.setReadOnly(True)
# Type frame
type_layout = QHBoxLayout()
type_label = QLabel(_("Import as"))
type_layout.addWidget(type_label)
data_btn = QRadioButton(_("data"))
data_btn.setChecked(True)
self._as_data= True
type_layout.addWidget(data_btn)
code_btn = QRadioButton(_("code"))
self._as_code = False
type_layout.addWidget(code_btn)
txt_btn = QRadioButton(_("text"))
type_layout.addWidget(txt_btn)
h_spacer = QSpacerItem(40, 20,
QSizePolicy.Expanding, QSizePolicy.Minimum)
type_layout.addItem(h_spacer)
type_frame = QFrame()
type_frame.setLayout(type_layout)
# Opts frame
grid_layout = QGridLayout()
grid_layout.setSpacing(0)
col_label = QLabel(_("Column separator:"))
grid_layout.addWidget(col_label, 0, 0)
col_w = QWidget()
col_btn_layout = QHBoxLayout()
self.tab_btn = QRadioButton(_("Tab"))
self.tab_btn.setChecked(False)
col_btn_layout.addWidget(self.tab_btn)
self.ws_btn = QRadioButton(_("Whitespace"))
self.ws_btn.setChecked(False)
col_btn_layout.addWidget(self.ws_btn)
other_btn_col = QRadioButton(_("other"))
other_btn_col.setChecked(True)
col_btn_layout.addWidget(other_btn_col)
col_w.setLayout(col_btn_layout)
grid_layout.addWidget(col_w, 0, 1)
self.line_edt = QLineEdit(",")
self.line_edt.setMaximumWidth(30)
self.line_edt.setEnabled(True)
other_btn_col.toggled.connect(self.line_edt.setEnabled)
grid_layout.addWidget(self.line_edt, 0, 2)
row_label = QLabel(_("Row separator:"))
grid_layout.addWidget(row_label, 1, 0)
row_w = QWidget()
row_btn_layout = QHBoxLayout()
self.eol_btn = QRadioButton(_("EOL"))
self.eol_btn.setChecked(True)
row_btn_layout.addWidget(self.eol_btn)
other_btn_row = QRadioButton(_("other"))
row_btn_layout.addWidget(other_btn_row)
row_w.setLayout(row_btn_layout)
grid_layout.addWidget(row_w, 1, 1)
self.line_edt_row = QLineEdit(";")
self.line_edt_row.setMaximumWidth(30)
self.line_edt_row.setEnabled(False)
other_btn_row.toggled.connect(self.line_edt_row.setEnabled)
grid_layout.addWidget(self.line_edt_row, 1, 2)
grid_layout.setRowMinimumHeight(2, 15)
other_group = QGroupBox(_("Additional options"))
other_layout = QGridLayout()
other_group.setLayout(other_layout)
skiprows_label = QLabel(_("Skip rows:"))
other_layout.addWidget(skiprows_label, 0, 0)
self.skiprows_edt = QLineEdit('0')
self.skiprows_edt.setMaximumWidth(30)
intvalid = QIntValidator(0, len(to_text_string(text).splitlines()),
self.skiprows_edt)
self.skiprows_edt.setValidator(intvalid)
other_layout.addWidget(self.skiprows_edt, 0, 1)
other_layout.setColumnMinimumWidth(2, 5)
comments_label = QLabel(_("Comments:"))
other_layout.addWidget(comments_label, 0, 3)
self.comments_edt = QLineEdit('#')
self.comments_edt.setMaximumWidth(30)
other_layout.addWidget(self.comments_edt, 0, 4)
self.trnsp_box = QCheckBox(_("Transpose"))
#self.trnsp_box.setEnabled(False)
other_layout.addWidget(self.trnsp_box, 1, 0, 2, 0)
grid_layout.addWidget(other_group, 3, 0, 2, 0)
opts_frame = QFrame()
opts_frame.setLayout(grid_layout)
data_btn.toggled.connect(opts_frame.setEnabled)
data_btn.toggled.connect(self.set_as_data)
code_btn.toggled.connect(self.set_as_code)
# self.connect(txt_btn, SIGNAL("toggled(bool)"),
# self, SLOT("is_text(bool)"))
# Final layout
layout = QVBoxLayout()
layout.addWidget(type_frame)
layout.addWidget(self.text_editor)
layout.addWidget(opts_frame)
self.setLayout(layout)
def setup(self):
"""Setup the ShortcutEditor with the provided arguments."""
# Widgets
icon_info = HelperToolButton()
icon_info.setIcon(get_std_icon('MessageBoxInformation'))
layout_icon_info = QVBoxLayout()
layout_icon_info.setContentsMargins(0, 0, 0, 0)
layout_icon_info.setSpacing(0)
layout_icon_info.addWidget(icon_info)
layout_icon_info.addStretch(100)
self.label_info = QLabel()
self.label_info.setText(
_("Press the new shortcut and select 'Ok' to confirm, "
"click 'Cancel' to revert to the previous state, "
"or use 'Clear' to unbind the command from a shortcut."))
self.label_info.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.label_info.setWordWrap(True)
layout_info = QHBoxLayout()
layout_info.setContentsMargins(0, 0, 0, 0)
layout_info.addLayout(layout_icon_info)
layout_info.addWidget(self.label_info)
layout_info.setStretch(1, 100)
self.label_current_sequence = QLabel(_("Current shortcut:"))
self.text_current_sequence = QLabel(self.current_sequence)
self.label_new_sequence = QLabel(_("New shortcut:"))
self.text_new_sequence = ShortcutLineEdit(self)
self.text_new_sequence.setPlaceholderText(_("Press shortcut."))
self.helper_button = HelperToolButton()
self.helper_button.setIcon(QIcon())
self.label_warning = QLabel()
self.label_warning.setWordWrap(True)
self.label_warning.setAlignment(Qt.AlignTop | Qt.AlignLeft)
self.button_default = QPushButton(_('Default'))
self.button_ok = QPushButton(_('Ok'))
self.button_ok.setEnabled(False)
self.button_clear = QPushButton(_('Clear'))
self.button_cancel = QPushButton(_('Cancel'))
button_box = QHBoxLayout()
button_box.addWidget(self.button_default)
button_box.addStretch(100)
button_box.addWidget(self.button_ok)
button_box.addWidget(self.button_clear)
button_box.addWidget(self.button_cancel)
# New Sequence button box
self.btn_clear_sequence = create_toolbutton(
self,
icon=ima.icon('editclear'),
tip=_("Clear all entered key sequences"),
triggered=self.clear_new_sequence)
self.button_back_sequence = create_toolbutton(
self,
icon=ima.icon('ArrowBack'),
tip=_("Remove last key sequence entered"),
triggered=self.back_new_sequence)
newseq_btnbar = QHBoxLayout()
newseq_btnbar.setSpacing(0)
newseq_btnbar.setContentsMargins(0, 0, 0, 0)
newseq_btnbar.addWidget(self.button_back_sequence)
newseq_btnbar.addWidget(self.btn_clear_sequence)
# Setup widgets
self.setWindowTitle(_('Shortcut: {0}').format(self.name))
self.helper_button.setToolTip('')
style = """
QToolButton {
margin:1px;
border: 0px solid grey;
padding:0px;
border-radius: 0px;
}"""
self.helper_button.setStyleSheet(style)
icon_info.setToolTip('')
icon_info.setStyleSheet(style)
# Layout
layout_sequence = QGridLayout()
layout_sequence.setContentsMargins(0, 0, 0, 0)
layout_sequence.addLayout(layout_info, 0, 0, 1, 4)
layout_sequence.addItem(QSpacerItem(15, 15), 1, 0, 1, 4)
layout_sequence.addWidget(self.label_current_sequence, 2, 0)
layout_sequence.addWidget(self.text_current_sequence, 2, 2)
layout_sequence.addWidget(self.label_new_sequence, 3, 0)
layout_sequence.addWidget(self.helper_button, 3, 1)
layout_sequence.addWidget(self.text_new_sequence, 3, 2)
layout_sequence.addLayout(newseq_btnbar, 3, 3)
layout_sequence.addWidget(self.label_warning, 4, 2, 1, 2)
layout_sequence.setColumnStretch(2, 100)
layout_sequence.setRowStretch(4, 100)
layout = QVBoxLayout(self)
layout.addLayout(layout_sequence)
layout.addSpacing(10)
layout.addLayout(button_box)
layout.setSizeConstraint(layout.SetFixedSize)
# Signals
self.button_ok.clicked.connect(self.accept_override)
self.button_clear.clicked.connect(self.unbind_shortcut)
self.button_cancel.clicked.connect(self.reject)
self.button_default.clicked.connect(self.set_sequence_to_default)
# Set all widget to no focus so that we can register <Tab> key
# press event.
widgets = (self.label_warning, self.helper_button,
self.text_new_sequence, self.button_clear,
self.button_default, self.button_cancel, self.button_ok,
self.btn_clear_sequence, self.button_back_sequence)
for w in widgets:
w.setFocusPolicy(Qt.NoFocus)
w.clearFocus()
class ArrayEditorWidget(QWidget):
dataChanged = Signal(list)
def __init__(self,
parent,
data=None,
readonly=False,
bg_value=None,
bg_gradient='blue-red',
minvalue=None,
maxvalue=None,
digits=None):
QWidget.__init__(self, parent)
assert bg_gradient in gradient_map
if data is not None and np.isscalar(data):
readonly = True
self.readonly = readonly
# prepare internal views and models
self.model_axes = AxesArrayModel(parent=self, readonly=readonly)
self.view_axes = AxesView(parent=self, model=self.model_axes)
self.model_hlabels = LabelsArrayModel(parent=self, readonly=readonly)
self.view_hlabels = LabelsView(parent=self,
model=self.model_hlabels,
hpos=RIGHT,
vpos=TOP)
self.model_vlabels = LabelsArrayModel(parent=self, readonly=readonly)
self.view_vlabels = LabelsView(parent=self,
model=self.model_vlabels,
hpos=LEFT,
vpos=BOTTOM)
self.model_data = DataArrayModel(parent=self,
readonly=readonly,
minvalue=minvalue,
maxvalue=maxvalue)
self.view_data = DataView(parent=self, model=self.model_data)
# in case data is None
self.data_adapter = None
# Create vertical and horizontal scrollbars
self.vscrollbar = ScrollBar(self, self.view_data.verticalScrollBar())
self.hscrollbar = ScrollBar(self, self.view_data.horizontalScrollBar())
# Synchronize resizing
self.view_axes.horizontalHeader().sectionResized.connect(
self.view_vlabels.updateSectionWidth)
self.view_axes.verticalHeader().sectionResized.connect(
self.view_hlabels.updateSectionHeight)
self.view_hlabels.horizontalHeader().sectionResized.connect(
self.view_data.updateSectionWidth)
self.view_vlabels.verticalHeader().sectionResized.connect(
self.view_data.updateSectionHeight)
# Synchronize auto-resizing
self.view_axes.horizontalHeader().sectionHandleDoubleClicked.connect(
self.resize_axes_column_to_contents)
self.view_hlabels.horizontalHeader(
).sectionHandleDoubleClicked.connect(
self.resize_hlabels_column_to_contents)
self.view_axes.verticalHeader().sectionHandleDoubleClicked.connect(
self.resize_axes_row_to_contents)
self.view_vlabels.verticalHeader().sectionHandleDoubleClicked.connect(
self.resize_vlabels_row_to_contents)
# synchronize specific methods
self.view_axes.allSelected.connect(self.view_data.selectAll)
self.view_data.signal_copy.connect(self.copy)
self.view_data.signal_excel.connect(self.to_excel)
self.view_data.signal_paste.connect(self.paste)
self.view_data.signal_plot.connect(self.plot)
# propagate changes (add new items in the QUndoStack attribute of MappingEditor)
self.model_data.newChanges.connect(self.data_changed)
# Synchronize scrolling
# data <--> hlabels
self.view_data.horizontalScrollBar().valueChanged.connect(
self.view_hlabels.horizontalScrollBar().setValue)
self.view_hlabels.horizontalScrollBar().valueChanged.connect(
self.view_data.horizontalScrollBar().setValue)
# data <--> vlabels
self.view_data.verticalScrollBar().valueChanged.connect(
self.view_vlabels.verticalScrollBar().setValue)
self.view_vlabels.verticalScrollBar().valueChanged.connect(
self.view_data.verticalScrollBar().setValue)
# Synchronize selecting columns(rows) via hor.(vert.) header of x(y)labels view
self.view_hlabels.horizontalHeader().sectionPressed.connect(
self.view_data.selectColumn)
self.view_hlabels.horizontalHeader().sectionEntered.connect(
self.view_data.selectNewColumn)
self.view_vlabels.verticalHeader().sectionPressed.connect(
self.view_data.selectRow)
self.view_vlabels.verticalHeader().sectionEntered.connect(
self.view_data.selectNewRow)
# following lines are required to keep usual selection color
# when selecting rows/columns via headers of label views.
# Otherwise, selected rows/columns appear in grey.
self.view_data.setStyleSheet("""QTableView {
selection-background-color: palette(highlight);
selection-color: white;
}""")
# set external borders
array_frame = QFrame(self)
array_frame.setFrameStyle(QFrame.StyledPanel)
# remove borders of internal tables
self.view_axes.setFrameStyle(QFrame.NoFrame)
self.view_hlabels.setFrameStyle(QFrame.NoFrame)
self.view_vlabels.setFrameStyle(QFrame.NoFrame)
self.view_data.setFrameStyle(QFrame.NoFrame)
# Set layout of table views:
# [ axes ][hlabels]|V|
# [vlabels][ data ]|s|
# | H. scrollbar |
array_layout = QGridLayout()
array_layout.addWidget(self.view_axes, 0, 0)
array_layout.addWidget(self.view_hlabels, 0, 1)
array_layout.addWidget(self.view_vlabels, 1, 0)
self.view_data.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
array_layout.addWidget(self.view_data, 1, 1)
array_layout.addWidget(self.vscrollbar, 0, 2, 2, 1)
array_layout.addWidget(self.hscrollbar, 2, 0, 1, 2)
array_layout.setSpacing(0)
array_layout.setContentsMargins(0, 0, 0, 0)
array_frame.setLayout(array_layout)
# Set filters and buttons layout
self.filters_layout = QHBoxLayout()
self.btn_layout = QHBoxLayout()
self.btn_layout.setAlignment(Qt.AlignLeft)
label = QLabel("Digits")
self.btn_layout.addWidget(label)
spin = QSpinBox(self)
spin.valueChanged.connect(self.digits_changed)
self.digits_spinbox = spin
self.btn_layout.addWidget(spin)
self.digits = 0
scientific = QCheckBox(_('Scientific'))
scientific.stateChanged.connect(self.scientific_changed)
self.scientific_checkbox = scientific
self.btn_layout.addWidget(scientific)
self.use_scientific = False
gradient_chooser = QComboBox()
gradient_chooser.setMaximumSize(120, 20)
gradient_chooser.setIconSize(QSize(100, 20))
pixmap = QPixmap(100, 15)
pixmap.fill(Qt.white)
gradient_chooser.addItem(QIcon(pixmap), " ")
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
for name, gradient in available_gradients[1:]:
qgradient = gradient.as_qgradient()
# * fill with white because gradient can be transparent and if we do not "start from whilte", it skews the
# colors.
# * 1 and 13 instead of 0 and 15 to have a transparent border around/between the gradients
painter.fillRect(0, 1, 100, 13, Qt.white)
painter.fillRect(0, 1, 100, 13, qgradient)
gradient_chooser.addItem(QIcon(pixmap), name, gradient)
# without this, we can crash python :)
del painter, pixmap
# select default gradient
# requires Qt5+
# gradient_chooser.setCurrentText(bg_gradient)
gradient_chooser.setCurrentIndex(
gradient_chooser.findText(bg_gradient))
gradient_chooser.currentIndexChanged.connect(self.gradient_changed)
self.btn_layout.addWidget(gradient_chooser)
self.gradient_chooser = gradient_chooser
# Set widget layout
layout = QVBoxLayout()
layout.addLayout(self.filters_layout)
layout.addWidget(array_frame)
layout.addLayout(self.btn_layout)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
# set gradient
self.model_data.set_bg_gradient(gradient_map[bg_gradient])
# set data
if data is not None:
self.set_data(data, bg_value=bg_value, digits=digits)
# See http://doc.qt.io/qt-4.8/qt-draganddrop-fridgemagnets-dragwidget-cpp.html for an example
self.setAcceptDrops(True)
def gradient_changed(self, index):
gradient = self.gradient_chooser.itemData(index) if index > 0 else None
self.model_data.set_bg_gradient(gradient)
def data_changed(self, data_model_changes):
changes = self.data_adapter.translate_changes(data_model_changes)
self.dataChanged.emit(changes)
def mousePressEvent(self, event):
self.dragLabel = self.childAt(
event.pos()) if event.button() == Qt.LeftButton else None
self.dragStartPosition = event.pos()
def mouseMoveEvent(self, event):
from qtpy.QtCore import QMimeData, QByteArray
from qtpy.QtGui import QPixmap, QDrag
if not (event.button() != Qt.LeftButton
and isinstance(self.dragLabel, QLabel)):
return
if (event.pos() - self.dragStartPosition
).manhattanLength() < QApplication.startDragDistance():
return
axis_index = self.filters_layout.indexOf(self.dragLabel) // 2
# prepare hotSpot, mimeData and pixmap objects
mimeData = QMimeData()
mimeData.setText(self.dragLabel.text())
mimeData.setData("application/x-axis-index",
QByteArray.number(axis_index))
pixmap = QPixmap(self.dragLabel.size())
self.dragLabel.render(pixmap)
# prepare drag object
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(pixmap)
drag.setHotSpot(event.pos() - self.dragStartPosition)
drag.exec_(Qt.MoveAction | Qt.CopyAction, Qt.CopyAction)
def dragEnterEvent(self, event):
if event.mimeData().hasText():
if self.filters_layout.geometry().contains(event.pos()):
event.setDropAction(Qt.MoveAction)
event.accept()
else:
event.acceptProposedAction()
else:
event.ignore()
def dragMoveEvent(self, event):
if event.mimeData().hasText() and self.filters_layout.geometry(
).contains(event.pos()):
child = self.childAt(event.pos())
if isinstance(child, QLabel) and child.text() != "Filters":
event.setDropAction(Qt.MoveAction)
event.accept()
else:
event.ignore()
else:
event.ignore()
def dropEvent(self, event):
if event.mimeData().hasText():
if self.filters_layout.geometry().contains(event.pos()):
old_index, success = event.mimeData().data(
"application/x-axis-index").toInt()
new_index = self.filters_layout.indexOf(
self.childAt(event.pos())) // 2
data, bg_value = self.data_adapter.data, self.data_adapter.bg_value
data, bg_value = self.data_adapter.move_axis(
data, bg_value, old_index, new_index)
self.set_data(data, bg_value)
event.setDropAction(Qt.MoveAction)
event.accept()
else:
event.acceptProposedAction()
else:
event.ignore()
def _reset_minmax(self):
self.model_data.reset_minmax()
def _update_models(self, reset_model_data, reset_minmax):
# axes names
axes_names = self.data_adapter.get_axes_names(fold_last_axis=True)
self.model_axes.set_data(axes_names)
# horizontal labels
hlabels = self.data_adapter.get_hlabels()
self.model_hlabels.set_data(hlabels)
# vertical labels
vlabels = self.data_adapter.get_vlabels()
self.model_vlabels.set_data(vlabels)
# raw data
# use flag reset=False to avoid calling reset() several times
raw_data = self.data_adapter.get_raw_data()
self.model_data.set_data(raw_data, reset=False)
# bg value
# use flag reset=False to avoid calling reset() several times
bg_value = self.data_adapter.get_bg_value()
self.model_data.set_bg_value(bg_value, reset=False)
# reset min and max values if required
if reset_minmax:
self._reset_minmax()
# reset the data model if required
if reset_model_data:
self.model_data.reset()
def set_data(self, data, bg_value=None, digits=None):
# get new adapter instance + set data
self.data_adapter = get_adapter(data=data, bg_value=bg_value)
# update filters
self._update_filter()
# update models
# Note: model_data is reset by call of _update_digits_scientific below which call
# set_format which reset the data_model
self._update_models(reset_model_data=False, reset_minmax=True)
# update data format
self._update_digits_scientific(digits=digits)
# update gradient_chooser
self.gradient_chooser.setEnabled(self.model_data.bgcolor_possible)
# reset default size
self._reset_default_size()
# update dtype in view_data
self.view_data.set_dtype(self.data_adapter.dtype)
def _reset_default_size(self):
self.view_axes.set_default_size()
self.view_vlabels.set_default_size()
self.view_hlabels.set_default_size()
self.view_data.set_default_size()
def _update_filter(self):
filters_layout = self.filters_layout
clear_layout(filters_layout)
axes = self.data_adapter.get_axes_filtered_data()
# size > 0 to avoid arrays with length 0 axes and len(axes) > 0 to avoid scalars (scalar.size == 1)
if self.data_adapter.size > 0 and len(axes) > 0:
filters_layout.addWidget(QLabel(_("Filters")))
for axis in axes:
filters_layout.addWidget(QLabel(axis.name))
# FIXME: on very large axes, this is getting too slow. Ideally the combobox should use a model which
# only fetch labels when they are needed to be displayed
if len(axis) < 10000:
filters_layout.addWidget(self.create_filter_combo(axis))
else:
filters_layout.addWidget(QLabel("too big to be filtered"))
filters_layout.addStretch()
def set_format(self, digits, scientific, reset=True):
"""Set format.
Parameters
----------
digits : int
Number of digits to display.
scientific : boolean
Whether or not to display values in scientific format.
reset: boolean, optional
Whether or not to reset the data model. Defaults to True.
"""
type = self.data_adapter.dtype.type
if type in (np.str, np.str_, np.bool_, np.bool, np.object_):
fmt = '%s'
else:
format_letter = 'e' if scientific else 'f'
fmt = '%%.%d%s' % (digits, format_letter)
self.model_data.set_format(fmt, reset)
# two cases:
# * set_data should update both scientific and ndigits
# * toggling scientific checkbox should update only ndigits
def _update_digits_scientific(self, scientific=None, digits=None):
dtype = self.data_adapter.dtype
if dtype.type in (np.str, np.str_, np.bool_, np.bool, np.object_):
scientific = False
ndecimals = 0
else:
data = self.data_adapter.get_sample()
# max_digits = self.get_max_digits()
# default width can fit 8 chars
# FIXME: use max_digits?
avail_digits = 8
frac_zeros, int_digits, has_negative = self.format_helper(data)
# choose whether or not to use scientific notation
# ================================================
if scientific is None:
# use scientific format if there are more integer digits than we can display or if we can display more
# information that way (scientific format "uses" 4 digits, so we have a net win if we have >= 4 zeros --
# *including the integer one*)
# TODO: only do so if we would actually display more information
# 0.00001 can be displayed with 8 chars
# 1e-05
# would
scientific = int_digits > avail_digits or frac_zeros >= 4
# determine best number of decimals to display
# ============================================
# TODO: ndecimals vs self.digits => rename self.digits to either frac_digits or ndecimals
if digits is not None:
ndecimals = digits
else:
data_frac_digits = self._data_digits(data)
if scientific:
int_digits = 2 if has_negative else 1
exp_digits = 4
else:
exp_digits = 0
# - 1 for the dot
ndecimals = avail_digits - 1 - int_digits - exp_digits
if ndecimals < 0:
ndecimals = 0
if data_frac_digits < ndecimals:
ndecimals = data_frac_digits
self.digits = ndecimals
self.use_scientific = scientific
# avoid triggering digits_changed which would cause a useless redraw
self.digits_spinbox.blockSignals(True)
self.digits_spinbox.setValue(ndecimals)
self.digits_spinbox.setEnabled(is_number(dtype))
self.digits_spinbox.blockSignals(False)
# avoid triggering scientific_changed which would call this function a second time
self.scientific_checkbox.blockSignals(True)
self.scientific_checkbox.setChecked(scientific)
self.scientific_checkbox.setEnabled(is_number(dtype))
self.scientific_checkbox.blockSignals(False)
# 1) setting the format explicitly instead of relying on digits_spinbox.digits_changed to set it because
# digits_changed is only triggered when digits actually changed, not when passing from
# scientific -> non scientific or number -> object
# 2) data model is reset in set_format by default
self.set_format(ndecimals, scientific)
def format_helper(self, data):
if not data.size:
return 0, 0, False
data = np.where(np.isfinite(data), data, 0)
vmin, vmax = np.min(data), np.max(data)
absmax = max(abs(vmin), abs(vmax))
logabsmax = math.log10(absmax) if absmax else 0
# minimum number of zeros before meaningful fractional part
frac_zeros = math.ceil(-logabsmax) - 1 if logabsmax < 0 else 0
int_digits = max(ndigits(vmin), ndigits(vmax))
return frac_zeros, int_digits, vmin < 0
def get_max_digits(self,
need_sign=False,
need_dot=False,
scientific=False):
font = get_font("arreditor") # QApplication.font()
col_width = 60
margin_width = 6 # a wild guess
avail_width = col_width - margin_width
metrics = QFontMetrics(font)
def str_width(c):
return metrics.size(Qt.TextSingleLine, c).width()
digit_width = max(str_width(str(i)) for i in range(10))
dot_width = str_width('.')
sign_width = max(str_width('+'), str_width('-'))
if need_sign:
avail_width -= sign_width
if need_dot:
avail_width -= dot_width
if scientific:
avail_width -= str_width('e') + sign_width + 2 * digit_width
return avail_width // digit_width
def _data_digits(self, data, maxdigits=6):
if not data.size:
return 0
threshold = 10**-(maxdigits + 1)
for ndigits in range(maxdigits):
maxdiff = np.max(np.abs(data - np.round(data, ndigits)))
if maxdiff < threshold:
return ndigits
return maxdigits
def autofit_columns(self):
self.view_axes.autofit_columns()
for column in range(self.model_axes.columnCount()):
self.resize_axes_column_to_contents(column)
self.view_hlabels.autofit_columns()
for column in range(self.model_hlabels.columnCount()):
self.resize_hlabels_column_to_contents(column)
def resize_axes_column_to_contents(self, column):
# must be connected to view_axes.horizontalHeader().sectionHandleDoubleClicked signal
width = max(self.view_axes.horizontalHeader().sectionSize(column),
self.view_vlabels.sizeHintForColumn(column))
# no need to call resizeSection on view_vlabels (see synchronization lines in init)
self.view_axes.horizontalHeader().resizeSection(column, width)
def resize_hlabels_column_to_contents(self, column):
# must be connected to view_labels.horizontalHeader().sectionHandleDoubleClicked signal
width = max(self.view_hlabels.horizontalHeader().sectionSize(column),
self.view_data.sizeHintForColumn(column))
# no need to call resizeSection on view_data (see synchronization lines in init)
self.view_hlabels.horizontalHeader().resizeSection(column, width)
def resize_axes_row_to_contents(self, row):
# must be connected to view_axes.verticalHeader().sectionHandleDoubleClicked
height = max(self.view_axes.verticalHeader().sectionSize(row),
self.view_hlabels.sizeHintForRow(row))
# no need to call resizeSection on view_hlabels (see synchronization lines in init)
self.view_axes.verticalHeader().resizeSection(row, height)
def resize_vlabels_row_to_contents(self, row):
# must be connected to view_labels.verticalHeader().sectionHandleDoubleClicked
height = max(self.view_vlabels.verticalHeader().sectionSize(row),
self.view_data.sizeHintForRow(row))
# no need to call resizeSection on view_data (see synchronization lines in init)
self.view_vlabels.verticalHeader().resizeSection(row, height)
def scientific_changed(self, value):
self._update_digits_scientific(scientific=value)
def digits_changed(self, value):
self.digits = value
self.set_format(value, self.use_scientific)
def change_filter(self, axis, indices):
self.data_adapter.update_filter(axis, indices)
self._update_models(reset_model_data=True, reset_minmax=False)
def create_filter_combo(self, axis):
def filter_changed(checked_items):
self.change_filter(axis, checked_items)
combo = FilterComboBox(self)
combo.addItems([str(l) for l in axis.labels])
combo.checkedItemsChanged.connect(filter_changed)
return combo
def _selection_data(self, headers=True, none_selects_all=True):
"""
Returns selected labels as lists and raw data as Numpy ndarray
if headers=True or only the raw data otherwise
Parameters
----------
headers : bool, optional
Labels are also returned if True.
none_selects_all : bool, optional
If True (default) and selection is empty, returns all data.
Returns
-------
raw_data: numpy.ndarray
axes_names: list
vlabels: nested list
hlabels: list
"""
bounds = self.view_data._selection_bounds(
none_selects_all=none_selects_all)
if bounds is None:
return None
row_min, row_max, col_min, col_max = bounds
raw_data = self.model_data.get_values(row_min, col_min, row_max,
col_max)
if headers:
if not self.data_adapter.ndim:
return raw_data, None, None, None
axes_names = self.model_axes.get_values()
hlabels = [
label[0]
for label in self.model_hlabels.get_values(top=col_min,
bottom=col_max)
]
vlabels = self.model_vlabels.get_values(
left=row_min,
right=row_max) if self.data_adapter.ndim > 1 else []
return raw_data, axes_names, vlabels, hlabels
else:
return raw_data
def copy(self):
"""Copy selection as text to clipboard"""
raw_data, axes_names, vlabels, hlabels = self._selection_data()
data = self.data_adapter.selection_to_chain(raw_data, axes_names,
vlabels, hlabels)
if data is None:
return
# np.savetxt make things more complicated, especially on py3
# XXX: why don't we use repr for everything?
def vrepr(v):
if isinstance(v, float):
return repr(v)
else:
return str(v)
text = '\n'.join('\t'.join(vrepr(v) for v in line) for line in data)
clipboard = QApplication.clipboard()
clipboard.setText(text)
def to_excel(self):
"""Export selection in Excel"""
raw_data, axes_names, vlabels, hlabels = self._selection_data()
try:
self.data_adapter.to_excel(raw_data, axes_names, vlabels, hlabels)
except ImportError:
QMessageBox.critical(
self, "Error",
"to_excel() is not available because xlwings is not installed")
def paste(self):
bounds = self.view_data._selection_bounds()
if bounds is None:
return
row_min, row_max, col_min, col_max = bounds
clipboard = QApplication.clipboard()
text = str(clipboard.text())
list_data = [line.split('\t') for line in text.splitlines()]
try:
# take the first cell which contains '\'
pos_last = next(i for i, v in enumerate(list_data[0]) if '\\' in v)
except StopIteration:
# if there isn't any, assume 1d array
pos_last = 0
if pos_last or '\\' in list_data[0][0]:
# ndim > 1
list_data = [line[pos_last + 1:] for line in list_data[1:]]
elif len(list_data) == 2 and list_data[1][0] == '':
# ndim == 1
list_data = [list_data[1][1:]]
new_data = np.array(list_data)
if new_data.shape[0] > 1:
row_max = row_min + new_data.shape[0]
if new_data.shape[1] > 1:
col_max = col_min + new_data.shape[1]
result = self.model_data.set_values(row_min, col_min, row_max, col_max,
new_data)
if result is None:
return
# TODO: when pasting near bottom/right boundaries and size of
# new_data exceeds destination size, we should either have an error
# or clip new_data
self.view_data.selectionModel().select(
QItemSelection(*result), QItemSelectionModel.ClearAndSelect)
def plot(self):
raw_data, axes_names, vlabels, hlabels = self._selection_data()
try:
from larray_editor.utils import show_figure
figure = self.data_adapter.plot(raw_data, axes_names, vlabels,
hlabels)
# Display figure
show_figure(self, figure)
except ImportError:
QMessageBox.critical(
self, "Error",
"plot() is not available because matplotlib is not installed")
class CommunityTab(WidgetBase):
"""Community tab."""
# Qt Signals
sig_video_started = Signal(str, int)
sig_status_updated = Signal(object, int, int, int)
sig_ready = Signal(object) # Sender
# Class variables
instances = []
# Maximum item count for different content type
VIDEOS_LIMIT = 25
WEBINARS_LIMIT = 25
EVENTS_LIMIT = 25
# Google analytics campaigns
UTM_MEDIUM = 'in-app'
UTM_SOURCE = 'navigator'
def __init__(self,
parent=None,
tags=None,
content_urls=None,
content_path=CONTENT_PATH,
image_path=IMAGE_DATA_PATH,
config=CONF,
bundle_path=LINKS_INFO_PATH,
saved_content_path=CONTENT_JSON_PATH,
tab_name=''):
"""Community tab."""
super(CommunityTab, self).__init__(parent=parent)
self._tab_name = ''
self.content_path = content_path
self.image_path = image_path
self.bundle_path = bundle_path
self.saved_content_path = saved_content_path
self.config = config
self._parent = parent
self._downloaded_thumbnail_urls = []
self._downloaded_urls = []
self._downloaded_filepaths = []
self.api = AnacondaAPI()
self.content_urls = content_urls
self.content_info = []
self.step = 0
self.step_size = 1
self.tags = tags
self.timer_load = QTimer()
self.pixmaps = {}
self.filter_widgets = []
self.default_pixmap = QPixmap(VIDEO_ICON_PATH).scaled(
100, 60, Qt.KeepAspectRatio, Qt.FastTransformation)
# Widgets
self.text_filter = LineEditSearch()
self.list = ListWidgetContent()
self.frame_header = FrameTabHeader()
self.frame_content = FrameTabContent()
# Widget setup
self.timer_load.setInterval(333)
self.list.setAttribute(Qt.WA_MacShowFocusRect, False)
self.text_filter.setPlaceholderText('Search')
self.text_filter.setAttribute(Qt.WA_MacShowFocusRect, False)
self.setObjectName("Tab")
self.list.setMinimumHeight(200)
fm = self.text_filter.fontMetrics()
self.text_filter.setMaximumWidth(fm.width('M' * 23))
# Layouts
self.filters_layout = QHBoxLayout()
layout_header = QHBoxLayout()
layout_header.addLayout(self.filters_layout)
layout_header.addStretch()
layout_header.addWidget(self.text_filter)
self.frame_header.setLayout(layout_header)
layout_content = QHBoxLayout()
layout_content.addWidget(self.list)
self.frame_content.setLayout(layout_content)
layout = QVBoxLayout()
layout.addWidget(self.frame_header)
layout.addWidget(self.frame_content)
self.setLayout(layout)
# Signals
self.timer_load.timeout.connect(self.set_content_list)
self.text_filter.textChanged.connect(self.filter_content)
def setup(self):
"""Setup tab content."""
self.download_content()
def _json_downloaded(self, worker, output, error):
"""Callbacl for download_content."""
url = worker.url
if url in self._downloaded_urls:
self._downloaded_urls.remove(url)
if not self._downloaded_urls:
self.load_content()
def download_content(self):
"""Download content to display in cards."""
self._downloaded_urls = []
self._downloaded_filepaths = []
if self.content_urls:
for url in self.content_urls:
url = url.lower() # Enforce lowecase... just in case
fname = url.split('/')[-1] + '.json'
filepath = os.sep.join([self.content_path, fname])
self._downloaded_urls.append(url)
self._downloaded_filepaths.append(filepath)
worker = self.api.download(url, filepath)
worker.url = url
worker.sig_finished.connect(self._json_downloaded)
else:
self.load_content()
def load_content(self, paths=None):
"""Load downloaded and bundled content."""
content = []
# Load downloaded content
for filepath in self._downloaded_filepaths:
fname = filepath.split(os.sep)[-1]
items = []
if os.path.isfile(filepath):
with open(filepath, 'r') as f:
data = f.read()
try:
items = json.loads(data)
except Exception as error:
logger.error(str((filepath, error)))
else:
items = []
if 'video' in fname:
for item in items:
try:
item['tags'] = ['video']
item['uri'] = item.get('video', '')
if item['uri']:
item['banner'] = item.get('thumbnail')
image_path = item['banner'].split('/')[-1]
item['image_file'] = image_path
else:
url = ''
item['image_file'] = ''
item['banner'] = url
item['date'] = item.get('date_start', '')
except Exception:
logger.debug("Video parse failed: {0}".format(item))
items = items[:self.VIDEOS_LIMIT]
elif 'event' in fname:
for item in items:
try:
item['tags'] = ['event']
item['uri'] = item.get('url', '')
if item['banner']:
image_path = item['banner'].split('/')[-1]
item['image_file'] = image_path
else:
item['banner'] = ''
except Exception:
logger.debug('Event parse failed: {0}'.format(item))
items = items[:self.EVENTS_LIMIT]
elif 'webinar' in fname:
for item in items:
try:
item['tags'] = ['webinar']
uri = item.get('url', '')
utm_campaign = item.get('utm_campaign', '')
item['uri'] = self.add_campaign(uri, utm_campaign)
image = item.get('image', '')
if image and isinstance(image, dict):
item['banner'] = image.get('src', '')
if item['banner']:
image_path = item['banner'].split('/')[-1]
item['image_file'] = image_path
else:
item['image_file'] = ''
else:
item['banner'] = ''
item['image_file_path'] = ''
except Exception:
logger.debug('Webinar parse failed: {0}'.format(item))
items = items[:self.WEBINARS_LIMIT]
if items:
content.extend(items)
# Load bundled content
with open(self.bundle_path, 'r') as f:
data = f.read()
items = []
try:
items = json.loads(data)
except Exception as error:
logger.error(str((filepath, error)))
content.extend(items)
# Add the image path to get the full path
for i, item in enumerate(content):
uri = item['uri']
uri = uri.replace('<p>', '').replace('</p>', '')
item['uri'] = uri.replace(' ', '%20')
filename = item.get('image_file', '')
item['image_file_path'] = os.path.sep.join(
[self.image_path, filename])
# if 'video' in item['tags']:
# print(i, item['uri'])
# print(item['banner'])
# print(item['image_file_path'])
# print('')
# Make sure items of the same type/tag are contiguous in the list
content = sorted(content, key=lambda i: i.get('tags'))
# But also make sure sticky content appears first
sticky_content = []
for i, item in enumerate(content[:]):
sticky = item.get('sticky')
if isinstance(sticky, str):
is_sticky = sticky == 'true'
elif sticky is None:
is_sticky = False
# print(i, sticky, is_sticky, item.get('title'))
if is_sticky:
sticky_content.append(item)
content.remove(item)
content = sticky_content + content
self.content_info = content
# Save loaded data in a single file
with open(self.saved_content_path, 'w') as f:
json.dump(content, f)
self.make_tag_filters()
self.timer_load.start(random.randint(25, 35))
def add_campaign(self, uri, utm_campaign):
"""Add tracking analytics campaing to url in content items."""
if uri and utm_campaign:
parameters = parse.urlencode({
'utm_source': self.UTM_SOURCE,
'utm_medium': self.UTM_MEDIUM,
'utm_campaign': utm_campaign
})
uri = '{0}?{1}'.format(uri, parameters)
return uri
def make_tag_filters(self):
"""Create tag filtering checkboxes based on available content tags."""
if not self.tags:
self.tags = set()
for content_item in self.content_info:
tags = content_item.get('tags', [])
for tag in tags:
if tag:
self.tags.add(tag)
# Get count
tag_count = {tag: 0 for tag in self.tags}
for tag in self.tags:
for content_item in self.content_info:
item_tags = content_item.get('tags', [])
if tag in item_tags:
tag_count[tag] += 1
logger.debug("TAGS: {0}".format(self.tags))
self.filter_widgets = []
for tag in sorted(self.tags):
count = tag_count[tag]
tag_text = "{0} ({1})".format(tag.capitalize(), count).strip()
item = ButtonToggle(tag_text)
item.setObjectName(tag.lower())
item.setChecked(self.config.get('checkboxes', tag.lower(), True))
item.clicked.connect(self.filter_content)
self.filter_widgets.append(item)
self.filters_layout.addWidget(item)
self.filters_layout.addWidget(SpacerHorizontal())
def filter_content(self, text=None):
"""
Filter content by a search string on all the fields of the item.
Using comma allows the use of several keywords, e.g. Peter,2015.
"""
text = self.text_filter.text().lower()
text = [t for t in re.split('\W', text) if t]
selected_tags = []
for item in self.filter_widgets:
tag_parts = item.text().lower().split()
tag = tag_parts[0]
# tag_count = tag_parts[-1]
if item.isChecked():
selected_tags.append(tag)
self.config.set('checkboxes', tag, True)
else:
self.config.set('checkboxes', tag, False)
for i in range(self.list.count()):
item = self.list.item(i)
all_checks = []
for t in text:
t = t.strip()
checks = (t in item.title.lower() or t in item.venue.lower() or
t in ' '.join(item.authors).lower() or
t in item.summary.lower())
all_checks.append(checks)
all_checks.append(
any(tag.lower() in selected_tags for tag in item.tags))
if all(all_checks):
item.setHidden(False)
else:
item.setHidden(True)
def set_content_list(self):
"""
Add items to the list, gradually.
Called by a timer.
"""
for i in range(self.step, self.step + self.step_size):
if i < len(self.content_info):
item = self.content_info[i]
banner = item.get('banner', '')
path = item.get('image_file_path', '')
content_item = ListItemContent(
title=item['title'],
subtitle=item.get('subtitle', "") or "",
uri=item['uri'],
date=item.get('date', '') or "",
summary=item.get('summary', '') or "",
tags=item.get('tags', []),
banner=banner,
path=path,
pixmap=self.default_pixmap, )
self.list.addItem(content_item)
# self.update_style_sheet(self.style_sheet)
# This allows the content to look for the pixmap
content_item.pixmaps = self.pixmaps
# Use images shipped with Navigator, if no image try the
# download
image_file = item.get('image_file', 'NaN')
local_image = os.path.join(LOGO_PATH, image_file)
if os.path.isfile(local_image):
self.pixmaps[path] = QPixmap(local_image)
else:
self.download_thumbnail(content_item, banner, path)
else:
self.timer_load.stop()
self.sig_ready.emit(self._tab_name)
break
self.step += self.step_size
self.filter_content()
def download_thumbnail(self, item, url, path):
"""Download all the video thumbnails."""
# Check url is not an empty string or not already downloaded
if url and url not in self._downloaded_thumbnail_urls:
self._downloaded_thumbnail_urls.append(url)
# For some content the app segfaults (with big files) so
# we dont use chunks
worker = self.api.download(url, path, chunked=True)
worker.url = url
worker.item = item
worker.path = path
worker.sig_finished.connect(self.convert_image)
logger.debug('Fetching thumbnail {}'.format(url))
def convert_image(self, worker, output, error):
"""
Load an image using PIL, and converts it to a QPixmap.
This was needed as some image libraries are not found in some OS.
"""
path = output
if path in self.pixmaps:
return
try:
if sys.platform == 'darwin' and PYQT4:
from PIL.ImageQt import ImageQt
from PIL import Image
if path:
image = Image.open(path)
image = ImageQt(image)
qt_image = QImage(image)
pixmap = QPixmap.fromImage(qt_image)
else:
pixmap = QPixmap()
else:
if path and os.path.isfile(path):
extension = path.split('.')[-1].upper()
if extension in ['PNG', 'JPEG', 'JPG']:
# This might be producing an error message on windows
# for some of the images
pixmap = QPixmap(path, format=extension)
else:
pixmap = QPixmap(path)
else:
pixmap = QPixmap()
self.pixmaps[path] = pixmap
except (IOError, OSError) as error:
logger.error(str(error))
def update_style_sheet(self, style_sheet=None):
"""Update custom CSS stylesheet."""
if style_sheet is None:
self.style_sheet = load_style_sheet()
else:
self.style_sheet = style_sheet
self.setStyleSheet(self.style_sheet)
self.list.update_style_sheet(self.style_sheet)
def ordered_widgets(self, next_widget=None):
"""Fix tab order of UI widgets."""
ordered_widgets = []
ordered_widgets += self.filter_widgets
ordered_widgets += [self.text_filter]
ordered_widgets += self.list.ordered_widgets()
return ordered_widgets
def __init__(self, parent=None, name=None, prefix=None):
"""Remove existing environment `name` dialog."""
super(RemoveDialog, self).__init__(parent=parent)
# Widgets
self.label_text = LabelBase('Do you want to remove the environment?')
self.label_name = LabelBase('Name:')
self.label_name_value = LabelBase(name)
self.label_location = LabelBase('Location:')
self.label_prefix = LabelBase(prefix)
self.button_cancel = ButtonNormal('Cancel')
self.button_ok = ButtonDanger('Remove')
# Setup
self.align_labels([self.label_name, self.label_location])
self.label_prefix.setObjectName('environment-location')
self.setWindowTitle('Remove environment')
self.setMinimumWidth(380)
self.label_name.setMinimumWidth(60)
self.label_location.setMinimumWidth(60)
# Layouts
layout_name = QHBoxLayout()
layout_name.addWidget(self.label_name)
layout_name.addWidget(SpacerHorizontal())
layout_name.addWidget(self.label_name_value)
layout_name.addStretch()
layout_location = QHBoxLayout()
layout_location.addWidget(self.label_location)
layout_location.addWidget(SpacerHorizontal())
layout_location.addWidget(self.label_prefix)
layout_location.addStretch()
layout_buttons = QHBoxLayout()
layout_buttons.addStretch()
layout_buttons.addWidget(self.button_cancel)
layout_buttons.addWidget(SpacerHorizontal())
layout_buttons.addWidget(self.button_ok)
layout = QVBoxLayout()
layout.addLayout(layout_name)
layout.addWidget(SpacerVertical())
layout.addLayout(layout_location)
layout.addWidget(SpacerVertical())
layout.addWidget(SpacerVertical())
layout.addLayout(layout_buttons)
self.setLayout(layout)
# Signals
self.button_ok.clicked.connect(self.accept)
self.button_cancel.clicked.connect(self.reject)
# Setup
self.update_location()
self.button_ok.setDisabled(False)
def __init__(self, parent, names, order, active):
super(LayoutSettingsDialog, self).__init__(parent)
# variables
self._parent = parent
self._selection_model = None
self.names = names
self.order = order
self.active = active
# widgets
self.button_move_up = QPushButton(_('Move Up'))
self.button_move_down = QPushButton(_('Move Down'))
self.button_delete = QPushButton(_('Delete Layout'))
self.button_box = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self)
self.group_box = QGroupBox(_("Layout Display and Order"))
self.table = QTableView(self)
self.ok_button = self.button_box.button(QDialogButtonBox.Ok)
self.cancel_button = self.button_box.button(QDialogButtonBox.Cancel)
self.cancel_button.setDefault(True)
self.cancel_button.setAutoDefault(True)
# widget setup
self.dialog_size = QSize(300, 200)
self.setMinimumSize(self.dialog_size)
self.setFixedSize(self.dialog_size)
self.setWindowTitle('Layout Settings')
self.table.setModel(LayoutModel(self.table, order, active))
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setSelectionMode(QAbstractItemView.SingleSelection)
self.table.verticalHeader().hide()
self.table.horizontalHeader().hide()
self.table.setAlternatingRowColors(True)
self.table.setShowGrid(False)
self.table.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.table.horizontalHeader().setStretchLastSection(True)
self.table.setColumnHidden(1, True)
# need to keep a reference for pyside not to segfault!
self._selection_model = self.table.selectionModel()
# layout
buttons_layout = QVBoxLayout()
buttons_layout.addWidget(self.button_move_up)
buttons_layout.addWidget(self.button_move_down)
buttons_layout.addStretch()
buttons_layout.addWidget(self.button_delete)
group_layout = QHBoxLayout()
group_layout.addWidget(self.table)
group_layout.addLayout(buttons_layout)
self.group_box.setLayout(group_layout)
layout = QVBoxLayout()
layout.addWidget(self.group_box)
layout.addWidget(self.button_box)
self.setLayout(layout)
# signals and slots
self.button_box.accepted.connect(self.accept)
self.button_box.rejected.connect(self.close)
self.button_delete.clicked.connect(self.delete_layout)
self.button_move_up.clicked.connect(lambda: self.move_layout(True))
self.button_move_down.clicked.connect(lambda: self.move_layout(False))
self.table.model().dataChanged.connect(
lambda: self.selection_changed(None, None))
self._selection_model.selectionChanged.connect(
lambda: self.selection_changed(None, None))
# focus table
index = self.table.model().index(0, 0)
self.table.setCurrentIndex(index)
self.table.setFocus()
def __init__(self,
parent=None,
tags=None,
content_urls=None,
content_path=CONTENT_PATH,
image_path=IMAGE_DATA_PATH,
config=CONF,
bundle_path=LINKS_INFO_PATH,
saved_content_path=CONTENT_JSON_PATH,
tab_name=''):
"""Community tab."""
super(CommunityTab, self).__init__(parent=parent)
self._tab_name = ''
self.content_path = content_path
self.image_path = image_path
self.bundle_path = bundle_path
self.saved_content_path = saved_content_path
self.config = config
self._parent = parent
self._downloaded_thumbnail_urls = []
self._downloaded_urls = []
self._downloaded_filepaths = []
self.api = AnacondaAPI()
self.content_urls = content_urls
self.content_info = []
self.step = 0
self.step_size = 1
self.tags = tags
self.timer_load = QTimer()
self.pixmaps = {}
self.filter_widgets = []
self.default_pixmap = QPixmap(VIDEO_ICON_PATH).scaled(
100, 60, Qt.KeepAspectRatio, Qt.FastTransformation)
# Widgets
self.text_filter = LineEditSearch()
self.list = ListWidgetContent()
self.frame_header = FrameTabHeader()
self.frame_content = FrameTabContent()
# Widget setup
self.timer_load.setInterval(333)
self.list.setAttribute(Qt.WA_MacShowFocusRect, False)
self.text_filter.setPlaceholderText('Search')
self.text_filter.setAttribute(Qt.WA_MacShowFocusRect, False)
self.setObjectName("Tab")
self.list.setMinimumHeight(200)
fm = self.text_filter.fontMetrics()
self.text_filter.setMaximumWidth(fm.width('M' * 23))
# Layouts
self.filters_layout = QHBoxLayout()
layout_header = QHBoxLayout()
layout_header.addLayout(self.filters_layout)
layout_header.addStretch()
layout_header.addWidget(self.text_filter)
self.frame_header.setLayout(layout_header)
layout_content = QHBoxLayout()
layout_content.addWidget(self.list)
self.frame_content.setLayout(layout_content)
layout = QVBoxLayout()
layout.addWidget(self.frame_header)
layout.addWidget(self.frame_content)
self.setLayout(layout)
# Signals
self.timer_load.timeout.connect(self.set_content_list)
self.text_filter.textChanged.connect(self.filter_content)
def __init__(self, parent=None):
"""Import environment from environment specification dialog."""
super(ImportDialog, self).__init__(parent=parent)
self.environments = None
self.env_dirs = None
self.selected_file_filter = None
# Widgets
self.label_name = LabelBase("Name:")
self.label_location = LabelBase("Location:")
self.label_path = LabelBase("Specification File")
self.text_name = LineEditBase()
self.label_prefix = LabelBase("")
self.text_path = LineEditBase()
self.button_path = ButtonNormal("")
self.button_cancel = ButtonNormal('Cancel')
self.button_ok = ButtonPrimary('Import')
# Widgets setup
self.align_labels(
[self.label_name, self.label_location, self.label_path])
self.label_prefix.setObjectName('environment-location')
self.button_path.setObjectName('import')
self.button_ok.setDefault(True)
self.text_path.setPlaceholderText("File to import from")
self.text_name.setPlaceholderText("New environment name")
self.setMinimumWidth(self.BASE_DIALOG_WIDTH)
self.setWindowTitle("Import new environment")
self.text_name.setValidator(self.get_regex_validator())
# Layouts
layout_infile = QHBoxLayout()
layout_infile.addWidget(self.text_path)
layout_infile.addWidget(SpacerHorizontal())
layout_infile.addWidget(self.button_path)
layout_grid = QGridLayout()
layout_grid.addWidget(self.label_name, 0, 0)
layout_grid.addWidget(SpacerHorizontal(), 0, 1)
layout_grid.addWidget(self.text_name, 0, 2)
layout_grid.addWidget(SpacerVertical(), 1, 0)
layout_grid.addWidget(self.label_location, 2, 0)
layout_grid.addWidget(SpacerHorizontal(), 2, 1)
layout_grid.addWidget(self.label_prefix, 2, 2)
layout_grid.addWidget(SpacerVertical(), 3, 0)
layout_grid.addWidget(self.label_path, 4, 0)
layout_grid.addWidget(SpacerHorizontal(), 4, 1)
layout_grid.addLayout(layout_infile, 4, 2)
layout_buttons = QHBoxLayout()
layout_buttons.addStretch()
layout_buttons.addWidget(self.button_cancel)
layout_buttons.addWidget(SpacerHorizontal())
layout_buttons.addWidget(self.button_ok)
layout = QVBoxLayout()
layout.addLayout(layout_grid)
layout.addWidget(SpacerVertical())
layout.addWidget(SpacerVertical())
layout.addLayout(layout_buttons)
self.setLayout(layout)
# Signals
self.button_ok.clicked.connect(self.accept)
self.button_cancel.clicked.connect(self.reject)
self.button_path.clicked.connect(self.choose)
self.text_path.textChanged.connect(self.refresh)
self.text_name.textChanged.connect(self.refresh)
# Setup
self.text_name.setFocus()
self.refresh()
class AddCycleData(AddDataTableMixin, QWidget):
""" QWidget containing a QTableWidget, where users can add new data.
User input is validated live; it is not possible to submit invalid data.
"""
newData = Signal(dict)
""" **signal** newData(dict `data`)
Emitted with a dict to be appended to the DataFrame.
"""
rowRemoved = Signal()
""" **signal** rowRemoved()
Emitted when the current row is removed from the table.
"""
def __init__(self, widthSpace=10):
super().__init__()
self.widthSpace = widthSpace
self._clicked = []
self._makeEmptyRow()
self.table.currentCellChanged.connect(self._cellClicked)
self.addLineButton = QPushButton("New line")
self.rmvLineButton = QPushButton("Remove line")
self.rmvLineButton.setToolTip("Remove currently selected line")
self.okButton = QPushButton("Ok")
try:
self.okButton.setShortcut(Qt.Key_Enter)
except:
self.okButton.setShortcut(QKeySequence(Qt.Key_Enter))
self.addLineButton.clicked.connect(self._makeEmptyRow)
self.rmvLineButton.clicked.connect(self._removeSelectedRow)
self.okButton.clicked.connect(self._addData)
self.buttonLayout = QHBoxLayout()
self.buttonLayout.addWidget(self.addLineButton)
self.buttonLayout.addWidget(self.rmvLineButton)
self.buttonLayout.addWidget(self.okButton)
self.buttonLayout.addStretch()
self.layout = QVBoxLayout()
self.layout.addLayout(self.buttonLayout)
self.layout.addWidget(self.table)
self.setLayout(self.layout)
msg = "Add new session(s) data to viewer and plot."
self.setToolTip(msg)
def sizeHint(self):
# can't believe this is necessary...
width = self.table.verticalHeader().length() + self.widthSpace
for i in range(self.table.columnCount()):
width += self.table.columnWidth(i)
height = self.table.sizeHint().height()
return QSize(width, height)
@Slot(int, int)
def _cellClicked(self, row, col):
if (row, col) not in self._clicked:
self._clicked.append((row, col))
@Slot()
def _makeEmptyRow(self):
""" Add a new row to the end of the table, with today's date in the
'Date' field and the rest blank.
"""
today = datetime.today()
month = calendar.month_abbr[today.month]
date = f"{today.day} {month} {today.year}"
row = self.table.rowCount()
self.table.insertRow(row)
item = TableWidgetDateItem(date)
item.setTextAlignment(Qt.AlignCenter)
self.table.setItem(row, 0, item)
for i in range(len(self.headerLabels[1:])):
item = QTableWidgetItem()
item.setTextAlignment(Qt.AlignCenter)
self.table.setItem(row, i + 1, item)
self._clicked = [item for item in self._clicked if item[0] != row]
self._cellClicked(row, 0)
@Slot()
def _removeSelectedRow(self):
""" Remove the currently selected row from the table. """
row = self.table.currentRow()
self._clicked = [item for item in self._clicked if item[0] != row]
self.table.removeRow(row)
self.rowRemoved.emit()
@Slot()
def _addData(self):
""" Take all data from the table and emit it as a list of dicts with
the `newData` signal, then clear the table.
"""
self.table.focusNextChild()
valid = self._validate()
if not valid:
return None
values = self._getValues()
self.newData.emit(values)
for row in reversed(range(self.table.rowCount())):
self.table.removeRow(row)
self._clicked = []
self._makeEmptyRow()
def __init__(self, parent=None, api=None):
"""Create new environment dialog."""
super(CreateDialog, self).__init__(parent=parent, api=api)
# Widgets
self.label_name = LabelBase("Name:")
self.label_location = LabelBase("Location:")
self.label_prefix = LabelBase('')
self.text_name = LineEditBase()
self.label_version = LabelBase("Python version")
self.label_packages = LabelBase("Packages:")
self.combo_version = ComboBoxBase()
self.check_python = CheckBoxBase("Python")
self.check_r = CheckBoxBase('R')
self.combo_r_type = ComboBoxBase()
self.button_ok = ButtonPrimary('Create')
self.button_cancel = ButtonNormal('Cancel')
# Widgets setup
self.align_labels(
[self.label_name, self.label_location, self.label_packages])
self.text_name.setPlaceholderText("New environment name")
self.setMinimumWidth(self.BASE_DIALOG_WIDTH)
self.setWindowTitle("Create new environment")
self.text_name.setValidator(self.get_regex_validator())
self.label_prefix.setObjectName('environment-location')
self.combo_version.setObjectName('package-version')
self.combo_r_type.setObjectName('r-type')
# Supported set of python versions
self.combo_version.setDisabled(True)
r_types = [self.R]
self.combo_r_type.clear()
self.combo_r_type.addItems(r_types)
self.combo_r_type.setCurrentIndex(0)
self.combo_r_type.setEnabled(len(r_types) != 1)
# Layouts
layout_packages = QGridLayout()
layout_packages.addWidget(self.check_python, 0, 0)
layout_packages.addWidget(SpacerHorizontal(), 0, 1)
layout_packages.addWidget(self.combo_version, 0, 2)
layout_packages.addWidget(SpacerVertical(), 1, 0)
layout_packages.addWidget(self.check_r, 2, 0)
layout_packages.addWidget(SpacerHorizontal(), 2, 1)
layout_packages.addWidget(self.combo_r_type, 2, 2)
grid = QGridLayout()
grid.addWidget(self.label_name, 0, 0, 1, 1)
grid.addWidget(SpacerHorizontal(), 0, 1, 1, 1)
grid.addWidget(self.text_name, 0, 2, 1, 4)
grid.addWidget(SpacerVertical(), 1, 0, 1, 1)
grid.addWidget(self.label_location, 2, 0, 1, 1)
grid.addWidget(SpacerHorizontal(), 2, 1, 1, 1)
grid.addWidget(self.label_prefix, 2, 2, 1, 4)
grid.addWidget(SpacerVertical(), 3, 0, 1, 1)
grid.addWidget(self.label_packages, 4, 0, 1, 1)
grid.addWidget(SpacerHorizontal(), 4, 1, 1, 1)
grid.addLayout(layout_packages, 4, 2, 3, 1)
layout_buttons = QHBoxLayout()
layout_buttons.addStretch()
layout_buttons.addWidget(self.button_cancel)
layout_buttons.addWidget(SpacerHorizontal())
layout_buttons.addWidget(self.button_ok)
main_layout = QVBoxLayout()
main_layout.addLayout(grid)
main_layout.addWidget(SpacerVertical())
main_layout.addWidget(SpacerVertical())
main_layout.addLayout(layout_buttons)
self.setLayout(main_layout)
# Signals
self.button_ok.clicked.connect(self.accept)
self.button_cancel.clicked.connect(self.reject)
self.text_name.textChanged.connect(self.refresh)
self.check_python.stateChanged.connect(self.refresh)
self.check_r.stateChanged.connect(self.refresh)
self.sig_setup_ready.connect(self.update_mro)
self.sig_setup_ready.connect(self.update_pyversions)
# Setup
self.text_name.setFocus()
self.check_python.setChecked(True)
self.check_r.setChecked(False)
self.refresh()
def __init__(self, parent=None, formats=None):
super(BaseConsole, self).__init__(parent)
self.edit = edit = InputArea()
self.pbar = pbar = PromptArea(
edit, self._get_prompt_text, PromptHighlighter(formats=formats))
layout = QHBoxLayout()
layout.addWidget(pbar)
layout.addWidget(edit)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
self._prompt_doc = ['']
self._prompt_pos = 0
self._output_inserted = False
self._tab_chars = 4 * ' '
self._ctrl_d_exits = False
self._copy_buffer = ''
self._last_input = ''
self._more = False
self._current_line = 0
self._ps1 = 'IN [%s]: '
self._ps2 = '...: '
self._ps_out = 'OUT[%s]: '
self._ps = self._ps1 % self._current_line
self.stdin = Stream()
self.stdout = Stream()
self.stdout.write_event.connect(self._stdout_data_handler)
# show frame around both child widgets:
self.setFrameStyle(edit.frameStyle())
edit.setFrameStyle(QFrame.NoFrame)
font = edit.document().defaultFont()
font.setFamily("Courier New")
font_width = QFontMetrics(font).width('M')
self.setFont(font)
geometry = edit.geometry()
geometry.setWidth(font_width*80+20)
geometry.setHeight(font_width*40)
edit.setGeometry(geometry)
edit.resize(font_width*80+20, font_width*40)
edit.setReadOnly(True)
edit.setTextInteractionFlags(
Qt.TextSelectableByMouse |
Qt.TextSelectableByKeyboard)
self.setFocusPolicy(Qt.NoFocus)
pbar.setFocusPolicy(Qt.NoFocus)
edit.setFocusPolicy(Qt.StrongFocus)
edit.setFocus()
edit.installEventFilter(self)
self._key_event_handlers = self._get_key_event_handlers()
self.command_history = CommandHistory(self)
self.auto_complete = jedi and AutoComplete(self)
self._show_ps()
def __init__(self, parent, max_entries=100, options_button=None):
QWidget.__init__(self, parent)
self.setWindowTitle("Pylint")
self.output = None
self.error_output = None
self.max_entries = max_entries
self.rdata = []
if osp.isfile(self.DATAPATH):
try:
data = pickle.loads(open(self.DATAPATH, 'rb').read())
if data[0] == self.VERSION:
self.rdata = data[1:]
except (EOFError, ImportError):
pass
self.filecombo = PythonModulesComboBox(self)
self.start_button = create_toolbutton(self, icon=ima.icon('run'),
text=_("Analyze"),
tip=_("Run analysis"),
triggered=self.start, text_beside_icon=True)
self.stop_button = create_toolbutton(self,
icon=ima.icon('stop'),
text=_("Stop"),
tip=_("Stop current analysis"),
text_beside_icon=True)
self.filecombo.valid.connect(self.start_button.setEnabled)
self.filecombo.valid.connect(self.show_data)
browse_button = create_toolbutton(self, icon=ima.icon('fileopen'),
tip=_('Select Python file'),
triggered=self.select_file)
self.ratelabel = QLabel()
self.datelabel = QLabel()
self.log_button = create_toolbutton(self, icon=ima.icon('log'),
text=_("Output"),
text_beside_icon=True,
tip=_("Complete output"),
triggered=self.show_log)
self.treewidget = ResultsTree(self)
hlayout1 = QHBoxLayout()
hlayout1.addWidget(self.filecombo)
hlayout1.addWidget(browse_button)
hlayout1.addWidget(self.start_button)
hlayout1.addWidget(self.stop_button)
if options_button:
hlayout1.addWidget(options_button)
hlayout2 = QHBoxLayout()
hlayout2.addWidget(self.ratelabel)
hlayout2.addStretch()
hlayout2.addWidget(self.datelabel)
hlayout2.addStretch()
hlayout2.addWidget(self.log_button)
layout = QVBoxLayout()
layout.addLayout(hlayout1)
layout.addLayout(hlayout2)
layout.addWidget(self.treewidget)
self.setLayout(layout)
self.process = None
self.set_running_state(False)
self.show_data()
if self.rdata:
self.remove_obsolete_items()
self.filecombo.addItems(self.get_filenames())
else:
self.start_button.setEnabled(False)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.dir = None
self.runconf = RunConfiguration()
firstrun_o = CONF.get('run', ALWAYS_OPEN_FIRST_RUN_OPTION, False)
# --- Interpreter ---
interpreter_group = QGroupBox(_("Console"))
interpreter_layout = QVBoxLayout()
interpreter_group.setLayout(interpreter_layout)
self.current_radio = QRadioButton(CURRENT_INTERPRETER)
interpreter_layout.addWidget(self.current_radio)
self.dedicated_radio = QRadioButton(DEDICATED_INTERPRETER)
interpreter_layout.addWidget(self.dedicated_radio)
self.systerm_radio = QRadioButton(SYSTERM_INTERPRETER)
interpreter_layout.addWidget(self.systerm_radio)
# --- General settings ----
common_group = QGroupBox(_("General settings"))
common_layout = QGridLayout()
common_group.setLayout(common_layout)
self.clear_var_cb = QCheckBox(CLEAR_ALL_VARIABLES)
common_layout.addWidget(self.clear_var_cb, 0, 0)
self.post_mortem_cb = QCheckBox(POST_MORTEM)
common_layout.addWidget(self.post_mortem_cb, 1, 0)
self.clo_cb = QCheckBox(_("Command line options:"))
common_layout.addWidget(self.clo_cb, 2, 0)
self.clo_edit = QLineEdit()
self.clo_cb.toggled.connect(self.clo_edit.setEnabled)
self.clo_edit.setEnabled(False)
common_layout.addWidget(self.clo_edit, 2, 1)
# --- Working directory ---
wdir_group = QGroupBox(_("Working Directory settings"))
wdir_layout = QVBoxLayout()
wdir_group.setLayout(wdir_layout)
self.file_dir_radio = QRadioButton(FILE_DIR)
wdir_layout.addWidget(self.file_dir_radio)
self.cwd_radio = QRadioButton(CW_DIR)
wdir_layout.addWidget(self.cwd_radio)
fixed_dir_layout = QHBoxLayout()
self.fixed_dir_radio = QRadioButton(FIXED_DIR)
fixed_dir_layout.addWidget(self.fixed_dir_radio)
self.wd_edit = QLineEdit()
self.fixed_dir_radio.toggled.connect(self.wd_edit.setEnabled)
self.wd_edit.setEnabled(False)
fixed_dir_layout.addWidget(self.wd_edit)
browse_btn = QPushButton(ima.icon('DirOpenIcon'), '', self)
browse_btn.setToolTip(_("Select directory"))
browse_btn.clicked.connect(self.select_directory)
fixed_dir_layout.addWidget(browse_btn)
wdir_layout.addLayout(fixed_dir_layout)
# --- System terminal ---
external_group = QGroupBox(_("External system terminal"))
external_group.setDisabled(True)
self.systerm_radio.toggled.connect(external_group.setEnabled)
external_layout = QGridLayout()
external_group.setLayout(external_layout)
self.interact_cb = QCheckBox(INTERACT)
external_layout.addWidget(self.interact_cb, 1, 0, 1, -1)
self.pclo_cb = QCheckBox(_("Command line options:"))
external_layout.addWidget(self.pclo_cb, 3, 0)
self.pclo_edit = QLineEdit()
self.pclo_cb.toggled.connect(self.pclo_edit.setEnabled)
self.pclo_edit.setEnabled(False)
self.pclo_edit.setToolTip(
_("<b>-u</b> is added to the "
"other options you set here"))
external_layout.addWidget(self.pclo_edit, 3, 1)
# Checkbox to preserve the old behavior, i.e. always open the dialog
# on first run
hline = QFrame()
hline.setFrameShape(QFrame.HLine)
hline.setFrameShadow(QFrame.Sunken)
self.firstrun_cb = QCheckBox(ALWAYS_OPEN_FIRST_RUN % _("this dialog"))
self.firstrun_cb.clicked.connect(self.set_firstrun_o)
self.firstrun_cb.setChecked(firstrun_o)
layout = QVBoxLayout()
layout.addWidget(interpreter_group)
layout.addWidget(common_group)
layout.addWidget(wdir_group)
layout.addWidget(external_group)
layout.addWidget(hline)
layout.addWidget(self.firstrun_cb)
self.setLayout(layout)
def create_layout(self):
cancel_box = QHBoxLayout()
cancel_box.addWidget(self.close_button)
grid1 = QGridLayout()
grid2 = QGridLayout()
#-----------------------------------------
# setup
self.radio_rectangular = QRadioButton('Rectangular')
self.radio_cylindrical = QRadioButton('Cylindrical')
self.radio_spherical = QRadioButton('Spherical')
coord_type_layout = QHBoxLayout()
coord_type_layout.addWidget(self.radio_rectangular)
coord_type_layout.addWidget(self.radio_cylindrical)
coord_type_layout.addWidget(self.radio_spherical)
location_layout = QHBoxLayout()
location_layout.addWidget(self.location_x_edit)
location_layout.addWidget(self.location_y_edit)
location_layout.addWidget(self.location_z_edit)
checkboxs = QButtonGroup(self)
checkboxs.addButton(self.checkbox_show)
checkboxs.addButton(self.checkbox_hide)
vbox1 = QVBoxLayout()
vbox1.addWidget(self.checkbox_show)
vbox1.addWidget(self.checkbox_hide)
#vbox1.addLayout(checkboxs)
#-----------------------------------------
irow = 0
grid1.addWidget(self.all_nodes_header, irow, 0)
irow += 1
grid1.addWidget(self.color, irow, 0)
grid1.addWidget(self.color_edit, irow, 1)
irow += 1
grid1.addWidget(self.opacity, irow, 0)
grid1.addWidget(self.opacity_edit, irow, 1)
irow += 1
grid1.addWidget(self.point_size, irow, 0)
grid1.addWidget(self.point_size_edit, irow, 1)
irow += 1
#-----------------------------------------
irow = 0
grid2.addWidget(self.nodes_header, irow, 0)
irow += 1
grid2.addWidget(self.name, irow, 0)
grid2.addWidget(self.name_edit, irow, 1)
irow += 1
grid2.addWidget(self.description, irow, 0)
grid2.addWidget(self.description_edit, irow, 1)
irow += 1
#| All Nodes: |
#| Color red |
#| PointSize 3 |
#| Opacity 0.3 |
#| Show/Hide |
#| |
#| Name LEwingTip |
#| Location X Y Z |
#| Coord 0 |
#| CoordType R, C, S |
#| |
#| Previous Next |
grid2.addWidget(self.coord, irow, 0)
grid2.addWidget(self.coord_edit, irow, 1)
irow += 1
grid2.addWidget(self.coord_type, irow, 0)
grid2.addLayout(coord_type_layout, irow, 1)
irow += 1
grid2.addWidget(self.location, irow, 0)
grid2.addLayout(location_layout, irow, 1)
irow += 1
#------------------------------------
vbox = QVBoxLayout()
vbox.addLayout(grid1)
vbox.addLayout(vbox1)
vbox.addStretch()
vbox.addWidget(self.table)
vbox.addLayout(grid2)
vbox.addStretch()
#vbox.addWidget(self.check_apply)
vbox.addLayout(cancel_box)
self.setLayout(vbox)
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.current_radio = None
self.dedicated_radio = None
self.systerm_radio = None
self.runconf = RunConfiguration()
firstrun_o = CONF.get('run', ALWAYS_OPEN_FIRST_RUN_OPTION, False)
# --- General settings ----
common_group = QGroupBox(_("General settings"))
common_layout = QGridLayout()
common_group.setLayout(common_layout)
self.clear_var_cb = QCheckBox(CLEAR_ALL_VARIABLES)
common_layout.addWidget(self.clear_var_cb, 0, 0)
self.clo_cb = QCheckBox(_("Command line options:"))
common_layout.addWidget(self.clo_cb, 1, 0)
self.clo_edit = QLineEdit()
self.clo_cb.toggled.connect(self.clo_edit.setEnabled)
self.clo_edit.setEnabled(False)
common_layout.addWidget(self.clo_edit, 1, 1)
self.wd_cb = QCheckBox(_("Working directory:"))
common_layout.addWidget(self.wd_cb, 2, 0)
wd_layout = QHBoxLayout()
self.wd_edit = QLineEdit()
self.wd_cb.toggled.connect(self.wd_edit.setEnabled)
self.wd_edit.setEnabled(False)
wd_layout.addWidget(self.wd_edit)
browse_btn = QPushButton(ima.icon('DirOpenIcon'), '', self)
browse_btn.setToolTip(_("Select directory"))
browse_btn.clicked.connect(self.select_directory)
wd_layout.addWidget(browse_btn)
common_layout.addLayout(wd_layout, 2, 1)
self.post_mortem_cb = QCheckBox(_("Enter debugging mode when "
"errors appear during execution"))
common_layout.addWidget(self.post_mortem_cb)
# --- Interpreter ---
interpreter_group = QGroupBox(_("Console"))
interpreter_layout = QVBoxLayout()
interpreter_group.setLayout(interpreter_layout)
self.current_radio = QRadioButton(CURRENT_INTERPRETER)
interpreter_layout.addWidget(self.current_radio)
self.dedicated_radio = QRadioButton(DEDICATED_INTERPRETER)
interpreter_layout.addWidget(self.dedicated_radio)
self.systerm_radio = QRadioButton(SYSTERM_INTERPRETER)
interpreter_layout.addWidget(self.systerm_radio)
# --- Dedicated interpreter ---
new_group = QGroupBox(_("Dedicated Python console"))
self.current_radio.toggled.connect(new_group.setDisabled)
new_layout = QGridLayout()
new_group.setLayout(new_layout)
self.interact_cb = QCheckBox(_("Interact with the Python "
"console after execution"))
new_layout.addWidget(self.interact_cb, 1, 0, 1, -1)
self.show_kill_warning_cb = QCheckBox(_("Show warning when killing"
" running process"))
new_layout.addWidget(self.show_kill_warning_cb, 2, 0, 1, -1)
self.pclo_cb = QCheckBox(_("Command line options:"))
new_layout.addWidget(self.pclo_cb, 3, 0)
self.pclo_edit = QLineEdit()
self.pclo_cb.toggled.connect(self.pclo_edit.setEnabled)
self.pclo_edit.setEnabled(False)
self.pclo_edit.setToolTip(_("<b>-u</b> is added to the "
"other options you set here"))
new_layout.addWidget(self.pclo_edit, 3, 1)
# Checkbox to preserve the old behavior, i.e. always open the dialog
# on first run
hline = QFrame()
hline.setFrameShape(QFrame.HLine)
hline.setFrameShadow(QFrame.Sunken)
self.firstrun_cb = QCheckBox(ALWAYS_OPEN_FIRST_RUN % _("this dialog"))
self.firstrun_cb.clicked.connect(self.set_firstrun_o)
self.firstrun_cb.setChecked(firstrun_o)
layout = QVBoxLayout()
layout.addWidget(interpreter_group)
layout.addWidget(common_group)
layout.addWidget(new_group)
layout.addWidget(hline)
layout.addWidget(self.firstrun_cb)
self.setLayout(layout)
def setup_layout(self, data, choices, clear_data=True, init=True):
"""creates the sidebar visual layout"""
if not init:
#self.frameGeometry().
width = self.frameGeometry().width()
height = self.frameGeometry().height()
#print('width=%s height=%s' % (width, height))
#print('init...')
vbox = QVBoxLayout()
hbox = QHBoxLayout()
irow = 0
self._add_from_setup_dict(vbox, irow)
hbox.addWidget(self.name_label)
hbox.addWidget(self.name_pulldown)
vbox.addLayout(hbox)
irow += 1
self._add_from_setup_dict(vbox, irow)
nwindows = len(self.result_case_windows)
#print('nwindows=%s self.names=%s' % (nwindows, self.names))
for i in range(nwindows):
#print('*using existing window')
result_case_window = self.result_case_windows[i]
vbox.addWidget(result_case_window)
#result_case_window.setVisible(False) # be very careful of this...
nwindows = len(self.result_case_windows)
for name in self.names[nwindows:]:
#print('*creating a window')
result_case_window = ResultsWindow(self, 'Case/Results', data, choices)
result_case_window.setVisible(False)
vbox.addWidget(result_case_window)
self.result_case_windows.append(result_case_window)
iname = 0
#if self.name is None:
#iname = 0
#else:
#iname = self.names.index(self.name)
#for i in range(nwindows):
#if i != iname:
#self.result_case_windows[iname].setVisible(False)
#self.result_case_windows[iname].setVisible(True)
irow += 1
self._add_from_setup_dict(vbox, irow)
if self.result_method_window:
vbox.addWidget(self.result_method_window)
if self.show_pulldown:
vbox.addWidget(self.pulldown)
irow += 1
self._add_from_setup_dict(vbox, irow)
vbox.addWidget(self.apply_button)
irow += 1
self._add_from_setup_dict(vbox, irow)
self.setLayout(vbox)
if clear_data:
self.clear_data()
