def __init__(self, config_file, check_ifu_valid=True):
"""
Given the configuration file, save it and grab the name and priority
:param config_file:
"""
self._config_file = config_file
self._check_ifu_valid = check_ifu_valid
# If we are testing, then don't display the popup
if self._check_ifu_valid:
self.popup_ui = load_ui('ifucube_popup.ui', None, directory=os.path.dirname(__file__))
with open(self._config_file, 'r') as ymlfile:
cfg = yaml.load(ymlfile)
self._name = cfg['name']
self._type = cfg['type']
try:
self._priority = int(cfg.get('priority', 0))
except Exception:
self._priority = 0
self._configuration = cfg['match']
self._data = cfg.get('data', None)
if 'flux_unit_replacements' in cfg:
self.flux_unit_replacements = cfg['flux_unit_replacements']
else:
self.flux_unit_replacements = {}
def __init__(self, collection, parent=None):
super(CustomComponentWidget, self).__init__(parent=parent)
# Load in ui file to set up widget
self.ui = load_ui("widget.ui", self, directory=os.path.dirname(__file__))
# In the ui file we do not create the text field for the expression
# because we want to use a custom widget that supports auto-complete.
self.ui.expression.setAlignment(Qt.AlignCenter)
self._labels = {}
self._data = {}
self._collection = collection
self._gather_components()
self._gather_data()
self._init_widgets()
self._connect()
# Set up auto-completion. While the auto-complete window is open, we
# cannot add/remove datasets or other components, so we can populate
# the auto_completer straight off.
self.ui.expression.set_word_list(list(self._labels.keys()))
self.ui.button_ok.clicked.connect(self.accept)
self.ui.button_cancel.clicked.connect(self.reject)
self.ui.expression.updated.connect(self._update_status)
self._update_status()
def __init__(self, parent=None):
super(LinkEquation, self).__init__(parent)
from glue.config import link_function, link_helper
# Set up mapping of function/helper name -> function/helper tuple. For the helpers, we use the 'display' name if available.
def get_name(item):
if hasattr(item, 'display') and item.display is not None:
return item.display
else:
return item.__name__
f = [f for f in link_function.members if len(f.output_labels) == 1]
self._functions = OrderedDict((get_name(l[0]), l) for l in
f + link_helper.members)
self._argument_widgets = []
self.spacer = None
self._output_widget = ArgumentWidget("")
# pyqt4 can't take self as second argument here
# for some reason. Manually embed
self._ui = load_ui('link_equation.ui', None,
directory=os.path.dirname(__file__))
l = QtGui.QHBoxLayout()
l.addWidget(self._ui)
self.setLayout(l)
self._init_widgets()
self._populate_function_combo()
self._connect()
self._setup_editor()
def __init__(self, layer_artist):
super(ScatterLayerStyleWidget, self).__init__()
self.ui = load_ui('layer_style_widget.ui', self,
directory=os.path.dirname(__file__))
self.layer_artist = layer_artist
self.layer = layer_artist.layer
# Set up size and color options
self._setup_size_options()
self._setup_color_options()
self._connect_global()
# Set initial values
self.layer_artist.size = self.layer.style.markersize
self.layer_artist.size_scaling = 1
self.layer_artist.size_mode = 'fixed'
self.size_mode = 'Fixed'
self.layer_artist.color = self.layer.style.color
self.layer_artist.alpha = self.layer.style.alpha
self.layer_artist.color_mode = 'fixed'
self.color_mode = 'Fixed'
self.ui.combo_size_attribute.setCurrentIndex(0)
self.ui.combo_cmap_attribute.setCurrentIndex(0)
self.ui.combo_cmap.setCurrentIndex(0)
self.layer_artist.visible = True
self._update_size_mode()
self._update_color_mode()
def __init__(self, collection, functions=None, parent=None):
super(LinkEditor, self).__init__(parent=parent)
self._collection = collection
self._ui = load_ui('link_editor.ui', self,
directory=os.path.dirname(__file__))
self._links = list(collection.external_links)
self._ui.graph_widget.set_data_collection(collection)
self._ui.graph_widget.selection_changed.connect(self._on_data_change_graph)
self._init_widgets()
self._connect()
self._size = None
if len(self._collection) == 2:
self._ui.left_components.data = self._collection[0]
self._ui.right_components.data = self._collection[1]
else:
self._ui.left_components.data = None
self._ui.right_components.data = None
self._ui.left_components.data_changed.connect(self._on_data_change_combo)
self._ui.right_components.data_changed.connect(self._on_data_change_combo)
self._on_data_change_combo()
def __init__(self, layer_artist):
super(WWTLayerStyleEditor, self).__init__()
self.ui = load_ui('layer_style_editor.ui', self,
directory=os.path.dirname(__file__))
fix_tab_widget_fontsize(self.ui.tab_widget)
self.state = layer_artist.state
self.layer_artist = layer_artist
self.layer = layer_artist.layer
connect_kwargs = {'value_alpha': dict(value_range=(0., 1.)),
'value_size_scaling': dict(value_range=(0.1, 10), log=True)}
autoconnect_callbacks_to_qt(self.state, self.ui, connect_kwargs)
# Set initial values
self._update_size_mode()
self._update_color_mode()
self.state.add_callback('color_mode', self._update_color_mode)
self.state.add_callback('size_mode', self._update_size_mode)
self.ui.button_center.clicked.connect(layer_artist.center)
self._viewer_state = layer_artist._viewer_state
self._viewer_state.add_callback('mode', self._on_mode_changed)
def __init__(self, autolinker_name, data_collection, suggested_links, parent=None):
super(AutoLinkPreview, self).__init__(parent=parent)
self._data_collection = data_collection
self._ui = load_ui('autolinker.ui', self,
directory=os.path.dirname(__file__))
self._autolinker_name = autolinker_name
self.link_widget = LinkEditorWidget(data_collection,
suggested_links=suggested_links,
parent=self)
self._ui.layout().insertWidget(2, self.link_widget)
self._ui.label.setText(DESCRIPTION.format(autolinker_name, len(suggested_links)))
self._ui.button_apply.clicked.connect(self.accept)
self._ui.button_ignore.clicked.connect(self.reject)
self._ui.button_details.clicked.connect(self._toggle_details)
self._set_details_visibility(False)
def __init__(self, session, parent=None, widget=None):
super(TableWidget, self).__init__(session, parent)
self.ui = load_ui('viewer_widget.ui',
directory=os.path.dirname(__file__))
self.setCentralWidget(self.ui)
hdr = self.ui.table.horizontalHeader()
hdr.setStretchLastSection(True)
if PYQT5:
hdr.setSectionResizeMode(hdr.Interactive)
else:
hdr.setResizeMode(hdr.Interactive)
hdr = self.ui.table.verticalHeader()
if PYQT5:
hdr.setSectionResizeMode(hdr.Interactive)
else:
hdr.setResizeMode(hdr.Interactive)
self.model = None
self.ui.table.selection_changed.connect(self.selection_changed)
def __init__(self, layer, parent=None):
super(ScatterLayerStyleEditor, self).__init__(parent=parent)
self.ui = load_ui('layer_style_editor_scatter.ui', self,
directory=os.path.dirname(__file__))
# The following is needed because of a bug in Qt which means that
# tab titles don't get scaled right.
if platform.system() == 'Darwin':
app = get_qapp()
app_font = app.font()
self.ui.tab_widget.setStyleSheet('font-size: {0}px'.format(app_font.pointSize()))
self.layer_state = layer.state
self.layer_state.add_callback('xerr_visible', self._update_xerr_att_combo)
self.layer_state.add_callback('yerr_visible', self._update_yerr_att_combo)
self.layer_state.add_callback('size_mode', self._update_size_mode)
self.layer_state.add_callback('cmap_mode', self._update_cmap_mode)
self.layer_state.add_callback('layer', self._update_warnings)
self._update_xerr_att_combo()
self._update_yerr_att_combo()
self._update_size_mode()
self._update_cmap_mode()
self._update_warnings()
def __init__(self, collection, parent=None):
# Load in ui file to set up widget
self.ui = load_ui('widget.ui', parent,
directory=os.path.dirname(__file__))
# In the ui file we do not create the text field for the expression
# because we want to use a custom widget that supports auto-complete.
self.ui.expression = ColorizedCompletionTextEdit()
self.ui.verticalLayout_3.addWidget(self.ui.expression)
self.ui.expression.setAlignment(Qt.AlignCenter)
self.ui.expression.setObjectName("expression")
self.ui.expression.setToolTip("Define a new component. You can either "
"type out the full name of a component\n"
"with the data:component syntax, or "
"start typing and press TAB to use "
"tab-completion.\n Blue-colored "
"components are valid, while "
"Red-colored components are invalid.")
self._labels = {}
self._data = {}
self._collection = collection
self._gather_components()
self._gather_data()
self._init_widgets()
self._connect()
# Set up auto-completion. While the auto-complete window is open, we
# cannot add/remove datasets or other components, so we can populate
# the auto_completer straight off.
self.ui.expression.set_word_list(list(self._labels.keys()))
def choose_vmin_vmax(self):
dialog = load_ui('contrastlimits.ui', None,
directory=os.path.dirname(__file__))
v = QtGui.QDoubleValidator()
dialog.vmin.setValidator(v)
dialog.vmax.setValidator(v)
vmin, vmax = self.get_vmin_vmax()
if vmin is not None:
dialog.vmin.setText(str(vmin))
if vmax is not None:
dialog.vmax.setText(str(vmax))
def _apply():
try:
vmin = float(dialog.vmin.text())
vmax = float(dialog.vmax.text())
self.set_vmin_vmax(vmin, vmax)
if self._move_callback is not None:
self._move_callback(self)
except ValueError:
pass
bb = dialog.buttonBox
bb.button(bb.Apply).clicked.connect(_apply)
dialog.accepted.connect(_apply)
dialog.show()
dialog.raise_()
dialog.exec_()
def _choose_merge(data, others):
w = load_ui('merge.ui', None, directory=os.path.dirname(__file__))
w.button_yes.clicked.connect(w.accept)
w.button_no.clicked.connect(w.reject)
w.show()
w.raise_()
# Add the main dataset to the list. Some of the 'others' may also be
# new ones, so it doesn't really make sense to distinguish between
# the two here. The main point is that some datasets, including at
# least one new one, have a common shape.
others.append(data)
others.sort(key=lambda x: x.label)
label = others[0].label
w.merged_label.setText(label)
entries = [QtWidgets.QListWidgetItem(other.label) for other in others]
for e in entries:
e.setCheckState(Qt.Checked)
for d, item in zip(others, entries):
w.choices.addItem(item)
if not w.exec_():
return None, None
result = [layer for layer, entry in zip(others, entries)
if entry.checkState() == Qt.Checked]
if result:
return result, str(w.merged_label.text())
return None, None
def __init__(self, data=None, equation=None, references=None, parent=None):
super(EquationEditorDialog, self).__init__(parent=parent)
self.ui = load_ui('equation_editor.ui', self,
directory=os.path.dirname(__file__))
self.equation = equation
# Get mapping from label to component ID
if references is not None:
self.references = references
elif data is not None:
self.references = OrderedDict()
for cid in data.primary_components:
self.references[cid.label] = cid
# Populate component combo
for label, cid in self.references.items():
self.ui.combosel_component.addItem(label, userData=cid)
# Set up labels for auto-completion
labels = ['{' + label + '}' for label in self.references]
self.ui.expression.set_word_list(labels)
self.ui.expression.insertPlainText(equation)
self.ui.button_ok.clicked.connect(self.accept)
self.ui.button_cancel.clicked.connect(self.reject)
self.ui.button_insert.clicked.connect(self._insert_component)
self.ui.expression.updated.connect(self._update_status)
self._update_status()
def __init__(self, layer_artist):
super(VolumeLayerStyleWidget, self).__init__()
self.ui = load_ui('layer_style_widget.ui', self,
directory=os.path.dirname(__file__))
self.state = layer_artist.state
if self.state.subset_mode == 'outline':
self.ui.radio_subset_outline.setChecked(True)
else:
self.ui.radio_subset_data.setChecked(True)
self.layer_artist = layer_artist
self.layer = layer_artist.layer
# autoconnect needs to come after setting up the component IDs
connect_kwargs = {'value_alpha': dict(value_range=(0., 1.))}
autoconnect_callbacks_to_qt(self.state, self.ui, connect_kwargs)
# Set up radio buttons for subset mode selection if this is a subset
if isinstance(self.layer, Subset):
self._radio_size = QtWidgets.QButtonGroup()
self._radio_size.addButton(self.ui.radio_subset_outline)
self._radio_size.addButton(self.ui.radio_subset_data)
self.ui.radio_subset_outline.toggled.connect(self._update_subset_mode)
self.ui.radio_subset_data.toggled.connect(self._update_subset_mode)
self.ui.valuetext_vmin.setEnabled(False)
else:
self.ui.radio_subset_outline.hide()
self.ui.radio_subset_data.hide()
self.ui.label_subset_mode.hide()
def __init__(self, data_collection, suggested_links=None, parent=None):
super(LinkEditorWidget, self).__init__(parent=parent)
self._data_collection = data_collection
self.state = LinkEditorState(data_collection, suggested_links=suggested_links)
self._ui = load_ui('link_editor_widget.ui', self,
directory=os.path.dirname(__file__))
autoconnect_callbacks_to_qt(self.state, self._ui)
self._ui.graph_widget.set_data_collection(data_collection, new_links=self.state.links)
self._ui.graph_widget.selection_changed.connect(self._on_data_change_graph)
self._menu = LinkMenu(parent=self._ui.button_add_link)
self._menu.triggered.connect(self._add_link)
self._ui.button_add_link.setMenu(self._menu)
self.state.add_callback('data1', self._on_data_change)
self.state.add_callback('data2', self._on_data_change)
self._on_data_change()
self.state.add_callback('data1', self._on_data_change_always)
self.state.add_callback('data2', self._on_data_change_always)
self._on_data_change_always()
self.state.add_callback('current_link', self._on_current_link_change)
self._on_current_link_change()
def __init__(self, parent=None, vispy_widget=None, data_viewer=None):
super(VispyOptionsWidget, self).__init__(parent=parent)
self.ui = load_ui('viewer_options.ui', self,
directory=os.path.dirname(__file__))
self._vispy_widget = vispy_widget
vispy_widget.options = self
self._data_viewer = data_viewer
self.stretch_sliders = [self.ui.slider_x_stretch,
self.ui.slider_y_stretch,
self.ui.slider_z_stretch]
self.stretch_values = [self.ui.value_x_stretch,
self.ui.value_y_stretch,
self.ui.value_z_stretch]
self._event_lock = False
for slider, label in zip(self.stretch_sliders, self.stretch_values):
slider.valueChanged.connect(partial(self._update_labels_from_sliders, label, slider))
label.editingFinished.connect(partial(self._update_sliders_from_labels, slider, label))
label.setText('1.0')
label.editingFinished.emit()
slider.valueChanged.connect(self._update_stretch)
connect_bool_button(self._vispy_widget, 'visible_axes', self.ui.checkbox_axes)
connect_bool_button(self._vispy_widget, 'perspective_view', self.ui.checkbox_perspective)
if self._data_viewer is not None:
self.ui.combo_x_attribute.currentIndexChanged.connect(self._data_viewer._update_attributes)
self.ui.combo_y_attribute.currentIndexChanged.connect(self._data_viewer._update_attributes)
self.ui.combo_z_attribute.currentIndexChanged.connect(self._data_viewer._update_attributes)
self.ui.combo_x_attribute.currentIndexChanged.connect(self._update_attribute_limits)
self.ui.combo_y_attribute.currentIndexChanged.connect(self._update_attribute_limits)
self.ui.combo_z_attribute.currentIndexChanged.connect(self._update_attribute_limits)
self.ui.value_x_min.editingFinished.connect(self._update_limits)
self.ui.value_y_min.editingFinished.connect(self._update_limits)
self.ui.value_z_min.editingFinished.connect(self._update_limits)
self.ui.value_x_max.editingFinished.connect(self._update_limits)
self.ui.value_y_max.editingFinished.connect(self._update_limits)
self.ui.value_z_max.editingFinished.connect(self._update_limits)
self.ui.button_flip_x.clicked.connect(self._flip_x)
self.ui.button_flip_y.clicked.connect(self._flip_y)
self.ui.button_flip_z.clicked.connect(self._flip_z)
self.ui.reset_button.clicked.connect(self._vispy_widget._reset_view)
self._components = {}
self._set_attributes_enabled(False)
self._set_limits_enabled(False)
self._first_attributes = True
def __init__(self, parent=None):
super(ComponentSelector, self).__init__(parent)
self._data = None
self._ui = load_ui('component_selector.ui', self,
directory=os.path.dirname(__file__))
self._init_widgets()
self._connect()
def __init__(self):
QtWidgets.QWidget.__init__(self)
self.ui = load_ui('message_widget.ui', self,
directory=os.path.dirname(__file__))
self.ui.messageTable.setColumnCount(3)
labels = ['Time', 'Message', 'Sender']
self.ui.messageTable.setHorizontalHeaderLabels(labels)
def __init__(self, application, parent=None):
super(PreferencesDialog, self).__init__(parent=parent)
self.app = application
self.ui = load_ui('preferences.ui', self,
directory=os.path.dirname(__file__))
self.ui.cancel.clicked.connect(self.reject)
self.ui.ok.clicked.connect(self.accept)
self.ui.combo_theme.currentIndexChanged.connect(nonpartial(self._update_colors_from_theme))
from glue.config import settings
self.background = settings.BACKGROUND_COLOR
self.foreground = settings.FOREGROUND_COLOR
self.data_color = settings.DATA_COLOR
self.data_alpha = settings.DATA_ALPHA
self.show_large_data_warning = settings.SHOW_LARGE_DATA_WARNING
self._update_theme_from_colors()
self.panes = []
from glue.config import preference_panes
for label, widget_cls in sorted(preference_panes):
pane = widget_cls()
self.ui.tab_widget.addTab(pane, label)
self.panes.append(pane)
def __init__(self, parent=None):
super(FeedbackWidget, self).__init__(parent=parent)
self.ui = load_ui('report_feedback.ui', self,
directory=os.path.dirname(__file__))
self.ui.area_comments.moveCursor(QtGui.QTextCursor.Start)
def __init__(self, parent=None, data_viewer=None):
super(LayerWidget, self).__init__(parent=parent)
self.ui = load_ui('layer_widget.ui', self,
directory=os.path.dirname(__file__))
self._layers = []
def __init__(self, layer_artist):
super(HistogramLayerStyleWidget, self).__init__()
self.ui = load_ui("layer_style_widget.ui", self, directory=os.path.dirname(__file__))
self.layer = layer_artist.layer
connect_color(self.layer.style, "color", self.ui.label_color)
connect_value(self.layer.style, "alpha", self.ui.slider_alpha, value_range=(0, 1))
def __init__(self, data_collection=None, initial_data=None, parent=None):
super(ComponentManagerWidget, self).__init__(parent=parent)
self.ui = load_ui('component_manager.ui', self,
directory=os.path.dirname(__file__))
self.list = {}
self.list = self.ui.list_main_components
self.data_collection = data_collection
self._components_main = defaultdict(list)
self._components_other = defaultdict(list)
self._state = defaultdict(dict)
for data in data_collection:
for cid in data.main_components:
comp_state = {}
comp_state['cid'] = cid
comp_state['label'] = cid.label
self._state[data][cid] = comp_state
self._components_main[data].append(cid)
# Keep track of all other components
self._components_other[data] = []
for cid in data.components:
if cid not in self._components_main[data]:
self._components_other[data].append(cid)
# Populate data combo
ComponentManagerWidget.data.set_choices(self, list(self.data_collection))
ComponentManagerWidget.data.set_display_func(self, lambda x: x.label)
connect_combo_selection(self, 'data', self.ui.combosel_data)
if initial_data is None:
self.ui.combosel_data.setCurrentIndex(0)
else:
self.data = initial_data
self.ui.combosel_data.currentIndexChanged.connect(self._update_component_lists)
self._update_component_lists()
self.ui.button_remove_main.clicked.connect(self._remove_main_component)
self.ui.list_main_components.itemSelectionChanged.connect(self._update_selection_main)
self._update_selection_main()
self.ui.list_main_components.itemChanged.connect(self._update_state)
self.ui.list_main_components.order_changed.connect(self._update_state)
self.ui.button_ok.clicked.connect(self.accept)
self.ui.button_cancel.clicked.connect(self.reject)
def __init__(self, viewer_state=None, session=None):
super(TutorialViewerStateWidget, self).__init__()
self.ui = load_ui('viewer_state.ui', self,
directory=os.path.dirname(__file__))
self.viewer_state = viewer_state
autoconnect_callbacks_to_qt(self.viewer_state, self.ui)
def __init__(self, collection, functions=None, parent=None):
self._collection = collection
self._ui = load_ui("link_editor.ui", parent, directory=os.path.dirname(__file__))
self._init_widgets()
self._connect()
if len(collection) > 1:
self._ui.right_components.set_data_row(1)
self._size = None
def __init__(self, layer_state, parent=None):
super(ScatterLayerStyleEditor, self).__init__(parent=parent)
self.ui = load_ui('layer_style_editor.ui', self,
directory=os.path.dirname(__file__))
autoconnect_qt(layer_state, self)
autoconnect_qt(layer_state.layer.style, self)
def __init__(self, layer_artist):
super(SpecvizLayerStateWidget, self).__init__()
self.ui = load_ui('layer_state.ui', self,
directory=os.path.dirname(__file__))
connect_kwargs = {'alpha': dict(value_range=(0, 1))}
autoconnect_callbacks_to_qt(layer_artist.state, self.ui, connect_kwargs)
def __init__(self, viewer_state, session, parent=None):
super(ScatterOptionsWidget, self).__init__(parent=parent)
self.ui = load_ui('options_widget.ui', self,
directory=os.path.dirname(__file__))
autoconnect_callbacks_to_qt(viewer_state, self.ui)
self.viewer_state = viewer_state
def __init__(self, layer, parent=None):
super(HistogramLayerStyleEditor, self).__init__(parent=parent)
self.ui = load_ui('layer_style_editor.ui', self,
directory=os.path.dirname(__file__))
connect_kwargs = {'alpha': dict(value_range=(0, 1))}
autoconnect_callbacks_to_qt(layer.state, self.ui, connect_kwargs)
def __init__(self, installed=None):
self.ui = load_ui("plugin_manager.ui", None, directory=os.path.dirname(__file__))
self.ui.cancel.clicked.connect(self.reject)
self.ui.confirm.clicked.connect(self.finalize)
self._checkboxes = {}
self.update_list(installed=installed)
def __init__(self, parent=None, data_viewer=None):
super(OptionsWidget, self).__init__(parent=parent)
self.ui = load_ui('viewer_options.ui',
self,
directory=os.path.dirname(__file__))
self.file_helper = ComponentIDComboHelper(self.ui.combo_file_attribute,
data_viewer._data)
self._data_viewer = data_viewer
self._data = None
def _setup_widget(self):
self.ui = load_ui('spectrum_fit_panel.ui',
None,
directory=os.path.dirname(__file__))
self.ui.uncertainty_combo.hide()
self.ui.uncertainty_label.hide()
font = QtGui.QFont("Courier")
font.setStyleHint(font.Monospace)
self.ui.results_box.document().setDefaultFont(font)
self.ui.results_box.setLineWrapMode(self.ui.results_box.NoWrap)
self.widget = self.ui
for fitter in list(fit_plugin):
self.ui.profile_combo.addItem(fitter.label, userData=fitter())
def __init__(self, collection, functions=None, parent=None):
super(LinkEditor, self).__init__(parent=parent)
self._collection = collection
self._ui = load_ui('link_editor.ui', self,
directory=os.path.dirname(__file__))
self._init_widgets()
self._connect()
if len(collection) > 1:
self._ui.right_components.set_data_row(1)
self._size = None
def __init__(self, plotly_args=[], plotly_kwargs={}, parent=None):
super(QtPlotlyExporter, self).__init__(parent=parent)
self.plotly_args = plotly_args
self.plotly_kwargs = plotly_kwargs
self.ui = load_ui('exporter.ui', self,
directory=os.path.dirname(__file__))
self.button_cancel.clicked.connect(self.reject)
self.button_export.clicked.connect(self.accept)
# Set up radio button groups
self._radio_account = QtWidgets.QButtonGroup()
self._radio_account.addButton(self.ui.radio_account_glue)
self._radio_account.addButton(self.ui.radio_account_config)
self._radio_account.addButton(self.ui.radio_account_manual)
self._radio_sharing = QtWidgets.QButtonGroup()
self._radio_sharing.addButton(self.ui.radio_sharing_public)
self._radio_sharing.addButton(self.ui.radio_sharing_secret)
self._radio_sharing.addButton(self.ui.radio_sharing_private)
# Find out stored credentials (note that this will create the
# credentials file if it doesn't already exist)
from plotly import plotly
credentials = plotly.get_credentials()
config_available = credentials['username'] != "" and credentials['api_key'] != ""
if config_available:
self.ui.radio_account_config.setChecked(True)
label = self.ui.radio_account_config.text()
self.ui.radio_account_config.setText(label + " (username: {0})".format(credentials['username']))
else:
self.ui.radio_account_glue.setChecked(True)
self.ui.radio_account_config.setEnabled(False)
self.ui.radio_sharing_secret.setChecked(True)
self.ui.text_username.textChanged.connect(nonpartial(self._set_manual_mode))
self.ui.text_api_key.textChanged.connect(nonpartial(self._set_manual_mode))
self.ui.radio_account_glue.toggled.connect(nonpartial(self._set_allowed_sharing_modes))
self.set_status('', color='black')
self._set_allowed_sharing_modes()
def _setup_widgets(self):
self.central_widget = self.make_central_widget()
self.label_widget = QtWidgets.QLabel("", self.central_widget)
self.setCentralWidget(self.central_widget)
self.option_widget = QtWidgets.QWidget()
self.ui = load_ui('options_widget.ui',
self.option_widget,
directory=os.path.dirname(__file__))
self.ui.slice = DataSlice()
self.ui.slice_layout.addWidget(self.ui.slice)
self._tweak_geometry()
self.ui.aspectCombo.addItem("Square Pixels", userData='equal')
self.ui.aspectCombo.addItem("Automatic", userData='auto')
def __init__(self, feedback='', parent=None):
"""
:param feedback: The default feedback report
:type feedback: str
Feedback will be supplemented with diagnostic system information.
The user can modify or add to any of this
"""
self._ui = load_ui('feedback.ui',
None,
directory=os.path.dirname(__file__))
feedback = '\n'.join(['-' * 80, feedback, _diagnostics()])
self._ui.report_area.insertPlainText('\n' + feedback)
self._ui.report_area.moveCursor(QtGui.QTextCursor.Start)
def __init__(self, viewer_state, parent=None):
super(WWTOptionPanel, self).__init__(parent=parent)
self._viewer_state = viewer_state
self.ui = load_ui('options_widget.ui',
self,
directory=os.path.dirname(__file__))
connect_kwargs = {'foreground_opacity': dict(value_range=(0, 100))}
autoconnect_callbacks_to_qt(self._viewer_state, self.ui,
connect_kwargs)
def __init__(self, layer, parent=None):
super(ProfileLayerStyleEditor, self).__init__(parent=parent)
self.ui = load_ui('layer_style_editor.ui', self,
directory=os.path.dirname(__file__))
connect_kwargs = {'alpha': dict(value_range=(0, 1))}
self._connections = autoconnect_callbacks_to_qt(layer.state, self.ui, connect_kwargs)
self.viewer_state = layer.state.viewer_state
self.viewer_state.add_callback('normalize', self._on_normalize_change)
self._on_normalize_change()
def __init__(self, viewer_state=None, session=None):
super(OpenSpaceViewerStateWidget, self).__init__()
self._viewer_state = viewer_state
self.ui = load_ui('viewer_state_widget.ui', self,
directory=os.path.dirname(__file__))
self._connect = autoconnect_callbacks_to_qt(self._viewer_state, self.ui)
self._viewer_state.add_callback('mode', self._update_visible_options)
self._viewer_state.add_callback('frame', self._update_visible_options)
self._update_visible_options()
def __init__(self, layer_artist):
super(HistogramLayerStyleWidget, self).__init__()
self.ui = load_ui('layer_style_widget.ui', self,
directory=os.path.dirname(__file__))
self.layer = layer_artist.layer
# Set up connections
self._connect_global()
# Set initial values
self.ui.label_color.setColor(self.layer.style.color)
self.alpha = self.layer.style.alpha
def __init__(self, layer_artist):
super(IsosurfaceLayerStyleWidget, self).__init__()
self.ui = load_ui('layer_style_widget.ui', self,
directory=os.path.dirname(__file__))
self.state = layer_artist.state
self.layer_artist = layer_artist
self.layer = layer_artist.layer
connect_kwargs = {'value_alpha': dict(value_range=(0., 1.)),
'value_step': dict(value_range=(1, 10))}
autoconnect_callbacks_to_qt(self.state, self.ui, connect_kwargs)
def __init__(self, *args, **kwargs):
super(QVersionsDialog, self).__init__(*args, **kwargs)
self.ui = load_ui('versions.ui', self, directory=os.path.dirname(__file__))
self.resize(400, 500)
self.setWindowFlags(Qt.Window | Qt.WindowStaysOnTopHint)
self.center()
self._update_deps()
self._clipboard = QtWidgets.QApplication.clipboard()
self.ui.button_copy.clicked.connect(nonpartial(self._copy))
def __init__(self, viewer_state, session, parent=None):
super(HistogramOptionsWidget, self).__init__(parent=parent)
self.ui = load_ui('options_widget.ui',
self,
directory=os.path.dirname(__file__))
fix_tab_widget_fontsize(self.ui.tab_widget)
autoconnect_callbacks_to_qt(viewer_state, self.ui)
self.viewer_state = viewer_state
viewer_state.add_callback('x_att', self._update_attribute)
def __init__(self, viewer_state, session, parent=None):
super(ScatterOptionsWidget, self).__init__(parent=parent)
self.ui = load_ui('options_widget.ui', self,
directory=os.path.dirname(__file__))
self.viewer_state = viewer_state
autoconnect_qt(self.viewer_state, self)
self.viewer_state.connect('layers', self._update_combo_data)
self.xatt_helper = ComponentIDComboHelper(self.ui.combo_xatt,
session.data_collection)
self.yatt_helper = ComponentIDComboHelper(self.ui.combo_yatt,
session.data_collection)
def __init__(self, crash_report='', parent=None):
"""
:param feedback: The default feedback report
:type feedback: str
Feedback will be supplemented with diagnostic system information.
The user can modify or add to any of this
"""
super(CrashReportWidget, self).__init__(parent=parent)
self.ui = load_ui('report_crash.ui', self,
directory=os.path.dirname(__file__))
self.ui.area_report.insertPlainText(diagnostics() + "\n\n" + crash_report)
self.ui.area_comments.moveCursor(QtGui.QTextCursor.Start)
def __init__(self, layer, parent=None):
super(ScatterLayerStyleEditor, self).__init__(parent=parent)
self.ui = load_ui('layer_style_editor.ui', self,
directory=os.path.dirname(__file__))
connect_kwargs = {'alpha': dict(value_range=(0, 1)),
'size_scaling': dict(value_range=(0.1, 10), log=True),
'density_contrast': dict(value_range=(0, 1)),
'vector_scaling': dict(value_range=(0.1, 10), log=True)}
autoconnect_callbacks_to_qt(layer.state, self.ui, connect_kwargs)
connect_value(layer.state.viewer_state, 'dpi', self.ui.value_dpi,
value_range=(12, 144), log=True)
fix_tab_widget_fontsize(self.ui.tab_widget)
self.layer_state = layer.state
self.layer_state.add_callback('markers_visible', self._update_markers_visible)
self.layer_state.add_callback('line_visible', self._update_line_visible)
self.layer_state.add_callback('xerr_visible', self._update_xerr_visible)
self.layer_state.add_callback('yerr_visible', self._update_yerr_visible)
self.layer_state.add_callback('vector_visible', self._update_vectors_visible)
self.layer_state.add_callback('cmap_mode', self._update_cmap_mode)
self.layer_state.add_callback('size_mode', self._update_size_mode)
self.layer_state.add_callback('vector_mode', self._update_vector_mode)
self.layer_state.add_callback('density_map', self._update_size_mode)
self.layer_state.add_callback('density_map', self._update_warnings)
self.layer_state.add_callback('layer', self._update_warnings)
self._update_markers_visible()
self._update_line_visible()
self._update_xerr_visible()
self._update_yerr_visible()
self._update_vectors_visible()
self._update_size_mode()
self._update_vector_mode()
self._update_cmap_mode()
self._update_warnings()
def __init__(self, session, parent=None):
super(HistogramWidget, self).__init__(session, parent)
self.central_widget = MplWidget()
self.setCentralWidget(self.central_widget)
self.option_widget = QtGui.QWidget()
self.ui = load_ui('options_widget.ui', self.option_widget,
directory=os.path.dirname(__file__))
self._tweak_geometry()
self.client = HistogramClient(self._data,
self.central_widget.canvas.fig,
layer_artist_container=self._layer_artist_container)
self._init_limits()
self.make_toolbar()
self._connect()
# maps _hash(componentID) -> componentID
self._component_hashes = {}
def __init__(self, label=None, data=None, equation=None, references=None, parent=None):
super(EquationEditorDialog, self).__init__(parent=parent)
self.ui = load_ui('equation_editor.ui', self,
directory=os.path.dirname(__file__))
# Get mapping from label to component ID
if references is not None:
self.references = references
elif data is not None:
self.references = OrderedDict()
for cid in data.primary_components:
self.references[cid.label] = cid
example = sorted(self.references, key=len)[0]
self.ui.text_label.setPlaceholderText("New attribute name")
self.ui.expression.setPlaceholderText(self.placeholder_text.format(example=example))
self.ui.label.setText(self.tip_text.format(example=example))
if label is not None:
self.ui.text_label.setText(label)
self.ui.text_label.textChanged.connect(self._update_status)
# Populate component combo
EquationEditorDialog.attribute.set_choices(self, list(self.references))
connect_combo_selection(self, 'attribute', self.ui.combosel_component)
# Set up labels for auto-completion
labels = ['{' + l + '}' for l in self.references]
self.ui.expression.set_word_list(labels)
if equation is not None:
self.ui.expression.insertPlainText(equation)
self.ui.button_ok.clicked.connect(self.accept)
self.ui.button_cancel.clicked.connect(self.reject)
self.ui.button_insert.clicked.connect(self._insert_component)
self.ui.expression.updated.connect(self._update_status)
self._update_status()
def __init__(self, application, parent=None):
super(PreferencesDialog, self).__init__(parent=parent)
self._app = weakref.ref(application)
self.ui = load_ui('preferences.ui',
self,
directory=os.path.dirname(__file__))
self.ui.cancel.clicked.connect(self.reject)
self.ui.ok.clicked.connect(self.accept)
self.ui.combo_theme.currentIndexChanged.connect(
self._update_colors_from_theme)
self.ui.button_reset_dialogs.clicked.connect(self._reset_dialogs)
# The following is needed because of a bug in Qt which means that
# tab titles don't get scaled right.
if platform.system() == 'Darwin':
app = get_qapp()
app_font = app.font()
self.ui.tab_widget.setStyleSheet('font-size: {0}px'.format(
app_font.pointSize()))
from glue.config import settings
self.background = settings.BACKGROUND_COLOR
self.foreground = settings.FOREGROUND_COLOR
self.data_color = settings.DATA_COLOR
self.data_alpha = settings.DATA_ALPHA
self.font_size = settings.FONT_SIZE
self._update_theme_from_colors()
self._autolink_pane = AutolinkPreferencesPane()
self.ui.tab_widget.addTab(self._autolink_pane, 'Autolinking')
self.panes = []
from glue.config import preference_panes
for label, widget_cls in sorted(preference_panes):
pane = widget_cls()
self.ui.tab_widget.addTab(pane, label)
self.panes.append(pane)
def __init__(self, viewer_state, session, parent=None):
super(HistogramOptionsWidget, self).__init__(parent=parent)
self.ui = load_ui('options_widget.ui', self,
directory=os.path.dirname(__file__))
fix_tab_widget_fontsize(self.ui.tab_widget)
self._connections = autoconnect_callbacks_to_qt(viewer_state, self.ui)
self._connections_axes = autoconnect_callbacks_to_qt(viewer_state, self.ui.axes_editor.ui)
self.viewer_state = viewer_state
viewer_state.add_callback('x_att', self._update_attribute)
self.session = session
self.ui.axes_editor.button_apply_all.clicked.connect(self._apply_all_viewers)
def __init__(self, viewer_state, session, parent=None):
super(ProfileOptionsWidget, self).__init__(parent=parent)
self.ui = load_ui('options_widget.ui', self,
directory=os.path.dirname(__file__))
fix_tab_widget_fontsize(self.ui.tab_widget)
autoconnect_callbacks_to_qt(viewer_state, self.ui)
self.viewer_state = viewer_state
self.session = session
self.viewer_state.add_callback('x_att', self._on_attribute_change)
self.ui.text_warning.hide()
def __init__(self, data_collection=None, parent=None):
super(YTWidget, self).__init__(parent=parent)
self.data_collection = data_collection
self.ui = load_ui('yt.ui', self, directory=os.path.dirname(__file__))
self.ui.value_step.setMinimum(0)
self.ui.value_step.setMaximum(len(data_collection[0].ds_all) - 1)
# Set up connections for UI elements
self.ui.value_step.valueChanged.connect(self.set_step)
self.ui.text_step.setText('')
self.data = None
self.n_steps = None
self.filename = None
def __init__(self, layer, parent=None):
super(ImageLayerStyleEditor, self).__init__(parent=parent)
self.ui = load_ui('layer_style_editor.ui', self,
directory=os.path.dirname(__file__))
connect_kwargs = {'alpha': dict(value_range=(0, 1)),
'contrast': dict(value_range=(0.1, 10), log=True),
'bias': dict(value_range=(1.5, -0.5))}
autoconnect_callbacks_to_qt(layer.state, self.ui, connect_kwargs)
layer._viewer_state.add_callback('color_mode', self._update_color_mode)
self._update_color_mode(layer._viewer_state.color_mode)
self.ui.bool_global_sync.setToolTip('Whether to sync the color and transparency with other viewers')
def __init__(self, viewer_state, session, parent=None):
super(ImageOptionsWidget, self).__init__(parent=parent)
self.ui = load_ui('options_widget.ui', self,
directory=os.path.dirname(__file__))
fix_tab_widget_fontsize(self.ui.tab_widget)
autoconnect_callbacks_to_qt(viewer_state, self.ui)
self.viewer_state = viewer_state
self.slice_helper = MultiSliceWidgetHelper(viewer_state=self.viewer_state,
layout=self.ui.layout_slices)
self.session = session
self.ui.axes_editor.button_apply_all.clicked.connect(self._apply_all_viewers)
def __init__(self, viewer_state, session=None, parent=None):
super(WWTOptionPanel, self).__init__(parent=parent)
self._viewer_state = viewer_state
self.ui = load_ui('options_widget.ui',
self,
directory=os.path.dirname(__file__))
connect_kwargs = {'foreground_opacity': dict(value_range=(0, 1))}
self._connect = autoconnect_callbacks_to_qt(self._viewer_state,
self.ui, connect_kwargs)
self._viewer_state.add_callback('mode', self._update_visible_options)
self._viewer_state.add_callback('frame', self._update_visible_options)
self._update_visible_options()
def __init__(self, session, parent=None, widget=None):
super(TableWidget, self).__init__(session, parent)
self.ui = load_ui('viewer_widget.ui',
directory=os.path.dirname(__file__))
self.setCentralWidget(self.ui)
hdr = self.ui.table.horizontalHeader()
hdr.setStretchLastSection(True)
hdr.setSectionResizeMode(hdr.Interactive)
hdr = self.ui.table.verticalHeader()
hdr.setSectionResizeMode(hdr.Interactive)
self.model = None
self.ui.table.selection_changed.connect(self.selection_changed)
def __init__(self, session, parent=None):
super(DendroWidget, self).__init__(session, parent)
self.central_widget = MplWidget()
self.option_widget = QtWidgets.QWidget()
self.setCentralWidget(self.central_widget)
self.ui = load_ui('options_widget.ui',
self.option_widget,
directory=os.path.dirname(__file__))
self.client = DendroClient(
self._data,
self.central_widget.canvas.fig,
layer_artist_container=self._layer_artist_container)
self._connect()
self.statusBar().setSizeGripEnabled(False)
def __init__(self, viewer_state, session, parent=None):
super(HistogramOptionsWidget, self).__init__(parent=parent)
self.ui = load_ui('options_widget.ui',
self,
directory=os.path.dirname(__file__))
autoconnect_callbacks_to_qt(viewer_state, self.ui)
viewer_state.add_callback('layers', self._update_combo_data)
self.x_att_helper = ComponentIDComboHelper(self.ui.combodata_x_att,
session.data_collection)
self.viewer_state = viewer_state
viewer_state.add_callback('x_att', nonpartial(self._update_attribute))
def _choose_merge(data, others):
w = load_ui('merge.ui', None, directory=os.path.dirname(__file__))
w.button_yes.clicked.connect(w.accept)
w.button_no.clicked.connect(w.reject)
w.show()
w.raise_()
# Add the main dataset to the list. Some of the 'others' may also be
# new ones, so it doesn't really make sense to distinguish between
# the two here. The main point is that some datasets, including at
# least one new one, have a common shape.
others.append(data)
others.sort(key=lambda x: x.label)
for i, d in enumerate(others):
if isinstance(d.coords, WCSCoordinates):
if i == 0:
break
else:
others[0], others[i] = others[i], others[0]
break
label = others[0].label
w.merged_label.setText(label)
entries = [QtWidgets.QListWidgetItem(other.label) for other in others]
for e in entries:
e.setCheckState(Qt.Checked)
for d, item in zip(others, entries):
w.choices.addItem(item)
if not w.exec_():
return None, None
result = [
layer for layer, entry in zip(others, entries)
if entry.checkState() == Qt.Checked
]
if result:
return result, str(w.merged_label.text())
return None, None
def __init__(self, parent=None):
super(LayerTreeWidget, self).__init__(parent)
self.ui = load_ui('layer_tree_widget.ui', None, directory=os.path.dirname(__file__))
self.setCentralWidget(self.ui)
self._signals = LayerCommunicator()
self._is_checkable = True
self._layer_check_changed = self._signals.layer_check_changed
self._layer_dict = {}
self._actions = {}
self._create_actions()
self._data_collection = None
self._hub = None
self.ui.layerTree.setDragEnabled(True)
self.setMinimumSize(300, 0)