def refresh_plots_item(self, item, vname, mp=None, sp=None):
expand = item.isExpanded()
item.takeChildren()
try:
num = self.ds().psy.num
except AttributeError:
return
if mp is None:
mp = gcp(True)
if sp is None:
sp = gcp()
for i in range(len(mp)):
sub = mp[i:i + 1]
array_info = sub.array_info(ds_description={'arr', 'num'})
arrs = sub._get_ds_descriptions(array_info).get(num, {})
if arrs and any(vname in arr.psy.base_variables
for arr in arrs['arr']):
child = QTreeWidgetItem(0)
prefix = '*' if sub[0] in sp else ''
text = sub[0].psy._short_info()
child.setText(0, prefix + text)
child.setToolTip(0, text)
item.addChild(child)
if expand and item.childCount():
item.setExpanded(True)
def initialize(self):
"""Fill the items of the :attr:`rc` into the tree"""
rcParams = self.rc
descriptions = self.descriptions
self.valid = [True] * len(rcParams)
validators = self.validators
vcol = self.value_col
for i, (key, val) in enumerate(sorted(rcParams.items())):
item = QTreeWidgetItem(0)
item.setText(0, key)
item.setToolTip(0, key)
item.setIcon(1, QIcon(get_icon('valid.png')))
desc = descriptions.get(key)
if desc:
item.setText(vcol, desc)
item.setToolTip(vcol, desc)
child = QTreeWidgetItem(0)
item.addChild(child)
self.addTopLevelItem(item)
editor = QTextEdit(self)
# set maximal height of the editor to 3 rows
editor.setMaximumHeight(
4 * QtGui.QFontMetrics(editor.font()).height())
editor.setPlainText(yaml.dump(val))
self.setItemWidget(child, vcol, editor)
editor.textChanged.connect(
self.set_icon_func(i, item, validators[key]))
self.resizeColumnToContents(0)
self.resizeColumnToContents(1)
def initialize(self):
"""Fill the items of the :attr:`rc` into the tree"""
rcParams = self.rc
descriptions = self.descriptions
self.valid = [True] * len(rcParams)
validators = self.validators
vcol = self.value_col
for i, (key, val) in enumerate(sorted(rcParams.items())):
item = QTreeWidgetItem(0)
item.setText(0, key)
item.setToolTip(0, key)
item.setIcon(1, QIcon(get_icon('valid.png')))
desc = descriptions.get(key)
if desc:
item.setText(vcol, desc)
item.setToolTip(vcol, desc)
child = QTreeWidgetItem(0)
item.addChild(child)
self.addTopLevelItem(item)
editor = QTextEdit(self)
# set maximal height of the editor to 3 rows
editor.setMaximumHeight(4 *
QtGui.QFontMetrics(editor.font()).height())
editor.setPlainText(yaml.dump(val))
self.setItemWidget(child, vcol, editor)
editor.textChanged.connect(
self.set_icon_func(i, item, validators[key]))
self.resizeColumnToContents(0)
self.resizeColumnToContents(1)
def add_attrs(self, attrs=None, item=None):
if attrs is None:
attrs = self.ds().attrs
self.attrs.takeChildren()
if item is None:
item = self.attrs
for key, val in attrs.items():
child = QTreeWidgetItem(0)
child.setText(0, key)
child.setText(1, str(val))
child.setToolTip(1, '{}: {}'.format(key, str(val)))
item.addChild(child)
def add_figures_from_cp(self, project):
"""Add the items in this tree based upon the figures in the given
project"""
if project is None or not project.is_main:
return
for item in map(self.takeTopLevelItem, [0] * self.topLevelItemCount()):
for child in item.takeChildren():
child.disconnect_from_array()
for fig, arrays in six.iteritems(project.figs):
item = QTreeWidgetItem(0)
item.setText(0, fig.canvas.get_window_title())
item.addChildren([FiguresTreeItem(arr, 0) for arr in arrays])
self.addTopLevelItem(item)
def add_figures_from_cp(self, project):
"""Add the items in this tree based upon the figures in the given
project"""
if project is None or not project.is_main:
return
for item in map(self.takeTopLevelItem, [0] * self.topLevelItemCount()):
for child in item.takeChildren():
child.disconnect_from_array()
for fig, arrays in six.iteritems(project.figs):
item = QTreeWidgetItem(0)
item.setText(0, fig.canvas.get_window_title())
item.addChildren(
[FiguresTreeItem(weakref.ref(arr), 0) for arr in arrays])
self.addTopLevelItem(item)
def add_variables(self, ds=None):
"""Add children of variables and coords to this TreeWidgetItem"""
if ds is None:
ds = self.ds()
self.variables.takeChildren()
self.coords.takeChildren()
else:
self.ds = weakref.ref(ds)
columns = self.columns
variables = self.variables
coords = self.coords
for vname, variable in six.iteritems(ds.variables):
item = QTreeWidgetItem(0)
item.setText(0, str(vname))
for i, attr in enumerate(columns, 1):
if attr == 'dims':
item.setText(i, ', '.join(variable.dims))
else:
item.setText(
i,
str(
variable.attrs.get(attr,
getattr(variable, attr, ''))))
if vname in ds.coords:
coords.addChild(item)
else:
variables.addChild(item)
if rcParams['content.load_tooltips']:
item.setToolTip(0, str(variable))
def add_dependencies(self, versions, parent=None):
"""
Add the version informations to the tree
This method creates an QTreeWidgetItem for each package in `versions`
and adds it to this tree.
Parameters
----------
%(DependenciesTree.parameters)s
parent: QTreeWidgetItem
The parent of the newly created items for the packages in
`versions`. If None, the newly created items are inserted as
top level items into the tree
"""
for pkg, pkg_d in versions.items():
new_item = QTreeWidgetItem(0)
new_item.setText(0, pkg)
if isinstance(pkg_d, dict):
new_item.setText(1, pkg_d['version'])
else:
new_item.setText(1, pkg_d)
if parent is None:
self.addTopLevelItem(new_item)
else:
parent.addChild(new_item)
if 'requirements' in pkg_d:
self.add_dependencies(pkg_d['requirements'], new_item)
def __init__(self, ds, columns=[], *args, **kwargs):
super(DatasetTreeItem, self).__init__(*args, **kwargs)
variables = QTreeWidgetItem(0)
variables.setText(0, 'variables')
coords = QTreeWidgetItem(0)
coords.setText(0, 'coords')
self.addChildren([variables, coords])
self.addChild(variables)
for vname, variable in six.iteritems(ds.variables):
item = QTreeWidgetItem(0)
item.setText(0, vname)
for i, attr in enumerate(columns, 1):
if attr == 'dims':
item.setText(i, ', '.join(variable.dims))
else:
item.setText(i, str(variable.attrs.get(attr, getattr(
variable, attr, ''))))
if vname in ds.coords:
coords.addChild(item)
else:
variables.addChild(item)
item.setToolTip(0, str(variable))
class StraditizerWidgets(QWidget, DockMixin):
"""A widget that contains widgets to control the straditization in a GUI
This widget is the basis of the straditize GUI and implemented as a
plugin into the psyplot gui. The open straditizers are handled in the
:attr:`_straditizer` attribute.
The central parts of this widget are
- The combobox to manage the open straditizers
- The QTreeWidget in the :attr:`tree` attribute that contains all the
controls to interface the straditizer
- the tutorial area
- the :guilabel:`Apply` and :guilabel:`Cancel` button"""
#: Boolean that is True if all dialogs should be answered with `Yes`
always_yes = False
#: The QTreeWidget that contains the different widgets for the digitization
tree = None
#: The apply button
apply_button = None
#: The cancel button
cancel_button = None
#: The button to edit the straditizer attributes
attrs_button = None
#: The button to start a tutorial
tutorial_button = None
#: An :class:`InfoButton` to display the docs
info_button = None
#: A QComboBox to select the current straditizer
stradi_combo = None
#: A button to open a new straditizer
btn_open_stradi = None
#: A button to close the current straditizer
btn_close_stradi = None
#: A button to reload the last autosaved state
btn_reload_autosaved = None
#: The :class:`straditize.widgets.progress_widget.ProgressWidget` to
#: display the progress of the straditization
progress_widget = None
#: The :class:`straditize.widgets.data.DigitizingControl` to interface
#: the :straditize.straditizer.Straditizer.data_reader`
digitizer = None
#: The :class:`straditize.widgets.colnames.ColumnNamesManager` to interface
#: the :straditize.straditizer.Straditizer.colnames_reader`
colnames_manager = None
#: The :class:`straditize.widgets.axes_translations.AxesTranslations` to
#: handle the y- and x-axis conversions
axes_translations = None
#: The :class:`straditize.widgets.image_correction.ImageRescaler` class to
#: rescale the image
image_rescaler = None
#: The :class:`straditize.widgets.image_correction.ImageRotator` class to
#: rotate the image
image_rotator = None
#: The :class:`straditize.widgets.plots.PlotControl` to display additional
#: information on the diagram
plot_control = None
#: The :class:`straditize.widgets.marker_control.MarkerControl` to modify
#: the appearance of the :class:`~straditize.straditizer.Straditizer.marks`
#: of the current straditizer
marker_control = None
#: The :class:`straditize.widgets.selection_toolbar.SelectionToolbar` to
#: select features in the stratigraphic diagram
selection_toolbar = None
#: The :class:`straditize.straditizer.Straditizer` instance
straditizer = None
#: open straditizers
_straditizers = []
#: The :class:`straditize.widgets.tutorial.Tutorial` class
tutorial = None
dock_position = Qt.LeftDockWidgetArea
#: Auto-saved straditizers
autosaved = []
hidden = True
title = 'Stratigraphic diagram digitization'
window_layout_action = None
open_external = QtCore.pyqtSignal(list)
def __init__(self, *args, **kwargs):
from straditize.widgets.menu_actions import StraditizerMenuActions
from straditize.widgets.progress_widget import ProgressWidget
from straditize.widgets.data import DigitizingControl
from straditize.widgets.selection_toolbar import SelectionToolbar
from straditize.widgets.marker_control import MarkerControl
from straditize.widgets.plots import PlotControl
from straditize.widgets.axes_translations import AxesTranslations
from straditize.widgets.image_correction import (ImageRotator,
ImageRescaler)
from straditize.widgets.colnames import ColumnNamesManager
self._straditizers = []
super(StraditizerWidgets, self).__init__(*args, **kwargs)
self.tree = QTreeWidget(parent=self)
self.tree.setSelectionMode(QTreeWidget.NoSelection)
self.refresh_button = QToolButton(self)
self.refresh_button.setIcon(QIcon(get_psy_icon('refresh.png')))
self.refresh_button.setToolTip('Refresh from the straditizer')
self.apply_button = EnableButton('Apply', parent=self)
self.cancel_button = EnableButton('Cancel', parent=self)
self.attrs_button = QPushButton('Attributes', parent=self)
self.tutorial_button = QPushButton('Tutorial', parent=self)
self.tutorial_button.setCheckable(True)
self.error_msg = PyErrorMessage(self)
self.stradi_combo = QComboBox()
self.btn_open_stradi = QToolButton()
self.btn_open_stradi.setIcon(QIcon(get_psy_icon('run_arrow.png')))
self.btn_close_stradi = QToolButton()
self.btn_close_stradi.setIcon(QIcon(get_psy_icon('invalid.png')))
self.btn_reload_autosaved = QPushButton("Reload")
self.btn_reload_autosaved.setToolTip(
"Close the straditizer and reload the last autosaved project")
# ---------------------------------------------------------------------
# --------------------------- Tree widgets ----------------------------
# ---------------------------------------------------------------------
self.tree.setHeaderLabels(['', ''])
self.tree.setColumnCount(2)
self.progress_item = QTreeWidgetItem(0)
self.progress_item.setText(0, 'ToDo list')
self.progress_widget = ProgressWidget(self, self.progress_item)
self.menu_actions_item = QTreeWidgetItem(0)
self.menu_actions_item.setText(0, 'Images import/export')
self.tree.addTopLevelItem(self.menu_actions_item)
self.menu_actions = StraditizerMenuActions(self)
self.digitizer_item = item = QTreeWidgetItem(0)
item.setText(0, 'Digitization control')
self.digitizer = DigitizingControl(self, item)
self.col_names_item = item = QTreeWidgetItem(0)
item.setText(0, 'Column names')
self.colnames_manager = ColumnNamesManager(self, item)
self.add_info_button(item, 'column_names.rst')
self.axes_translations_item = item = QTreeWidgetItem(0)
item.setText(0, 'Axes translations')
self.axes_translations = AxesTranslations(self, item)
self.image_transform_item = item = QTreeWidgetItem(0)
item.setText(0, 'Transform source image')
self.image_rescaler = ImageRescaler(self, item)
self.image_rotator_item = item = QTreeWidgetItem(0)
item.setText(0, 'Rotate image')
self.image_rotator = ImageRotator(self)
self.image_transform_item.addChild(item)
self.image_rotator.setup_children(item)
self.plot_control_item = item = QTreeWidgetItem(0)
item.setText(0, 'Plot control')
self.plot_control = PlotControl(self, item)
self.add_info_button(item, 'plot_control.rst')
self.marker_control_item = item = QTreeWidgetItem(0)
item.setText(0, 'Marker control')
self.marker_control = MarkerControl(self, item)
self.add_info_button(item, 'marker_control.rst')
# ---------------------------------------------------------------------
# ----------------------------- Toolbars ------------------------------
# ---------------------------------------------------------------------
self.selection_toolbar = SelectionToolbar(self, 'Selection toolbar')
# ---------------------------------------------------------------------
# ----------------------------- InfoButton ----------------------------
# ---------------------------------------------------------------------
self.info_button = InfoButton(self, get_doc_file('straditize.rst'))
# ---------------------------------------------------------------------
# --------------------------- Layouts ---------------------------------
# ---------------------------------------------------------------------
stradi_box = QHBoxLayout()
stradi_box.addWidget(self.stradi_combo, 1)
stradi_box.addWidget(self.btn_open_stradi)
stradi_box.addWidget(self.btn_close_stradi)
attrs_box = QHBoxLayout()
attrs_box.addWidget(self.attrs_button)
attrs_box.addStretch(0)
attrs_box.addWidget(self.tutorial_button)
btn_box = QHBoxLayout()
btn_box.addWidget(self.refresh_button)
btn_box.addWidget(self.info_button)
btn_box.addStretch(0)
btn_box.addWidget(self.apply_button)
btn_box.addWidget(self.cancel_button)
reload_box = QHBoxLayout()
reload_box.addWidget(self.btn_reload_autosaved)
reload_box.addStretch(0)
vbox = QVBoxLayout()
vbox.addLayout(stradi_box)
vbox.addWidget(self.tree)
vbox.addLayout(attrs_box)
vbox.addLayout(btn_box)
vbox.addLayout(reload_box)
self.setLayout(vbox)
self.apply_button.setEnabled(False)
self.cancel_button.setEnabled(False)
self.tree.expandItem(self.progress_item)
self.tree.expandItem(self.digitizer_item)
# ---------------------------------------------------------------------
# --------------------------- Connections -----------------------------
# ---------------------------------------------------------------------
self.stradi_combo.currentIndexChanged.connect(self.set_current_stradi)
self.refresh_button.clicked.connect(self.refresh)
self.attrs_button.clicked.connect(self.edit_attrs)
self.tutorial_button.clicked.connect(self.start_tutorial)
self.open_external.connect(self._create_straditizer_from_args)
self.btn_open_stradi.clicked.connect(
self.menu_actions.open_straditizer)
self.btn_close_stradi.clicked.connect(self.close_straditizer)
self.btn_reload_autosaved.clicked.connect(self.reload_autosaved)
self.refresh()
header = self.tree.header()
header.setStretchLastSection(False)
header.setSectionResizeMode(0, QHeaderView.Stretch)
def disable_apply_button(self):
"""Method that is called when the :attr:`cancel_button` is clicked"""
for w in [self.apply_button, self.cancel_button]:
try:
w.clicked.disconnect()
except TypeError:
pass
w.setEnabled(False)
self.apply_button.setText('Apply')
self.cancel_button.setText('Cancel')
self.refresh_button.setEnabled(True)
def switch_to_straditizer_layout(self):
"""Switch to the straditizer layout
This method makes this widget visible and stacks it with the psyplot
content widget"""
mainwindow = self.dock.parent()
mainwindow.figures_tree.hide_plugin()
mainwindow.ds_tree.hide_plugin()
mainwindow.fmt_widget.hide_plugin()
self.show_plugin()
mainwindow.tabifyDockWidget(mainwindow.project_content.dock, self.dock)
hsize = self.marker_control.sizeHint().width() + 50
self.menu_actions.setup_shortcuts(mainwindow)
if with_qt5:
mainwindow.resizeDocks([self.dock], [hsize], Qt.Horizontal)
self.tree.resizeColumnToContents(0)
self.tree.resizeColumnToContents(1)
self.info_button.click()
def to_dock(self, main, *args, **kwargs):
ret = super(StraditizerWidgets, self).to_dock(main, *args, **kwargs)
if self.menu_actions.window_layout_action is None:
main.window_layouts_menu.addAction(self.window_layout_action)
main.callbacks['straditize'] = self.open_external.emit
main.addToolBar(self.selection_toolbar)
self.dock.toggleViewAction().triggered.connect(
self.show_or_hide_toolbar)
self.menu_actions.setup_menu_actions(main)
self.menu_actions.setup_children(self.menu_actions_item)
try:
main.open_file_options['Straditize project'] = \
self.create_straditizer_from_args
except AttributeError: # psyplot-gui <= 1.1.0
pass
return ret
def show_or_hide_toolbar(self):
"""Show or hide the toolbar depending on the visibility of this widget
"""
self.selection_toolbar.setVisible(self.is_shown)
def _create_straditizer_from_args(self, args):
"""A method that is called when the :attr:`psyplot_gui.main.mainwindow`
receives a 'straditize' callback"""
self.create_straditizer_from_args(*args)
def create_straditizer_from_args(self,
fnames,
project=None,
xlim=None,
ylim=None,
full=False,
reader_type='area'):
"""Create a straditizer from the given file name
This method is called when the :attr:`psyplot_gui.main.mainwindow`
receives a 'straditize' callback"""
fname = fnames[0]
if fname is not None:
self.menu_actions.open_straditizer(fname)
stradi = self.straditizer
if stradi is None:
return
if xlim is not None:
stradi.data_xlim = xlim
if ylim is not None:
stradi.data_ylim = ylim
if xlim is not None or ylim is not None or full:
if stradi.data_xlim is None:
stradi.data_xlim = [0, np.shape(stradi.image)[1]]
if stradi.data_ylim is None:
stradi.data_ylim = [0, np.shape(stradi.image)[0]]
stradi.init_reader(reader_type)
stradi.data_reader.digitize()
self.refresh()
if not self.is_shown:
self.switch_to_straditizer_layout()
return fname is not None
def start_tutorial(self, state, tutorial_cls=None):
"""Start or stop the tutorial
Parameters
----------
state: bool
If False, the tutorial is stopped. Otherwise it is started
tutorial_cls: straditize.widgets.tutorial.beginner.Tutorial
The tutorial class to use. If None, it will be asked in a
QInputDialog"""
if self.tutorial is not None or not state:
self.tutorial.close()
self.tutorial_button.setText('Tutorial')
elif state:
if tutorial_cls is None:
tutorial_cls, ok = QInputDialog.getItem(
self,
'Start tutorial',
"Select the tutorial type",
["Beginner", "Advanced (Hoya del Castillo)"],
editable=False)
if not ok:
self.tutorial_button.blockSignals(True)
self.tutorial_button.setChecked(False)
self.tutorial_button.blockSignals(False)
return
if tutorial_cls == 'Beginner':
from straditize.widgets.tutorial import Tutorial
else:
from straditize.widgets.tutorial import (
HoyaDelCastilloTutorial as Tutorial)
else:
Tutorial = tutorial_cls
self.tutorial = Tutorial(self)
self.tutorial_button.setText('Stop tutorial')
def edit_attrs(self):
"""Edit the attributes of the current straditizer
This creates a new dataframe editor to edit the
:attr:`straditize.straditizer.Straditizer.attrs` meta informations"""
def add_attr(key):
model = editor.table.model()
n = len(attrs)
model.insertRow(n)
model.setData(model.index(n, 0), key)
model.setData(model.index(n, 1), '', change_type=six.text_type)
from psyplot_gui.main import mainwindow
from straditize.straditizer import common_attributes
attrs = self.straditizer.attrs
editor = mainwindow.new_data_frame_editor(attrs,
'Straditizer attributes')
editor.table.resizeColumnToContents(1)
editor.table.horizontalHeader().setVisible(False)
editor.table.frozen_table_view.horizontalHeader().setVisible(False)
combo = QComboBox()
combo.addItems([''] + common_attributes)
combo.currentTextChanged.connect(add_attr)
hbox = QHBoxLayout()
hbox.addWidget(QLabel('Common attributes:'))
hbox.addWidget(combo)
hbox.addStretch(0)
editor.layout().insertLayout(1, hbox)
return editor, combo
def refresh(self):
"""Refresh from the straditizer"""
for i, stradi in enumerate(self._straditizers):
self.stradi_combo.setItemText(
i,
self.get_attr(stradi, 'project_file')
or self.get_attr(stradi, 'image_file') or '')
# toggle visibility of close button and attributes button
enable = self.straditizer is not None
self.btn_close_stradi.setVisible(enable)
self.attrs_button.setEnabled(enable)
# refresh controls
self.menu_actions.refresh()
self.progress_widget.refresh()
self.digitizer.refresh()
self.selection_toolbar.refresh()
self.plot_control.refresh()
self.marker_control.refresh()
self.axes_translations.refresh()
if self.tutorial is not None:
self.tutorial.refresh()
self.image_rotator.refresh()
self.image_rescaler.refresh()
self.colnames_manager.refresh()
self.btn_reload_autosaved.setEnabled(bool(self.autosaved))
def get_attr(self, stradi, attr):
try:
return stradi.get_attr(attr)
except KeyError:
pass
docstrings.delete_params('InfoButton.parameters', 'parent')
@docstrings.get_sectionsf('StraditizerWidgets.add_info_button')
@docstrings.with_indent(8)
def add_info_button(self,
child,
fname=None,
rst=None,
name=None,
connections=[]):
"""Add an infobutton to the :attr:`tree` widget
Parameters
----------
child: QTreeWidgetItem
The item to which to add the infobutton
%(InfoButton.parameters.no_parent)s
connections: list of QPushButtons
Buttons that should be clicked when the info button is clicked"""
button = InfoButton(self, fname=fname, rst=rst, name=name)
self.tree.setItemWidget(child, 1, button)
for btn in connections:
btn.clicked.connect(button.click)
return button
def raise_figures(self):
"""Raise the figures of the current straditizer in the GUI"""
from psyplot_gui.main import mainwindow
if mainwindow.figures and self.straditizer:
dock = self.straditizer.ax.figure.canvas.manager.window
dock.widget().show_plugin()
dock.raise_()
if self.straditizer.magni is not None:
dock = self.straditizer.magni.ax.figure.canvas.manager.window
dock.widget().show_plugin()
dock.raise_()
def set_current_stradi(self, i):
"""Set the i-th straditizer to the current one"""
if not self._straditizers:
return
self.straditizer = self._straditizers[i]
self.menu_actions.set_stradi_in_console()
block = self.stradi_combo.blockSignals(True)
self.stradi_combo.setCurrentIndex(i)
self.stradi_combo.blockSignals(block)
self.raise_figures()
self.refresh()
self.autosaved.clear()
def _close_stradi(self, stradi):
"""Close the given straditizer and all it's figures"""
is_current = stradi is self.straditizer
if is_current:
self.selection_toolbar.disconnect()
stradi.close()
try:
i = self._straditizers.index(stradi)
except ValueError:
pass
else:
del self._straditizers[i]
self.stradi_combo.removeItem(i)
if is_current and self._straditizers:
self.stradi_combo.setCurrentIndex(0)
elif not self._straditizers:
self.straditizer = None
self.refresh()
self.digitizer.digitize_item.takeChildren()
self.digitizer.btn_digitize.setChecked(False)
self.digitizer.btn_digitize.setCheckable(False)
self.digitizer.toggle_txt_tolerance('')
def close_straditizer(self):
"""Close the current straditizer"""
self._close_stradi(self.straditizer)
def close_all_straditizers(self):
"""Close all straditizers"""
self.selection_toolbar.disconnect()
for stradi in self._straditizers:
stradi.close()
self._straditizers.clear()
self.straditizer = None
self.stradi_combo.clear()
self.digitizer.digitize_item.takeChildren()
self.digitizer.btn_digitize.setChecked(False)
self.digitizer.btn_digitize.setCheckable(False)
self.digitizer.toggle_txt_tolerance('')
self.refresh()
def add_straditizer(self, stradi):
"""Add a straditizer to the list of open straditizers"""
if stradi and stradi not in self._straditizers:
self._straditizers.append(stradi)
self.stradi_combo.addItem(' ')
self.set_current_stradi(len(self._straditizers) - 1)
def reset_control(self):
"""Reset the GUI of straditize"""
if getattr(self.selection_toolbar, '_pattern_selection', None):
self.selection_toolbar._pattern_selection.remove_plugin()
del self.selection_toolbar._pattern_selection
if getattr(self.digitizer, '_samples_editor', None):
self.digitizer._close_samples_fig()
tb = self.selection_toolbar
tb.set_label_wand_mode()
tb.set_rect_select_mode()
tb.new_select_action.setChecked(True)
tb.select_action.setChecked(False)
tb.wand_action.setChecked(False)
self.disable_apply_button()
self.close_all_straditizers()
self.colnames_manager.reset_control()
def autosave(self):
"""Autosave the current straditizer"""
self.autosaved = [self.straditizer.to_dataset().copy(True)] + \
self.autosaved[:4]
def reload_autosaved(self):
"""Reload the autosaved straditizer and close the old one"""
from straditize.straditizer import Straditizer
if not self.autosaved:
return
answer = QMessageBox.question(
self, 'Reload autosave',
'Shall I reload the last autosaved stage? This will close the '
'current figures.')
if answer == QMessageBox.Yes:
self.close_straditizer()
stradi = Straditizer.from_dataset(self.autosaved.pop(0))
self.menu_actions.finish_loading(stradi)
def add_variables(self, ds=None):
"""Add children of variables and coords to this TreeWidgetItem"""
if ds is None:
ds = self.ds()
self.variables.takeChildren()
self.coords.takeChildren()
else:
self.ds = weakref.ref(ds)
columns = self.columns
variables = self.variables
coords = self.coords
for vname, variable in six.iteritems(ds.variables):
item = QTreeWidgetItem(0)
item.setText(0, str(vname))
for i, attr in enumerate(columns, 1):
if attr == 'dims':
item.setText(i, ', '.join(variable.dims))
else:
item.setText(
i,
str(
variable.attrs.get(attr,
getattr(variable, attr, ''))))
if vname in ds.coords:
coords.addChild(item)
else:
variables.addChild(item)
if rcParams['content.load_tooltips']:
item.setToolTip(
0, '<pre>' + escape_html(str(variable)) + '</pre>')
# Add shape
shape_item = QTreeWidgetItem(0)
shape_item.setText(0, 'shape')
shape_item.setText(1, str(variable.shape))
item.addChild(shape_item)
# Add dimensions
dims_item = QTreeWidgetItem(0)
dims_item.setText(0, 'dims')
dims_item.setText(1, ', '.join(variable.dims))
item.addChild(dims_item)
# add open plots
plots_item = QTreeWidgetItem(0)
plots_item.setText(0, 'Plots')
self.refresh_plots_item(plots_item, vname)
item.addChild(plots_item)
# add variable attribute
attrs_item = QTreeWidgetItem(0)
attrs_item.setText(0, 'Attributes')
self.add_attrs(variable.attrs, attrs_item)
item.addChild(attrs_item)
# add variable encoding
encoding_item = QTreeWidgetItem(0)
encoding_item.setText(0, 'Encoded attributes')
self.add_attrs(variable.encoding, encoding_item)
item.addChild(encoding_item)
