def register_to_hub(self, hub):
super(ScatterWidget, self).register_to_hub(hub)
self.client.register_to_hub(hub)
hub.subscribe(self, core.message.DataUpdateMessage,
nonpartial(self._sync_labels))
hub.subscribe(self, core.message.ComponentsChangedMessage,
nonpartial(self._update_combos))
hub.subscribe(self, core.message.ComponentReplacedMessage,
self._on_component_replace)
def __init__(self, label='', pix2world=None, lo=0, hi=10,
parent=None, aggregation=None):
super(SliceWidget, self).__init__(parent)
if aggregation is not None:
raise NotImplemented("Aggregation option not implemented")
if pix2world is not None:
raise NotImplemented("Pix2world option not implemented")
layout = QtGui.QVBoxLayout()
layout.setContentsMargins(3, 1, 3, 1)
layout.setSpacing(0)
top = QtGui.QHBoxLayout()
top.setContentsMargins(3, 3, 3, 3)
label = QtGui.QLabel(label)
top.addWidget(label)
mode = QtGui.QComboBox()
mode.addItem('x', 'x')
mode.addItem('y', 'y')
mode.addItem('slice', 'slice')
mode.currentIndexChanged.connect(lambda x:
self.mode_changed.emit(self.mode))
mode.currentIndexChanged.connect(self._update_mode)
top.addWidget(mode)
layout.addLayout(top)
slider = load_ui('cube_slider')
slider.slider
slider.slider.setMinimum(lo)
slider.slider.setMaximum(hi)
slider.slider.setValue((lo + hi) / 2)
slider.slider.valueChanged.connect(lambda x:
self.slice_changed.emit(self.mode))
slider.slider.valueChanged.connect(lambda x: slider.label.setText(str(x)))
slider.label.setMinimumWidth(50)
slider.label.setText(str(slider.slider.value()))
slider.label.textChanged.connect(lambda x: slider.slider.setValue(int(x)))
slider.first.clicked.connect(nonpartial(self._browse_slice, 'first'))
slider.prev.clicked.connect(nonpartial(self._browse_slice, 'prev'))
slider.next.clicked.connect(nonpartial(self._browse_slice, 'next'))
slider.last.clicked.connect(nonpartial(self._browse_slice, 'last'))
layout.addWidget(slider)
self.setLayout(layout)
self._ui_label = label
self._ui_slider = slider
self._ui_mode = mode
self._update_mode()
self._frozen = False
def __init__(self, instance, option):
super(BoolFormItem, self).__init__(instance, option)
value = option.__get__(instance)
self.widget = QtGui.QCheckBox()
self.widget.setChecked(value)
self.widget.clicked.connect(nonpartial(self.changed.emit))
def make_toolbar(self):
result = GlueToolbar(self.central_widget.canvas, self, name='Image')
for mode in self._mouse_modes():
result.add_mode(mode)
cmap = _colormap_mode(self, self.client.set_cmap)
result.addWidget(cmap)
# connect viewport update buttons to client commands to
# allow resampling
cl = self.client
result.buttons['HOME'].triggered.connect(nonpartial(cl.check_update))
result.buttons['FORWARD'].triggered.connect(nonpartial(
cl.check_update))
result.buttons['BACK'].triggered.connect(nonpartial(cl.check_update))
return result
def _make_mode(self, name, tip, icon, mode):
a = act(name, self, tip, icon)
a.setCheckable(True)
a.triggered.connect(nonpartial(set_mode, mode))
self._group.addAction(a)
self.addAction(a)
self._modes[mode] = a
label = name.split()[0].lower().replace('&', '')
self._modes[label] = mode
def add_mode(self, mode):
parent = QtGui.QToolBar.parent(self)
def toggle():
self._custom_mode(mode)
def enable():
# turn on if not
if self._active != mode.mode_id:
self._custom_mode(mode)
action = QtGui.QAction(mode.icon, mode.action_text, parent)
action.triggered.connect(nonpartial(toggle))
parent.addAction(action)
self.__signals.extend([toggle, enable])
if mode.shortcut is not None:
action.setShortcut(mode.shortcut)
action.setShortcutContext(Qt.WidgetShortcut)
action.setToolTip(mode.tool_tip)
action.setCheckable(True)
self.buttons[mode.mode_id] = action
menu_actions = mode.menu_actions()
if len(menu_actions) > 0:
menu = QtGui.QMenu(self)
for ma in mode.menu_actions():
ma.setParent(self)
menu.addAction(ma)
action.setMenu(menu)
menu.triggered.connect(nonpartial(enable))
self.addAction(action)
# bind action status to mode.enabled
def toggle(state):
action.setVisible(state)
action.setEnabled(state)
add_callback(mode, 'enabled', toggle)
return action
def __init__(self, instance, option):
super(NumberFormItem, self).__init__(instance, option)
value = option.__get__(instance)
w = self.widget_cls()
w.setRange(option.min, option.max)
w.setValue(value)
w.valueChanged.connect(nonpartial(self.changed.emit))
self.widget = w
def _create_actions(self):
act = QtGui.QAction('Edit style', self)
act.triggered.connect(nonpartial(self._edit_style))
self.addAction(act)
act = QtGui.QAction('Remove', self)
act.setShortcut(QtGui.QKeySequence(Qt.Key_Backspace))
act.setShortcutContext(Qt.WidgetShortcut)
act.triggered.connect(
lambda *args: self.model().removeRow(self.current_row()))
self.addAction(act)
def _connect(self):
ui = self.ui
ui.monochrome.toggled.connect(self._update_rgb_console)
ui.rgb_options.colors_changed.connect(self.update_window_title)
# sync client and widget slices
ui.slice.slice_changed.connect(lambda: setattr(self, 'slice', self.ui.slice.slice))
update_ui_slice = lambda val: setattr(ui.slice, 'slice', val)
add_callback(self.client, 'slice', update_ui_slice)
add_callback(self.client, 'display_data', self.ui.slice.set_data)
# sync window title to data/attribute
add_callback(self.client, 'display_data', nonpartial(self._display_data_changed))
add_callback(self.client, 'display_attribute', nonpartial(self._display_attribute_changed))
add_callback(self.client, 'display_aspect', nonpartial(self.client._update_aspect))
# sync data/attribute combos with client properties
connect_current_combo(self.client, 'display_data', self.ui.displayDataCombo)
connect_current_combo(self.client, 'display_attribute', self.ui.attributeComboBox)
connect_current_combo(self.client, 'display_aspect', self.ui.aspectCombo)
def _init_toolbar(self):
self.basedir = os.path.join(matplotlib.rcParams['datapath'], 'images')
parent = QtGui.QToolBar.parent(self)
a = QtGui.QAction(get_icon('glue_home'),
'Home', parent)
a.triggered.connect(nonpartial(self.home))
a.setToolTip('Reset original zoom')
a.setShortcut('H')
a.setShortcutContext(Qt.WidgetShortcut)
parent.addAction(a)
self.buttons['HOME'] = a
self.addAction(a)
a = QtGui.QAction(get_icon('glue_filesave'),
'Save', parent)
a.triggered.connect(nonpartial(self.save_figure))
a.setToolTip('Save the figure')
a.setShortcut('Ctrl+Shift+S')
parent.addAction(a)
self.buttons['SAVE'] = a
self.addAction(a)
a = QtGui.QAction(get_icon('glue_back'),
'Back', parent)
a.triggered.connect(nonpartial(self.back))
parent.addAction(a)
self.addAction(a)
self.buttons['BACK'] = a
a.setToolTip('Back to previous view')
a = QtGui.QAction(get_icon('glue_forward'),
'Forward', parent)
a.triggered.connect(nonpartial(self.forward))
a.setToolTip('Forward to next view')
parent.addAction(a)
self.buttons['FORWARD'] = a
self.addAction(a)
a = QtGui.QAction(get_icon('glue_move'),
'Pan', parent)
a.triggered.connect(nonpartial(self.pan))
a.setToolTip('Pan axes with left mouse, zoom with right')
a.setCheckable(True)
a.setShortcut('M')
a.setShortcutContext(Qt.WidgetShortcut)
parent.addAction(a)
self.addAction(a)
self.buttons['PAN'] = a
a = QtGui.QAction(get_icon('glue_zoom_to_rect'),
'Zoom', parent)
a.triggered.connect(nonpartial(self.zoom))
a.setToolTip('Zoom to rectangle')
a.setShortcut('Z')
a.setShortcutContext(Qt.WidgetShortcut)
a.setCheckable(True)
parent.addAction(a)
self.addAction(a)
self.buttons['ZOOM'] = a
def _connect(self):
""" Connect widget signals to methods """
self._actions['link'] = LinkAction(self)
self.layerAddButton.clicked.connect(nonpartial(self._load_data))
self.layerRemoveButton.clicked.connect(self._actions['delete'].trigger)
self.linkButton.set_action(self._actions['link'])
self.newSubsetButton.set_action(self._actions['new'], text=False)
rbut = self.layerRemoveButton
def update_enabled():
return rbut.setEnabled(self._actions['delete'].isEnabled())
self.layerTree.selection_changed.connect(update_enabled)
def menu(self):
m = QtGui.QMenu()
a = QtGui.QAction("Or", m)
a.setIcon(get_icon('glue_or'))
a.triggered.connect(nonpartial(self._paste, OrMode))
m.addAction(a)
a = QtGui.QAction("And", m)
a.setIcon(get_icon('glue_and'))
a.triggered.connect(nonpartial(self._paste, AndMode))
m.addAction(a)
a = QtGui.QAction("XOR", m)
a.setIcon(get_icon('glue_xor'))
a.triggered.connect(nonpartial(self._paste, XorMode))
m.addAction(a)
a = QtGui.QAction("Not", m)
a.setIcon(get_icon('glue_andnot'))
a.triggered.connect(nonpartial(self._paste, AndNotMode))
m.addAction(a)
return m
def _connect(self):
ui = self.ui
cl = self.client
connect_bool_button(cl, 'xlog', ui.xLogCheckBox)
connect_bool_button(cl, 'ylog', ui.yLogCheckBox)
connect_bool_button(cl, 'xflip', ui.xFlipCheckBox)
connect_bool_button(cl, 'yflip', ui.yFlipCheckBox)
ui.xAxisComboBox.currentIndexChanged.connect(self.update_xatt)
ui.yAxisComboBox.currentIndexChanged.connect(self.update_yatt)
ui.hidden_attributes.toggled.connect(lambda x: self._update_combos())
ui.swapAxes.clicked.connect(nonpartial(self.swap_axes))
ui.snapLimits.clicked.connect(cl.snap)
connect_float_edit(cl, 'xmin', ui.xmin)
connect_float_edit(cl, 'xmax', ui.xmax)
connect_float_edit(cl, 'ymin', ui.ymin)
connect_float_edit(cl, 'ymax', ui.ymax)
def _colormap_mode(parent, on_trigger):
# actions for each colormap
acts = []
# for label, cmap in config.colormaps:
for label in ginga_cmap.get_names():
cmap = ginga_cmap.get_cmap(label)
a = ColormapAction(label, cmap, parent)
a.triggered.connect(nonpartial(on_trigger, cmap))
acts.append(a)
# Toolbar button
tb = QtGui.QToolButton()
tb.setWhatsThis("Set color scale")
tb.setToolTip("Set color scale")
icon = get_icon('glue_rainbow')
tb.setIcon(icon)
tb.setPopupMode(QtGui.QToolButton.InstantPopup)
tb.addActions(acts)
return tb
def __init__(self, x, y, dy, initial_models=None):
QObject.__init__(self)
self.x = x
self.y = y
self.dy = dy
if initial_models is None:
initial_models = [models.Const1D(0.0)]
self.models = initial_models
self.ui = ModelBrowserUI(self, self.models, self.x, self.y)
self.plot, self.resid = _build_axes(self.ui.canvas.fig)
self._draw(preserve_limits=False)
self.mouse_handler = ModelEventHandler(self.plot, self.active_model)
add_callback(self.mouse_handler, 'model', self.set_model)
self.ui.fit.pressed.connect(nonpartial(self.fit))
self._sync_model_list()
def _create_actions(self):
tree = self.layerTree
sep = QtGui.QAction("", tree)
sep.setSeparator(True)
tree.addAction(sep)
self._actions['save'] = SaveAction(self)
self._actions['copy'] = CopyAction(self)
self._actions['paste'] = PasteAction(self)
self._actions['paste_special'] = PasteSpecialAction(self)
self._actions['invert'] = Inverter(self)
self._actions['new'] = NewAction(self)
self._actions['clear'] = ClearAction(self)
self._actions['delete'] = DeleteAction(self)
self._actions['facet'] = FacetAction(self)
self._actions['merge'] = MergeAction(self)
self._actions['maskify'] = MaskifySubsetAction(self)
# new component definer
separator = QtGui.QAction("sep", tree)
separator.setSeparator(True)
tree.addAction(separator)
a = _act("Define new component", self,
tip="Define a new component using python expressions")
tree.addAction(a)
a.triggered.connect(nonpartial(self._create_component))
self._actions['new_component'] = a
# user-defined layer actions
for name, callback, tooltip, icon in single_subset_action:
self._actions[name] = SingleSubsetUserAction(self, callback,
name=name,
tooltip=tooltip,
icon=icon)
# right click pulls up menu
tree.setContextMenuPolicy(Qt.ActionsContextMenu)
def __init__(self, x, y, dy, initial_models=None):
QObject.__init__(self)
self.x = x
self.y = y
self.dy = dy
if initial_models is None:
initial_models = [models.Const1D(0.0)]
self.models = initial_models
self.ui = ModelBrowserUI(self, self.models, self.x, self.y)
self.plot, self.resid = _build_axes(self.ui.canvas.fig)
self._draw(preserve_limits=False)
self.mouse_handler = ModelEventHandler(self.plot, self.active_model)
add_callback(self.mouse_handler, 'model', self.set_model)
self.ui.fit.pressed.connect(nonpartial(self.fit))
self._sync_model_list()
def menu_actions(self):
result = []
a = QtGui.QAction("minmax", None)
a.triggered.connect(nonpartial(self.set_clip_percentile, 0, 100))
result.append(a)
a = QtGui.QAction("99%", None)
a.triggered.connect(nonpartial(self.set_clip_percentile, 1, 99))
result.append(a)
a = QtGui.QAction("95%", None)
a.triggered.connect(nonpartial(self.set_clip_percentile, 5, 95))
result.append(a)
a = QtGui.QAction("90%", None)
a.triggered.connect(nonpartial(self.set_clip_percentile, 10, 90))
result.append(a)
rng = QtGui.QAction("Set range...", None)
rng.triggered.connect(nonpartial(self.choose_vmin_vmax))
result.append(rng)
a = QtGui.QAction("", None)
a.setSeparator(True)
result.append(a)
a = QtGui.QAction("linear", None)
a.triggered.connect(nonpartial(setattr, self, 'stretch', 'linear'))
result.append(a)
a = QtGui.QAction("log", None)
a.triggered.connect(nonpartial(setattr, self, 'stretch', 'log'))
result.append(a)
a = QtGui.QAction("power", None)
a.triggered.connect(nonpartial(setattr, self, 'stretch', 'power'))
result.append(a)
a = QtGui.QAction("square root", None)
a.triggered.connect(nonpartial(setattr, self, 'stretch', 'sqrt'))
result.append(a)
a = QtGui.QAction("squared", None)
a.triggered.connect(nonpartial(setattr, self, 'stretch', 'squared'))
result.append(a)
a = QtGui.QAction("asinh", None)
a.triggered.connect(nonpartial(setattr, self, 'stretch', 'arcsinh'))
result.append(a)
for r in result:
if r is rng:
continue
if self._move_callback is not None:
r.triggered.connect(nonpartial(self._move_callback, self))
return result
def _create_actions(self):
""" Create and connect actions, store in _actions dict """
self._actions = {}
a = act("&New Data Viewer", self,
tip="Open a new visualization window in the current tab",
shortcut=QtGui.QKeySequence.New
)
a.triggered.connect(nonpartial(self.choose_new_data_viewer))
self._actions['viewer_new'] = a
a = act('New &Tab', self,
shortcut=QtGui.QKeySequence.AddTab,
tip='Add a new tab')
a.triggered.connect(nonpartial(self.new_tab))
self._actions['tab_new'] = a
a = act('&Rename Tab', self,
shortcut="Ctrl+R",
tip='Set a new label for the current tab')
a.triggered.connect(nonpartial(self.tab_bar.rename_tab))
self._actions['tab_rename'] = a
a = act('&Gather Windows', self,
tip='Gather plot windows side-by-side',
shortcut='Ctrl+G')
a.triggered.connect(nonpartial(self.gather_current_tab))
self._actions['gather'] = a
a = act('&Save Session', self,
tip='Save the current session')
a.triggered.connect(nonpartial(self._choose_save_session))
self._actions['session_save'] = a
# Add file loader as first item in File menu for convenience. We then
# also add it again below in the Import menu for consistency.
a = act("&Open Data Set", self, tip="Open a new data set",
shortcut=QtGui.QKeySequence.Open)
a.triggered.connect(nonpartial(self._choose_load_data,
data_wizard))
self._actions['data_new'] = a
# We now populate the "Import data" menu
from glue.config import importer
acts = []
# Add default file loader (later we can add this to the registry)
a = act("Import from file", self, tip="Import from file")
a.triggered.connect(nonpartial(self._choose_load_data,
data_wizard))
acts.append(a)
for i in importer:
label, data_importer = i
a = act(label, self, tip=label)
a.triggered.connect(nonpartial(self._choose_load_data,
data_importer))
acts.append(a)
self._actions['data_importers'] = acts
from glue.config import exporters
if len(exporters) > 0:
acts = []
for e in exporters:
label, saver, checker, mode = e
a = act(label, self,
tip='Export the current session to %s format' %
label)
a.triggered.connect(nonpartial(self._choose_export_session,
saver, checker, mode))
acts.append(a)
self._actions['session_export'] = acts
a = act('Open S&ession', self,
tip='Restore a saved session')
a.triggered.connect(nonpartial(self._restore_session))
self._actions['session_restore'] = a
a = act('Reset S&ession', self,
tip='Reset session to clean state')
a.triggered.connect(nonpartial(self._reset_session))
self._actions['session_reset'] = a
a = act("Undo", self,
tip='Undo last action',
shortcut=QtGui.QKeySequence.Undo)
a.triggered.connect(nonpartial(self.undo))
a.setEnabled(False)
self._actions['undo'] = a
a = act("Redo", self,
tip='Redo last action',
shortcut=QtGui.QKeySequence.Redo)
a.triggered.connect(nonpartial(self.redo))
a.setEnabled(False)
self._actions['redo'] = a
# Create actions for menubar plugins
from glue.config import menubar_plugin
acts = []
for label, function in menubar_plugin:
a = act(label, self, tip=label)
a.triggered.connect(nonpartial(function,
self.session,
self.data_collection))
acts.append(a)
self._actions['plugins'] = acts
a = act('&Plugin Manager', self,
tip='Open plugin manager')
a.triggered.connect(nonpartial(self.plugin_manager))
self._actions['plugin_manager'] = a
def _create_menu(self):
mbar = self.menuBar()
menu = QtGui.QMenu(mbar)
menu.setTitle("&File")
menu.addAction(self._actions['data_new'])
if 'data_importers' in self._actions:
submenu = menu.addMenu("I&mport data")
for a in self._actions['data_importers']:
submenu.addAction(a)
# menu.addAction(self._actions['data_save']) # XXX add this
menu.addAction(self._actions['session_reset'])
menu.addAction(self._actions['session_restore'])
menu.addAction(self._actions['session_save'])
if 'session_export' in self._actions:
submenu = menu.addMenu("E&xport")
for a in self._actions['session_export']:
submenu.addAction(a)
menu.addSeparator()
menu.addAction("Edit &Settings", self._edit_settings)
mbar.addMenu(menu)
menu = QtGui.QMenu(mbar)
menu.setTitle("&Edit ")
menu.addAction(self._actions['undo'])
menu.addAction(self._actions['redo'])
mbar.addMenu(menu)
menu = QtGui.QMenu(mbar)
menu.setTitle("&View ")
a = QtGui.QAction("&Console Log", menu)
a.triggered.connect(self._ui.log._show)
menu.addAction(a)
mbar.addMenu(menu)
menu = QtGui.QMenu(mbar)
menu.setTitle("&Canvas")
menu.addAction(self._actions['tab_new'])
menu.addAction(self._actions['viewer_new'])
menu.addSeparator()
menu.addAction(self._actions['gather'])
menu.addAction(self._actions['tab_rename'])
mbar.addMenu(menu)
menu = QtGui.QMenu(mbar)
menu.setTitle("Data &Manager")
menu.addActions(self._ui.layerWidget.actions())
mbar.addMenu(menu)
menu = QtGui.QMenu(mbar)
menu.setTitle("&Toolbars")
tbar = EditSubsetModeToolBar()
self._mode_toolbar = tbar
self.addToolBar(tbar)
tbar.hide()
a = QtGui.QAction("Selection Mode &Toolbar", menu)
a.setCheckable(True)
a.toggled.connect(tbar.setVisible)
try:
tbar.visibilityChanged.connect(a.setChecked)
except AttributeError: # Qt < 4.7. QtCore.Signal not supported
pass
menu.addAction(a)
menu.addActions(tbar.actions())
mbar.addMenu(menu)
menu = QtGui.QMenu(mbar)
menu.setTitle("&Plugins")
menu.addAction(self._actions['plugin_manager'])
menu.addSeparator()
if 'plugins' in self._actions:
for plugin in self._actions['plugins']:
menu.addAction(plugin)
mbar.addMenu(menu)
# trigger inclusion of Mac Native "Help" tool
menu = mbar.addMenu("&Help")
a = QtGui.QAction("&Online Documentation", menu)
a.triggered.connect(nonpartial(webbrowser.open, DOCS_URL))
menu.addAction(a)
a = QtGui.QAction("Send &Feedback", menu)
a.triggered.connect(nonpartial(submit_bug_report))
menu.addAction(a)
def register_to_hub(self, hub):
super(DendroWidget, self).register_to_hub(hub)
self.client.register_to_hub(hub)
hub.subscribe(self, core.message.ComponentsChangedMessage,
nonpartial(self._update_combos()))
def _connect(self):
self._parent.selection_changed.connect(
self.update_enabled)
self.triggered.connect(nonpartial(self._do_action))
def _connect(self):
self.ui.model_list.currentRowChanged.connect(self._change_active_model)
self.ui.add.pressed.connect(nonpartial(self.add_model))
self.ui.remove.pressed.connect(nonpartial(self.remove_model))
self.ui.fit.pressed.connect(nonpartial(self.fit))
