def process_dialog(delay=0, accept=False, reject=False, function=None):
"""
Context manager to automatically capture the active dialog and carry out
certain actions.
Note that only one of ``accept``, ``reject``, or ``function`` should be
specified.
Parameters
----------
delay : int, optional
The delay in ms before acting on the dialog (since it may not yet exist
when the context manager is called).
accept : bool, optional
If `True`, accept the dialog after the specified delay.
reject : bool, optional
If `False`, reject the dialog after the specified delay
function : func, optional
For more complex user actions, specify a function that takes the dialog
as the first and only argument.
"""
def _accept(dialog):
dialog.accept()
def _reject(dialog):
dialog.reject()
n_args = sum((accept, reject, function is not None))
if n_args > 1:
raise ValueError("Only one of ``accept``, ``reject``, or "
"``function`` should be specified")
elif n_args == 0:
raise ValueError("One of ``accept``, ``reject``, or "
"``function`` should be specified")
if accept:
function = _accept
elif reject:
function = _reject
def wrapper():
from glue.external.qt import get_qapp
app = get_qapp()
dialog = app.focusWidget().window()
function(dialog)
timer = QtCore.QTimer()
timer.setInterval(delay)
timer.setSingleShot(True)
timer.timeout.connect(wrapper)
timer.start()
yield
def start(self):
# handoff between IOLoop and QApplication event loops
loop = ioloop.IOLoop.instance()
# We used to have a value of 0ms as the second argument
# (callback_time) in the following call, but this caused the
# application to hang on certain setups, so use 1ms instead.
stopper = ioloop.PeriodicCallback(loop.stop, 1, loop)
self.timer = QtCore.QTimer()
self.timer.timeout.connect(loop.start)
self.timer.start(100)
stopper.start()
super(EmbeddedQtKernelApp, self).start()
def __init__(self, parent=None):
super(WebcamView, self).__init__()
self._frozen = False
self._webcam = Webcam()
self._update_image()
self._timer = QtCore.QTimer(self)
self._timer.timeout.connect(self._update_image)
self._timer.start(100)
def __init__(self, parent=None):
super(DataCollectionView, self).__init__(parent)
self.doubleClicked.connect(self._edit)
# this keeps the full-row of the selection bar in-sync
self.pressed.connect(nonpartial(self._update_viewport))
# only edit label on model.new_item
self.setItemDelegate(LabeledDelegate())
self.setEditTriggers(self.NoEditTriggers)
self._timer = QtCore.QTimer(self)
self._timer.timeout.connect(nonpartial(self._update_viewport))
self._timer.start(1000)
def __init__(self, parent=None):
super(LayerArtistView, self).__init__(parent)
self.setDragEnabled(True)
self.setAcceptDrops(True)
self.setDragDropMode(QtGui.QAbstractItemView.InternalMove)
self.setIconSize(QtCore.QSize(15, 15))
self.setSelectionMode(QtGui.QAbstractItemView.SingleSelection)
self.setSelectionBehavior(QtGui.QAbstractItemView.SelectRows)
self.setContextMenuPolicy(Qt.ActionsContextMenu)
self.setEditTriggers(self.NoEditTriggers)
self._set_palette()
self._actions = {}
self._create_actions()
self._timer = QtCore.QTimer(self)
self._timer.timeout.connect(nonpartial(self._update_viewport))
self._timer.start(1000)
def __init__(self):
self._draw_count = 0
interactive = matplotlib.is_interactive()
matplotlib.interactive(False)
self.roi_callback = None
self.fig = Figure(facecolor='#ffffff')
FigureCanvas.__init__(self, self.fig)
FigureCanvas.setSizePolicy(self, QtGui.QSizePolicy.Expanding,
QtGui.QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
self.manager = FigureManager(self, 0)
matplotlib.interactive(interactive)
self._resize_timer = QtCore.QTimer()
self._resize_timer.setInterval(250)
self._resize_timer.setSingleShot(True)
self._resize_timer.timeout.connect(self._on_timeout)
self.renderer = None
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('data_slice_widget.ui',
None,
directory=os.path.dirname(__file__))
slider.slider
slider.button_first.setStyleSheet('border: 0px')
slider.button_first.setIcon(get_icon('playback_first'))
slider.button_prev.setStyleSheet('border: 0px')
slider.button_prev.setIcon(get_icon('playback_prev'))
slider.button_back.setStyleSheet('border: 0px')
slider.button_back.setIcon(get_icon('playback_back'))
slider.button_stop.setStyleSheet('border: 0px')
slider.button_stop.setIcon(get_icon('playback_stop'))
slider.button_forw.setStyleSheet('border: 0px')
slider.button_forw.setIcon(get_icon('playback_forw'))
slider.button_next.setStyleSheet('border: 0px')
slider.button_next.setIcon(get_icon('playback_next'))
slider.button_last.setStyleSheet('border: 0px')
slider.button_last.setIcon(get_icon('playback_last'))
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)))
self._play_timer = QtCore.QTimer()
self._play_timer.setInterval(500)
self._play_timer.timeout.connect(nonpartial(self._play_slice))
slider.button_first.clicked.connect(
nonpartial(self._browse_slice, 'first'))
slider.button_prev.clicked.connect(
nonpartial(self._browse_slice, 'prev'))
slider.button_back.clicked.connect(
nonpartial(self._adjust_play, 'back'))
slider.button_stop.clicked.connect(
nonpartial(self._adjust_play, 'stop'))
slider.button_forw.clicked.connect(
nonpartial(self._adjust_play, 'forw'))
slider.button_next.clicked.connect(
nonpartial(self._browse_slice, 'next'))
slider.button_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
self._play_speed = 0
def __init__(self, interval, callback):
from glue.external.qt import QtCore
self._timer = QtCore.QTimer()
self._timer.setInterval(interval)
self._timer.timeout.connect(callback)
def non_blocking_eventloop(kernel):
kernel.timer = QtCore.QTimer()
kernel.timer.timeout.connect(kernel.do_one_iteration)
kernel.timer.start(1000 * kernel._poll_interval)
def event_loop(kernel):
""" Non-blocking qt event loop."""
kernel.timer = QtCore.QTimer()
kernel.timer.timeout.connect(kernel.do_one_iteration)
kernel.timer.start(1000 * kernel._poll_interval)