def setup_ui(self):
main = QHBoxLayout()
sub = QVBoxLayout()
for i in range(10):
sub.addWidget(QLabel(str(i)))
main.addLayout(sub)
self.setLayout(main)
def create_scedit(self,
text,
option,
default=NoDefault,
tip=None,
without_layout=False,
section=None):
label = QLabel(text)
clayout = ColorLayout(QColor(Qt.black), self)
clayout.lineedit.setMaximumWidth(80)
if tip is not None:
clayout.setToolTip(tip)
cb_bold = QCheckBox()
cb_bold.setIcon(ima.icon('bold'))
cb_bold.setToolTip(_("Bold"))
cb_italic = QCheckBox()
cb_italic.setIcon(ima.icon('italic'))
cb_italic.setToolTip(_("Italic"))
self.scedits[(clayout, cb_bold, cb_italic)] = (section, option,
default)
if without_layout:
return label, clayout, cb_bold, cb_italic
layout = QHBoxLayout()
layout.addWidget(label)
layout.addLayout(clayout)
layout.addSpacing(10)
layout.addWidget(cb_bold)
layout.addWidget(cb_italic)
layout.addStretch(1)
layout.setContentsMargins(0, 0, 0, 0)
widget = QWidget(self)
widget.setLayout(layout)
return widget
def __init__(self):
super(AdvancedTab, self).__init__()
# Widgets
self.button_cluster = QPushButton(qta.icon('fa.sitemap'), 'Cluster')
self.button_service = QPushButton(qta.icon('fa.database'), 'Services')
self.button_auth = QPushButton(qta.icon('fa.lock'), 'Auth')
self.widget = QWidget()
# Layouts
buttons_layout = QVBoxLayout()
buttons_layout.addWidget(self.button_cluster)
buttons_layout.addWidget(self.button_service)
buttons_layout.addWidget(self.button_auth)
buttons_layout.addStretch()
layout = QHBoxLayout()
layout.addLayout(buttons_layout)
layout.addStretch()
main_layout = QVBoxLayout()
main_layout.addWidget(self.widget)
self.widget.setLayout(layout)
self.setLayout(main_layout)
# Signals
self.button_auth.clicked.connect(self.ask_havoc)
self.button_service.clicked.connect(self.ask_havoc)
self.button_cluster.clicked.connect(self.ask_havoc)
def __init__(self, *args, **kwargs):
"""About dialog."""
super(AboutDialog, self).__init__(*args, **kwargs)
# Variables
text = """<b>Anaconda Navigator {version}</b><br>
<br>Copyright © 2016 Anaconda, Inc.
<p>Created by Anaconda
<br>
<p>For bug reports and feature requests, please visit our
""".format(version=__version__)
# Widgets
self.widget_icon = QSvgWidget(images.ANACONDA_LOGO)
self.label_about = QLabel(text)
self.button_link = ButtonLink('Issue Tracker')
self.button_label = ButtonLabel('on GitHub.')
self.button_ok = ButtonNormal('Ok')
# Widgets setup
self.widget_icon.setFixedSize(self.widget_icon.size_for_width(100))
self.button_ok.setMinimumWidth(70)
self.button_ok.setDefault(True)
self.setWindowTitle("About Anaconda Navigator")
# Layouts
layout_h = QHBoxLayout()
layout_h.addWidget(self.widget_icon, 0, Qt.AlignTop)
layout_h.addWidget(SpacerHorizontal())
layout_content = QVBoxLayout()
layout_content.addWidget(self.label_about, 0, Qt.AlignBottom)
layout_content_h = QHBoxLayout()
layout_content_h.addWidget(self.button_link, 0, Qt.AlignLeft)
layout_content_h.addWidget(self.button_label, 0, Qt.AlignLeft)
layout_content_h.addStretch(0)
layout_content.addLayout(layout_content_h)
layout_h.addLayout(layout_content)
layout_buttons = QHBoxLayout()
layout_buttons.addStretch()
layout_buttons.addWidget(self.button_ok)
layout_main = QVBoxLayout()
layout_main.addLayout(layout_h)
layout_main.addWidget(SpacerVertical())
layout_main.addWidget(SpacerVertical())
layout_main.addLayout(layout_buttons)
self.setLayout(layout_main)
# Signals
self.button_link.clicked.connect(
lambda: self.sig_url_clicked.
emit(self.GITHUB_URL, 'content', 'click')
)
self.button_ok.clicked.connect(self.accept)
# Setup
self.button_ok.setFocus()
def __init__(self, channel=None, location=None):
"""Conda channels list widget item used in CSS styling."""
super(ListWidgetItemChannel, self).__init__()
self.channel = channel if channel else ''
self.location = location if location else ''
# Widgets
self.widget = FrameChannels()
self.label_location = LabelConfigLocation(location)
self.text_channel = LineEditChannel()
self.label_info = LabelChannelInfo()
self.button_remove = ButtonRemoveChannel()
# Widgets setup
self.button_remove.setVisible(path_is_writable(location))
self.text_channel.setText(channel)
# Layouts
layout_name = QVBoxLayout()
layout_name.addWidget(self.text_channel)
layout_name.addWidget(self.label_location)
self.label_location.setToolTip(location)
layout_frame = QHBoxLayout()
layout_frame.addLayout(layout_name)
layout_frame.addStretch()
layout_frame.addWidget(self.label_info)
layout_frame.addWidget(self.button_remove)
self.widget.setLayout(layout_frame)
self.setSizeHint(self.widget_size())
def __init__(self, model, *args, **kwargs):
super().__init__(*args, **kwargs)
self.model = model
vbox = QVBoxLayout()
hbox = QHBoxLayout()
hbox.addWidget(QtReEnvironmentControls(model))
hbox.addWidget(QtReQueueControls(model))
hbox.addWidget(QtReExecutionControls(model))
hbox.addWidget(QtReStatusMonitor(model))
hbox.addStretch()
vbox.addLayout(hbox)
hbox = QHBoxLayout()
vbox1 = QVBoxLayout()
# Register plan editor (opening plans in the editor by double-clicking the plan in the table)
pe = QtRePlanEditor(model)
pq = QtRePlanQueue(model)
pq.registered_item_editors.append(pe.edit_queue_item)
vbox1.addWidget(pe, stretch=1)
vbox1.addWidget(pq, stretch=1)
hbox.addLayout(vbox1)
vbox2 = QVBoxLayout()
vbox2.addWidget(QtReRunningPlan(model), stretch=1)
vbox2.addWidget(QtRePlanHistory(model), stretch=2)
hbox.addLayout(vbox2)
vbox.addLayout(hbox)
self.setLayout(vbox)
def setup_ui(self):
main = QHBoxLayout()
sub = QVBoxLayout()
for i in range(10):
sub.addWidget(QLabel(str(i)))
main.addLayout(sub)
self.setLayout(main)
def __init__(self, model, *args, **kwargs):
super().__init__(*args, **kwargs)
self.model = model
vbox = QVBoxLayout()
hbox = QHBoxLayout()
hbox.addWidget(QtReManagerConnection(model))
hbox.addWidget(QtReEnvironmentControls(model))
hbox.addWidget(QtReQueueControls(model))
hbox.addWidget(QtReExecutionControls(model))
hbox.addWidget(QtReStatusMonitor(model))
hbox.addStretch()
vbox.addLayout(hbox)
hbox = QHBoxLayout()
vbox1 = QVBoxLayout()
vbox1.addWidget(QtRePlanEditor(model), stretch=1)
vbox1.addWidget(QtRePlanQueue(model), stretch=1)
hbox.addLayout(vbox1)
vbox2 = QVBoxLayout()
vbox2.addWidget(QtReRunningPlan(model), stretch=1)
vbox2.addWidget(QtRePlanHistory(model), stretch=2)
hbox.addLayout(vbox2)
vbox.addLayout(hbox)
self.setLayout(vbox)
def setupui(self):
"""."""
gdl = QGridLayout(self)
gdl.setContentsMargins(0, 0, 0, 0)
scr_ar = QScrollArea(self)
gdl.addWidget(scr_ar, 0, 0, 1, 1)
scr_ar.setSizeAdjustPolicy(QScrollArea.AdjustToContentsOnFirstShow)
scr_ar.setWidgetResizable(True)
scr_ar_wid = QWidget()
scr_ar.setWidget(scr_ar_wid)
scr_ar_wid.setObjectName('scr_ar_wid')
scr_ar_wid.setStyleSheet("""
#scr_ar_wid{
min-width:40em; min-height:10em;
background-color: transparent;
}""")
hbl = QHBoxLayout(scr_ar_wid)
hbl.setContentsMargins(0, 0, 0, 0)
vbl = QVBoxLayout()
hbl.addLayout(vbl)
self.registers = []
for i in range(self._nr_registers):
reg = OrbitRegister(self,
self.device,
self._orbits,
i + 1,
prefix=self.prefix,
acc=self.acc)
vbl.addWidget(reg)
self.registers.append(reg)
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 create_coloredit(self,
text,
option,
default=NoDefault,
tip=None,
without_layout=False,
section=None):
if section is not None and section != self.CONF_SECTION:
self.cross_section_options[option] = section
label = QLabel(text)
clayout = ColorLayout(QColor(Qt.black), self)
clayout.lineedit.setMaximumWidth(80)
if tip is not None:
clayout.setToolTip(tip)
self.coloredits[clayout] = (section, option, default)
if without_layout:
return label, clayout
layout = QHBoxLayout()
layout.addWidget(label)
layout.addLayout(clayout)
layout.addStretch(1)
layout.setContentsMargins(0, 0, 0, 0)
widget = QWidget(self)
widget.setLayout(layout)
return widget
def __init__(self, settings: StackSettings, parent=None):
super().__init__(parent)
self.settings = settings
self.calculate_btn = QPushButton("Calculate")
self.calculate_btn.clicked.connect(self.calculate)
self.result_view = QTableWidget()
self.channel_select = ChannelComboBox()
self.units_select = EnumComboBox(Units)
self.units_select.set_value(self.settings.get("simple_measurements.units", Units.nm))
self.units_select.currentIndexChanged.connect(self.change_units)
layout = QHBoxLayout()
self.measurement_layout = QVBoxLayout()
l1 = QHBoxLayout()
l1.addWidget(QLabel("Units"))
l1.addWidget(self.units_select)
self.measurement_layout.addLayout(l1)
l2 = QHBoxLayout()
l2.addWidget(QLabel("Channel"))
l2.addWidget(self.channel_select)
self.measurement_layout.addLayout(l2)
layout.addLayout(self.measurement_layout)
result_layout = QVBoxLayout()
result_layout.addWidget(self.result_view)
result_layout.addWidget(self.calculate_btn)
layout.addLayout(result_layout)
self.setLayout(layout)
self.setWindowTitle("Measurement")
if self.window() == self:
try:
geometry = self.settings.get_from_profile("simple_measurement_window_geometry")
self.restoreGeometry(QByteArray.fromHex(bytes(geometry, "ascii")))
except KeyError:
pass
def create_scedit(self, text, option, default=NoDefault, tip=None,
without_layout=False):
label = QLabel(text)
clayout = ColorLayout(QColor(Qt.black), self)
clayout.lineedit.setMaximumWidth(80)
if tip is not None:
clayout.setToolTip(tip)
cb_bold = QCheckBox()
cb_bold.setIcon(ima.icon('bold'))
cb_bold.setToolTip(_("Bold"))
cb_italic = QCheckBox()
cb_italic.setIcon(ima.icon('italic'))
cb_italic.setToolTip(_("Italic"))
self.scedits[(clayout, cb_bold, cb_italic)] = (option, default)
if without_layout:
return label, clayout, cb_bold, cb_italic
layout = QHBoxLayout()
layout.addWidget(label)
layout.addLayout(clayout)
layout.addSpacing(10)
layout.addWidget(cb_bold)
layout.addWidget(cb_italic)
layout.addStretch(1)
layout.setContentsMargins(0, 0, 0, 0)
widget = QWidget(self)
widget.setLayout(layout)
return widget
def _generate_box_layout(t: str, widgets: List[Union[QWidget, QLayout,
Tuple]]):
if t == 'h':
layout = QHBoxLayout()
elif t == 'v':
layout = QVBoxLayout()
else:
raise RuntimeError()
for widget in widgets:
if isinstance(widget, tuple):
w, stretch = widget
assert isinstance(stretch, int)
else:
w = widget
stretch = 0
if isinstance(w, QWidget):
layout.addWidget(w, stretch)
elif isinstance(w, QLayout):
layout.addLayout(w, stretch)
else:
raise TypeError(f'Illegal type of widget is detected: {widget}')
return layout
def connection_changed(self, connected):
build = (self._node is None) and (self._connected != connected
and connected is True)
super(RunControl, self).connection_changed(connected)
if not build:
return
self._node = nodeFromAddress(self.channel)
self._path = self.channel
vb = QVBoxLayout()
self.setLayout(vb)
gb = QGroupBox('Run Control ({})'.format(self._node.name))
vb.addWidget(gb)
vb = QVBoxLayout()
gb.setLayout(vb)
fl = QFormLayout()
fl.setRowWrapPolicy(QFormLayout.DontWrapRows)
fl.setFormAlignment(Qt.AlignHCenter | Qt.AlignTop)
fl.setLabelAlignment(Qt.AlignRight)
vb.addLayout(fl)
w = PyDMEnumComboBox(parent=None, init_channel=self._path + '.runRate')
w.alarmSensitiveContent = False
w.alarmSensitiveBorder = False
fl.addRow('Run Rate:', w)
hb = QHBoxLayout()
vb.addLayout(hb)
fl = QFormLayout()
fl.setRowWrapPolicy(QFormLayout.DontWrapRows)
fl.setFormAlignment(Qt.AlignHCenter | Qt.AlignTop)
fl.setLabelAlignment(Qt.AlignRight)
hb.addLayout(fl)
w = PyDMEnumComboBox(parent=None,
init_channel=self._path + '.runState')
w.alarmSensitiveContent = False
w.alarmSensitiveBorder = False
fl.addRow('Run State:', w)
fl = QFormLayout()
fl.setRowWrapPolicy(QFormLayout.DontWrapRows)
fl.setFormAlignment(Qt.AlignHCenter | Qt.AlignTop)
fl.setLabelAlignment(Qt.AlignRight)
hb.addLayout(fl)
w = PyDMLabel(parent=None, init_channel=self._path + '.runCount')
w.showUnits = False
w.precisionFromPV = True
w.alarmSensitiveContent = False
w.alarmSensitiveBorder = False
fl.addRow('Run Count:', w)
def __init__(self, parent):
super(KiteWelcome, self).__init__(parent)
self.setFixedHeight(350)
# Left side
install_info = QLabel(
_("<big><b>Level up your completions with "
"Kite</b></big><br><br>"
"Kite is a native app that runs locally "
"on your computer <br>and uses machine learning "
"to provide advanced <br>completions.<br><br>"
"✓ Specialized support for Python "
"data analysis packages<br><br>"
"✓ 1.5x more completions "
"than the builtin engine<br><br>"
"✓ Completions ranked by code context <br><br>"
"✓ Full line code completions<br><br>"
"✓ 100% local - no internet "
"connection required<br><br>"
"✓ 100% free to use<br><br>"
"<a href=\"https://kite.com/spyder-integration\">"
"Go to Kite website</a>"))
install_info.setOpenExternalLinks(True)
# Right side
action_layout = QVBoxLayout()
install_gif_source = get_image_path('kite.gif')
install_gif = QMovie(install_gif_source)
install_gif_label = QLabel()
install_gif.start()
install_image = install_gif.currentPixmap()
image_height = install_image.height() * 0.8
image_width = install_image.width() * 0.8
install_gif.setScaledSize(QSize(image_width, image_height))
install_gif_label.setMovie(install_gif)
button_layout = QHBoxLayout()
install_button = QPushButton(_('Install Kite'))
dismiss_button = QPushButton(_('Dismiss'))
button_layout.addStretch()
button_layout.addWidget(install_button)
button_layout.addWidget(dismiss_button)
button_layout.addStretch()
action_layout.addWidget(install_gif_label)
action_layout.addStretch()
action_layout.addLayout(button_layout)
# Layout
general_layout = QHBoxLayout()
general_layout.addWidget(install_info)
general_layout.addLayout(action_layout)
self.setLayout(general_layout)
# Signals
install_button.clicked.connect(self.sig_install_button_clicked)
dismiss_button.clicked.connect(self.sig_dismiss_button_clicked)
def setup_ui(self):
"""Initialize widgets."""
info_label = QLabel()
info_label.setText("Hit enter to capture your image!")
self.image_label = QLabel()
self.image_label.setMinimumSize(320, 240)
self.image_label.setScaledContents(True)
button_layout = QVBoxLayout()
button_layout.setAlignment(Qt.AlignLeft)
self.style_buttons = [
QRadioButton(settings.STYLE_SHORTCUTS[i] + ". " + style.name
if i < len(settings.STYLE_SHORTCUTS) else style.name)
for i, style in enumerate(self.styles)
]
self.style_buttons[self.styles.index(
self.selected_style)].setChecked(True)
self.style_button_group = QButtonGroup()
for i, btn in enumerate(self.style_buttons):
button_layout.addWidget(btn)
self.style_button_group.addButton(btn, i)
btn.clicked.connect(
partial(lambda style: self.style_button_clicked(style),
self.styles[i]))
button_layout.addStretch(1)
ctrl_layout = QHBoxLayout()
if not settings.KIOSK:
fullscreen_button = QPushButton('[ ]')
fullscreen_button.setMaximumWidth(
fullscreen_button.fontMetrics().boundingRect('[ ]').width() +
10)
fullscreen_button.clicked.connect(self.toggle_fullscreen)
ctrl_layout.addWidget(fullscreen_button)
ctrl_layout.addStretch(1)
self.size_combo = QComboBox()
for s in settings.SIZES:
self.size_combo.addItem(s)
self.size_combo.setCurrentIndex(settings.SIZES.index(self.quality))
ctrl_layout.addWidget(self.size_combo)
self.size_combo.activated[str].connect(self.quality_choice)
button_layout.addLayout(ctrl_layout)
sub_layout = QHBoxLayout()
sub_layout.addLayout(button_layout)
sub_layout.addWidget(self.image_label, 1)
main_layout = QVBoxLayout()
main_layout.addWidget(info_label)
main_layout.addLayout(sub_layout)
self.setLayout(main_layout)
def __init__(self, model, *args, **kwargs):
super().__init__(*args, **kwargs)
self.model = model
layout = QHBoxLayout()
self.setLayout(layout)
layout.addWidget(QtSearchWithButton(model.search))
plot_layout = QVBoxLayout()
plot_layout.addWidget(QtAddCustomPlot(self.model))
plot_layout.addWidget(QtFigures(model.auto_plot_builder.figures))
layout.addLayout(plot_layout)
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=None, tags=None, content_urls=None):
super(CommunityTab, self).__init__(parent)
self._parent = parent
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.default_pixmap = QPixmap(VIDEO_ICON_PATH).scaled(
100, 60, Qt.KeepAspectRatio, Qt.FastTransformation)
# Widgets
self.text_filter = LineEditSearch()
self.frame_community = FrameCommunity()
self.list = ListWidgetContent()
# 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
hlayout = QHBoxLayout()
self.filters_layout = QHBoxLayout()
layout = QVBoxLayout()
layout.addLayout(hlayout)
controls_layout = QHBoxLayout()
controls_layout.addLayout(self.filters_layout)
controls_layout.addStretch()
controls_layout.addWidget(self.text_filter)
layout.addLayout(controls_layout)
layout.addWidget(self.list)
self.frame_community.setLayout(layout)
layout = QHBoxLayout()
layout.addWidget(self.frame_community)
self.setLayout(layout)
# Signals
self.timer_load.timeout.connect(self.set_content_list)
self.text_filter.textChanged.connect(self.filter_content)
def __init__(self, editor):
QDialog.__init__(self, editor, Qt.WindowTitleHint
| Qt.WindowCloseButtonHint)
# 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.lineno = None
self.editor = editor
self.setWindowTitle(_("Editor"))
self.setModal(True)
label = QLabel(_("Go to line:"))
self.lineedit = QLineEdit()
validator = QIntValidator(self.lineedit)
validator.setRange(1, editor.get_line_count())
self.lineedit.setValidator(validator)
self.lineedit.textChanged.connect(self.text_has_changed)
cl_label = QLabel(_("Current line:"))
cl_label_v = QLabel("<b>%d</b>" % editor.get_cursor_line_number())
last_label = QLabel(_("Line count:"))
last_label_v = QLabel("%d" % editor.get_line_count())
glayout = QGridLayout()
glayout.addWidget(label, 0, 0, Qt.AlignVCenter | Qt.AlignRight)
glayout.addWidget(self.lineedit, 0, 1, Qt.AlignVCenter)
glayout.addWidget(cl_label, 1, 0, Qt.AlignVCenter | Qt.AlignRight)
glayout.addWidget(cl_label_v, 1, 1, Qt.AlignVCenter)
glayout.addWidget(last_label, 2, 0, Qt.AlignVCenter | Qt.AlignRight)
glayout.addWidget(last_label_v, 2, 1, Qt.AlignVCenter)
bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel,
Qt.Vertical, self)
bbox.accepted.connect(self.accept)
bbox.rejected.connect(self.reject)
btnlayout = QVBoxLayout()
btnlayout.addWidget(bbox)
btnlayout.addStretch(1)
ok_button = bbox.button(QDialogButtonBox.Ok)
ok_button.setEnabled(False)
self.lineedit.textChanged.connect(
lambda text: ok_button.setEnabled(len(text) > 0))
layout = QHBoxLayout()
layout.addLayout(glayout)
layout.addLayout(btnlayout)
self.setLayout(layout)
self.lineedit.setFocus()
def createTopLayout(self):
top_layout = QHBoxLayout()
image_label = QLabel()
image = resourceImage("splash.png")
image_label.setPixmap(image.scaled(200, 240, Qt.KeepAspectRatio))
top_layout.addWidget(image_label)
top_layout.addLayout(self.createInfoLayout(), 1)
return top_layout
def __init__(self, model, *args, **kwargs):
super().__init__(*args, **kwargs)
self.model = model
layout = QHBoxLayout()
self.setLayout(layout)
layout.addWidget(QtSearchWithButton(model.search))
plot_layout = QVBoxLayout()
plot_layout.addWidget(QtAddCustomPlot(self.model))
# How would this work with a list of auto plot builders?
for auto_plot_builder in self.model.auto_plot_builders:
plot_layout.addWidget(QtFigures(auto_plot_builder.figures))
layout.addLayout(plot_layout)
def __init__(self, parent=None):
super(Checkable, self).__init__(parent)
label = MLabel("Categories:")
topic_lay = QHBoxLayout()
topic_lay.addWidget(label)
for i in ["Movies", "Books", "Music", "Sports"]:
topic_lay.addWidget(MCheckableTag(text=i))
topic_lay.addStretch()
main_lay = QHBoxLayout()
main_lay.addLayout(topic_lay)
self.setLayout(main_lay)
class SummaryPanel(QFrame):
def __init__(self, ert: EnKFMain):
self.ert = ert
QFrame.__init__(self)
self.setMinimumWidth(250)
self.setMinimumHeight(150)
widget = QWidget()
self.layout = QHBoxLayout()
widget.setLayout(self.layout)
scroll = QScrollArea()
scroll.setWidgetResizable(True)
scroll.setWidget(widget)
layout = QGridLayout()
layout.addWidget(scroll)
self.setLayout(layout)
self.updateSummary()
def updateSummary(self):
summary = ErtSummary(self.ert)
text = SummaryTemplate("Forward models")
for job in summary.getForwardModels():
text.addRow(job)
self.addColumn(text.getText())
text = SummaryTemplate("Parameters")
for parameters in summary.getParameters():
text.addRow(parameters)
self.addColumn(text.getText())
text = SummaryTemplate("Observations")
for observations in summary.getObservations():
text.addRow(observations)
self.addColumn(text.getText())
def addColumn(self, text):
layout = QVBoxLayout()
text_widget = QLabel(text)
text_widget.setWordWrap(True)
text_widget.setTextFormat(Qt.RichText)
layout.addWidget(text_widget)
layout.addStretch(1)
self.layout.addLayout(layout)
def get_selection_lists_widget(self, parent):
"""."""
sel_wid = QWidget(parent)
sel_lay = QHBoxLayout(sel_wid)
icon = qta.icon('fa5s.hammer', color=get_appropriate_color(self.acc))
Window = create_window_from_widget(
SelectionMatrix, title='Corrs and BPMs selection', icon=icon)
btn = QPushButton('', sel_wid)
btn.setObjectName('btn')
btn.setIcon(qta.icon('fa5s.tasks'))
btn.setToolTip('Open window to select BPMs and correctors')
btn.setStyleSheet(
'#btn{min-width:3.8em; max-width:3.8em;\
min-height:2em; max-height:2em; icon-size:25px;}')
connect_window(
btn, Window, None, device=self.device,
prefix=self.prefix, acc=self.acc)
sel_lay.addWidget(btn)
lay = QVBoxLayout()
sel_lay.addStretch()
sel_lay.addLayout(lay)
hlay = QHBoxLayout()
lay.addLayout(hlay)
hlay.addWidget(SiriusEnumComboBox(
sel_wid, self.devpref.substitute(propty='RespMatMode-Sel')))
hlay.addWidget(SiriusLabel(
sel_wid, self.devpref.substitute(propty='RespMatMode-Sts')))
if self.acc in {'SI', 'BO'}:
hlay = QHBoxLayout()
lay.addLayout(hlay)
pdm_chbx = PyDMCheckbox(
sel_wid, self.devpref.substitute(propty='RFEnbl-Sel'))
pdm_chbx.setText('use RF')
pdm_led = SiriusLedState(
sel_wid, self.devpref.substitute(propty='RFEnbl-Sts'))
hlay.addWidget(pdm_chbx)
hlay.addWidget(pdm_led)
btn = QPushButton('', sel_wid)
btn.setToolTip('Visualize RespMat')
btn.setIcon(qta.icon('mdi.chart-line'))
btn.setObjectName('btn')
btn.setStyleSheet('#btn{max-width:40px; icon-size:40px;}')
connect_newprocess(
btn, [f'sirius-hla-{self.acc.lower():s}-ap-sofb.py', '--matrix'])
sel_lay.addWidget(btn)
return sel_wid
def __init__(self, *args, **kwargs):
super(AboutDialog, self).__init__(*args, **kwargs)
self.tracker = GATracker()
text = """<b>Anaconda Navigator {version}</b><br>
<br>Copyright © 2016 Continuum Analytics
<p>Created by Continuum Analytics
<br>
<p>For bug reports and feature requests, please visit our
""".format(version=__version__)
self.label_icon = QLabel()
self.label_about = QLabel(text)
self.button_link = ButtonLink('Issue Tracker')
self.button_label = ButtonLabel('on GitHub.')
self.button_ok = QPushButton('Ok')
# Widget setup
self.button_ok.setMinimumWidth(70)
self.label_about.setOpenExternalLinks(True)
self.label_icon.setPixmap(QPixmap(images.ANACONDA_ICON_64_PATH))
self.setWindowTitle("About Anaconda Navigator")
# Layouts
h_layout = QHBoxLayout()
h_layout.addWidget(self.label_icon, 0, Qt.AlignTop)
h_layout.addSpacing(10)
content_layout = QVBoxLayout()
content_layout.addWidget(self.label_about, 0, Qt.AlignBottom)
content_layout.setContentsMargins(0, 0, 0, 0)
h_content_layout = QHBoxLayout()
h_content_layout.addWidget(self.button_link, 0, Qt.AlignLeft)
h_content_layout.addWidget(self.button_label, 0, Qt.AlignLeft)
h_content_layout.addStretch(0)
h_content_layout.setContentsMargins(0, 0, 0, 0)
content_layout.addLayout(h_content_layout)
h_layout.addLayout(content_layout)
buttons_layout = QHBoxLayout()
buttons_layout.addStretch()
buttons_layout.addWidget(self.button_ok)
main_layout = QVBoxLayout()
main_layout.addLayout(h_layout)
main_layout.addSpacing(24)
main_layout.addLayout(buttons_layout)
self.setLayout(main_layout)
# Signals
self.button_ok.clicked.connect(self.accept)
self.button_link.clicked.connect(
lambda: self.open_url(self.GITHUB_URL))
def setupUI(self):
mainLayout = QGridLayout()
leftColumnWidget = QGroupBox(config.thisTranslation["commentaries"])
commentaryLayout = QVBoxLayout()
commentaryLayout.addWidget(self.commentaryListView())
subSubLayout = QHBoxLayout()
button = QPushButton(config.thisTranslation["open"])
button.clicked.connect(self.openPreviousCommentary)
subSubLayout.addWidget(button)
button = QPushButton(config.thisTranslation["activeOnly"])
button.clicked.connect(self.showActiveOnlyCommentaries)
subSubLayout.addWidget(button)
commentaryLayout.addLayout(subSubLayout)
leftColumnWidget.setLayout(commentaryLayout)
rightColumnWidget = QGroupBox(config.thisTranslation["menu10_books"])
bookLayout = QHBoxLayout()
subLayout = QVBoxLayout()
subLayout.addWidget(self.bookListView())
subSubLayout = QHBoxLayout()
button = QPushButton(config.thisTranslation["showAll"])
button.clicked.connect(self.showAllBooks)
subSubLayout.addWidget(button)
button = QPushButton(config.thisTranslation["favouriteOnly"])
button.clicked.connect(self.favouriteBookOnly)
subSubLayout.addWidget(button)
button = QPushButton(config.thisTranslation["addFavourite"])
button.clicked.connect(self.addFavorite)
subSubLayout.addWidget(button)
button = QPushButton(config.thisTranslation["removeFavourite"])
button.clicked.connect(self.removeFavorite)
subSubLayout.addWidget(button)
subLayout.addLayout(subSubLayout)
bookLayout.addLayout(subLayout)
subLayout = QVBoxLayout()
subLayout.addWidget(self.chapterListView())
button = QPushButton(config.thisTranslation["open"])
button.clicked.connect(self.openPreviousBookChapter)
subLayout.addWidget(button)
bookLayout.addLayout(subLayout)
rightColumnWidget.setLayout(bookLayout)
mainLayout.addWidget(leftColumnWidget, 0, 0)
mainLayout.addWidget(rightColumnWidget, 0, 1)
mainLayout.setColumnStretch(1, 2)
self.setLayout(mainLayout)
def _configure_ui(self):
bottom_hbox = self._configure_status_bar()
# Put everything together
plot_ch_hbox = QHBoxLayout()
plot_ch_hbox.addLayout(self._plt_grid)
main_vbox = QVBoxLayout()
main_vbox.addLayout(plot_ch_hbox)
main_vbox.addLayout(bottom_hbox)
central_widget = QWidget()
central_widget.setLayout(main_vbox)
self.setCentralWidget(central_widget)
class ConfigDBInfoHeader(QFrame):
def __init__(self, client, parent=None, config_type=None):
super().__init__(parent)
self._client = client
self._config_type = config_type or 'notexist'
self.setupui()
def setupui(self):
# Sub header with database general information
self.layout = QHBoxLayout(self)
vbl = QVBoxLayout()
self.layout.addLayout(vbl)
hbl = QHBoxLayout()
hbl.addWidget(QLabel('<b>Server:</b>', self))
hbl.addWidget(QLabel(self._client.url, self))
hbl.addStretch()
vbl.addLayout(hbl)
hbl = QHBoxLayout()
hbl.addWidget(QLabel('<b>DB Size:</b>', self))
try:
dbsize = self._client.get_dbsize()
dbsize = '{:.2f} MB'.format(dbsize / (1024 * 1024))
except ConfigDBException:
dbsize = 'Failed to retrieve information'
hbl.addWidget(QLabel(dbsize, self))
hbl.addStretch()
vbl.addLayout(hbl)
vbl = QVBoxLayout()
self.layout.addLayout(vbl)
hbl = QHBoxLayout()
hbl.addWidget(QLabel('<b>Configuration Type:</b>', self))
hbl.addWidget(QLabel(self._config_type, self))
hbl.addStretch()
vbl.addLayout(hbl)
hbl = QHBoxLayout()
hbl.addWidget(QLabel('<b>Number of Configurations:</b>', self))
self.nr_configs = QLabel(self)
hbl.addWidget(self.nr_configs)
try:
leng = len(
self._client.find_configs(config_type=self._config_type))
except ConfigDBException:
leng = 'NA'
self.nr_configs.setText(str(leng))
hbl.addStretch()
vbl.addLayout(hbl)
def __init__(self, parent=None):
super(AddDeleteExampleWidget, self).__init__(parent)
self.tag_lay = MFlowLayout()
tag1 = MTag("Unremoveable")
tag2 = MTag("Tag2").closeable()
tag3 = MTag("Tag3").closeable()
add_tag = MNewTag("New Tag")
add_tag.sig_add_tag.connect(self.slot_add_tag)
self.tag_lay.addWidget(tag1)
self.tag_lay.addWidget(tag2)
self.tag_lay.addWidget(tag3)
self.tag_lay.addWidget(add_tag)
main_lay = QHBoxLayout()
main_lay.addLayout(self.tag_lay)
self.setLayout(main_lay)
def __init__(self, description: str, widget: GetPropertyWidget):
super().__init__(self)
self.widget = widget
save = QPushButton("Save", self)
save.clicked.connect(self.accept)
cancel = QPushButton("Cancel", self)
cancel.clicked.connect(self.reject)
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(QLabel(description))
layout.addWidget(self.widget)
btn_layout = QVBoxLayout()
btn_layout.addWidget(cancel)
btn_layout.addWidget(cancel)
layout.addLayout(btn_layout)
self.setLayout(layout)
def _setupUi(self):
# menubar
self.menubar = QMenuBar(self)
self.menubar.setNativeMenuBar(False)
self.setMenuBar(self.menubar)
self.menu = self.menubar.addMenu("Open...")
self._setupMenu()
# auxiliar diagnostics widget
self.auxdig_wid = None
self._setupDiagWidget()
# lattice widget
self.lattice_wid = QSvgWidget(
_os.path.join(self._curr_dir, self.SVG_FILE))
# screens view widget (create only one ScrnView)
self._scrns_wids_dict = dict()
self._currScrn = 0
scrn_wid = SiriusScrnView(parent=self,
prefix=self.prefix,
device=self._scrns[self._currScrn])
scrn_wid.setVisible(True)
self._scrns_wids_dict[self._currScrn] = scrn_wid
self.scrns_wid = QWidget()
lay_scrns = QGridLayout(self.scrns_wid)
lay_scrns.addWidget(scrn_wid)
# correction widget
self.corr_wid = QGroupBox('Screens and Correctors Panel')
self._scrns_sel_bg = QButtonGroup(parent=self.corr_wid)
self._scrns_sel_bg.setExclusive(True)
self._setupScrnsCorrsWidget()
vlay1 = QVBoxLayout()
if self.auxdig_wid:
vlay1.addWidget(self.auxdig_wid)
vlay1.addWidget(self.scrns_wid)
vlay2 = QVBoxLayout()
vlay2.addWidget(self.lattice_wid)
vlay2.addWidget(self.corr_wid)
cw = QWidget()
lay = QHBoxLayout(cw)
lay.addLayout(vlay1)
lay.addLayout(vlay2)
self.setCentralWidget(cw)
def create_coloredit(self, text, option, default=NoDefault, tip=None,
without_layout=False):
label = QLabel(text)
clayout = ColorLayout(QColor(Qt.black), self)
clayout.lineedit.setMaximumWidth(80)
if tip is not None:
clayout.setToolTip(tip)
self.coloredits[clayout] = (option, default)
if without_layout:
return label, clayout
layout = QHBoxLayout()
layout.addWidget(label)
layout.addLayout(clayout)
layout.addStretch(1)
layout.setContentsMargins(0, 0, 0, 0)
widget = QWidget(self)
widget.setLayout(layout)
return widget
def __init__(self, parent):
QWidget.__init__(self, parent)
layout = QHBoxLayout()
row_nb = 14
cindex = 0
for child in dir(QStyle):
if child.startswith('SP_'):
if cindex == 0:
col_layout = QVBoxLayout()
icon_layout = QHBoxLayout()
icon = get_std_icon(child)
label = QLabel()
label.setPixmap(icon.pixmap(32, 32))
icon_layout.addWidget( label )
icon_layout.addWidget( QLineEdit(child.replace('SP_', '')) )
col_layout.addLayout(icon_layout)
cindex = (cindex+1) % row_nb
if cindex == 0:
layout.addLayout(col_layout)
self.setLayout(layout)
self.setWindowTitle('Standard Platform Icons')
self.setWindowIcon(get_std_icon('TitleBarMenuButton'))
def setup_page(self):
newcb = self.create_checkbox
# Interface Group
interface_group = QGroupBox(_("Interface"))
banner_box = newcb(_("Display initial banner"), 'show_banner',
tip=_("This option lets you hide the message "
"shown at\nthe top of the console when "
"it's opened."))
pager_box = newcb(_("Use a pager to display additional text inside "
"the console"), 'use_pager',
tip=_("Useful if you don't want to fill the "
"console with long help or completion "
"texts.\n"
"Note: Use the Q key to get out of the "
"pager."))
calltips_box = newcb(_("Show calltips"), 'show_calltips')
ask_box = newcb(_("Ask for confirmation before closing"),
'ask_before_closing')
reset_namespace_box = newcb(
_("Ask for confirmation before removing all user-defined "
"variables"),
'show_reset_namespace_warning',
tip=_("This option lets you hide the warning message shown\n"
"when resetting the namespace from Spyder."))
show_time_box = newcb(_("Show elapsed time"), 'show_elapsed_time')
ask_restart_box = newcb(
_("Ask for confirmation before restarting"),
'ask_before_restart',
tip=_("This option lets you hide the warning message shown\n"
"when restarting the kernel."))
interface_layout = QVBoxLayout()
interface_layout.addWidget(banner_box)
interface_layout.addWidget(pager_box)
interface_layout.addWidget(calltips_box)
interface_layout.addWidget(ask_box)
interface_layout.addWidget(reset_namespace_box)
interface_layout.addWidget(show_time_box)
interface_layout.addWidget(ask_restart_box)
interface_group.setLayout(interface_layout)
comp_group = QGroupBox(_("Completion Type"))
comp_label = QLabel(_("Decide what type of completion to use"))
comp_label.setWordWrap(True)
completers = [(_("Graphical"), 0), (_("Terminal"), 1), (_("Plain"), 2)]
comp_box = self.create_combobox(_("Completion:")+" ", completers,
'completion_type')
comp_layout = QVBoxLayout()
comp_layout.addWidget(comp_label)
comp_layout.addWidget(comp_box)
comp_group.setLayout(comp_layout)
# Source Code Group
source_code_group = QGroupBox(_("Source code"))
buffer_spin = self.create_spinbox(
_("Buffer: "), _(" lines"),
'buffer_size', min_=-1, max_=1000000, step=100,
tip=_("Set the maximum number of lines of text shown in the\n"
"console before truncation. Specifying -1 disables it\n"
"(not recommended!)"))
source_code_layout = QVBoxLayout()
source_code_layout.addWidget(buffer_spin)
source_code_group.setLayout(source_code_layout)
# --- Graphics ---
# Pylab Group
pylab_group = QGroupBox(_("Support for graphics (Matplotlib)"))
pylab_box = newcb(_("Activate support"), 'pylab')
autoload_pylab_box = newcb(
_("Automatically load Pylab and NumPy modules"),
'pylab/autoload',
tip=_("This lets you load graphics support without importing\n"
"the commands to do plots. Useful to work with other\n"
"plotting libraries different to Matplotlib or to develop\n"
"GUIs with Spyder."))
autoload_pylab_box.setEnabled(self.get_option('pylab'))
pylab_box.toggled.connect(autoload_pylab_box.setEnabled)
pylab_layout = QVBoxLayout()
pylab_layout.addWidget(pylab_box)
pylab_layout.addWidget(autoload_pylab_box)
pylab_group.setLayout(pylab_layout)
# Pylab backend Group
inline = _("Inline")
automatic = _("Automatic")
backend_group = QGroupBox(_("Graphics backend"))
bend_label = QLabel(_("Decide how graphics are going to be displayed "
"in the console. If unsure, please select "
"<b>%s</b> to put graphics inside the "
"console or <b>%s</b> to interact with "
"them (through zooming and panning) in a "
"separate window.") % (inline, automatic))
bend_label.setWordWrap(True)
backends = [(inline, 0), (automatic, 1), ("Qt5", 2), ("Qt4", 3)]
if sys.platform == 'darwin':
backends.append(("OS X", 4))
if sys.platform.startswith('linux'):
backends.append(("Gtk3", 5))
backends.append(("Gtk", 6))
if PY2:
backends.append(("Wx", 7))
backends.append(("Tkinter", 8))
backends = tuple(backends)
backend_box = self.create_combobox(
_("Backend:") + " ",
backends,
'pylab/backend', default=0,
tip=_("This option will be applied the next time a console is "
"opened."))
backend_layout = QVBoxLayout()
backend_layout.addWidget(bend_label)
backend_layout.addWidget(backend_box)
backend_group.setLayout(backend_layout)
backend_group.setEnabled(self.get_option('pylab'))
pylab_box.toggled.connect(backend_group.setEnabled)
# Inline backend Group
inline_group = QGroupBox(_("Inline backend"))
inline_label = QLabel(_("Decide how to render the figures created by "
"this backend"))
inline_label.setWordWrap(True)
formats = (("PNG", 0), ("SVG", 1))
format_box = self.create_combobox(_("Format:")+" ", formats,
'pylab/inline/figure_format',
default=0)
resolution_spin = self.create_spinbox(
_("Resolution:")+" ", " "+_("dpi"),
'pylab/inline/resolution', min_=50, max_=999, step=0.1,
tip=_("Only used when the format is PNG. Default is "
"72"))
width_spin = self.create_spinbox(
_("Width:")+" ", " "+_("inches"),
'pylab/inline/width', min_=2, max_=20, step=1,
tip=_("Default is 6"))
height_spin = self.create_spinbox(
_("Height:")+" ", " "+_("inches"),
'pylab/inline/height', min_=1, max_=20, step=1,
tip=_("Default is 4"))
bbox_inches_box = newcb(
_("Use a tight layout for inline plots"),
'pylab/inline/bbox_inches',
tip=_("Sets bbox_inches to \"tight\" when\n"
"plotting inline with matplotlib.\n"
"When enabled, can cause discrepancies\n"
"between the image displayed inline and\n"
"that created using savefig."))
inline_v_layout = QVBoxLayout()
inline_v_layout.addWidget(inline_label)
inline_layout = QGridLayout()
inline_layout.addWidget(format_box.label, 1, 0)
inline_layout.addWidget(format_box.combobox, 1, 1)
inline_layout.addWidget(resolution_spin.plabel, 2, 0)
inline_layout.addWidget(resolution_spin.spinbox, 2, 1)
inline_layout.addWidget(resolution_spin.slabel, 2, 2)
inline_layout.addWidget(width_spin.plabel, 3, 0)
inline_layout.addWidget(width_spin.spinbox, 3, 1)
inline_layout.addWidget(width_spin.slabel, 3, 2)
inline_layout.addWidget(height_spin.plabel, 4, 0)
inline_layout.addWidget(height_spin.spinbox, 4, 1)
inline_layout.addWidget(height_spin.slabel, 4, 2)
inline_layout.addWidget(bbox_inches_box, 5, 0, 1, 4)
inline_h_layout = QHBoxLayout()
inline_h_layout.addLayout(inline_layout)
inline_h_layout.addStretch(1)
inline_v_layout.addLayout(inline_h_layout)
inline_group.setLayout(inline_v_layout)
inline_group.setEnabled(self.get_option('pylab'))
pylab_box.toggled.connect(inline_group.setEnabled)
# --- Startup ---
# Run lines Group
run_lines_group = QGroupBox(_("Run code"))
run_lines_label = QLabel(_("You can run several lines of code when "
"a console is started. Please introduce "
"each one separated by semicolons and a "
"space, for example:<br>"
"<i>import os; import sys</i>"))
run_lines_label.setWordWrap(True)
run_lines_edit = self.create_lineedit(_("Lines:"), 'startup/run_lines',
'', alignment=Qt.Horizontal)
run_lines_layout = QVBoxLayout()
run_lines_layout.addWidget(run_lines_label)
run_lines_layout.addWidget(run_lines_edit)
run_lines_group.setLayout(run_lines_layout)
# Run file Group
run_file_group = QGroupBox(_("Run a file"))
run_file_label = QLabel(_("You can also run a whole file at startup "
"instead of just some lines (This is "
"similar to have a PYTHONSTARTUP file)."))
run_file_label.setWordWrap(True)
file_radio = newcb(_("Use the following file:"),
'startup/use_run_file', False)
run_file_browser = self.create_browsefile('', 'startup/run_file', '')
run_file_browser.setEnabled(False)
file_radio.toggled.connect(run_file_browser.setEnabled)
run_file_layout = QVBoxLayout()
run_file_layout.addWidget(run_file_label)
run_file_layout.addWidget(file_radio)
run_file_layout.addWidget(run_file_browser)
run_file_group.setLayout(run_file_layout)
# ---- Advanced settings ----
# Enable Jedi completion
jedi_group = QGroupBox(_("Jedi completion"))
jedi_label = QLabel(_("Enable Jedi-based <tt>Tab</tt> completion "
"in the IPython console; similar to the "
"greedy completer, but without evaluating "
"the code.<br>"
"<b>Warning:</b> Slows down your console "
"when working with large dataframes!"))
jedi_label.setWordWrap(True)
jedi_box = newcb(_("Use Jedi completion in the IPython console"),
"jedi_completer",
tip=_("<b>Warning</b>: "
"Slows down your console when working with "
"large dataframes!<br>"
"Allows completion of nested lists etc."))
jedi_layout = QVBoxLayout()
jedi_layout.addWidget(jedi_label)
jedi_layout.addWidget(jedi_box)
jedi_group.setLayout(jedi_layout)
# Greedy completer group
greedy_group = QGroupBox(_("Greedy completion"))
greedy_label = QLabel(_("Enable <tt>Tab</tt> completion on elements "
"of lists, results of function calls, etc, "
"<i>without</i> assigning them to a variable, "
"like <tt>li[0].<Tab></tt> or "
"<tt>ins.meth().<Tab></tt> <br>"
"<b>Warning:</b> Due to a bug, IPython's "
"greedy completer requires a leading "
"<tt><Space></tt> for some completions; "
"e.g. <tt>np.sin(<Space>np.<Tab>"
"</tt> works while <tt>np.sin(np.<Tab> "
"</tt> doesn't."))
greedy_label.setWordWrap(True)
greedy_box = newcb(_("Use greedy completion in the IPython console"),
"greedy_completer",
tip="<b>Warning</b>: It can be unsafe because the "
"code is actually evaluated when you press "
"<tt>Tab</tt>.")
greedy_layout = QVBoxLayout()
greedy_layout.addWidget(greedy_label)
greedy_layout.addWidget(greedy_box)
greedy_group.setLayout(greedy_layout)
# Autocall group
autocall_group = QGroupBox(_("Autocall"))
autocall_label = QLabel(_("Autocall makes IPython automatically call "
"any callable object even if you didn't "
"type explicit parentheses.<br>"
"For example, if you type <i>str 43</i> it "
"becomes <i>str(43)</i> automatically."))
autocall_label.setWordWrap(True)
smart = _('Smart')
full = _('Full')
autocall_opts = ((_('Off'), 0), (smart, 1), (full, 2))
autocall_box = self.create_combobox(
_("Autocall: "), autocall_opts, 'autocall', default=0,
tip=_("On <b>%s</b> mode, Autocall is not applied if "
"there are no arguments after the callable. On "
"<b>%s</b> mode, all callable objects are "
"automatically called (even if no arguments are "
"present).") % (smart, full))
autocall_layout = QVBoxLayout()
autocall_layout.addWidget(autocall_label)
autocall_layout.addWidget(autocall_box)
autocall_group.setLayout(autocall_layout)
# Sympy group
sympy_group = QGroupBox(_("Symbolic Mathematics"))
sympy_label = QLabel(_("Perfom symbolic operations in the console "
"(e.g. integrals, derivatives, vector "
"calculus, etc) and get the outputs in a "
"beautifully printed style (it requires the "
"Sympy module)."))
sympy_label.setWordWrap(True)
sympy_box = newcb(_("Use symbolic math"), "symbolic_math",
tip=_("This option loads the Sympy library to work "
"with.<br>Please refer to its documentation "
"to learn how to use it."))
sympy_layout = QVBoxLayout()
sympy_layout.addWidget(sympy_label)
sympy_layout.addWidget(sympy_box)
sympy_group.setLayout(sympy_layout)
# Prompts group
prompts_group = QGroupBox(_("Prompts"))
prompts_label = QLabel(_("Modify how Input and Output prompts are "
"shown in the console."))
prompts_label.setWordWrap(True)
in_prompt_edit = self.create_lineedit(
_("Input prompt:"),
'in_prompt', '',
_('Default is<br>'
'In [<span class="in-prompt-number">'
'%i</span>]:'),
alignment=Qt.Horizontal)
out_prompt_edit = self.create_lineedit(
_("Output prompt:"),
'out_prompt', '',
_('Default is<br>'
'Out[<span class="out-prompt-number">'
'%i</span>]:'),
alignment=Qt.Horizontal)
prompts_layout = QVBoxLayout()
prompts_layout.addWidget(prompts_label)
prompts_g_layout = QGridLayout()
prompts_g_layout.addWidget(in_prompt_edit.label, 0, 0)
prompts_g_layout.addWidget(in_prompt_edit.textbox, 0, 1)
prompts_g_layout.addWidget(out_prompt_edit.label, 1, 0)
prompts_g_layout.addWidget(out_prompt_edit.textbox, 1, 1)
prompts_layout.addLayout(prompts_g_layout)
prompts_group.setLayout(prompts_layout)
# Windows adjustments
windows_group = QGroupBox(_("Windows adjustments"))
hide_cmd_windows = newcb(
_("Hide command line output windows "
"generated by the subprocess module."),
'hide_cmd_windows')
windows_layout = QVBoxLayout()
windows_layout.addWidget(hide_cmd_windows)
windows_group.setLayout(windows_layout)
# --- Tabs organization ---
tabs = QTabWidget()
tabs.addTab(self.create_tab(interface_group, comp_group,
source_code_group), _("Display"))
tabs.addTab(self.create_tab(pylab_group, backend_group, inline_group),
_("Graphics"))
tabs.addTab(self.create_tab(run_lines_group, run_file_group),
_("Startup"))
tabs.addTab(self.create_tab(jedi_group, greedy_group, autocall_group,
sympy_group, prompts_group,
windows_group),
_("Advanced Settings"))
vlayout = QVBoxLayout()
vlayout.addWidget(tabs)
self.setLayout(vlayout)
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()
layout.addLayout(layout_sequence)
layout.addSpacing(5)
layout.addLayout(button_box)
self.setLayout(layout)
# 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 MainWidget(QWidget):
def __init__(self, *args, **kwargs):
super(MainWidget, self).__init__(*args, **kwargs)
#Widgets
self.label_Title1 = QLabel()
self.label_Title1.setText("INGRESE LOS DATOS")
self.label_Title2 = QLabel()
self.label_Title2.setText("DATOS BOMBILLOS ESTANDAR")
self.label_Title3 = QLabel()
self.label_Title3.setText("DATOS BOMBILLOS LED")
self.label_Data1 = QLabel()
self.label_Data1.setText("Costo de la electricidad (kW/hora)")
self.label_Data2 = QLabel()
self.label_Data2.setText("Numero de bombillos a reemplazar")
self.label_Data3 = QLabel()
self.label_Data3.setText("Vatios del bombillo existente")
self.label_Data4 = QLabel()
self.label_Data4.setText("Numero de Horas por Dia encendido")
self.label_Data5 = QLabel()
self.label_Data5.setText("Vida util bombillo actual")
self.label_Data6 = QLabel()
self.label_Data6.setText("Costo Bombillo actual")
self.label_Data7 = QLabel()
self.label_Data7.setText("Costo estimado mantenimiento por bombillo")
self.label_Data8 = QLabel()
self.label_Data8.setText("Vatios del bombillo LED")
self.label_Data9 = QLabel()
self.label_Data9.setText("Vida util estimada del bombillo")
self.label_Data10 = QLabel()
self.label_Data10.setText("Costo del bombillo led")
#Widgets Titulos del Form
self.label_Titlef1 = QLabel()
self.label_Titlef1.setText("INFORMACION DE COSTOS CALCULADOS")
self.label_Titlef2 = QLabel()
self.label_Titlef2.setText("INFORMACION DE AHORROS CALCULADOS")
self.line_Data1 = QLineEdit()
#self.line_Data1.setValidator()
self.line_Data2 = QLineEdit()
self.line_Data2.setValidator(QIntValidator())
self.line_Data3 = QLineEdit()
self.line_Data3.setValidator(QIntValidator())
self.line_Data4 = QLineEdit()
self.line_Data4.setValidator(QIntValidator())
self.line_Data5 = QLineEdit()
self.line_Data5.setValidator(QIntValidator())
self.line_Data6 = QLineEdit()
#self.line_Data6.setValidator()
self.line_Data7 = QLineEdit()
#self.line_Data7.setValidator()
self.line_Data8 = QLineEdit()
#self.line_Data8.setValidator()
self.line_Data9 = QLineEdit()
#self.line_Data9.setValidator()
self.line_Data10 = QLineEdit()
#self.line_Data10.setValidator()
#Widget Informacion Calculada Form1 Costos
self.line_Inf1 = QLineEdit()
self.line_Inf1.setValidator(QIntValidator())
self.line_Inf2 = QLineEdit()
self.line_Inf2.setValidator(QIntValidator())
self.line_Inf3 = QLineEdit()
self.line_Inf3.setValidator(QIntValidator())
self.line_Inf4 = QLineEdit()
self.line_Inf4.setValidator(QIntValidator())
self.line_Inf5 = QLineEdit()
self.line_Inf5.setValidator(QIntValidator())
self.line_Inf6 = QLineEdit()
self.line_Inf6.setValidator(QIntValidator())
self.line_Inf7 = QLineEdit()
self.line_Inf7.setValidator(QIntValidator())
self.line_Inf8 = QLineEdit()
self.line_Inf8.setValidator(QIntValidator())
self.line_Inf9 = QLineEdit()
self.line_Inf9.setValidator(QIntValidator())
#Widget Informacion Calculada Form2 Ahorros
self.line_Sav1 = QLineEdit()
self.line_Sav1.setValidator(QIntValidator())
self.line_Sav2 = QLineEdit()
self.line_Sav2.setValidator(QIntValidator())
self.line_Sav3 = QLineEdit()
self.line_Sav3.setValidator(QIntValidator())
self.line_Sav4 = QLineEdit()
self.line_Sav4.setValidator(QIntValidator())
self.line_Sav5 = QLineEdit()
self.line_Sav5.setValidator(QIntValidator())
self.line_Sav6 = QLineEdit()
self.line_Sav6.setValidator(QIntValidator())
self.button_Calc = QPushButton('Calcular Ahorro', parent=self)
self.button_Impr = QPushButton('Imprimir', parent=self)
#Layouts
layout = QGridLayout()
layout.addWidget(self.label_Title1,0,0)
layout.addWidget(self.label_Data1,1,0)
layout.addWidget(self.line_Data1,1,1)
layout.addWidget(self.label_Title2,2,0)
layout.addWidget(self.label_Data2,3,0)
layout.addWidget(self.line_Data2,3,1)
layout.addWidget(self.label_Data5,3,2)
layout.addWidget(self.line_Data5,3,3)
layout.addWidget(self.label_Data3,4,0)
layout.addWidget(self.line_Data3,4,1)
layout.addWidget(self.label_Data6,4,2)
layout.addWidget(self.line_Data6,4,3)
layout.addWidget(self.label_Data4,5,0)
layout.addWidget(self.line_Data4,5,1)
layout.addWidget(self.label_Data7,5,2)
layout.addWidget(self.line_Data7,5,3)
layout.addWidget(self.label_Title3,6,0)
layout.addWidget(self.label_Data8,7,0)
layout.addWidget(self.line_Data8,7,1)
layout.addWidget(self.label_Data10,7,2)
layout.addWidget(self.line_Data10,7,3)
layout.addWidget(self.label_Data9,8,0)
layout.addWidget(self.line_Data9,8,1)
layout.addWidget(self.button_Calc,8,3)
layout1 = QFormLayout()
layout1.addRow("Horas por año",self.line_Inf1)
layout1.addRow("Costo de Energia por Dia",self.line_Inf2)
layout1.addRow("Costo de Energia por Año",self.line_Inf3)
layout1.addRow("Costo total de la Compra",self.line_Inf4)
layout1.addRow("Costo Total de la compra con mantenimiento",self.line_Inf5)
layout1.addRow("Costo Reemplazo Actuales Año",self.line_Inf6)
layout1.addRow("Costo Energia por Dia LED",self.line_Inf7)
layout1.addRow("Costo de Energia por Año LED",self.line_Inf8)
layout1.addRow("Costo Total de la Compra LED",self.line_Inf9)
layout2 = QFormLayout()
layout2.addRow("Ahorro Energia Anual",self.line_Sav1)
layout2.addRow("Ahorro Energia Mensual",self.line_Sav2)
layout2.addRow("Periodo Retorno Inversion en Años",self.line_Sav3)
layout2.addRow("Periodo Retorno Inversion en Meses",self.line_Sav4)
layout2.addWidget(self.button_Impr)
#Layout Horizontal Titulos del Form
self.LayoutTitle = QHBoxLayout()
self.LayoutTitle.addWidget(self.label_Titlef1)
self.LayoutTitle.addWidget(self.label_Titlef2)
### Layout HOrizontal que une los dos Form
self.LayoutForm = QHBoxLayout()
self.LayoutForm.addLayout(layout1)
self.LayoutForm.addLayout(layout2)
## LAyout Vertical Final
self.myLayout = QVBoxLayout()
self.myLayout.setMargin(20)
self.myLayout.addLayout(layout)
self.myLayout.addLayout(self.LayoutTitle)
self.myLayout.addLayout(self.LayoutForm)
self.setLayout(self.myLayout)
# Signals
self.button_Calc.clicked.connect(self.result_method)
def result_method(self):
v_Data1 = self.line_Data1.text()
v_Data2 = self.line_Data2.text()
v_Data3 = self.line_Data3.text()
v_Data4 = self.line_Data4.text()
v_Data5 = self.line_Data5.text()
v_Data6 = self.line_Data6.text()
v_Data7 = self.line_Data7.text()
v_Data8 = self.line_Data8.text()
v_Data9 = self.line_Data9.text()
v_Data10 = self.line_Data10.text()
#Calculo Informacion de costos Form1
v_Inf1 = int(v_Data4) * (365)
self.line_Inf1.setText(str(v_Inf1))
v_Inf2 = ((int(v_Data3) * int(v_Data4))/100) * int(v_Data1)
self.line_Inf2.setText(str(v_Inf2))
v_Inf3 = v_Inf2 * 365
self.line_Inf3.setText(str(v_Inf3))
v_Inf4 = int(v_Data2) * int(v_Data6)
self.line_Inf4.setText(str(v_Inf4))
v_Inf5 = v_Inf4 + (int(v_Data2) * int(v_Data7))
self.line_Inf5.setText(str(v_Inf5))
#v_Inf6 =
v_Inf7 = ((int(v_Data8) * int(v_Data4))/100) * int(v_Data1)
self.line_Inf7.setText(str(v_Inf7))
v_Inf8 = v_Inf7 * 365
self.line_Inf8.setText(str(v_Inf8))
v_Inf9 = (int(v_Data2) * int(v_Data10))
self.line_Inf9.setText(str(v_Inf9))
#Calculo Informacion de Ahorros Form2
v_Sav1 = v_Inf3 - v_Inf8
self.line_Sav1.setText(str(v_Sav1))
v_Sav2 = (v_Inf2 * 30) - (v_Inf7 * 30)
self.line_Sav2.setText(str(v_Sav2))
v_Sav3 = v_Inf9 / v_Sav1
self.line_Sav3.setText(str(v_Sav3))
v_Sav4 = v_Inf9 / v_Sav2
self.line_Sav4.setText(str(v_Sav4))
def setup_page(self):
self.ICON = ima.icon('genprefs')
newcb = self.create_checkbox
# --- Interface
general_group = QGroupBox(_("General"))
languages = LANGUAGE_CODES.items()
language_choices = sorted([(val, key) for key, val in languages])
language_combo = self.create_combobox(_('Language:'),
language_choices,
'interface_language',
restart=True)
opengl_options = ['Automatic', 'Desktop', 'Software', 'GLES']
opengl_choices = list(zip(opengl_options,
[c.lower() for c in opengl_options]))
opengl_combo = self.create_combobox(_('Rendering engine:'),
opengl_choices,
'opengl',
restart=True)
single_instance_box = newcb(_("Use a single instance"),
'single_instance',
tip=_("Set this to open external<br> "
"Python files in an already running "
"instance (Requires a restart)"))
prompt_box = newcb(_("Prompt when exiting"), 'prompt_on_exit')
popup_console_box = newcb(_("Show internal Spyder errors to report "
"them to Github"), 'show_internal_errors')
check_updates = newcb(_("Check for updates on startup"),
'check_updates_on_startup')
# Decide if it's possible to activate or not single instance mode
if running_in_mac_app():
self.set_option("single_instance", True)
single_instance_box.setEnabled(False)
comboboxes_advanced_layout = QHBoxLayout()
cbs_adv_grid = QGridLayout()
cbs_adv_grid.addWidget(language_combo.label, 0, 0)
cbs_adv_grid.addWidget(language_combo.combobox, 0, 1)
cbs_adv_grid.addWidget(opengl_combo.label, 1, 0)
cbs_adv_grid.addWidget(opengl_combo.combobox, 1, 1)
comboboxes_advanced_layout.addLayout(cbs_adv_grid)
comboboxes_advanced_layout.addStretch(1)
general_layout = QVBoxLayout()
general_layout.addLayout(comboboxes_advanced_layout)
general_layout.addWidget(single_instance_box)
general_layout.addWidget(prompt_box)
general_layout.addWidget(popup_console_box)
general_layout.addWidget(check_updates)
general_group.setLayout(general_layout)
# --- Theme
interface_group = QGroupBox(_("Interface"))
vertdock_box = newcb(_("Vertical title bars in panes"),
'vertical_dockwidget_titlebars')
verttabs_box = newcb(_("Vertical tabs in panes"),
'vertical_tabs')
animated_box = newcb(_("Animated toolbars and panes"),
'animated_docks')
tear_off_box = newcb(_("Tear off menus"), 'tear_off_menus',
tip=_("Set this to detach any<br> "
"menu from the main window"))
margin_box = newcb(_("Custom margin for panes:"),
'use_custom_margin')
margin_spin = self.create_spinbox("", _("pixels"), 'custom_margin',
0, 0, 30)
margin_box.toggled.connect(margin_spin.spinbox.setEnabled)
margin_box.toggled.connect(margin_spin.slabel.setEnabled)
margin_spin.spinbox.setEnabled(self.get_option('use_custom_margin'))
margin_spin.slabel.setEnabled(self.get_option('use_custom_margin'))
cursor_box = newcb(_("Cursor blinking:"),
'use_custom_cursor_blinking')
cursor_spin = self.create_spinbox(
"", _("ms"),
'custom_cursor_blinking',
default=QApplication.cursorFlashTime(),
min_=0, max_=5000, step=100)
cursor_box.toggled.connect(cursor_spin.spinbox.setEnabled)
cursor_box.toggled.connect(cursor_spin.slabel.setEnabled)
cursor_spin.spinbox.setEnabled(
self.get_option('use_custom_cursor_blinking'))
cursor_spin.slabel.setEnabled(
self.get_option('use_custom_cursor_blinking'))
margins_cursor_layout = QGridLayout()
margins_cursor_layout.addWidget(margin_box, 0, 0)
margins_cursor_layout.addWidget(margin_spin.spinbox, 0, 1)
margins_cursor_layout.addWidget(margin_spin.slabel, 0, 2)
margins_cursor_layout.addWidget(cursor_box, 1, 0)
margins_cursor_layout.addWidget(cursor_spin.spinbox, 1, 1)
margins_cursor_layout.addWidget(cursor_spin.slabel, 1, 2)
margins_cursor_layout.setColumnStretch(2, 100)
# Layout interface
interface_layout = QVBoxLayout()
interface_layout.addWidget(vertdock_box)
interface_layout.addWidget(verttabs_box)
interface_layout.addWidget(animated_box)
interface_layout.addWidget(tear_off_box)
interface_layout.addLayout(margins_cursor_layout)
interface_group.setLayout(interface_layout)
# --- Status bar
sbar_group = QGroupBox(_("Status bar"))
show_status_bar = newcb(_("Show status bar"), 'show_status_bar')
memory_box = newcb(_("Show memory usage every"), 'memory_usage/enable',
tip=self.main.mem_status.toolTip())
memory_spin = self.create_spinbox("", _(" ms"), 'memory_usage/timeout',
min_=100, max_=1000000, step=100)
memory_box.toggled.connect(memory_spin.setEnabled)
memory_spin.setEnabled(self.get_option('memory_usage/enable'))
memory_box.setEnabled(self.main.mem_status.is_supported())
memory_spin.setEnabled(self.main.mem_status.is_supported())
cpu_box = newcb(_("Show CPU usage every"), 'cpu_usage/enable',
tip=self.main.cpu_status.toolTip())
cpu_spin = self.create_spinbox("", _(" ms"), 'cpu_usage/timeout',
min_=100, max_=1000000, step=100)
cpu_box.toggled.connect(cpu_spin.setEnabled)
cpu_spin.setEnabled(self.get_option('cpu_usage/enable'))
cpu_box.setEnabled(self.main.cpu_status.is_supported())
cpu_spin.setEnabled(self.main.cpu_status.is_supported())
status_bar_o = self.get_option('show_status_bar')
show_status_bar.toggled.connect(memory_box.setEnabled)
show_status_bar.toggled.connect(memory_spin.setEnabled)
show_status_bar.toggled.connect(cpu_box.setEnabled)
show_status_bar.toggled.connect(cpu_spin.setEnabled)
memory_box.setEnabled(status_bar_o)
memory_spin.setEnabled(status_bar_o)
cpu_box.setEnabled(status_bar_o)
cpu_spin.setEnabled(status_bar_o)
# Layout status bar
cpu_memory_layout = QGridLayout()
cpu_memory_layout.addWidget(memory_box, 0, 0)
cpu_memory_layout.addWidget(memory_spin, 0, 1)
cpu_memory_layout.addWidget(cpu_box, 1, 0)
cpu_memory_layout.addWidget(cpu_spin, 1, 1)
sbar_layout = QVBoxLayout()
sbar_layout.addWidget(show_status_bar)
sbar_layout.addLayout(cpu_memory_layout)
sbar_group.setLayout(sbar_layout)
# --- Screen resolution Group (hidpi)
screen_resolution_group = QGroupBox(_("Screen resolution"))
screen_resolution_bg = QButtonGroup(screen_resolution_group)
screen_resolution_label = QLabel(_("Configuration for high DPI "
"screens<br><br>"
"Please see "
"<a href=\"{0}\">{0}</a><> "
"for more information about "
"these options (in "
"English).").format(HDPI_QT_PAGE))
screen_resolution_label.setWordWrap(True)
normal_radio = self.create_radiobutton(
_("Normal"),
'normal_screen_resolution',
button_group=screen_resolution_bg)
auto_scale_radio = self.create_radiobutton(
_("Enable auto high DPI scaling"),
'high_dpi_scaling',
button_group=screen_resolution_bg,
tip=_("Set this for high DPI displays"),
restart=True)
custom_scaling_radio = self.create_radiobutton(
_("Set a custom high DPI scaling"),
'high_dpi_custom_scale_factor',
button_group=screen_resolution_bg,
tip=_("Set this for high DPI displays when "
"auto scaling does not work"),
restart=True)
custom_scaling_edit = self.create_lineedit(
"",
'high_dpi_custom_scale_factors',
tip=_("Enter values for different screens "
"separated by semicolons ';', "
"float values are supported"),
alignment=Qt.Horizontal,
regex=r"[0-9]+(?:\.[0-9]*)(;[0-9]+(?:\.[0-9]*))*",
restart=True)
normal_radio.toggled.connect(custom_scaling_edit.setDisabled)
auto_scale_radio.toggled.connect(custom_scaling_edit.setDisabled)
custom_scaling_radio.toggled.connect(custom_scaling_edit.setEnabled)
# Layout Screen resolution
screen_resolution_layout = QVBoxLayout()
screen_resolution_layout.addWidget(screen_resolution_label)
screen_resolution_inner_layout = QGridLayout()
screen_resolution_inner_layout.addWidget(normal_radio, 0, 0)
screen_resolution_inner_layout.addWidget(auto_scale_radio, 1, 0)
screen_resolution_inner_layout.addWidget(custom_scaling_radio, 2, 0)
screen_resolution_inner_layout.addWidget(custom_scaling_edit, 2, 1)
screen_resolution_layout.addLayout(screen_resolution_inner_layout)
screen_resolution_group.setLayout(screen_resolution_layout)
tabs = QTabWidget()
tabs.addTab(self.create_tab(screen_resolution_group, interface_group),
_("Interface"))
tabs.addTab(self.create_tab(general_group, sbar_group),
_("Advanced Settings"))
vlayout = QVBoxLayout()
vlayout.addWidget(tabs)
self.setLayout(vlayout)
def __init__(self, parent=None):
QDialog.__init__(self, parent=parent)
self._shortcuts_summary_title = _("Spyder Keyboard ShortCuts")
# Calculate font and amount of elements in each column according screen size
width, height = self.get_screen_resolution()
font_size = height / 80
font_size = max(min(font_size, MAX_FONT_SIZE), MIN_FONT_SIZE)
shortcuts_column = (height - 8 * font_size) / (font_size +16)
# Widgets
style = """
QDialog {
margin:0px;
padding:0px;
border-radius: 2px;
}"""
self.setStyleSheet(style)
font_names = QFont()
font_names.setPointSize(font_size)
font_names.setBold(True)
font_keystr = QFont()
font_keystr.setPointSize(font_size)
font_title = QFont()
font_title.setPointSize(font_size+2)
font_title.setBold(True)
title_label = QLabel(self._shortcuts_summary_title)
title_label.setAlignment(Qt.AlignCenter)
title_label.setFont(font_title)
# iter over shortcuts and create GroupBox for each context
# with shortcuts in a grid
columns_layout = QHBoxLayout()
added_shortcuts = 0
group = None
# group shortcuts by context
shortcuts = groupby(sorted(iter_shortcuts()), key=itemgetter(0))
for context, group_shortcuts in shortcuts:
for i, (context, name, keystr) in enumerate(group_shortcuts):
# start of every column
if added_shortcuts == 0:
column_layout = QVBoxLayout()
# at start of new context add previous context group
if i == 0 and added_shortcuts > 0:
column_layout.addWidget(group)
# create group at start of column or context
if added_shortcuts == 0 or i == 0:
if context == '_': context = 'Global'
group = QGroupBox(context.capitalize())
group.setFont(font_names)
group_layout = QGridLayout()
group.setLayout(group_layout)
# Count space for titles
added_shortcuts += 1
# Widgets
label_name = QLabel(name.capitalize().replace('_', ' '))
label_name.setFont(font_names)
keystr = QKeySequence(keystr).toString(QKeySequence.NativeText)
label_keystr = QLabel(keystr)
label_keystr.setFont(font_keystr)
group_layout.addWidget(label_name, i, 0)
group_layout.addWidget(label_keystr, i, 1)
added_shortcuts += 1
if added_shortcuts >= shortcuts_column:
column_layout.addWidget(group)
columns_layout.addLayout(column_layout)
added_shortcuts = 0
column_layout.addWidget(group)
column_layout.addStretch() # avoid lasts sections to appear too big
columns_layout.addLayout(column_layout)
# Scroll widget
self.scroll_widget = QWidget()
self.scroll_widget.setLayout(columns_layout)
self.scroll_area = QScrollArea()
self.scroll_area.setWidget(self.scroll_widget)
# widget setup
self.setWindowFlags(Qt.FramelessWindowHint)
self.setWindowOpacity(0.95)
# layout
self._layout = QVBoxLayout()
self._layout.addWidget(title_label)
self._layout.addWidget(self.scroll_area)
self.setLayout(self._layout)
self.setGeometry(0, 0, width, height)
def setup_grain_design():
# grain table view
master = QHBoxLayout(self)
master.addWidget(QTableView())
# grain design controls
controls = QVBoxLayout(self)
# add a push button
self.btn_new_grain = QPushButton(self.tr("New Grain"))
self.btn_new_grain.setMinimumHeight(50)
controls.addWidget(self.btn_new_grain)
# add a dividing line
line = QFrame()
line.setFrameShape(QFrame.HLine)
line.setFrameShadow(QFrame.Sunken)
controls.addSpacing(5)
controls.addWidget(line)
# rest of the controls buttons
self.btn_edit_grain = QPushButton(self.tr("Edit"))
self.btn_edit_grain.setMinimumHeight(30)
controls.addWidget(self.btn_edit_grain)
self.btn_delete_Grain = QPushButton(self.tr("Delete"))
self.btn_delete_Grain.setMinimumHeight(30)
controls.addWidget(self.btn_delete_Grain)
# move grain up and down
moveup = QHBoxLayout()
self.btn_move_up = QToolButton()
self.btn_move_up.setArrowType(Qt.UpArrow)
moveup.addWidget(self.btn_move_up)
moveup.addWidget(QLabel(self.tr("Move Up")))
controls.addLayout(moveup)
movedown = QHBoxLayout()
self.btn_move_down = QToolButton()
self.btn_move_down.setArrowType(Qt.DownArrow)
movedown.addWidget(self.btn_move_down)
movedown.addWidget(QLabel(self.tr("Move Down")))
controls.addLayout(movedown)
controls.addStretch()
# add info for motor design
fl_propellant_info = QFormLayout()
gb_motor_info = QGroupBox(self.tr("Propellant Info"))
gb_motor_info.setLayout(fl_propellant_info)
self.lbl_num_grains = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Number of Segments:")), self.lbl_num_grains)
self.lbl_motor_dia = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Motor Diameter:")), self.lbl_motor_dia)
self.lbl_motor_len = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Propellant Length:")), self.lbl_motor_len)
self.lbl_prop_mass = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Propellant Mass:")), self.lbl_prop_mass)
self.lbl_volume_loading = QLabel()
fl_propellant_info.addRow(QLabel(self.tr("Volume Loading:")), self.lbl_volume_loading)
# set group box's layout
controls.addWidget(gb_motor_info)
# setup master layout
master.addLayout(controls)
self.gb_design = QGroupBox(self.tr("Grain Design"))
self.gb_design.setLayout(master)
def __init__(self, parent, language=None, cmd='', host='127.0.0.1',
port=2084, args='', external=False, configurations={},
**kwargs):
super(LSPServerEditor, self).__init__(parent)
self.parent = parent
self.external = external
bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_ok = bbox.button(QDialogButtonBox.Ok)
self.button_cancel = bbox.button(QDialogButtonBox.Cancel)
self.button_ok.setEnabled(False)
description = _('To create a new configuration, '
'you need to select a programming '
'language, along with a executable '
'name for the server to execute '
'(If the instance is local), '
'and the host and port. Finally, '
'you need to provide the '
'arguments that the server accepts. '
'The placeholders <tt>%(host)s</tt> and '
'<tt>%(port)s</tt> refer to the host '
'and the port, respectively.')
server_settings_description = QLabel(description)
server_settings_description.setWordWrap(True)
lang_label = QLabel(_('Language:'))
self.lang_cb = QComboBox(self)
self.lang_cb.setToolTip(_('Programming language provided '
'by the LSP server'))
self.lang_cb.addItem(_('Select a language'))
self.lang_cb.addItems(LSP_LANGUAGES)
if language is not None:
idx = LSP_LANGUAGES.index(language)
self.lang_cb.setCurrentIndex(idx + 1)
self.button_ok.setEnabled(True)
host_label = QLabel(_('Host:'))
self.host_input = QLineEdit(self)
self.host_input.setToolTip(_('Name of the host that will provide '
'access to the server'))
self.host_input.setText(host)
self.host_input.textChanged.connect(lambda x: self.validate())
port_label = QLabel(_('Port:'))
self.port_spinner = QSpinBox(self)
self.port_spinner.setToolTip(_('TCP port number of the server'))
self.port_spinner.setMinimum(1)
self.port_spinner.setMaximum(60000)
self.port_spinner.setValue(port)
cmd_label = QLabel(_('Command to execute:'))
self.cmd_input = QLineEdit(self)
self.cmd_input.setToolTip(_('Command used to start the '
'LSP server locally'))
self.cmd_input.setText(cmd)
if not external:
self.cmd_input.textChanged.connect(lambda x: self.validate())
args_label = QLabel(_('Server arguments:'))
self.args_input = QLineEdit(self)
self.args_input.setToolTip(_('Additional arguments required to '
'start the server'))
self.args_input.setText(args)
conf_label = QLabel(_('LSP Server Configurations:'))
self.conf_input = CodeEditor(None)
self.conf_input.textChanged.connect(self.validate)
color_scheme = CONF.get('appearance', 'selected')
self.conf_input.setup_editor(
language='JSON',
color_scheme=color_scheme,
wrap=False,
edge_line=True,
highlight_current_line=True,
highlight_current_cell=True,
occurrence_highlighting=True,
auto_unindent=True,
font=get_font(),
filename='config.json')
self.conf_input.setToolTip(_('Additional LSP server configurations '
'set at runtime. JSON required'))
conf_text = '{}'
try:
conf_text = json.dumps(configurations, indent=4, sort_keys=True)
except Exception:
pass
self.conf_input.set_text(conf_text)
self.json_label = QLabel(self.JSON_VALID, self)
self.external_cb = QCheckBox(_('External server'), self)
self.external_cb.setToolTip(_('Check if the server runs '
'on a remote location'))
self.external_cb.setChecked(external)
self.external_cb.stateChanged.connect(self.set_local_options)
hlayout = QHBoxLayout()
general_vlayout = QVBoxLayout()
general_vlayout.addWidget(server_settings_description)
vlayout = QVBoxLayout()
lang_layout = QVBoxLayout()
lang_layout.addWidget(lang_label)
lang_layout.addWidget(self.lang_cb)
# layout2 = QHBoxLayout()
# layout2.addLayout(lang_layout)
lang_layout.addWidget(self.external_cb)
vlayout.addLayout(lang_layout)
host_layout = QVBoxLayout()
host_layout.addWidget(host_label)
host_layout.addWidget(self.host_input)
port_layout = QVBoxLayout()
port_layout.addWidget(port_label)
port_layout.addWidget(self.port_spinner)
conn_info_layout = QHBoxLayout()
conn_info_layout.addLayout(host_layout)
conn_info_layout.addLayout(port_layout)
vlayout.addLayout(conn_info_layout)
cmd_layout = QVBoxLayout()
cmd_layout.addWidget(cmd_label)
cmd_layout.addWidget(self.cmd_input)
vlayout.addLayout(cmd_layout)
args_layout = QVBoxLayout()
args_layout.addWidget(args_label)
args_layout.addWidget(self.args_input)
vlayout.addLayout(args_layout)
conf_layout = QVBoxLayout()
conf_layout.addWidget(conf_label)
conf_layout.addWidget(self.conf_input)
conf_layout.addWidget(self.json_label)
hlayout.addLayout(vlayout)
hlayout.addLayout(conf_layout)
general_vlayout.addLayout(hlayout)
general_vlayout.addWidget(bbox)
self.setLayout(general_vlayout)
bbox.accepted.connect(self.accept)
bbox.rejected.connect(self.reject)
self.lang_cb.currentIndexChanged.connect(
self.lang_selection_changed)
self.form_status(False)
if language is not None:
self.form_status(True)
self.validate()
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 add_color_scheme_stack(self, scheme_name, custom=False):
"""Add a stack for a given scheme and connects the CONF values."""
color_scheme_groups = [
(_('Text'), ["normal", "comment", "string", "number", "keyword",
"builtin", "definition", "instance", ]),
(_('Highlight'), ["currentcell", "currentline", "occurrence",
"matched_p", "unmatched_p", "ctrlclick"]),
(_('Background'), ["background", "sideareas"])
]
parent = self.parent
line_edit = parent.create_lineedit(_("Scheme name:"),
'{0}/name'.format(scheme_name))
self.widgets[scheme_name] = {}
# Widget setup
line_edit.label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.setWindowTitle(_('Color scheme editor'))
# Layout
name_layout = QHBoxLayout()
name_layout.addWidget(line_edit.label)
name_layout.addWidget(line_edit.textbox)
self.scheme_name_textbox[scheme_name] = line_edit.textbox
if not custom:
line_edit.textbox.setDisabled(True)
if not self.isVisible():
line_edit.setVisible(False)
cs_layout = QVBoxLayout()
cs_layout.addLayout(name_layout)
h_layout = QHBoxLayout()
v_layout = QVBoxLayout()
for index, item in enumerate(color_scheme_groups):
group_name, keys = item
group_layout = QGridLayout()
for row, key in enumerate(keys):
option = "{0}/{1}".format(scheme_name, key)
value = self.parent.get_option(option)
name = syntaxhighlighters.COLOR_SCHEME_KEYS[key]
if is_text_string(value):
label, clayout = parent.create_coloredit(
name,
option,
without_layout=True,
)
label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
group_layout.addWidget(label, row+1, 0)
group_layout.addLayout(clayout, row+1, 1)
# Needed to update temp scheme to obtain instant preview
self.widgets[scheme_name][key] = [clayout]
else:
label, clayout, cb_bold, cb_italic = parent.create_scedit(
name,
option,
without_layout=True,
)
label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
group_layout.addWidget(label, row+1, 0)
group_layout.addLayout(clayout, row+1, 1)
group_layout.addWidget(cb_bold, row+1, 2)
group_layout.addWidget(cb_italic, row+1, 3)
# Needed to update temp scheme to obtain instant preview
self.widgets[scheme_name][key] = [clayout, cb_bold,
cb_italic]
group_box = QGroupBox(group_name)
group_box.setLayout(group_layout)
if index == 0:
h_layout.addWidget(group_box)
else:
v_layout.addWidget(group_box)
h_layout.addLayout(v_layout)
cs_layout.addLayout(h_layout)
stackitem = QWidget()
stackitem.setLayout(cs_layout)
self.stack.addWidget(stackitem)
self.order.append(scheme_name)
def setup_page(self):
newcb = self.create_checkbox
# --- Display tab ---
showtabbar_box = newcb(_("Show tab bar"), 'show_tab_bar')
showclassfuncdropdown_box = newcb(
_("Show selector for classes and functions"),
'show_class_func_dropdown')
showindentguides_box = newcb(_("Show Indent Guides"),
'indent_guides')
linenumbers_box = newcb(_("Show line numbers"), 'line_numbers')
blanks_box = newcb(_("Show blank spaces"), 'blank_spaces')
currentline_box = newcb(_("Highlight current line"),
'highlight_current_line')
currentcell_box = newcb(_("Highlight current cell"),
'highlight_current_cell')
wrap_mode_box = newcb(_("Wrap lines"), 'wrap')
scroll_past_end_box = newcb(_("Scroll past the end"),
'scroll_past_end')
edgeline_box = newcb(_("Show vertical lines at"), 'edge_line')
edgeline_edit = self.create_lineedit(
"",
'edge_line_columns',
tip=("Enter values separated by commas"),
alignment=Qt.Horizontal,
regex="[0-9]+(,[0-9]+)*")
edgeline_edit_label = QLabel(_("characters"))
edgeline_box.toggled.connect(edgeline_edit.setEnabled)
edgeline_box.toggled.connect(edgeline_edit_label.setEnabled)
edgeline_edit.setEnabled(self.get_option('edge_line'))
edgeline_edit_label.setEnabled(self.get_option('edge_line'))
occurrence_box = newcb(_("Highlight occurrences after"),
'occurrence_highlighting')
occurrence_spin = self.create_spinbox(
"", _(" ms"),
'occurrence_highlighting/timeout',
min_=100, max_=1000000, step=100)
occurrence_box.toggled.connect(occurrence_spin.spinbox.setEnabled)
occurrence_box.toggled.connect(occurrence_spin.slabel.setEnabled)
occurrence_spin.spinbox.setEnabled(
self.get_option('occurrence_highlighting'))
occurrence_spin.slabel.setEnabled(
self.get_option('occurrence_highlighting'))
display_g_layout = QGridLayout()
display_g_layout.addWidget(edgeline_box, 0, 0)
display_g_layout.addWidget(edgeline_edit.textbox, 0, 1)
display_g_layout.addWidget(edgeline_edit_label, 0, 2)
display_g_layout.addWidget(occurrence_box, 1, 0)
display_g_layout.addWidget(occurrence_spin.spinbox, 1, 1)
display_g_layout.addWidget(occurrence_spin.slabel, 1, 2)
display_h_layout = QHBoxLayout()
display_h_layout.addLayout(display_g_layout)
display_h_layout.addStretch(1)
display_layout = QVBoxLayout()
display_layout.addWidget(showtabbar_box)
display_layout.addWidget(showclassfuncdropdown_box)
display_layout.addWidget(showindentguides_box)
display_layout.addWidget(linenumbers_box)
display_layout.addWidget(blanks_box)
display_layout.addWidget(currentline_box)
display_layout.addWidget(currentcell_box)
display_layout.addWidget(wrap_mode_box)
display_layout.addWidget(scroll_past_end_box)
display_layout.addLayout(display_h_layout)
display_widget = QWidget()
display_widget.setLayout(display_layout)
# --- Source code tab ---
closepar_box = newcb(
_("Automatic insertion of parentheses, braces and brackets"),
'close_parentheses')
close_quotes_box = newcb(
_("Automatic insertion of closing quotes"),
'close_quotes')
add_colons_box = newcb(
_("Automatic insertion of colons after 'for', 'if', 'def', etc"),
'add_colons')
autounindent_box = newcb(
_("Automatic indentation after 'else', 'elif', etc."),
'auto_unindent')
tab_mode_box = newcb(
_("Tab always indent"),
'tab_always_indent', default=False,
tip=_("If enabled, pressing Tab will always indent,\n"
"even when the cursor is not at the beginning\n"
"of a line (when this option is enabled, code\n"
"completion may be triggered using the alternate\n"
"shortcut: Ctrl+Space)"))
ibackspace_box = newcb(
_("Intelligent backspace"),
'intelligent_backspace',
default=True)
removetrail_box = newcb(
_("Automatically remove trailing spaces when saving files"),
'always_remove_trailing_spaces',
default=False)
indent_chars_box = self.create_combobox(
_("Indentation characters: "),
((_("2 spaces"), '* *'),
(_("3 spaces"), '* *'),
(_("4 spaces"), '* *'),
(_("5 spaces"), '* *'),
(_("6 spaces"), '* *'),
(_("7 spaces"), '* *'),
(_("8 spaces"), '* *'),
(_("Tabulations"), '*\t*')),
'indent_chars')
tabwidth_spin = self.create_spinbox(
_("Tab stop width:"),
_("spaces"),
'tab_stop_width_spaces',
4, 1, 8, 1)
def enable_tabwidth_spin(index):
if index == 7: # Tabulations
tabwidth_spin.plabel.setEnabled(True)
tabwidth_spin.spinbox.setEnabled(True)
else:
tabwidth_spin.plabel.setEnabled(False)
tabwidth_spin.spinbox.setEnabled(False)
indent_chars_box.combobox.currentIndexChanged.connect(
enable_tabwidth_spin)
indent_tab_grid_layout = QGridLayout()
indent_tab_grid_layout.addWidget(indent_chars_box.label, 0, 0)
indent_tab_grid_layout.addWidget(indent_chars_box.combobox, 0, 1)
indent_tab_grid_layout.addWidget(tabwidth_spin.plabel, 1, 0)
indent_tab_grid_layout.addWidget(tabwidth_spin.spinbox, 1, 1)
indent_tab_grid_layout.addWidget(tabwidth_spin.slabel, 1, 2)
indent_tab_layout = QHBoxLayout()
indent_tab_layout.addLayout(indent_tab_grid_layout)
indent_tab_layout.addStretch(1)
sourcecode_layout = QVBoxLayout()
sourcecode_layout.addWidget(closepar_box)
sourcecode_layout.addWidget(autounindent_box)
sourcecode_layout.addWidget(add_colons_box)
sourcecode_layout.addWidget(close_quotes_box)
sourcecode_layout.addWidget(tab_mode_box)
sourcecode_layout.addWidget(ibackspace_box)
sourcecode_layout.addWidget(removetrail_box)
sourcecode_layout.addLayout(indent_tab_layout)
sourcecode_widget = QWidget()
sourcecode_widget.setLayout(sourcecode_layout)
# --- Run code tab ---
saveall_box = newcb(_("Save all files before running script"),
'save_all_before_run')
focus_box = newcb(_("Maintain focus in the Editor after running cells "
"or selections"), 'focus_to_editor')
run_cell_box = newcb(_("Copy full cell contents to the console when "
"running code cells"), 'run_cell_copy')
run_layout = QVBoxLayout()
run_layout.addWidget(saveall_box)
run_layout.addWidget(focus_box)
run_layout.addWidget(run_cell_box)
run_widget = QWidget()
run_widget.setLayout(run_layout)
# --- Advanced tab ---
# -- Templates
template_btn = self.create_button(_("Edit template for new files"),
self.plugin.edit_template)
# -- Autosave
autosave_group = QGroupBox(_('Autosave'))
autosave_checkbox = newcb(
_('Automatically save a copy of files with unsaved changes'),
'autosave_enabled')
autosave_spinbox = self.create_spinbox(
_('Autosave interval: '),
_('seconds'),
'autosave_interval',
min_=1, max_=3600)
autosave_checkbox.toggled.connect(autosave_spinbox.setEnabled)
autosave_layout = QVBoxLayout()
autosave_layout.addWidget(autosave_checkbox)
autosave_layout.addWidget(autosave_spinbox)
autosave_group.setLayout(autosave_layout)
# -- Docstring
docstring_group = QGroupBox(_('Docstring type'))
numpy_url = "<a href='{}'>Numpy</a>".format(NUMPYDOC)
googledoc_url = "<a href='{}'>Google</a>".format(GOOGLEDOC)
docstring_label = QLabel(
_("Here you can select the type of docstrings ({} or {}) you "
"want the editor to automatically introduce when pressing "
"<tt>{}</tt> after a function/method/class "
"declaration.").format(
numpy_url, googledoc_url, DOCSTRING_SHORTCUT))
docstring_label.setOpenExternalLinks(True)
docstring_label.setWordWrap(True)
docstring_combo_choices = ((_("Numpy"), 'Numpydoc'),
(_("Google"), 'Googledoc'),)
docstring_combo = self.create_combobox(
"Type:",
docstring_combo_choices,
'docstring_type')
docstring_layout = QVBoxLayout()
docstring_layout.addWidget(docstring_label)
docstring_layout.addWidget(docstring_combo)
docstring_group.setLayout(docstring_layout)
# -- Annotations
annotations_group = QGroupBox(_("Annotations"))
annotations_label = QLabel(
_("Display a marker to the left of line numbers when the "
"following annotations appear at the beginning of a comment: "
"<tt>TODO, FIXME, XXX, HINT, TIP, @todo, HACK, BUG, OPTIMIZE, "
"!!!, ???</tt>"))
annotations_label.setWordWrap(True)
todolist_box = newcb(
_("Display code annotations"),
'todo_list')
annotations_layout = QVBoxLayout()
annotations_layout.addWidget(annotations_label)
annotations_layout.addWidget(todolist_box)
annotations_group.setLayout(annotations_layout)
# -- EOL
eol_group = QGroupBox(_("End-of-line characters"))
eol_label = QLabel(_("When opening a text file containing "
"mixed end-of-line characters (this may "
"raise syntax errors in the consoles "
"on Windows platforms), Spyder may fix the "
"file automatically."))
eol_label.setWordWrap(True)
check_eol_box = newcb(_("Fix automatically and show warning "
"message box"),
'check_eol_chars', default=True)
convert_eol_on_save_box = newcb(_("On Save: convert EOL characters"
" to"),
'convert_eol_on_save', default=False)
eol_combo_choices = ((_("LF (UNIX)"), 'LF'),
(_("CRLF (Windows)"), 'CRLF'),
(_("CR (Mac)"), 'CR'),
)
convert_eol_on_save_combo = self.create_combobox("",
eol_combo_choices,
('convert_eol_on_'
'save_to'),
)
convert_eol_on_save_box.toggled.connect(
convert_eol_on_save_combo.setEnabled)
convert_eol_on_save_combo.setEnabled(
self.get_option('convert_eol_on_save'))
eol_on_save_layout = QHBoxLayout()
eol_on_save_layout.addWidget(convert_eol_on_save_box)
eol_on_save_layout.addWidget(convert_eol_on_save_combo)
eol_layout = QVBoxLayout()
eol_layout.addWidget(eol_label)
eol_layout.addWidget(check_eol_box)
eol_layout.addLayout(eol_on_save_layout)
eol_group.setLayout(eol_layout)
# --- Tabs ---
tabs = QTabWidget()
tabs.addTab(self.create_tab(display_widget), _("Display"))
tabs.addTab(self.create_tab(sourcecode_widget), _("Source code"))
tabs.addTab(self.create_tab(run_widget), _('Run Code'))
tabs.addTab(self.create_tab(template_btn, autosave_group,
docstring_group, annotations_group,
eol_group),
_("Advanced settings"))
vlayout = QVBoxLayout()
vlayout.addWidget(tabs)
self.setLayout(vlayout)
