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, TimeSeries):
self.is_time_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.dataTable.resizeColumnsToContents)
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_time_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 setup_page(self):
tabs = QTabWidget()
names = self.get_option("names")
names.pop(names.index(CUSTOM_COLOR_SCHEME_NAME))
names.insert(0, CUSTOM_COLOR_SCHEME_NAME)
fieldnames = {
"background": _("Background:"),
"currentline": _("Current line:"),
"currentcell": _("Current cell:"),
"occurence": _("Occurence:"),
"ctrlclick": _("Link:"),
"sideareas": _("Side areas:"),
"matched_p": _("Matched parentheses:"),
"unmatched_p": _("Unmatched parentheses:"),
"normal": _("Normal text:"),
"keyword": _("Keyword:"),
"builtin": _("Builtin:"),
"definition": _("Definition:"),
"comment": _("Comment:"),
"string": _("String:"),
"number": _("Number:"),
"instance": _("Instance:"),
}
from spyderlib.widgets.sourcecode import syntaxhighlighters
assert all([key in fieldnames
for key in syntaxhighlighters.COLOR_SCHEME_KEYS])
for tabname in names:
cs_group = QGroupBox(_("Color scheme"))
cs_layout = QGridLayout()
for row, key in enumerate(syntaxhighlighters.COLOR_SCHEME_KEYS):
option = "%s/%s" % (tabname, key)
value = self.get_option(option)
name = fieldnames[key]
if is_text_string(value):
label, clayout = self.create_coloredit(name, option,
without_layout=True)
label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
cs_layout.addWidget(label, row+1, 0)
cs_layout.addLayout(clayout, row+1, 1)
else:
label, clayout, cb_bold, cb_italic = self.create_scedit(
name, option, without_layout=True)
label.setAlignment(Qt.AlignRight|Qt.AlignVCenter)
cs_layout.addWidget(label, row+1, 0)
cs_layout.addLayout(clayout, row+1, 1)
cs_layout.addWidget(cb_bold, row+1, 2)
cs_layout.addWidget(cb_italic, row+1, 3)
cs_group.setLayout(cs_layout)
if tabname in sh.COLOR_SCHEME_NAMES:
def_btn = self.create_button(_("Reset to default values"),
lambda: self.reset_to_default(tabname))
tabs.addTab(self.create_tab(cs_group, def_btn), tabname)
else:
tabs.addTab(self.create_tab(cs_group), tabname)
vlayout = QVBoxLayout()
vlayout.addWidget(tabs)
self.setLayout(vlayout)
def setup_page(self):
network_group = QGroupBox(_("Network settings"))
self.checkbox_proxy = self.create_checkbox(_("Use network proxy"),
'use_proxy_flag',
default=False)
server = self.create_lineedit(_('Server'),
'server',
default='',
alignment=Qt.Horizontal)
port = self.create_lineedit(_('Port'),
'port',
default='',
alignment=Qt.Horizontal)
user = self.create_lineedit(_('User'),
'user',
default='',
alignment=Qt.Horizontal)
password = self.create_lineedit(_('Password'),
'password',
default='',
alignment=Qt.Horizontal)
self.widgets = [server, port, user, password]
network_layout = QGridLayout()
network_layout.addWidget(self.checkbox_proxy, 0, 0)
network_layout.addWidget(server, 1, 0)
network_layout.addWidget(port, 1, 1)
network_layout.addWidget(user, 2, 0)
network_layout.addWidget(password, 2, 1)
network_group.setLayout(network_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(network_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
# signals
self.checkbox_proxy.clicked.connect(self.proxy_settings)
self.proxy_settings()
def setup_page(self):
newcb = self.create_checkbox
# --- Interface
interface_group = QGroupBox(_("Interface"))
styles = [str(txt) for txt in list(QStyleFactory.keys())]
# Don't offer users the possibility to change to a different
# style in Gtk-based desktops
# Fixes Issue 2036
if is_gtk_desktop() and ('GTK+' in styles):
styles = ['GTK+']
choices = list(zip(styles, [style.lower() for style in styles]))
style_combo = self.create_combobox(_('Qt windows style'),
choices,
'windows_style',
default=self.main.default_style)
themes = ['Spyder 2', 'Spyder 3']
icon_choices = list(zip(themes, [theme.lower() for theme in themes]))
icons_combo = self.create_combobox(_('Icon theme'),
icon_choices,
'icon_theme',
restart=True)
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)
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)"))
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.setEnabled)
margin_spin.setEnabled(self.get_option('use_custom_margin'))
margins_layout = QHBoxLayout()
margins_layout.addWidget(margin_box)
margins_layout.addWidget(margin_spin)
prompt_box = newcb(_("Prompt when exiting"), 'prompt_on_exit')
# 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)
# Layout interface
comboboxes_layout = QHBoxLayout()
cbs_layout = QGridLayout()
cbs_layout.addWidget(style_combo.label, 0, 0)
cbs_layout.addWidget(style_combo.combobox, 0, 1)
cbs_layout.addWidget(icons_combo.label, 1, 0)
cbs_layout.addWidget(icons_combo.combobox, 1, 1)
cbs_layout.addWidget(language_combo.label, 2, 0)
cbs_layout.addWidget(language_combo.combobox, 2, 1)
comboboxes_layout.addLayout(cbs_layout)
comboboxes_layout.addStretch(1)
interface_layout = QVBoxLayout()
interface_layout.addLayout(comboboxes_layout)
interface_layout.addWidget(single_instance_box)
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_layout)
interface_layout.addWidget(prompt_box)
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)
# --- Debugging
debug_group = QGroupBox(_("Debugging"))
popup_console_box = newcb(
_("Pop up internal console when internal "
"errors appear"), 'show_internal_console_if_traceback')
debug_layout = QVBoxLayout()
debug_layout.addWidget(popup_console_box)
debug_group.setLayout(debug_layout)
# --- Spyder updates
update_group = QGroupBox(_("Updates"))
check_updates = newcb(_("Check for updates on startup"),
'check_updates_on_startup')
update_layout = QVBoxLayout()
update_layout.addWidget(check_updates)
update_group.setLayout(update_layout)
vlayout = QVBoxLayout()
vlayout.addWidget(interface_group)
vlayout.addWidget(sbar_group)
vlayout.addWidget(debug_group)
vlayout.addWidget(update_group)
vlayout.addStretch(1)
self.setLayout(vlayout)
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.clo_cb = QCheckBox(_("Command line options:"))
common_layout.addWidget(self.clo_cb, 0, 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, 0, 1)
self.wd_cb = QCheckBox(_("Working directory:"))
common_layout.addWidget(self.wd_cb, 1, 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(get_std_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, 1, 1)
self.post_mortem_cb = QCheckBox(_("Enter post mortem debugging"
" for uncaught exceptions"))
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 __init__(self, parent, context, name, sequence, shortcuts):
super(ShortcutEditor, self).__init__(parent)
self._parent = parent
self.context = context
self.npressed = 0
self.keys = set()
self.key_modifiers = set()
self.key_non_modifiers = list()
self.key_text = list()
self.sequence = sequence
self.new_sequence = None
self.edit_state = True
self.shortcuts = shortcuts
# Widgets
self.label_info = QLabel()
self.label_info.setText(_("Press the new shortcut and select 'Ok': \n"
"(Press 'Tab' once to switch focus between the shortcut entry \n"
"and the buttons below it)"))
self.label_current_sequence = QLabel(_("Current shortcut:"))
self.text_current_sequence = QLabel(sequence)
self.label_new_sequence = QLabel(_("New shortcut:"))
self.text_new_sequence = CustomLineEdit(self)
self.text_new_sequence.setPlaceholderText(sequence)
self.helper_button = HelperToolButton()
self.helper_button.hide()
self.label_warning = QLabel()
self.label_warning.hide()
bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.button_ok = bbox.button(QDialogButtonBox.Ok)
self.button_cancel = bbox.button(QDialogButtonBox.Cancel)
# Setup widgets
self.setWindowTitle(_('Shortcut: {0}').format(name))
self.button_ok.setFocusPolicy(Qt.NoFocus)
self.button_ok.setEnabled(False)
self.button_cancel.setFocusPolicy(Qt.NoFocus)
self.helper_button.setToolTip('')
self.helper_button.setFocusPolicy(Qt.NoFocus)
style = """
QToolButton {
margin:1px;
border: 0px solid grey;
padding:0px;
border-radius: 0px;
}"""
self.helper_button.setStyleSheet(style)
self.text_new_sequence.setFocusPolicy(Qt.NoFocus)
self.label_warning.setFocusPolicy(Qt.NoFocus)
# Layout
spacing = 5
layout_sequence = QGridLayout()
layout_sequence.addWidget(self.label_info, 0, 0, 1, 3)
layout_sequence.addItem(QSpacerItem(spacing, spacing), 1, 0, 1, 2)
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.addWidget(self.label_warning, 4, 2, 1, 2)
layout = QVBoxLayout()
layout.addLayout(layout_sequence)
layout.addSpacing(spacing)
layout.addWidget(bbox)
self.setLayout(layout)
# Signals
bbox.accepted.connect(self.accept)
bbox.rejected.connect(self.reject)
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=get_std_icon("DialogCloseButton"))
glayout.addWidget(self.close_button, 0, 0)
# Find layout
self.search_text = PatternComboBox(self,
tip=_("Search string"),
adjust_to_minimum=False)
self.search_text.valid.connect(lambda state: self.find(
changed=False, forward=True, rehighlight=False))
self.search_text.lineEdit().textEdited.connect(
self.text_has_been_edited)
self.previous_button = create_toolbutton(self,
triggered=self.find_previous,
icon=get_std_icon("ArrowUp"))
self.next_button = create_toolbutton(self,
triggered=self.find_next,
icon=get_std_icon("ArrowDown"))
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=get_icon("advanced.png"),
tip=_("Regular expression"))
self.re_button.setCheckable(True)
self.re_button.toggled.connect(lambda state: self.find())
self.case_button = create_toolbutton(self,
icon=get_icon("upper_lower.png"),
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.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_button = create_toolbutton(
self,
text=_("Replace/find"),
icon=get_std_icon("DialogApplyButton"),
triggered=self.replace_find,
text_beside_icon=True)
self.replace_button.clicked.connect(self.update_replace_combo)
self.replace_button.clicked.connect(self.update_search_combo)
self.all_check = QCheckBox(_("Replace all"))
self.replace_layout = QHBoxLayout()
widgets = [
replace_with, self.replace_text, self.replace_button,
self.all_check
]
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)
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)
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_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
is_record_array = data.dtype.names is not None
is_masked_array = isinstance(data, np.ma.MaskedArray)
if data.size == 0:
self.error(_("Array is empty"))
return False
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 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(get_icon('arredit.png'))
if title:
title = to_text_string(title) # in case title is not a string
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()
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()
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)
self.setMinimumSize(400, 300)
# Make the dialog act as a window
self.setWindowFlags(Qt.Window)
return True
def setup_and_check(self, data, title=''):
"""
Setup DataFrameEditor:
return False if data is not supported, True otherwise
"""
size = 1
for dim in data.shape:
size *= dim
if size > 1e6:
answer = QMessageBox.warning(
self,
_("%s editor") % data.__class__.__name__,
_("Opening and browsing this "
"%s can be slow\n\n"
"Do you want to continue anyway?") % data.__class__.__name__,
QMessageBox.Yes | QMessageBox.No)
if answer == QMessageBox.No:
return
self.layout = QGridLayout()
self.setLayout(self.layout)
self.setWindowIcon(get_icon('arredit.png'))
if title:
title = to_text_string(title) # in case title is not a string
else:
title = _("%s editor") % data.__class__.__name__
if isinstance(data, TimeSeries):
self.is_time_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)
self.connect(btn, SIGNAL("clicked()"), self.change_format)
btn = QPushButton(_('Resize'))
btn_layout.addWidget(btn)
self.connect(btn, SIGNAL("clicked()"),
self.dataTable.resizeColumnsToContents)
bgcolor = QCheckBox(_('Background color'))
bgcolor.setChecked(self.dataModel.bgcolor_enabled)
bgcolor.setEnabled(self.dataModel.bgcolor_enabled)
self.connect(bgcolor, SIGNAL("stateChanged(int)"),
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_time_series
and self.dataModel.bgcolor_enabled)
self.connect(self.bgcolor_global, SIGNAL("stateChanged(int)"),
self.dataModel.colum_avg)
btn_layout.addWidget(self.bgcolor_global)
btn_layout.addStretch()
bbox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.connect(bbox, SIGNAL("accepted()"), SLOT("accept()"))
self.connect(bbox, SIGNAL("rejected()"), SLOT("reject()"))
btn_layout.addWidget(bbox)
self.layout.addLayout(btn_layout, 2, 0)
return True
def __init__(self, parent, max_entries=100):
"Initialize Various list objects before assignment"
displaylist = []
displaynamelist = []
infixmod = []
infixlist = []
desclist = []
parameternamelist = []
parameterdesclist = []
parameterstringlist = []
paramcountlist = []
buttonlist = []
xmldoc = minidom.parse('C:\\Users\\Jayit\\.spyder2\\ratelaw2_0_3.xml')
#xmldoc = minidom.parse('%\\Downloads\\ratelaw2_0_3.xml')
lawlistxml = xmldoc.getElementsByTagName('law')
o = 0
for s in lawlistxml:
o = o + 1
parameternamelistlist = [0 for x in range(o)]
parameterdesclistlist = [0 for x in range(o)]
"""i is the number of laws currently in the xml file"""
i = 0
"""
Parsing xml: Acquiring rate law name, description, and list of parameter information
"""
for s in lawlistxml:
#RATE_LAW_MESSAGE += s.getAttribute('displayName') + "\n"
"""Gets Latec Expression"""
displaylist.append(s.getAttribute('display'))
"""Gets Rate-Law Name"""
displaynamelist.append(s.getAttribute('displayName'))
""""Gets Raw Rate-Law expression"""
infixlist.append(s.getAttribute('infixExpression'))
"""Gets description statement"""
desclist.append(s.getAttribute('description'))
"""Gets listOfParameters Object"""
parameterlist = s.getElementsByTagName('listOfParameters')[0]
"""Gets a list of parameters within ListOfParameters object"""
parameters = parameterlist.getElementsByTagName('parameter')
for param in parameters:
parameternamelist.append(param.attributes['name'].value)
#print(param.attributes['name'].value)
parameterdesclist.append(param.attributes['description'].value)
parameternamelistlist[i] = parameternamelist
#print("break")
parameterdesclistlist[i] = parameterdesclist
parameternamelist = []
parameterdesclist = []
i = i + 1
SLElistlist = [0 for x in range(i)]
PLElistlist = [0 for x in range(i)]
ILElistlist = [0 for x in range(i)]
paramLElistlist = [0 for x in range(i)]
numlistlist = [0 for x in range(i)]
QWidget.__init__(self, parent)
self.setWindowTitle("Rate Law Library")
self.output = None
self.error_output = None
self._last_wdir = None
self._last_args = None
self._last_pythonpath = None
#self.textlabel = QLabel(RATE_LAW_MESSAGE)
self.lawlist = QListWidget()
self.lawpage = QStackedWidget()
index = 0
for j in range(i):
item = QListWidgetItem(displaynamelist[j])
self.lawlist.addItem(item)
self.lawdetailpage = QWidget()
setup_group = QGroupBox(displaynamelist[j])
infixmod.append(infixlist[j].replace("___", " "))
setup_label = QLabel(infixmod[j])
setup_label.setWordWrap(True)
desc_group = QGroupBox("Description")
desc_label = QLabel(desclist[j])
desc_label.setWordWrap(True)
param_label = QGridLayout()
nm = QLabel("Name:")
des = QLabel("Description:")
repl = QLabel("Replace with:")
param_label.addWidget(nm, 0, 0)
param_label.addWidget(des, 0, 1)
param_label.addWidget(repl, 0, 2)
"""g is the total number of alterable values"""
g = 0
"""t is the total number of alterable non-parameters"""
t = 1
snum = 0
pnum = 0
inum = 0
"""range of N is the max number of possible substrates OR products"""
N = 5
for n in range(N):
nl = n + 1
if (infixmod[j].find('S%s' % nl) > -1):
z = QLabel('S%s is present' % nl)
param_label.addWidget(z, t, 0)
snum = snum + 1
t = t + 1
for n in range(N):
nl = n + 1
if (infixmod[j].find('P%s' % nl) > -1):
z = QLabel('P%s is present' % nl)
param_label.addWidget(z, t, 0)
pnum = pnum + 1
t = t + 1
for n in range(N):
nl = n + 1
if (infixmod[j].find('I%s' % nl) > -1):
z = QLabel('I%s is present' % nl)
param_label.addWidget(z, t, 0)
inum = inum + 1
t = t + 1
"""Initialize lists of list of parameter lineedit"""
length = len(parameternamelistlist[j])
for b in range(length):
p = QLabel("%s :" % parameternamelistlist[j][b])
param_label.addWidget(p, b + t, 0)
d = QLabel("'%s'" % parameterdesclistlist[j][b])
param_label.addWidget(d, b + t, 1)
g = t + length
Slineeditlist = [0 for x in range(snum)]
Plineeditlist = [0 for x in range(pnum)]
Ilineeditlist = [0 for x in range(inum)]
paramlineeditlist = [0 for x in range(length)]
editcount = 1
"""Place lineedit widgets for parameters"""
for s in range(snum):
Slineeditlist[s] = QLineEdit()
param_label.addWidget(Slineeditlist[s], editcount, 2)
editcount = editcount + 1
SLElistlist[j] = Slineeditlist
for s in range(pnum):
Plineeditlist[s] = QLineEdit()
param_label.addWidget(Plineeditlist[s], editcount, 2)
editcount = editcount + 1
PLElistlist[j] = Plineeditlist
for s in range(inum):
Ilineeditlist[s] = QLineEdit()
param_label.addWidget(Ilineeditlist[s], editcount, 2)
editcount = editcount + 1
ILElistlist[j] = Ilineeditlist
for s in range(length):
paramlineeditlist[s] = QLineEdit()
param_label.addWidget(paramlineeditlist[s], editcount, 2)
editcount = editcount + 1
paramLElistlist[j] = paramlineeditlist
"""Necessary lists for editable parameters. Housekeeping essentially."""
stuff = paramlineeditlist[0].text()
numlistlist[j] = [snum, pnum, inum, length]
charlist = ["S", "P", "I"]
buttonlist.append(QPushButton(self))
buttonlist[j].setText("Insert Rate Law: %s" % displaynamelist[j])
# Warning: do not try to regroup the following QLabel contents with
# widgets above -- this string was isolated here in a single QLabel
# on purpose: to fix Issue 863
"""Page formatting"""
setup_layout = QVBoxLayout()
setup_layout.addWidget(setup_label)
setup_group.setLayout(setup_layout)
desc_group.setLayout(param_label)
vlayout = QVBoxLayout()
vlayout.addWidget(setup_group)
vlayout.addWidget(desc_group)
vlayout.addWidget(buttonlist[j])
vlayout.addStretch(1)
self.lawdetailpage.setLayout(vlayout)
self.lawpage.addWidget(self.lawdetailpage)
"""Set up button functionality"""
for k in range(47):
buttonlist[k].clicked.connect(
pressbutton(self, infixmod[k], SLElistlist[k], PLElistlist[k],
ILElistlist[k], paramLElistlist[k],
parameternamelistlist[k], numlistlist[k], charlist,
k))
self.lawlist.currentRowChanged.connect(self.lawpage.setCurrentIndex)
self.lawlist.setCurrentRow(0)
"""Set up high-level widget formatting."""
hsplitter = QSplitter()
hsplitter.addWidget(self.lawlist)
hsplitter.addWidget(self.lawpage)
layout = QVBoxLayout()
layout.addWidget(hsplitter)
self.setLayout(layout)
